/*!
 * antd v2.13.14
 * 
 * Copyright 2015-present, Alipay, Inc.
 * All rights reserved.
 */
(function webpackUniversalModuleDefinition(root, factory) {
	if(typeof exports === 'object' && typeof module === 'object')
		module.exports = factory(require("react"), require("react-dom"));
	else if(typeof define === 'function' && define.amd)
		define(["react", "react-dom"], factory);
	else if(typeof exports === 'object')
		exports["antd"] = factory(require("react"), require("react-dom"));
	else
		root["antd"] = factory(root["React"], root["ReactDOM"]);
})(this, function(__WEBPACK_EXTERNAL_MODULE_1__, __WEBPACK_EXTERNAL_MODULE_10__) {
return /******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};
/******/
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/
/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId])
/******/ 			return installedModules[moduleId].exports;
/******/
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			exports: {},
/******/ 			id: moduleId,
/******/ 			loaded: false
/******/ 		};
/******/
/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ 		// Flag the module as loaded
/******/ 		module.loaded = true;
/******/
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/
/******/
/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;
/******/
/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;
/******/
/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "";
/******/
/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(0);
/******/ })
/************************************************************************/
/******/ ((function(modules) {
	// Check all modules for deduplicated modules
	for(var i in modules) {
		if(Object.prototype.hasOwnProperty.call(modules, i)) {
			switch(typeof modules[i]) {
			case "function": break;
			case "object":
				// Module can be created from a template
				modules[i] = (function(_m) {
					var args = _m.slice(1), fn = modules[_m[0]];
					return function (a,b,c) {
						fn.apply(this, [a,b,c].concat(args));
					};
				}(modules[i]));
				break;
			default:
				// Module is a copy of another module
				modules[i] = modules[modules[i]];
				break;
			}
		}
	}
	return modules;
}([
/* 0 */
/***/ (function(module, exports, __webpack_require__) {

	module.exports = __webpack_require__(875);


/***/ }),
/* 1 */
/***/ (function(module, exports) {

	module.exports = __WEBPACK_EXTERNAL_MODULE_1__;

/***/ }),
/* 2 */
/***/ (function(module, exports, __webpack_require__) {

	"use strict";
	
	exports.__esModule = true;
	
	var _assign = __webpack_require__(413);
	
	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;
	};

/***/ }),
/* 3 */
/***/ (function(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");
	  }
	};

/***/ }),
/* 4 */
/***/ (function(module, exports, __webpack_require__) {

	"use strict";
	
	exports.__esModule = true;
	
	var _setPrototypeOf = __webpack_require__(417);
	
	var _setPrototypeOf2 = _interopRequireDefault(_setPrototypeOf);
	
	var _create = __webpack_require__(414);
	
	var _create2 = _interopRequireDefault(_create);
	
	var _typeof2 = __webpack_require__(21);
	
	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;
	};

/***/ }),
/* 5 */
/***/ (function(module, exports, __webpack_require__) {

	"use strict";
	
	exports.__esModule = true;
	
	var _typeof2 = __webpack_require__(21);
	
	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;
	};

/***/ }),
/* 6 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 */
	
	if (true) {
	  var REACT_ELEMENT_TYPE = (typeof Symbol === 'function' &&
	    Symbol.for &&
	    Symbol.for('react.element')) ||
	    0xeac7;
	
	  var isValidElement = function(object) {
	    return typeof object === 'object' &&
	      object !== null &&
	      object.$$typeof === REACT_ELEMENT_TYPE;
	  };
	
	  // By explicitly using `prop-types` you are opting into new development behavior.
	  // http://fb.me/prop-types-in-prod
	  var throwOnDirectAccess = true;
	  module.exports = __webpack_require__(654)(isValidElement, throwOnDirectAccess);
	} else {
	  // By explicitly using `prop-types` you are opting into new production behavior.
	  // http://fb.me/prop-types-in-prod
	  module.exports = require('./factoryWithThrowingShims')();
	}


/***/ }),
/* 7 */
/***/ (function(module, exports, __webpack_require__) {

	"use strict";
	
	exports.__esModule = true;
	
	var _defineProperty = __webpack_require__(185);
	
	var _defineProperty2 = _interopRequireDefault(_defineProperty);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
	
	exports.default = 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;
	      (0, _defineProperty2.default)(target, descriptor.key, descriptor);
	    }
	  }
	
	  return function (Constructor, protoProps, staticProps) {
	    if (protoProps) defineProperties(Constructor.prototype, protoProps);
	    if (staticProps) defineProperties(Constructor, staticProps);
	    return Constructor;
	  };
	}();

/***/ }),
/* 8 */
/***/ (function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!
	  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 (true) {
			// register as 'classnames', consistent with npm package name
			!(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = function () {
				return classNames;
			}.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
		} else {
			window.classNames = classNames;
		}
	}());


/***/ }),
/* 9 */
/***/ (function(module, exports, __webpack_require__) {

	"use strict";
	
	exports.__esModule = true;
	
	var _defineProperty = __webpack_require__(185);
	
	var _defineProperty2 = _interopRequireDefault(_defineProperty);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
	
	exports.default = function (obj, key, value) {
	  if (key in obj) {
	    (0, _defineProperty2.default)(obj, key, {
	      value: value,
	      enumerable: true,
	      configurable: true,
	      writable: true
	    });
	  } else {
	    obj[key] = value;
	  }
	
	  return obj;
	};

/***/ }),
/* 10 */
/***/ (function(module, exports) {

	module.exports = __WEBPACK_EXTERNAL_MODULE_10__;

/***/ }),
/* 11 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 *  Copyright (c) 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.
	 */
	
	(function (global, factory) {
	   true ? module.exports = factory() :
	  typeof define === 'function' && define.amd ? define(factory) :
	  global.Immutable = factory();
	}(this, function () { 'use strict';var SLICE$0 = Array.prototype.slice;
	
	  function createClass(ctor, superClass) {
	    if (superClass) {
	      ctor.prototype = Object.create(superClass.prototype);
	    }
	    ctor.prototype.constructor = ctor;
	  }
	
	  function Iterable(value) {
	      return isIterable(value) ? value : Seq(value);
	    }
	
	
	  createClass(KeyedIterable, Iterable);
	    function KeyedIterable(value) {
	      return isKeyed(value) ? value : KeyedSeq(value);
	    }
	
	
	  createClass(IndexedIterable, Iterable);
	    function IndexedIterable(value) {
	      return isIndexed(value) ? value : IndexedSeq(value);
	    }
	
	
	  createClass(SetIterable, Iterable);
	    function SetIterable(value) {
	      return isIterable(value) && !isAssociative(value) ? value : SetSeq(value);
	    }
	
	
	
	  function isIterable(maybeIterable) {
	    return !!(maybeIterable && maybeIterable[IS_ITERABLE_SENTINEL]);
	  }
	
	  function isKeyed(maybeKeyed) {
	    return !!(maybeKeyed && maybeKeyed[IS_KEYED_SENTINEL]);
	  }
	
	  function isIndexed(maybeIndexed) {
	    return !!(maybeIndexed && maybeIndexed[IS_INDEXED_SENTINEL]);
	  }
	
	  function isAssociative(maybeAssociative) {
	    return isKeyed(maybeAssociative) || isIndexed(maybeAssociative);
	  }
	
	  function isOrdered(maybeOrdered) {
	    return !!(maybeOrdered && maybeOrdered[IS_ORDERED_SENTINEL]);
	  }
	
	  Iterable.isIterable = isIterable;
	  Iterable.isKeyed = isKeyed;
	  Iterable.isIndexed = isIndexed;
	  Iterable.isAssociative = isAssociative;
	  Iterable.isOrdered = isOrdered;
	
	  Iterable.Keyed = KeyedIterable;
	  Iterable.Indexed = IndexedIterable;
	  Iterable.Set = SetIterable;
	
	
	  var IS_ITERABLE_SENTINEL = '@@__IMMUTABLE_ITERABLE__@@';
	  var IS_KEYED_SENTINEL = '@@__IMMUTABLE_KEYED__@@';
	  var IS_INDEXED_SENTINEL = '@@__IMMUTABLE_INDEXED__@@';
	  var IS_ORDERED_SENTINEL = '@@__IMMUTABLE_ORDERED__@@';
	
	  // Used for setting prototype methods that IE8 chokes on.
	  var DELETE = 'delete';
	
	  // Constants describing the size of trie nodes.
	  var SHIFT = 5; // Resulted in best performance after ______?
	  var SIZE = 1 << SHIFT;
	  var MASK = SIZE - 1;
	
	  // A consistent shared value representing "not set" which equals nothing other
	  // than itself, and nothing that could be provided externally.
	  var NOT_SET = {};
	
	  // Boolean references, Rough equivalent of `bool &`.
	  var CHANGE_LENGTH = { value: false };
	  var DID_ALTER = { value: false };
	
	  function MakeRef(ref) {
	    ref.value = false;
	    return ref;
	  }
	
	  function SetRef(ref) {
	    ref && (ref.value = true);
	  }
	
	  // A function which returns a value representing an "owner" for transient writes
	  // to tries. The return value will only ever equal itself, and will not equal
	  // the return of any subsequent call of this function.
	  function OwnerID() {}
	
	  // http://jsperf.com/copy-array-inline
	  function arrCopy(arr, offset) {
	    offset = offset || 0;
	    var len = Math.max(0, arr.length - offset);
	    var newArr = new Array(len);
	    for (var ii = 0; ii < len; ii++) {
	      newArr[ii] = arr[ii + offset];
	    }
	    return newArr;
	  }
	
	  function ensureSize(iter) {
	    if (iter.size === undefined) {
	      iter.size = iter.__iterate(returnTrue);
	    }
	    return iter.size;
	  }
	
	  function wrapIndex(iter, index) {
	    // This implements "is array index" which the ECMAString spec defines as:
	    //
	    //     A String property name P is an array index if and only if
	    //     ToString(ToUint32(P)) is equal to P and ToUint32(P) is not equal
	    //     to 2^32−1.
	    //
	    // http://www.ecma-international.org/ecma-262/6.0/#sec-array-exotic-objects
	    if (typeof index !== 'number') {
	      var uint32Index = index >>> 0; // N >>> 0 is shorthand for ToUint32
	      if ('' + uint32Index !== index || uint32Index === 4294967295) {
	        return NaN;
	      }
	      index = uint32Index;
	    }
	    return index < 0 ? ensureSize(iter) + index : index;
	  }
	
	  function returnTrue() {
	    return true;
	  }
	
	  function wholeSlice(begin, end, size) {
	    return (begin === 0 || (size !== undefined && begin <= -size)) &&
	      (end === undefined || (size !== undefined && end >= size));
	  }
	
	  function resolveBegin(begin, size) {
	    return resolveIndex(begin, size, 0);
	  }
	
	  function resolveEnd(end, size) {
	    return resolveIndex(end, size, size);
	  }
	
	  function resolveIndex(index, size, defaultIndex) {
	    return index === undefined ?
	      defaultIndex :
	      index < 0 ?
	        Math.max(0, size + index) :
	        size === undefined ?
	          index :
	          Math.min(size, index);
	  }
	
	  /* global Symbol */
	
	  var ITERATE_KEYS = 0;
	  var ITERATE_VALUES = 1;
	  var ITERATE_ENTRIES = 2;
	
	  var REAL_ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;
	  var FAUX_ITERATOR_SYMBOL = '@@iterator';
	
	  var ITERATOR_SYMBOL = REAL_ITERATOR_SYMBOL || FAUX_ITERATOR_SYMBOL;
	
	
	  function Iterator(next) {
	      this.next = next;
	    }
	
	    Iterator.prototype.toString = function() {
	      return '[Iterator]';
	    };
	
	
	  Iterator.KEYS = ITERATE_KEYS;
	  Iterator.VALUES = ITERATE_VALUES;
	  Iterator.ENTRIES = ITERATE_ENTRIES;
	
	  Iterator.prototype.inspect =
	  Iterator.prototype.toSource = function () { return this.toString(); }
	  Iterator.prototype[ITERATOR_SYMBOL] = function () {
	    return this;
	  };
	
	
	  function iteratorValue(type, k, v, iteratorResult) {
	    var value = type === 0 ? k : type === 1 ? v : [k, v];
	    iteratorResult ? (iteratorResult.value = value) : (iteratorResult = {
	      value: value, done: false
	    });
	    return iteratorResult;
	  }
	
	  function iteratorDone() {
	    return { value: undefined, done: true };
	  }
	
	  function hasIterator(maybeIterable) {
	    return !!getIteratorFn(maybeIterable);
	  }
	
	  function isIterator(maybeIterator) {
	    return maybeIterator && typeof maybeIterator.next === 'function';
	  }
	
	  function getIterator(iterable) {
	    var iteratorFn = getIteratorFn(iterable);
	    return iteratorFn && iteratorFn.call(iterable);
	  }
	
	  function getIteratorFn(iterable) {
	    var iteratorFn = iterable && (
	      (REAL_ITERATOR_SYMBOL && iterable[REAL_ITERATOR_SYMBOL]) ||
	      iterable[FAUX_ITERATOR_SYMBOL]
	    );
	    if (typeof iteratorFn === 'function') {
	      return iteratorFn;
	    }
	  }
	
	  function isArrayLike(value) {
	    return value && typeof value.length === 'number';
	  }
	
	  createClass(Seq, Iterable);
	    function Seq(value) {
	      return value === null || value === undefined ? emptySequence() :
	        isIterable(value) ? value.toSeq() : seqFromValue(value);
	    }
	
	    Seq.of = function(/*...values*/) {
	      return Seq(arguments);
	    };
	
	    Seq.prototype.toSeq = function() {
	      return this;
	    };
	
	    Seq.prototype.toString = function() {
	      return this.__toString('Seq {', '}');
	    };
	
	    Seq.prototype.cacheResult = function() {
	      if (!this._cache && this.__iterateUncached) {
	        this._cache = this.entrySeq().toArray();
	        this.size = this._cache.length;
	      }
	      return this;
	    };
	
	    // abstract __iterateUncached(fn, reverse)
	
	    Seq.prototype.__iterate = function(fn, reverse) {
	      return seqIterate(this, fn, reverse, true);
	    };
	
	    // abstract __iteratorUncached(type, reverse)
	
	    Seq.prototype.__iterator = function(type, reverse) {
	      return seqIterator(this, type, reverse, true);
	    };
	
	
	
	  createClass(KeyedSeq, Seq);
	    function KeyedSeq(value) {
	      return value === null || value === undefined ?
	        emptySequence().toKeyedSeq() :
	        isIterable(value) ?
	          (isKeyed(value) ? value.toSeq() : value.fromEntrySeq()) :
	          keyedSeqFromValue(value);
	    }
	
	    KeyedSeq.prototype.toKeyedSeq = function() {
	      return this;
	    };
	
	
	
	  createClass(IndexedSeq, Seq);
	    function IndexedSeq(value) {
	      return value === null || value === undefined ? emptySequence() :
	        !isIterable(value) ? indexedSeqFromValue(value) :
	        isKeyed(value) ? value.entrySeq() : value.toIndexedSeq();
	    }
	
	    IndexedSeq.of = function(/*...values*/) {
	      return IndexedSeq(arguments);
	    };
	
	    IndexedSeq.prototype.toIndexedSeq = function() {
	      return this;
	    };
	
	    IndexedSeq.prototype.toString = function() {
	      return this.__toString('Seq [', ']');
	    };
	
	    IndexedSeq.prototype.__iterate = function(fn, reverse) {
	      return seqIterate(this, fn, reverse, false);
	    };
	
	    IndexedSeq.prototype.__iterator = function(type, reverse) {
	      return seqIterator(this, type, reverse, false);
	    };
	
	
	
	  createClass(SetSeq, Seq);
	    function SetSeq(value) {
	      return (
	        value === null || value === undefined ? emptySequence() :
	        !isIterable(value) ? indexedSeqFromValue(value) :
	        isKeyed(value) ? value.entrySeq() : value
	      ).toSetSeq();
	    }
	
	    SetSeq.of = function(/*...values*/) {
	      return SetSeq(arguments);
	    };
	
	    SetSeq.prototype.toSetSeq = function() {
	      return this;
	    };
	
	
	
	  Seq.isSeq = isSeq;
	  Seq.Keyed = KeyedSeq;
	  Seq.Set = SetSeq;
	  Seq.Indexed = IndexedSeq;
	
	  var IS_SEQ_SENTINEL = '@@__IMMUTABLE_SEQ__@@';
	
	  Seq.prototype[IS_SEQ_SENTINEL] = true;
	
	
	
	  createClass(ArraySeq, IndexedSeq);
	    function ArraySeq(array) {
	      this._array = array;
	      this.size = array.length;
	    }
	
	    ArraySeq.prototype.get = function(index, notSetValue) {
	      return this.has(index) ? this._array[wrapIndex(this, index)] : notSetValue;
	    };
	
	    ArraySeq.prototype.__iterate = function(fn, reverse) {
	      var array = this._array;
	      var maxIndex = array.length - 1;
	      for (var ii = 0; ii <= maxIndex; ii++) {
	        if (fn(array[reverse ? maxIndex - ii : ii], ii, this) === false) {
	          return ii + 1;
	        }
	      }
	      return ii;
	    };
	
	    ArraySeq.prototype.__iterator = function(type, reverse) {
	      var array = this._array;
	      var maxIndex = array.length - 1;
	      var ii = 0;
	      return new Iterator(function() 
	        {return ii > maxIndex ?
	          iteratorDone() :
	          iteratorValue(type, ii, array[reverse ? maxIndex - ii++ : ii++])}
	      );
	    };
	
	
	
	  createClass(ObjectSeq, KeyedSeq);
	    function ObjectSeq(object) {
	      var keys = Object.keys(object);
	      this._object = object;
	      this._keys = keys;
	      this.size = keys.length;
	    }
	
	    ObjectSeq.prototype.get = function(key, notSetValue) {
	      if (notSetValue !== undefined && !this.has(key)) {
	        return notSetValue;
	      }
	      return this._object[key];
	    };
	
	    ObjectSeq.prototype.has = function(key) {
	      return this._object.hasOwnProperty(key);
	    };
	
	    ObjectSeq.prototype.__iterate = function(fn, reverse) {
	      var object = this._object;
	      var keys = this._keys;
	      var maxIndex = keys.length - 1;
	      for (var ii = 0; ii <= maxIndex; ii++) {
	        var key = keys[reverse ? maxIndex - ii : ii];
	        if (fn(object[key], key, this) === false) {
	          return ii + 1;
	        }
	      }
	      return ii;
	    };
	
	    ObjectSeq.prototype.__iterator = function(type, reverse) {
	      var object = this._object;
	      var keys = this._keys;
	      var maxIndex = keys.length - 1;
	      var ii = 0;
	      return new Iterator(function()  {
	        var key = keys[reverse ? maxIndex - ii : ii];
	        return ii++ > maxIndex ?
	          iteratorDone() :
	          iteratorValue(type, key, object[key]);
	      });
	    };
	
	  ObjectSeq.prototype[IS_ORDERED_SENTINEL] = true;
	
	
	  createClass(IterableSeq, IndexedSeq);
	    function IterableSeq(iterable) {
	      this._iterable = iterable;
	      this.size = iterable.length || iterable.size;
	    }
	
	    IterableSeq.prototype.__iterateUncached = function(fn, reverse) {
	      if (reverse) {
	        return this.cacheResult().__iterate(fn, reverse);
	      }
	      var iterable = this._iterable;
	      var iterator = getIterator(iterable);
	      var iterations = 0;
	      if (isIterator(iterator)) {
	        var step;
	        while (!(step = iterator.next()).done) {
	          if (fn(step.value, iterations++, this) === false) {
	            break;
	          }
	        }
	      }
	      return iterations;
	    };
	
	    IterableSeq.prototype.__iteratorUncached = function(type, reverse) {
	      if (reverse) {
	        return this.cacheResult().__iterator(type, reverse);
	      }
	      var iterable = this._iterable;
	      var iterator = getIterator(iterable);
	      if (!isIterator(iterator)) {
	        return new Iterator(iteratorDone);
	      }
	      var iterations = 0;
	      return new Iterator(function()  {
	        var step = iterator.next();
	        return step.done ? step : iteratorValue(type, iterations++, step.value);
	      });
	    };
	
	
	
	  createClass(IteratorSeq, IndexedSeq);
	    function IteratorSeq(iterator) {
	      this._iterator = iterator;
	      this._iteratorCache = [];
	    }
	
	    IteratorSeq.prototype.__iterateUncached = function(fn, reverse) {
	      if (reverse) {
	        return this.cacheResult().__iterate(fn, reverse);
	      }
	      var iterator = this._iterator;
	      var cache = this._iteratorCache;
	      var iterations = 0;
	      while (iterations < cache.length) {
	        if (fn(cache[iterations], iterations++, this) === false) {
	          return iterations;
	        }
	      }
	      var step;
	      while (!(step = iterator.next()).done) {
	        var val = step.value;
	        cache[iterations] = val;
	        if (fn(val, iterations++, this) === false) {
	          break;
	        }
	      }
	      return iterations;
	    };
	
	    IteratorSeq.prototype.__iteratorUncached = function(type, reverse) {
	      if (reverse) {
	        return this.cacheResult().__iterator(type, reverse);
	      }
	      var iterator = this._iterator;
	      var cache = this._iteratorCache;
	      var iterations = 0;
	      return new Iterator(function()  {
	        if (iterations >= cache.length) {
	          var step = iterator.next();
	          if (step.done) {
	            return step;
	          }
	          cache[iterations] = step.value;
	        }
	        return iteratorValue(type, iterations, cache[iterations++]);
	      });
	    };
	
	
	
	
	  // # pragma Helper functions
	
	  function isSeq(maybeSeq) {
	    return !!(maybeSeq && maybeSeq[IS_SEQ_SENTINEL]);
	  }
	
	  var EMPTY_SEQ;
	
	  function emptySequence() {
	    return EMPTY_SEQ || (EMPTY_SEQ = new ArraySeq([]));
	  }
	
	  function keyedSeqFromValue(value) {
	    var seq =
	      Array.isArray(value) ? new ArraySeq(value).fromEntrySeq() :
	      isIterator(value) ? new IteratorSeq(value).fromEntrySeq() :
	      hasIterator(value) ? new IterableSeq(value).fromEntrySeq() :
	      typeof value === 'object' ? new ObjectSeq(value) :
	      undefined;
	    if (!seq) {
	      throw new TypeError(
	        'Expected Array or iterable object of [k, v] entries, '+
	        'or keyed object: ' + value
	      );
	    }
	    return seq;
	  }
	
	  function indexedSeqFromValue(value) {
	    var seq = maybeIndexedSeqFromValue(value);
	    if (!seq) {
	      throw new TypeError(
	        'Expected Array or iterable object of values: ' + value
	      );
	    }
	    return seq;
	  }
	
	  function seqFromValue(value) {
	    var seq = maybeIndexedSeqFromValue(value) ||
	      (typeof value === 'object' && new ObjectSeq(value));
	    if (!seq) {
	      throw new TypeError(
	        'Expected Array or iterable object of values, or keyed object: ' + value
	      );
	    }
	    return seq;
	  }
	
	  function maybeIndexedSeqFromValue(value) {
	    return (
	      isArrayLike(value) ? new ArraySeq(value) :
	      isIterator(value) ? new IteratorSeq(value) :
	      hasIterator(value) ? new IterableSeq(value) :
	      undefined
	    );
	  }
	
	  function seqIterate(seq, fn, reverse, useKeys) {
	    var cache = seq._cache;
	    if (cache) {
	      var maxIndex = cache.length - 1;
	      for (var ii = 0; ii <= maxIndex; ii++) {
	        var entry = cache[reverse ? maxIndex - ii : ii];
	        if (fn(entry[1], useKeys ? entry[0] : ii, seq) === false) {
	          return ii + 1;
	        }
	      }
	      return ii;
	    }
	    return seq.__iterateUncached(fn, reverse);
	  }
	
	  function seqIterator(seq, type, reverse, useKeys) {
	    var cache = seq._cache;
	    if (cache) {
	      var maxIndex = cache.length - 1;
	      var ii = 0;
	      return new Iterator(function()  {
	        var entry = cache[reverse ? maxIndex - ii : ii];
	        return ii++ > maxIndex ?
	          iteratorDone() :
	          iteratorValue(type, useKeys ? entry[0] : ii - 1, entry[1]);
	      });
	    }
	    return seq.__iteratorUncached(type, reverse);
	  }
	
	  function fromJS(json, converter) {
	    return converter ?
	      fromJSWith(converter, json, '', {'': json}) :
	      fromJSDefault(json);
	  }
	
	  function fromJSWith(converter, json, key, parentJSON) {
	    if (Array.isArray(json)) {
	      return converter.call(parentJSON, key, IndexedSeq(json).map(function(v, k)  {return fromJSWith(converter, v, k, json)}));
	    }
	    if (isPlainObj(json)) {
	      return converter.call(parentJSON, key, KeyedSeq(json).map(function(v, k)  {return fromJSWith(converter, v, k, json)}));
	    }
	    return json;
	  }
	
	  function fromJSDefault(json) {
	    if (Array.isArray(json)) {
	      return IndexedSeq(json).map(fromJSDefault).toList();
	    }
	    if (isPlainObj(json)) {
	      return KeyedSeq(json).map(fromJSDefault).toMap();
	    }
	    return json;
	  }
	
	  function isPlainObj(value) {
	    return value && (value.constructor === Object || value.constructor === undefined);
	  }
	
	  /**
	   * An extension of the "same-value" algorithm as [described for use by ES6 Map
	   * and Set](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map#Key_equality)
	   *
	   * NaN is considered the same as NaN, however -0 and 0 are considered the same
	   * value, which is different from the algorithm described by
	   * [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is).
	   *
	   * This is extended further to allow Objects to describe the values they
	   * represent, by way of `valueOf` or `equals` (and `hashCode`).
	   *
	   * Note: because of this extension, the key equality of Immutable.Map and the
	   * value equality of Immutable.Set will differ from ES6 Map and Set.
	   *
	   * ### Defining custom values
	   *
	   * The easiest way to describe the value an object represents is by implementing
	   * `valueOf`. For example, `Date` represents a value by returning a unix
	   * timestamp for `valueOf`:
	   *
	   *     var date1 = new Date(1234567890000); // Fri Feb 13 2009 ...
	   *     var date2 = new Date(1234567890000);
	   *     date1.valueOf(); // 1234567890000
	   *     assert( date1 !== date2 );
	   *     assert( Immutable.is( date1, date2 ) );
	   *
	   * Note: overriding `valueOf` may have other implications if you use this object
	   * where JavaScript expects a primitive, such as implicit string coercion.
	   *
	   * For more complex types, especially collections, implementing `valueOf` may
	   * not be performant. An alternative is to implement `equals` and `hashCode`.
	   *
	   * `equals` takes another object, presumably of similar type, and returns true
	   * if the it is equal. Equality is symmetrical, so the same result should be
	   * returned if this and the argument are flipped.
	   *
	   *     assert( a.equals(b) === b.equals(a) );
	   *
	   * `hashCode` returns a 32bit integer number representing the object which will
	   * be used to determine how to store the value object in a Map or Set. You must
	   * provide both or neither methods, one must not exist without the other.
	   *
	   * Also, an important relationship between these methods must be upheld: if two
	   * values are equal, they *must* return the same hashCode. If the values are not
	   * equal, they might have the same hashCode; this is called a hash collision,
	   * and while undesirable for performance reasons, it is acceptable.
	   *
	   *     if (a.equals(b)) {
	   *       assert( a.hashCode() === b.hashCode() );
	   *     }
	   *
	   * All Immutable collections implement `equals` and `hashCode`.
	   *
	   */
	  function is(valueA, valueB) {
	    if (valueA === valueB || (valueA !== valueA && valueB !== valueB)) {
	      return true;
	    }
	    if (!valueA || !valueB) {
	      return false;
	    }
	    if (typeof valueA.valueOf === 'function' &&
	        typeof valueB.valueOf === 'function') {
	      valueA = valueA.valueOf();
	      valueB = valueB.valueOf();
	      if (valueA === valueB || (valueA !== valueA && valueB !== valueB)) {
	        return true;
	      }
	      if (!valueA || !valueB) {
	        return false;
	      }
	    }
	    if (typeof valueA.equals === 'function' &&
	        typeof valueB.equals === 'function' &&
	        valueA.equals(valueB)) {
	      return true;
	    }
	    return false;
	  }
	
	  function deepEqual(a, b) {
	    if (a === b) {
	      return true;
	    }
	
	    if (
	      !isIterable(b) ||
	      a.size !== undefined && b.size !== undefined && a.size !== b.size ||
	      a.__hash !== undefined && b.__hash !== undefined && a.__hash !== b.__hash ||
	      isKeyed(a) !== isKeyed(b) ||
	      isIndexed(a) !== isIndexed(b) ||
	      isOrdered(a) !== isOrdered(b)
	    ) {
	      return false;
	    }
	
	    if (a.size === 0 && b.size === 0) {
	      return true;
	    }
	
	    var notAssociative = !isAssociative(a);
	
	    if (isOrdered(a)) {
	      var entries = a.entries();
	      return b.every(function(v, k)  {
	        var entry = entries.next().value;
	        return entry && is(entry[1], v) && (notAssociative || is(entry[0], k));
	      }) && entries.next().done;
	    }
	
	    var flipped = false;
	
	    if (a.size === undefined) {
	      if (b.size === undefined) {
	        if (typeof a.cacheResult === 'function') {
	          a.cacheResult();
	        }
	      } else {
	        flipped = true;
	        var _ = a;
	        a = b;
	        b = _;
	      }
	    }
	
	    var allEqual = true;
	    var bSize = b.__iterate(function(v, k)  {
	      if (notAssociative ? !a.has(v) :
	          flipped ? !is(v, a.get(k, NOT_SET)) : !is(a.get(k, NOT_SET), v)) {
	        allEqual = false;
	        return false;
	      }
	    });
	
	    return allEqual && a.size === bSize;
	  }
	
	  createClass(Repeat, IndexedSeq);
	
	    function Repeat(value, times) {
	      if (!(this instanceof Repeat)) {
	        return new Repeat(value, times);
	      }
	      this._value = value;
	      this.size = times === undefined ? Infinity : Math.max(0, times);
	      if (this.size === 0) {
	        if (EMPTY_REPEAT) {
	          return EMPTY_REPEAT;
	        }
	        EMPTY_REPEAT = this;
	      }
	    }
	
	    Repeat.prototype.toString = function() {
	      if (this.size === 0) {
	        return 'Repeat []';
	      }
	      return 'Repeat [ ' + this._value + ' ' + this.size + ' times ]';
	    };
	
	    Repeat.prototype.get = function(index, notSetValue) {
	      return this.has(index) ? this._value : notSetValue;
	    };
	
	    Repeat.prototype.includes = function(searchValue) {
	      return is(this._value, searchValue);
	    };
	
	    Repeat.prototype.slice = function(begin, end) {
	      var size = this.size;
	      return wholeSlice(begin, end, size) ? this :
	        new Repeat(this._value, resolveEnd(end, size) - resolveBegin(begin, size));
	    };
	
	    Repeat.prototype.reverse = function() {
	      return this;
	    };
	
	    Repeat.prototype.indexOf = function(searchValue) {
	      if (is(this._value, searchValue)) {
	        return 0;
	      }
	      return -1;
	    };
	
	    Repeat.prototype.lastIndexOf = function(searchValue) {
	      if (is(this._value, searchValue)) {
	        return this.size;
	      }
	      return -1;
	    };
	
	    Repeat.prototype.__iterate = function(fn, reverse) {
	      for (var ii = 0; ii < this.size; ii++) {
	        if (fn(this._value, ii, this) === false) {
	          return ii + 1;
	        }
	      }
	      return ii;
	    };
	
	    Repeat.prototype.__iterator = function(type, reverse) {var this$0 = this;
	      var ii = 0;
	      return new Iterator(function() 
	        {return ii < this$0.size ? iteratorValue(type, ii++, this$0._value) : iteratorDone()}
	      );
	    };
	
	    Repeat.prototype.equals = function(other) {
	      return other instanceof Repeat ?
	        is(this._value, other._value) :
	        deepEqual(other);
	    };
	
	
	  var EMPTY_REPEAT;
	
	  function invariant(condition, error) {
	    if (!condition) throw new Error(error);
	  }
	
	  createClass(Range, IndexedSeq);
	
	    function Range(start, end, step) {
	      if (!(this instanceof Range)) {
	        return new Range(start, end, step);
	      }
	      invariant(step !== 0, 'Cannot step a Range by 0');
	      start = start || 0;
	      if (end === undefined) {
	        end = Infinity;
	      }
	      step = step === undefined ? 1 : Math.abs(step);
	      if (end < start) {
	        step = -step;
	      }
	      this._start = start;
	      this._end = end;
	      this._step = step;
	      this.size = Math.max(0, Math.ceil((end - start) / step - 1) + 1);
	      if (this.size === 0) {
	        if (EMPTY_RANGE) {
	          return EMPTY_RANGE;
	        }
	        EMPTY_RANGE = this;
	      }
	    }
	
	    Range.prototype.toString = function() {
	      if (this.size === 0) {
	        return 'Range []';
	      }
	      return 'Range [ ' +
	        this._start + '...' + this._end +
	        (this._step > 1 ? ' by ' + this._step : '') +
	      ' ]';
	    };
	
	    Range.prototype.get = function(index, notSetValue) {
	      return this.has(index) ?
	        this._start + wrapIndex(this, index) * this._step :
	        notSetValue;
	    };
	
	    Range.prototype.includes = function(searchValue) {
	      var possibleIndex = (searchValue - this._start) / this._step;
	      return possibleIndex >= 0 &&
	        possibleIndex < this.size &&
	        possibleIndex === Math.floor(possibleIndex);
	    };
	
	    Range.prototype.slice = function(begin, end) {
	      if (wholeSlice(begin, end, this.size)) {
	        return this;
	      }
	      begin = resolveBegin(begin, this.size);
	      end = resolveEnd(end, this.size);
	      if (end <= begin) {
	        return new Range(0, 0);
	      }
	      return new Range(this.get(begin, this._end), this.get(end, this._end), this._step);
	    };
	
	    Range.prototype.indexOf = function(searchValue) {
	      var offsetValue = searchValue - this._start;
	      if (offsetValue % this._step === 0) {
	        var index = offsetValue / this._step;
	        if (index >= 0 && index < this.size) {
	          return index
	        }
	      }
	      return -1;
	    };
	
	    Range.prototype.lastIndexOf = function(searchValue) {
	      return this.indexOf(searchValue);
	    };
	
	    Range.prototype.__iterate = function(fn, reverse) {
	      var maxIndex = this.size - 1;
	      var step = this._step;
	      var value = reverse ? this._start + maxIndex * step : this._start;
	      for (var ii = 0; ii <= maxIndex; ii++) {
	        if (fn(value, ii, this) === false) {
	          return ii + 1;
	        }
	        value += reverse ? -step : step;
	      }
	      return ii;
	    };
	
	    Range.prototype.__iterator = function(type, reverse) {
	      var maxIndex = this.size - 1;
	      var step = this._step;
	      var value = reverse ? this._start + maxIndex * step : this._start;
	      var ii = 0;
	      return new Iterator(function()  {
	        var v = value;
	        value += reverse ? -step : step;
	        return ii > maxIndex ? iteratorDone() : iteratorValue(type, ii++, v);
	      });
	    };
	
	    Range.prototype.equals = function(other) {
	      return other instanceof Range ?
	        this._start === other._start &&
	        this._end === other._end &&
	        this._step === other._step :
	        deepEqual(this, other);
	    };
	
	
	  var EMPTY_RANGE;
	
	  createClass(Collection, Iterable);
	    function Collection() {
	      throw TypeError('Abstract');
	    }
	
	
	  createClass(KeyedCollection, Collection);function KeyedCollection() {}
	
	  createClass(IndexedCollection, Collection);function IndexedCollection() {}
	
	  createClass(SetCollection, Collection);function SetCollection() {}
	
	
	  Collection.Keyed = KeyedCollection;
	  Collection.Indexed = IndexedCollection;
	  Collection.Set = SetCollection;
	
	  var imul =
	    typeof Math.imul === 'function' && Math.imul(0xffffffff, 2) === -2 ?
	    Math.imul :
	    function imul(a, b) {
	      a = a | 0; // int
	      b = b | 0; // int
	      var c = a & 0xffff;
	      var d = b & 0xffff;
	      // Shift by 0 fixes the sign on the high part.
	      return (c * d) + ((((a >>> 16) * d + c * (b >>> 16)) << 16) >>> 0) | 0; // int
	    };
	
	  // v8 has an optimization for storing 31-bit signed numbers.
	  // Values which have either 00 or 11 as the high order bits qualify.
	  // This function drops the highest order bit in a signed number, maintaining
	  // the sign bit.
	  function smi(i32) {
	    return ((i32 >>> 1) & 0x40000000) | (i32 & 0xBFFFFFFF);
	  }
	
	  function hash(o) {
	    if (o === false || o === null || o === undefined) {
	      return 0;
	    }
	    if (typeof o.valueOf === 'function') {
	      o = o.valueOf();
	      if (o === false || o === null || o === undefined) {
	        return 0;
	      }
	    }
	    if (o === true) {
	      return 1;
	    }
	    var type = typeof o;
	    if (type === 'number') {
	      var h = o | 0;
	      if (h !== o) {
	        h ^= o * 0xFFFFFFFF;
	      }
	      while (o > 0xFFFFFFFF) {
	        o /= 0xFFFFFFFF;
	        h ^= o;
	      }
	      return smi(h);
	    }
	    if (type === 'string') {
	      return o.length > STRING_HASH_CACHE_MIN_STRLEN ? cachedHashString(o) : hashString(o);
	    }
	    if (typeof o.hashCode === 'function') {
	      return o.hashCode();
	    }
	    if (type === 'object') {
	      return hashJSObj(o);
	    }
	    if (typeof o.toString === 'function') {
	      return hashString(o.toString());
	    }
	    throw new Error('Value type ' + type + ' cannot be hashed.');
	  }
	
	  function cachedHashString(string) {
	    var hash = stringHashCache[string];
	    if (hash === undefined) {
	      hash = hashString(string);
	      if (STRING_HASH_CACHE_SIZE === STRING_HASH_CACHE_MAX_SIZE) {
	        STRING_HASH_CACHE_SIZE = 0;
	        stringHashCache = {};
	      }
	      STRING_HASH_CACHE_SIZE++;
	      stringHashCache[string] = hash;
	    }
	    return hash;
	  }
	
	  // http://jsperf.com/hashing-strings
	  function hashString(string) {
	    // This is the hash from JVM
	    // The hash code for a string is computed as
	    // s[0] * 31 ^ (n - 1) + s[1] * 31 ^ (n - 2) + ... + s[n - 1],
	    // where s[i] is the ith character of the string and n is the length of
	    // the string. We "mod" the result to make it between 0 (inclusive) and 2^31
	    // (exclusive) by dropping high bits.
	    var hash = 0;
	    for (var ii = 0; ii < string.length; ii++) {
	      hash = 31 * hash + string.charCodeAt(ii) | 0;
	    }
	    return smi(hash);
	  }
	
	  function hashJSObj(obj) {
	    var hash;
	    if (usingWeakMap) {
	      hash = weakMap.get(obj);
	      if (hash !== undefined) {
	        return hash;
	      }
	    }
	
	    hash = obj[UID_HASH_KEY];
	    if (hash !== undefined) {
	      return hash;
	    }
	
	    if (!canDefineProperty) {
	      hash = obj.propertyIsEnumerable && obj.propertyIsEnumerable[UID_HASH_KEY];
	      if (hash !== undefined) {
	        return hash;
	      }
	
	      hash = getIENodeHash(obj);
	      if (hash !== undefined) {
	        return hash;
	      }
	    }
	
	    hash = ++objHashUID;
	    if (objHashUID & 0x40000000) {
	      objHashUID = 0;
	    }
	
	    if (usingWeakMap) {
	      weakMap.set(obj, hash);
	    } else if (isExtensible !== undefined && isExtensible(obj) === false) {
	      throw new Error('Non-extensible objects are not allowed as keys.');
	    } else if (canDefineProperty) {
	      Object.defineProperty(obj, UID_HASH_KEY, {
	        'enumerable': false,
	        'configurable': false,
	        'writable': false,
	        'value': hash
	      });
	    } else if (obj.propertyIsEnumerable !== undefined &&
	               obj.propertyIsEnumerable === obj.constructor.prototype.propertyIsEnumerable) {
	      // Since we can't define a non-enumerable property on the object
	      // we'll hijack one of the less-used non-enumerable properties to
	      // save our hash on it. Since this is a function it will not show up in
	      // `JSON.stringify` which is what we want.
	      obj.propertyIsEnumerable = function() {
	        return this.constructor.prototype.propertyIsEnumerable.apply(this, arguments);
	      };
	      obj.propertyIsEnumerable[UID_HASH_KEY] = hash;
	    } else if (obj.nodeType !== undefined) {
	      // At this point we couldn't get the IE `uniqueID` to use as a hash
	      // and we couldn't use a non-enumerable property to exploit the
	      // dontEnum bug so we simply add the `UID_HASH_KEY` on the node
	      // itself.
	      obj[UID_HASH_KEY] = hash;
	    } else {
	      throw new Error('Unable to set a non-enumerable property on object.');
	    }
	
	    return hash;
	  }
	
	  // Get references to ES5 object methods.
	  var isExtensible = Object.isExtensible;
	
	  // True if Object.defineProperty works as expected. IE8 fails this test.
	  var canDefineProperty = (function() {
	    try {
	      Object.defineProperty({}, '@', {});
	      return true;
	    } catch (e) {
	      return false;
	    }
	  }());
	
	  // IE has a `uniqueID` property on DOM nodes. We can construct the hash from it
	  // and avoid memory leaks from the IE cloneNode bug.
	  function getIENodeHash(node) {
	    if (node && node.nodeType > 0) {
	      switch (node.nodeType) {
	        case 1: // Element
	          return node.uniqueID;
	        case 9: // Document
	          return node.documentElement && node.documentElement.uniqueID;
	      }
	    }
	  }
	
	  // If possible, use a WeakMap.
	  var usingWeakMap = typeof WeakMap === 'function';
	  var weakMap;
	  if (usingWeakMap) {
	    weakMap = new WeakMap();
	  }
	
	  var objHashUID = 0;
	
	  var UID_HASH_KEY = '__immutablehash__';
	  if (typeof Symbol === 'function') {
	    UID_HASH_KEY = Symbol(UID_HASH_KEY);
	  }
	
	  var STRING_HASH_CACHE_MIN_STRLEN = 16;
	  var STRING_HASH_CACHE_MAX_SIZE = 255;
	  var STRING_HASH_CACHE_SIZE = 0;
	  var stringHashCache = {};
	
	  function assertNotInfinite(size) {
	    invariant(
	      size !== Infinity,
	      'Cannot perform this action with an infinite size.'
	    );
	  }
	
	  createClass(Map, KeyedCollection);
	
	    // @pragma Construction
	
	    function Map(value) {
	      return value === null || value === undefined ? emptyMap() :
	        isMap(value) && !isOrdered(value) ? value :
	        emptyMap().withMutations(function(map ) {
	          var iter = KeyedIterable(value);
	          assertNotInfinite(iter.size);
	          iter.forEach(function(v, k)  {return map.set(k, v)});
	        });
	    }
	
	    Map.prototype.toString = function() {
	      return this.__toString('Map {', '}');
	    };
	
	    // @pragma Access
	
	    Map.prototype.get = function(k, notSetValue) {
	      return this._root ?
	        this._root.get(0, undefined, k, notSetValue) :
	        notSetValue;
	    };
	
	    // @pragma Modification
	
	    Map.prototype.set = function(k, v) {
	      return updateMap(this, k, v);
	    };
	
	    Map.prototype.setIn = function(keyPath, v) {
	      return this.updateIn(keyPath, NOT_SET, function()  {return v});
	    };
	
	    Map.prototype.remove = function(k) {
	      return updateMap(this, k, NOT_SET);
	    };
	
	    Map.prototype.deleteIn = function(keyPath) {
	      return this.updateIn(keyPath, function()  {return NOT_SET});
	    };
	
	    Map.prototype.update = function(k, notSetValue, updater) {
	      return arguments.length === 1 ?
	        k(this) :
	        this.updateIn([k], notSetValue, updater);
	    };
	
	    Map.prototype.updateIn = function(keyPath, notSetValue, updater) {
	      if (!updater) {
	        updater = notSetValue;
	        notSetValue = undefined;
	      }
	      var updatedValue = updateInDeepMap(
	        this,
	        forceIterator(keyPath),
	        notSetValue,
	        updater
	      );
	      return updatedValue === NOT_SET ? undefined : updatedValue;
	    };
	
	    Map.prototype.clear = function() {
	      if (this.size === 0) {
	        return this;
	      }
	      if (this.__ownerID) {
	        this.size = 0;
	        this._root = null;
	        this.__hash = undefined;
	        this.__altered = true;
	        return this;
	      }
	      return emptyMap();
	    };
	
	    // @pragma Composition
	
	    Map.prototype.merge = function(/*...iters*/) {
	      return mergeIntoMapWith(this, undefined, arguments);
	    };
	
	    Map.prototype.mergeWith = function(merger) {var iters = SLICE$0.call(arguments, 1);
	      return mergeIntoMapWith(this, merger, iters);
	    };
	
	    Map.prototype.mergeIn = function(keyPath) {var iters = SLICE$0.call(arguments, 1);
	      return this.updateIn(
	        keyPath,
	        emptyMap(),
	        function(m ) {return typeof m.merge === 'function' ?
	          m.merge.apply(m, iters) :
	          iters[iters.length - 1]}
	      );
	    };
	
	    Map.prototype.mergeDeep = function(/*...iters*/) {
	      return mergeIntoMapWith(this, deepMerger, arguments);
	    };
	
	    Map.prototype.mergeDeepWith = function(merger) {var iters = SLICE$0.call(arguments, 1);
	      return mergeIntoMapWith(this, deepMergerWith(merger), iters);
	    };
	
	    Map.prototype.mergeDeepIn = function(keyPath) {var iters = SLICE$0.call(arguments, 1);
	      return this.updateIn(
	        keyPath,
	        emptyMap(),
	        function(m ) {return typeof m.mergeDeep === 'function' ?
	          m.mergeDeep.apply(m, iters) :
	          iters[iters.length - 1]}
	      );
	    };
	
	    Map.prototype.sort = function(comparator) {
	      // Late binding
	      return OrderedMap(sortFactory(this, comparator));
	    };
	
	    Map.prototype.sortBy = function(mapper, comparator) {
	      // Late binding
	      return OrderedMap(sortFactory(this, comparator, mapper));
	    };
	
	    // @pragma Mutability
	
	    Map.prototype.withMutations = function(fn) {
	      var mutable = this.asMutable();
	      fn(mutable);
	      return mutable.wasAltered() ? mutable.__ensureOwner(this.__ownerID) : this;
	    };
	
	    Map.prototype.asMutable = function() {
	      return this.__ownerID ? this : this.__ensureOwner(new OwnerID());
	    };
	
	    Map.prototype.asImmutable = function() {
	      return this.__ensureOwner();
	    };
	
	    Map.prototype.wasAltered = function() {
	      return this.__altered;
	    };
	
	    Map.prototype.__iterator = function(type, reverse) {
	      return new MapIterator(this, type, reverse);
	    };
	
	    Map.prototype.__iterate = function(fn, reverse) {var this$0 = this;
	      var iterations = 0;
	      this._root && this._root.iterate(function(entry ) {
	        iterations++;
	        return fn(entry[1], entry[0], this$0);
	      }, reverse);
	      return iterations;
	    };
	
	    Map.prototype.__ensureOwner = function(ownerID) {
	      if (ownerID === this.__ownerID) {
	        return this;
	      }
	      if (!ownerID) {
	        this.__ownerID = ownerID;
	        this.__altered = false;
	        return this;
	      }
	      return makeMap(this.size, this._root, ownerID, this.__hash);
	    };
	
	
	  function isMap(maybeMap) {
	    return !!(maybeMap && maybeMap[IS_MAP_SENTINEL]);
	  }
	
	  Map.isMap = isMap;
	
	  var IS_MAP_SENTINEL = '@@__IMMUTABLE_MAP__@@';
	
	  var MapPrototype = Map.prototype;
	  MapPrototype[IS_MAP_SENTINEL] = true;
	  MapPrototype[DELETE] = MapPrototype.remove;
	  MapPrototype.removeIn = MapPrototype.deleteIn;
	
	
	  // #pragma Trie Nodes
	
	
	
	    function ArrayMapNode(ownerID, entries) {
	      this.ownerID = ownerID;
	      this.entries = entries;
	    }
	
	    ArrayMapNode.prototype.get = function(shift, keyHash, key, notSetValue) {
	      var entries = this.entries;
	      for (var ii = 0, len = entries.length; ii < len; ii++) {
	        if (is(key, entries[ii][0])) {
	          return entries[ii][1];
	        }
	      }
	      return notSetValue;
	    };
	
	    ArrayMapNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {
	      var removed = value === NOT_SET;
	
	      var entries = this.entries;
	      var idx = 0;
	      for (var len = entries.length; idx < len; idx++) {
	        if (is(key, entries[idx][0])) {
	          break;
	        }
	      }
	      var exists = idx < len;
	
	      if (exists ? entries[idx][1] === value : removed) {
	        return this;
	      }
	
	      SetRef(didAlter);
	      (removed || !exists) && SetRef(didChangeSize);
	
	      if (removed && entries.length === 1) {
	        return; // undefined
	      }
	
	      if (!exists && !removed && entries.length >= MAX_ARRAY_MAP_SIZE) {
	        return createNodes(ownerID, entries, key, value);
	      }
	
	      var isEditable = ownerID && ownerID === this.ownerID;
	      var newEntries = isEditable ? entries : arrCopy(entries);
	
	      if (exists) {
	        if (removed) {
	          idx === len - 1 ? newEntries.pop() : (newEntries[idx] = newEntries.pop());
	        } else {
	          newEntries[idx] = [key, value];
	        }
	      } else {
	        newEntries.push([key, value]);
	      }
	
	      if (isEditable) {
	        this.entries = newEntries;
	        return this;
	      }
	
	      return new ArrayMapNode(ownerID, newEntries);
	    };
	
	
	
	
	    function BitmapIndexedNode(ownerID, bitmap, nodes) {
	      this.ownerID = ownerID;
	      this.bitmap = bitmap;
	      this.nodes = nodes;
	    }
	
	    BitmapIndexedNode.prototype.get = function(shift, keyHash, key, notSetValue) {
	      if (keyHash === undefined) {
	        keyHash = hash(key);
	      }
	      var bit = (1 << ((shift === 0 ? keyHash : keyHash >>> shift) & MASK));
	      var bitmap = this.bitmap;
	      return (bitmap & bit) === 0 ? notSetValue :
	        this.nodes[popCount(bitmap & (bit - 1))].get(shift + SHIFT, keyHash, key, notSetValue);
	    };
	
	    BitmapIndexedNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {
	      if (keyHash === undefined) {
	        keyHash = hash(key);
	      }
	      var keyHashFrag = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;
	      var bit = 1 << keyHashFrag;
	      var bitmap = this.bitmap;
	      var exists = (bitmap & bit) !== 0;
	
	      if (!exists && value === NOT_SET) {
	        return this;
	      }
	
	      var idx = popCount(bitmap & (bit - 1));
	      var nodes = this.nodes;
	      var node = exists ? nodes[idx] : undefined;
	      var newNode = updateNode(node, ownerID, shift + SHIFT, keyHash, key, value, didChangeSize, didAlter);
	
	      if (newNode === node) {
	        return this;
	      }
	
	      if (!exists && newNode && nodes.length >= MAX_BITMAP_INDEXED_SIZE) {
	        return expandNodes(ownerID, nodes, bitmap, keyHashFrag, newNode);
	      }
	
	      if (exists && !newNode && nodes.length === 2 && isLeafNode(nodes[idx ^ 1])) {
	        return nodes[idx ^ 1];
	      }
	
	      if (exists && newNode && nodes.length === 1 && isLeafNode(newNode)) {
	        return newNode;
	      }
	
	      var isEditable = ownerID && ownerID === this.ownerID;
	      var newBitmap = exists ? newNode ? bitmap : bitmap ^ bit : bitmap | bit;
	      var newNodes = exists ? newNode ?
	        setIn(nodes, idx, newNode, isEditable) :
	        spliceOut(nodes, idx, isEditable) :
	        spliceIn(nodes, idx, newNode, isEditable);
	
	      if (isEditable) {
	        this.bitmap = newBitmap;
	        this.nodes = newNodes;
	        return this;
	      }
	
	      return new BitmapIndexedNode(ownerID, newBitmap, newNodes);
	    };
	
	
	
	
	    function HashArrayMapNode(ownerID, count, nodes) {
	      this.ownerID = ownerID;
	      this.count = count;
	      this.nodes = nodes;
	    }
	
	    HashArrayMapNode.prototype.get = function(shift, keyHash, key, notSetValue) {
	      if (keyHash === undefined) {
	        keyHash = hash(key);
	      }
	      var idx = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;
	      var node = this.nodes[idx];
	      return node ? node.get(shift + SHIFT, keyHash, key, notSetValue) : notSetValue;
	    };
	
	    HashArrayMapNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {
	      if (keyHash === undefined) {
	        keyHash = hash(key);
	      }
	      var idx = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;
	      var removed = value === NOT_SET;
	      var nodes = this.nodes;
	      var node = nodes[idx];
	
	      if (removed && !node) {
	        return this;
	      }
	
	      var newNode = updateNode(node, ownerID, shift + SHIFT, keyHash, key, value, didChangeSize, didAlter);
	      if (newNode === node) {
	        return this;
	      }
	
	      var newCount = this.count;
	      if (!node) {
	        newCount++;
	      } else if (!newNode) {
	        newCount--;
	        if (newCount < MIN_HASH_ARRAY_MAP_SIZE) {
	          return packNodes(ownerID, nodes, newCount, idx);
	        }
	      }
	
	      var isEditable = ownerID && ownerID === this.ownerID;
	      var newNodes = setIn(nodes, idx, newNode, isEditable);
	
	      if (isEditable) {
	        this.count = newCount;
	        this.nodes = newNodes;
	        return this;
	      }
	
	      return new HashArrayMapNode(ownerID, newCount, newNodes);
	    };
	
	
	
	
	    function HashCollisionNode(ownerID, keyHash, entries) {
	      this.ownerID = ownerID;
	      this.keyHash = keyHash;
	      this.entries = entries;
	    }
	
	    HashCollisionNode.prototype.get = function(shift, keyHash, key, notSetValue) {
	      var entries = this.entries;
	      for (var ii = 0, len = entries.length; ii < len; ii++) {
	        if (is(key, entries[ii][0])) {
	          return entries[ii][1];
	        }
	      }
	      return notSetValue;
	    };
	
	    HashCollisionNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {
	      if (keyHash === undefined) {
	        keyHash = hash(key);
	      }
	
	      var removed = value === NOT_SET;
	
	      if (keyHash !== this.keyHash) {
	        if (removed) {
	          return this;
	        }
	        SetRef(didAlter);
	        SetRef(didChangeSize);
	        return mergeIntoNode(this, ownerID, shift, keyHash, [key, value]);
	      }
	
	      var entries = this.entries;
	      var idx = 0;
	      for (var len = entries.length; idx < len; idx++) {
	        if (is(key, entries[idx][0])) {
	          break;
	        }
	      }
	      var exists = idx < len;
	
	      if (exists ? entries[idx][1] === value : removed) {
	        return this;
	      }
	
	      SetRef(didAlter);
	      (removed || !exists) && SetRef(didChangeSize);
	
	      if (removed && len === 2) {
	        return new ValueNode(ownerID, this.keyHash, entries[idx ^ 1]);
	      }
	
	      var isEditable = ownerID && ownerID === this.ownerID;
	      var newEntries = isEditable ? entries : arrCopy(entries);
	
	      if (exists) {
	        if (removed) {
	          idx === len - 1 ? newEntries.pop() : (newEntries[idx] = newEntries.pop());
	        } else {
	          newEntries[idx] = [key, value];
	        }
	      } else {
	        newEntries.push([key, value]);
	      }
	
	      if (isEditable) {
	        this.entries = newEntries;
	        return this;
	      }
	
	      return new HashCollisionNode(ownerID, this.keyHash, newEntries);
	    };
	
	
	
	
	    function ValueNode(ownerID, keyHash, entry) {
	      this.ownerID = ownerID;
	      this.keyHash = keyHash;
	      this.entry = entry;
	    }
	
	    ValueNode.prototype.get = function(shift, keyHash, key, notSetValue) {
	      return is(key, this.entry[0]) ? this.entry[1] : notSetValue;
	    };
	
	    ValueNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {
	      var removed = value === NOT_SET;
	      var keyMatch = is(key, this.entry[0]);
	      if (keyMatch ? value === this.entry[1] : removed) {
	        return this;
	      }
	
	      SetRef(didAlter);
	
	      if (removed) {
	        SetRef(didChangeSize);
	        return; // undefined
	      }
	
	      if (keyMatch) {
	        if (ownerID && ownerID === this.ownerID) {
	          this.entry[1] = value;
	          return this;
	        }
	        return new ValueNode(ownerID, this.keyHash, [key, value]);
	      }
	
	      SetRef(didChangeSize);
	      return mergeIntoNode(this, ownerID, shift, hash(key), [key, value]);
	    };
	
	
	
	  // #pragma Iterators
	
	  ArrayMapNode.prototype.iterate =
	  HashCollisionNode.prototype.iterate = function (fn, reverse) {
	    var entries = this.entries;
	    for (var ii = 0, maxIndex = entries.length - 1; ii <= maxIndex; ii++) {
	      if (fn(entries[reverse ? maxIndex - ii : ii]) === false) {
	        return false;
	      }
	    }
	  }
	
	  BitmapIndexedNode.prototype.iterate =
	  HashArrayMapNode.prototype.iterate = function (fn, reverse) {
	    var nodes = this.nodes;
	    for (var ii = 0, maxIndex = nodes.length - 1; ii <= maxIndex; ii++) {
	      var node = nodes[reverse ? maxIndex - ii : ii];
	      if (node && node.iterate(fn, reverse) === false) {
	        return false;
	      }
	    }
	  }
	
	  ValueNode.prototype.iterate = function (fn, reverse) {
	    return fn(this.entry);
	  }
	
	  createClass(MapIterator, Iterator);
	
	    function MapIterator(map, type, reverse) {
	      this._type = type;
	      this._reverse = reverse;
	      this._stack = map._root && mapIteratorFrame(map._root);
	    }
	
	    MapIterator.prototype.next = function() {
	      var type = this._type;
	      var stack = this._stack;
	      while (stack) {
	        var node = stack.node;
	        var index = stack.index++;
	        var maxIndex;
	        if (node.entry) {
	          if (index === 0) {
	            return mapIteratorValue(type, node.entry);
	          }
	        } else if (node.entries) {
	          maxIndex = node.entries.length - 1;
	          if (index <= maxIndex) {
	            return mapIteratorValue(type, node.entries[this._reverse ? maxIndex - index : index]);
	          }
	        } else {
	          maxIndex = node.nodes.length - 1;
	          if (index <= maxIndex) {
	            var subNode = node.nodes[this._reverse ? maxIndex - index : index];
	            if (subNode) {
	              if (subNode.entry) {
	                return mapIteratorValue(type, subNode.entry);
	              }
	              stack = this._stack = mapIteratorFrame(subNode, stack);
	            }
	            continue;
	          }
	        }
	        stack = this._stack = this._stack.__prev;
	      }
	      return iteratorDone();
	    };
	
	
	  function mapIteratorValue(type, entry) {
	    return iteratorValue(type, entry[0], entry[1]);
	  }
	
	  function mapIteratorFrame(node, prev) {
	    return {
	      node: node,
	      index: 0,
	      __prev: prev
	    };
	  }
	
	  function makeMap(size, root, ownerID, hash) {
	    var map = Object.create(MapPrototype);
	    map.size = size;
	    map._root = root;
	    map.__ownerID = ownerID;
	    map.__hash = hash;
	    map.__altered = false;
	    return map;
	  }
	
	  var EMPTY_MAP;
	  function emptyMap() {
	    return EMPTY_MAP || (EMPTY_MAP = makeMap(0));
	  }
	
	  function updateMap(map, k, v) {
	    var newRoot;
	    var newSize;
	    if (!map._root) {
	      if (v === NOT_SET) {
	        return map;
	      }
	      newSize = 1;
	      newRoot = new ArrayMapNode(map.__ownerID, [[k, v]]);
	    } else {
	      var didChangeSize = MakeRef(CHANGE_LENGTH);
	      var didAlter = MakeRef(DID_ALTER);
	      newRoot = updateNode(map._root, map.__ownerID, 0, undefined, k, v, didChangeSize, didAlter);
	      if (!didAlter.value) {
	        return map;
	      }
	      newSize = map.size + (didChangeSize.value ? v === NOT_SET ? -1 : 1 : 0);
	    }
	    if (map.__ownerID) {
	      map.size = newSize;
	      map._root = newRoot;
	      map.__hash = undefined;
	      map.__altered = true;
	      return map;
	    }
	    return newRoot ? makeMap(newSize, newRoot) : emptyMap();
	  }
	
	  function updateNode(node, ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {
	    if (!node) {
	      if (value === NOT_SET) {
	        return node;
	      }
	      SetRef(didAlter);
	      SetRef(didChangeSize);
	      return new ValueNode(ownerID, keyHash, [key, value]);
	    }
	    return node.update(ownerID, shift, keyHash, key, value, didChangeSize, didAlter);
	  }
	
	  function isLeafNode(node) {
	    return node.constructor === ValueNode || node.constructor === HashCollisionNode;
	  }
	
	  function mergeIntoNode(node, ownerID, shift, keyHash, entry) {
	    if (node.keyHash === keyHash) {
	      return new HashCollisionNode(ownerID, keyHash, [node.entry, entry]);
	    }
	
	    var idx1 = (shift === 0 ? node.keyHash : node.keyHash >>> shift) & MASK;
	    var idx2 = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;
	
	    var newNode;
	    var nodes = idx1 === idx2 ?
	      [mergeIntoNode(node, ownerID, shift + SHIFT, keyHash, entry)] :
	      ((newNode = new ValueNode(ownerID, keyHash, entry)), idx1 < idx2 ? [node, newNode] : [newNode, node]);
	
	    return new BitmapIndexedNode(ownerID, (1 << idx1) | (1 << idx2), nodes);
	  }
	
	  function createNodes(ownerID, entries, key, value) {
	    if (!ownerID) {
	      ownerID = new OwnerID();
	    }
	    var node = new ValueNode(ownerID, hash(key), [key, value]);
	    for (var ii = 0; ii < entries.length; ii++) {
	      var entry = entries[ii];
	      node = node.update(ownerID, 0, undefined, entry[0], entry[1]);
	    }
	    return node;
	  }
	
	  function packNodes(ownerID, nodes, count, excluding) {
	    var bitmap = 0;
	    var packedII = 0;
	    var packedNodes = new Array(count);
	    for (var ii = 0, bit = 1, len = nodes.length; ii < len; ii++, bit <<= 1) {
	      var node = nodes[ii];
	      if (node !== undefined && ii !== excluding) {
	        bitmap |= bit;
	        packedNodes[packedII++] = node;
	      }
	    }
	    return new BitmapIndexedNode(ownerID, bitmap, packedNodes);
	  }
	
	  function expandNodes(ownerID, nodes, bitmap, including, node) {
	    var count = 0;
	    var expandedNodes = new Array(SIZE);
	    for (var ii = 0; bitmap !== 0; ii++, bitmap >>>= 1) {
	      expandedNodes[ii] = bitmap & 1 ? nodes[count++] : undefined;
	    }
	    expandedNodes[including] = node;
	    return new HashArrayMapNode(ownerID, count + 1, expandedNodes);
	  }
	
	  function mergeIntoMapWith(map, merger, iterables) {
	    var iters = [];
	    for (var ii = 0; ii < iterables.length; ii++) {
	      var value = iterables[ii];
	      var iter = KeyedIterable(value);
	      if (!isIterable(value)) {
	        iter = iter.map(function(v ) {return fromJS(v)});
	      }
	      iters.push(iter);
	    }
	    return mergeIntoCollectionWith(map, merger, iters);
	  }
	
	  function deepMerger(existing, value, key) {
	    return existing && existing.mergeDeep && isIterable(value) ?
	      existing.mergeDeep(value) :
	      is(existing, value) ? existing : value;
	  }
	
	  function deepMergerWith(merger) {
	    return function(existing, value, key)  {
	      if (existing && existing.mergeDeepWith && isIterable(value)) {
	        return existing.mergeDeepWith(merger, value);
	      }
	      var nextValue = merger(existing, value, key);
	      return is(existing, nextValue) ? existing : nextValue;
	    };
	  }
	
	  function mergeIntoCollectionWith(collection, merger, iters) {
	    iters = iters.filter(function(x ) {return x.size !== 0});
	    if (iters.length === 0) {
	      return collection;
	    }
	    if (collection.size === 0 && !collection.__ownerID && iters.length === 1) {
	      return collection.constructor(iters[0]);
	    }
	    return collection.withMutations(function(collection ) {
	      var mergeIntoMap = merger ?
	        function(value, key)  {
	          collection.update(key, NOT_SET, function(existing )
	            {return existing === NOT_SET ? value : merger(existing, value, key)}
	          );
	        } :
	        function(value, key)  {
	          collection.set(key, value);
	        }
	      for (var ii = 0; ii < iters.length; ii++) {
	        iters[ii].forEach(mergeIntoMap);
	      }
	    });
	  }
	
	  function updateInDeepMap(existing, keyPathIter, notSetValue, updater) {
	    var isNotSet = existing === NOT_SET;
	    var step = keyPathIter.next();
	    if (step.done) {
	      var existingValue = isNotSet ? notSetValue : existing;
	      var newValue = updater(existingValue);
	      return newValue === existingValue ? existing : newValue;
	    }
	    invariant(
	      isNotSet || (existing && existing.set),
	      'invalid keyPath'
	    );
	    var key = step.value;
	    var nextExisting = isNotSet ? NOT_SET : existing.get(key, NOT_SET);
	    var nextUpdated = updateInDeepMap(
	      nextExisting,
	      keyPathIter,
	      notSetValue,
	      updater
	    );
	    return nextUpdated === nextExisting ? existing :
	      nextUpdated === NOT_SET ? existing.remove(key) :
	      (isNotSet ? emptyMap() : existing).set(key, nextUpdated);
	  }
	
	  function popCount(x) {
	    x = x - ((x >> 1) & 0x55555555);
	    x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
	    x = (x + (x >> 4)) & 0x0f0f0f0f;
	    x = x + (x >> 8);
	    x = x + (x >> 16);
	    return x & 0x7f;
	  }
	
	  function setIn(array, idx, val, canEdit) {
	    var newArray = canEdit ? array : arrCopy(array);
	    newArray[idx] = val;
	    return newArray;
	  }
	
	  function spliceIn(array, idx, val, canEdit) {
	    var newLen = array.length + 1;
	    if (canEdit && idx + 1 === newLen) {
	      array[idx] = val;
	      return array;
	    }
	    var newArray = new Array(newLen);
	    var after = 0;
	    for (var ii = 0; ii < newLen; ii++) {
	      if (ii === idx) {
	        newArray[ii] = val;
	        after = -1;
	      } else {
	        newArray[ii] = array[ii + after];
	      }
	    }
	    return newArray;
	  }
	
	  function spliceOut(array, idx, canEdit) {
	    var newLen = array.length - 1;
	    if (canEdit && idx === newLen) {
	      array.pop();
	      return array;
	    }
	    var newArray = new Array(newLen);
	    var after = 0;
	    for (var ii = 0; ii < newLen; ii++) {
	      if (ii === idx) {
	        after = 1;
	      }
	      newArray[ii] = array[ii + after];
	    }
	    return newArray;
	  }
	
	  var MAX_ARRAY_MAP_SIZE = SIZE / 4;
	  var MAX_BITMAP_INDEXED_SIZE = SIZE / 2;
	  var MIN_HASH_ARRAY_MAP_SIZE = SIZE / 4;
	
	  createClass(List, IndexedCollection);
	
	    // @pragma Construction
	
	    function List(value) {
	      var empty = emptyList();
	      if (value === null || value === undefined) {
	        return empty;
	      }
	      if (isList(value)) {
	        return value;
	      }
	      var iter = IndexedIterable(value);
	      var size = iter.size;
	      if (size === 0) {
	        return empty;
	      }
	      assertNotInfinite(size);
	      if (size > 0 && size < SIZE) {
	        return makeList(0, size, SHIFT, null, new VNode(iter.toArray()));
	      }
	      return empty.withMutations(function(list ) {
	        list.setSize(size);
	        iter.forEach(function(v, i)  {return list.set(i, v)});
	      });
	    }
	
	    List.of = function(/*...values*/) {
	      return this(arguments);
	    };
	
	    List.prototype.toString = function() {
	      return this.__toString('List [', ']');
	    };
	
	    // @pragma Access
	
	    List.prototype.get = function(index, notSetValue) {
	      index = wrapIndex(this, index);
	      if (index >= 0 && index < this.size) {
	        index += this._origin;
	        var node = listNodeFor(this, index);
	        return node && node.array[index & MASK];
	      }
	      return notSetValue;
	    };
	
	    // @pragma Modification
	
	    List.prototype.set = function(index, value) {
	      return updateList(this, index, value);
	    };
	
	    List.prototype.remove = function(index) {
	      return !this.has(index) ? this :
	        index === 0 ? this.shift() :
	        index === this.size - 1 ? this.pop() :
	        this.splice(index, 1);
	    };
	
	    List.prototype.insert = function(index, value) {
	      return this.splice(index, 0, value);
	    };
	
	    List.prototype.clear = function() {
	      if (this.size === 0) {
	        return this;
	      }
	      if (this.__ownerID) {
	        this.size = this._origin = this._capacity = 0;
	        this._level = SHIFT;
	        this._root = this._tail = null;
	        this.__hash = undefined;
	        this.__altered = true;
	        return this;
	      }
	      return emptyList();
	    };
	
	    List.prototype.push = function(/*...values*/) {
	      var values = arguments;
	      var oldSize = this.size;
	      return this.withMutations(function(list ) {
	        setListBounds(list, 0, oldSize + values.length);
	        for (var ii = 0; ii < values.length; ii++) {
	          list.set(oldSize + ii, values[ii]);
	        }
	      });
	    };
	
	    List.prototype.pop = function() {
	      return setListBounds(this, 0, -1);
	    };
	
	    List.prototype.unshift = function(/*...values*/) {
	      var values = arguments;
	      return this.withMutations(function(list ) {
	        setListBounds(list, -values.length);
	        for (var ii = 0; ii < values.length; ii++) {
	          list.set(ii, values[ii]);
	        }
	      });
	    };
	
	    List.prototype.shift = function() {
	      return setListBounds(this, 1);
	    };
	
	    // @pragma Composition
	
	    List.prototype.merge = function(/*...iters*/) {
	      return mergeIntoListWith(this, undefined, arguments);
	    };
	
	    List.prototype.mergeWith = function(merger) {var iters = SLICE$0.call(arguments, 1);
	      return mergeIntoListWith(this, merger, iters);
	    };
	
	    List.prototype.mergeDeep = function(/*...iters*/) {
	      return mergeIntoListWith(this, deepMerger, arguments);
	    };
	
	    List.prototype.mergeDeepWith = function(merger) {var iters = SLICE$0.call(arguments, 1);
	      return mergeIntoListWith(this, deepMergerWith(merger), iters);
	    };
	
	    List.prototype.setSize = function(size) {
	      return setListBounds(this, 0, size);
	    };
	
	    // @pragma Iteration
	
	    List.prototype.slice = function(begin, end) {
	      var size = this.size;
	      if (wholeSlice(begin, end, size)) {
	        return this;
	      }
	      return setListBounds(
	        this,
	        resolveBegin(begin, size),
	        resolveEnd(end, size)
	      );
	    };
	
	    List.prototype.__iterator = function(type, reverse) {
	      var index = 0;
	      var values = iterateList(this, reverse);
	      return new Iterator(function()  {
	        var value = values();
	        return value === DONE ?
	          iteratorDone() :
	          iteratorValue(type, index++, value);
	      });
	    };
	
	    List.prototype.__iterate = function(fn, reverse) {
	      var index = 0;
	      var values = iterateList(this, reverse);
	      var value;
	      while ((value = values()) !== DONE) {
	        if (fn(value, index++, this) === false) {
	          break;
	        }
	      }
	      return index;
	    };
	
	    List.prototype.__ensureOwner = function(ownerID) {
	      if (ownerID === this.__ownerID) {
	        return this;
	      }
	      if (!ownerID) {
	        this.__ownerID = ownerID;
	        return this;
	      }
	      return makeList(this._origin, this._capacity, this._level, this._root, this._tail, ownerID, this.__hash);
	    };
	
	
	  function isList(maybeList) {
	    return !!(maybeList && maybeList[IS_LIST_SENTINEL]);
	  }
	
	  List.isList = isList;
	
	  var IS_LIST_SENTINEL = '@@__IMMUTABLE_LIST__@@';
	
	  var ListPrototype = List.prototype;
	  ListPrototype[IS_LIST_SENTINEL] = true;
	  ListPrototype[DELETE] = ListPrototype.remove;
	  ListPrototype.setIn = MapPrototype.setIn;
	  ListPrototype.deleteIn =
	  ListPrototype.removeIn = MapPrototype.removeIn;
	  ListPrototype.update = MapPrototype.update;
	  ListPrototype.updateIn = MapPrototype.updateIn;
	  ListPrototype.mergeIn = MapPrototype.mergeIn;
	  ListPrototype.mergeDeepIn = MapPrototype.mergeDeepIn;
	  ListPrototype.withMutations = MapPrototype.withMutations;
	  ListPrototype.asMutable = MapPrototype.asMutable;
	  ListPrototype.asImmutable = MapPrototype.asImmutable;
	  ListPrototype.wasAltered = MapPrototype.wasAltered;
	
	
	
	    function VNode(array, ownerID) {
	      this.array = array;
	      this.ownerID = ownerID;
	    }
	
	    // TODO: seems like these methods are very similar
	
	    VNode.prototype.removeBefore = function(ownerID, level, index) {
	      if (index === level ? 1 << level : 0 || this.array.length === 0) {
	        return this;
	      }
	      var originIndex = (index >>> level) & MASK;
	      if (originIndex >= this.array.length) {
	        return new VNode([], ownerID);
	      }
	      var removingFirst = originIndex === 0;
	      var newChild;
	      if (level > 0) {
	        var oldChild = this.array[originIndex];
	        newChild = oldChild && oldChild.removeBefore(ownerID, level - SHIFT, index);
	        if (newChild === oldChild && removingFirst) {
	          return this;
	        }
	      }
	      if (removingFirst && !newChild) {
	        return this;
	      }
	      var editable = editableVNode(this, ownerID);
	      if (!removingFirst) {
	        for (var ii = 0; ii < originIndex; ii++) {
	          editable.array[ii] = undefined;
	        }
	      }
	      if (newChild) {
	        editable.array[originIndex] = newChild;
	      }
	      return editable;
	    };
	
	    VNode.prototype.removeAfter = function(ownerID, level, index) {
	      if (index === (level ? 1 << level : 0) || this.array.length === 0) {
	        return this;
	      }
	      var sizeIndex = ((index - 1) >>> level) & MASK;
	      if (sizeIndex >= this.array.length) {
	        return this;
	      }
	
	      var newChild;
	      if (level > 0) {
	        var oldChild = this.array[sizeIndex];
	        newChild = oldChild && oldChild.removeAfter(ownerID, level - SHIFT, index);
	        if (newChild === oldChild && sizeIndex === this.array.length - 1) {
	          return this;
	        }
	      }
	
	      var editable = editableVNode(this, ownerID);
	      editable.array.splice(sizeIndex + 1);
	      if (newChild) {
	        editable.array[sizeIndex] = newChild;
	      }
	      return editable;
	    };
	
	
	
	  var DONE = {};
	
	  function iterateList(list, reverse) {
	    var left = list._origin;
	    var right = list._capacity;
	    var tailPos = getTailOffset(right);
	    var tail = list._tail;
	
	    return iterateNodeOrLeaf(list._root, list._level, 0);
	
	    function iterateNodeOrLeaf(node, level, offset) {
	      return level === 0 ?
	        iterateLeaf(node, offset) :
	        iterateNode(node, level, offset);
	    }
	
	    function iterateLeaf(node, offset) {
	      var array = offset === tailPos ? tail && tail.array : node && node.array;
	      var from = offset > left ? 0 : left - offset;
	      var to = right - offset;
	      if (to > SIZE) {
	        to = SIZE;
	      }
	      return function()  {
	        if (from === to) {
	          return DONE;
	        }
	        var idx = reverse ? --to : from++;
	        return array && array[idx];
	      };
	    }
	
	    function iterateNode(node, level, offset) {
	      var values;
	      var array = node && node.array;
	      var from = offset > left ? 0 : (left - offset) >> level;
	      var to = ((right - offset) >> level) + 1;
	      if (to > SIZE) {
	        to = SIZE;
	      }
	      return function()  {
	        do {
	          if (values) {
	            var value = values();
	            if (value !== DONE) {
	              return value;
	            }
	            values = null;
	          }
	          if (from === to) {
	            return DONE;
	          }
	          var idx = reverse ? --to : from++;
	          values = iterateNodeOrLeaf(
	            array && array[idx], level - SHIFT, offset + (idx << level)
	          );
	        } while (true);
	      };
	    }
	  }
	
	  function makeList(origin, capacity, level, root, tail, ownerID, hash) {
	    var list = Object.create(ListPrototype);
	    list.size = capacity - origin;
	    list._origin = origin;
	    list._capacity = capacity;
	    list._level = level;
	    list._root = root;
	    list._tail = tail;
	    list.__ownerID = ownerID;
	    list.__hash = hash;
	    list.__altered = false;
	    return list;
	  }
	
	  var EMPTY_LIST;
	  function emptyList() {
	    return EMPTY_LIST || (EMPTY_LIST = makeList(0, 0, SHIFT));
	  }
	
	  function updateList(list, index, value) {
	    index = wrapIndex(list, index);
	
	    if (index !== index) {
	      return list;
	    }
	
	    if (index >= list.size || index < 0) {
	      return list.withMutations(function(list ) {
	        index < 0 ?
	          setListBounds(list, index).set(0, value) :
	          setListBounds(list, 0, index + 1).set(index, value)
	      });
	    }
	
	    index += list._origin;
	
	    var newTail = list._tail;
	    var newRoot = list._root;
	    var didAlter = MakeRef(DID_ALTER);
	    if (index >= getTailOffset(list._capacity)) {
	      newTail = updateVNode(newTail, list.__ownerID, 0, index, value, didAlter);
	    } else {
	      newRoot = updateVNode(newRoot, list.__ownerID, list._level, index, value, didAlter);
	    }
	
	    if (!didAlter.value) {
	      return list;
	    }
	
	    if (list.__ownerID) {
	      list._root = newRoot;
	      list._tail = newTail;
	      list.__hash = undefined;
	      list.__altered = true;
	      return list;
	    }
	    return makeList(list._origin, list._capacity, list._level, newRoot, newTail);
	  }
	
	  function updateVNode(node, ownerID, level, index, value, didAlter) {
	    var idx = (index >>> level) & MASK;
	    var nodeHas = node && idx < node.array.length;
	    if (!nodeHas && value === undefined) {
	      return node;
	    }
	
	    var newNode;
	
	    if (level > 0) {
	      var lowerNode = node && node.array[idx];
	      var newLowerNode = updateVNode(lowerNode, ownerID, level - SHIFT, index, value, didAlter);
	      if (newLowerNode === lowerNode) {
	        return node;
	      }
	      newNode = editableVNode(node, ownerID);
	      newNode.array[idx] = newLowerNode;
	      return newNode;
	    }
	
	    if (nodeHas && node.array[idx] === value) {
	      return node;
	    }
	
	    SetRef(didAlter);
	
	    newNode = editableVNode(node, ownerID);
	    if (value === undefined && idx === newNode.array.length - 1) {
	      newNode.array.pop();
	    } else {
	      newNode.array[idx] = value;
	    }
	    return newNode;
	  }
	
	  function editableVNode(node, ownerID) {
	    if (ownerID && node && ownerID === node.ownerID) {
	      return node;
	    }
	    return new VNode(node ? node.array.slice() : [], ownerID);
	  }
	
	  function listNodeFor(list, rawIndex) {
	    if (rawIndex >= getTailOffset(list._capacity)) {
	      return list._tail;
	    }
	    if (rawIndex < 1 << (list._level + SHIFT)) {
	      var node = list._root;
	      var level = list._level;
	      while (node && level > 0) {
	        node = node.array[(rawIndex >>> level) & MASK];
	        level -= SHIFT;
	      }
	      return node;
	    }
	  }
	
	  function setListBounds(list, begin, end) {
	    // Sanitize begin & end using this shorthand for ToInt32(argument)
	    // http://www.ecma-international.org/ecma-262/6.0/#sec-toint32
	    if (begin !== undefined) {
	      begin = begin | 0;
	    }
	    if (end !== undefined) {
	      end = end | 0;
	    }
	    var owner = list.__ownerID || new OwnerID();
	    var oldOrigin = list._origin;
	    var oldCapacity = list._capacity;
	    var newOrigin = oldOrigin + begin;
	    var newCapacity = end === undefined ? oldCapacity : end < 0 ? oldCapacity + end : oldOrigin + end;
	    if (newOrigin === oldOrigin && newCapacity === oldCapacity) {
	      return list;
	    }
	
	    // If it's going to end after it starts, it's empty.
	    if (newOrigin >= newCapacity) {
	      return list.clear();
	    }
	
	    var newLevel = list._level;
	    var newRoot = list._root;
	
	    // New origin might need creating a higher root.
	    var offsetShift = 0;
	    while (newOrigin + offsetShift < 0) {
	      newRoot = new VNode(newRoot && newRoot.array.length ? [undefined, newRoot] : [], owner);
	      newLevel += SHIFT;
	      offsetShift += 1 << newLevel;
	    }
	    if (offsetShift) {
	      newOrigin += offsetShift;
	      oldOrigin += offsetShift;
	      newCapacity += offsetShift;
	      oldCapacity += offsetShift;
	    }
	
	    var oldTailOffset = getTailOffset(oldCapacity);
	    var newTailOffset = getTailOffset(newCapacity);
	
	    // New size might need creating a higher root.
	    while (newTailOffset >= 1 << (newLevel + SHIFT)) {
	      newRoot = new VNode(newRoot && newRoot.array.length ? [newRoot] : [], owner);
	      newLevel += SHIFT;
	    }
	
	    // Locate or create the new tail.
	    var oldTail = list._tail;
	    var newTail = newTailOffset < oldTailOffset ?
	      listNodeFor(list, newCapacity - 1) :
	      newTailOffset > oldTailOffset ? new VNode([], owner) : oldTail;
	
	    // Merge Tail into tree.
	    if (oldTail && newTailOffset > oldTailOffset && newOrigin < oldCapacity && oldTail.array.length) {
	      newRoot = editableVNode(newRoot, owner);
	      var node = newRoot;
	      for (var level = newLevel; level > SHIFT; level -= SHIFT) {
	        var idx = (oldTailOffset >>> level) & MASK;
	        node = node.array[idx] = editableVNode(node.array[idx], owner);
	      }
	      node.array[(oldTailOffset >>> SHIFT) & MASK] = oldTail;
	    }
	
	    // If the size has been reduced, there's a chance the tail needs to be trimmed.
	    if (newCapacity < oldCapacity) {
	      newTail = newTail && newTail.removeAfter(owner, 0, newCapacity);
	    }
	
	    // If the new origin is within the tail, then we do not need a root.
	    if (newOrigin >= newTailOffset) {
	      newOrigin -= newTailOffset;
	      newCapacity -= newTailOffset;
	      newLevel = SHIFT;
	      newRoot = null;
	      newTail = newTail && newTail.removeBefore(owner, 0, newOrigin);
	
	    // Otherwise, if the root has been trimmed, garbage collect.
	    } else if (newOrigin > oldOrigin || newTailOffset < oldTailOffset) {
	      offsetShift = 0;
	
	      // Identify the new top root node of the subtree of the old root.
	      while (newRoot) {
	        var beginIndex = (newOrigin >>> newLevel) & MASK;
	        if (beginIndex !== (newTailOffset >>> newLevel) & MASK) {
	          break;
	        }
	        if (beginIndex) {
	          offsetShift += (1 << newLevel) * beginIndex;
	        }
	        newLevel -= SHIFT;
	        newRoot = newRoot.array[beginIndex];
	      }
	
	      // Trim the new sides of the new root.
	      if (newRoot && newOrigin > oldOrigin) {
	        newRoot = newRoot.removeBefore(owner, newLevel, newOrigin - offsetShift);
	      }
	      if (newRoot && newTailOffset < oldTailOffset) {
	        newRoot = newRoot.removeAfter(owner, newLevel, newTailOffset - offsetShift);
	      }
	      if (offsetShift) {
	        newOrigin -= offsetShift;
	        newCapacity -= offsetShift;
	      }
	    }
	
	    if (list.__ownerID) {
	      list.size = newCapacity - newOrigin;
	      list._origin = newOrigin;
	      list._capacity = newCapacity;
	      list._level = newLevel;
	      list._root = newRoot;
	      list._tail = newTail;
	      list.__hash = undefined;
	      list.__altered = true;
	      return list;
	    }
	    return makeList(newOrigin, newCapacity, newLevel, newRoot, newTail);
	  }
	
	  function mergeIntoListWith(list, merger, iterables) {
	    var iters = [];
	    var maxSize = 0;
	    for (var ii = 0; ii < iterables.length; ii++) {
	      var value = iterables[ii];
	      var iter = IndexedIterable(value);
	      if (iter.size > maxSize) {
	        maxSize = iter.size;
	      }
	      if (!isIterable(value)) {
	        iter = iter.map(function(v ) {return fromJS(v)});
	      }
	      iters.push(iter);
	    }
	    if (maxSize > list.size) {
	      list = list.setSize(maxSize);
	    }
	    return mergeIntoCollectionWith(list, merger, iters);
	  }
	
	  function getTailOffset(size) {
	    return size < SIZE ? 0 : (((size - 1) >>> SHIFT) << SHIFT);
	  }
	
	  createClass(OrderedMap, Map);
	
	    // @pragma Construction
	
	    function OrderedMap(value) {
	      return value === null || value === undefined ? emptyOrderedMap() :
	        isOrderedMap(value) ? value :
	        emptyOrderedMap().withMutations(function(map ) {
	          var iter = KeyedIterable(value);
	          assertNotInfinite(iter.size);
	          iter.forEach(function(v, k)  {return map.set(k, v)});
	        });
	    }
	
	    OrderedMap.of = function(/*...values*/) {
	      return this(arguments);
	    };
	
	    OrderedMap.prototype.toString = function() {
	      return this.__toString('OrderedMap {', '}');
	    };
	
	    // @pragma Access
	
	    OrderedMap.prototype.get = function(k, notSetValue) {
	      var index = this._map.get(k);
	      return index !== undefined ? this._list.get(index)[1] : notSetValue;
	    };
	
	    // @pragma Modification
	
	    OrderedMap.prototype.clear = function() {
	      if (this.size === 0) {
	        return this;
	      }
	      if (this.__ownerID) {
	        this.size = 0;
	        this._map.clear();
	        this._list.clear();
	        return this;
	      }
	      return emptyOrderedMap();
	    };
	
	    OrderedMap.prototype.set = function(k, v) {
	      return updateOrderedMap(this, k, v);
	    };
	
	    OrderedMap.prototype.remove = function(k) {
	      return updateOrderedMap(this, k, NOT_SET);
	    };
	
	    OrderedMap.prototype.wasAltered = function() {
	      return this._map.wasAltered() || this._list.wasAltered();
	    };
	
	    OrderedMap.prototype.__iterate = function(fn, reverse) {var this$0 = this;
	      return this._list.__iterate(
	        function(entry ) {return entry && fn(entry[1], entry[0], this$0)},
	        reverse
	      );
	    };
	
	    OrderedMap.prototype.__iterator = function(type, reverse) {
	      return this._list.fromEntrySeq().__iterator(type, reverse);
	    };
	
	    OrderedMap.prototype.__ensureOwner = function(ownerID) {
	      if (ownerID === this.__ownerID) {
	        return this;
	      }
	      var newMap = this._map.__ensureOwner(ownerID);
	      var newList = this._list.__ensureOwner(ownerID);
	      if (!ownerID) {
	        this.__ownerID = ownerID;
	        this._map = newMap;
	        this._list = newList;
	        return this;
	      }
	      return makeOrderedMap(newMap, newList, ownerID, this.__hash);
	    };
	
	
	  function isOrderedMap(maybeOrderedMap) {
	    return isMap(maybeOrderedMap) && isOrdered(maybeOrderedMap);
	  }
	
	  OrderedMap.isOrderedMap = isOrderedMap;
	
	  OrderedMap.prototype[IS_ORDERED_SENTINEL] = true;
	  OrderedMap.prototype[DELETE] = OrderedMap.prototype.remove;
	
	
	
	  function makeOrderedMap(map, list, ownerID, hash) {
	    var omap = Object.create(OrderedMap.prototype);
	    omap.size = map ? map.size : 0;
	    omap._map = map;
	    omap._list = list;
	    omap.__ownerID = ownerID;
	    omap.__hash = hash;
	    return omap;
	  }
	
	  var EMPTY_ORDERED_MAP;
	  function emptyOrderedMap() {
	    return EMPTY_ORDERED_MAP || (EMPTY_ORDERED_MAP = makeOrderedMap(emptyMap(), emptyList()));
	  }
	
	  function updateOrderedMap(omap, k, v) {
	    var map = omap._map;
	    var list = omap._list;
	    var i = map.get(k);
	    var has = i !== undefined;
	    var newMap;
	    var newList;
	    if (v === NOT_SET) { // removed
	      if (!has) {
	        return omap;
	      }
	      if (list.size >= SIZE && list.size >= map.size * 2) {
	        newList = list.filter(function(entry, idx)  {return entry !== undefined && i !== idx});
	        newMap = newList.toKeyedSeq().map(function(entry ) {return entry[0]}).flip().toMap();
	        if (omap.__ownerID) {
	          newMap.__ownerID = newList.__ownerID = omap.__ownerID;
	        }
	      } else {
	        newMap = map.remove(k);
	        newList = i === list.size - 1 ? list.pop() : list.set(i, undefined);
	      }
	    } else {
	      if (has) {
	        if (v === list.get(i)[1]) {
	          return omap;
	        }
	        newMap = map;
	        newList = list.set(i, [k, v]);
	      } else {
	        newMap = map.set(k, list.size);
	        newList = list.set(list.size, [k, v]);
	      }
	    }
	    if (omap.__ownerID) {
	      omap.size = newMap.size;
	      omap._map = newMap;
	      omap._list = newList;
	      omap.__hash = undefined;
	      return omap;
	    }
	    return makeOrderedMap(newMap, newList);
	  }
	
	  createClass(ToKeyedSequence, KeyedSeq);
	    function ToKeyedSequence(indexed, useKeys) {
	      this._iter = indexed;
	      this._useKeys = useKeys;
	      this.size = indexed.size;
	    }
	
	    ToKeyedSequence.prototype.get = function(key, notSetValue) {
	      return this._iter.get(key, notSetValue);
	    };
	
	    ToKeyedSequence.prototype.has = function(key) {
	      return this._iter.has(key);
	    };
	
	    ToKeyedSequence.prototype.valueSeq = function() {
	      return this._iter.valueSeq();
	    };
	
	    ToKeyedSequence.prototype.reverse = function() {var this$0 = this;
	      var reversedSequence = reverseFactory(this, true);
	      if (!this._useKeys) {
	        reversedSequence.valueSeq = function()  {return this$0._iter.toSeq().reverse()};
	      }
	      return reversedSequence;
	    };
	
	    ToKeyedSequence.prototype.map = function(mapper, context) {var this$0 = this;
	      var mappedSequence = mapFactory(this, mapper, context);
	      if (!this._useKeys) {
	        mappedSequence.valueSeq = function()  {return this$0._iter.toSeq().map(mapper, context)};
	      }
	      return mappedSequence;
	    };
	
	    ToKeyedSequence.prototype.__iterate = function(fn, reverse) {var this$0 = this;
	      var ii;
	      return this._iter.__iterate(
	        this._useKeys ?
	          function(v, k)  {return fn(v, k, this$0)} :
	          ((ii = reverse ? resolveSize(this) : 0),
	            function(v ) {return fn(v, reverse ? --ii : ii++, this$0)}),
	        reverse
	      );
	    };
	
	    ToKeyedSequence.prototype.__iterator = function(type, reverse) {
	      if (this._useKeys) {
	        return this._iter.__iterator(type, reverse);
	      }
	      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);
	      var ii = reverse ? resolveSize(this) : 0;
	      return new Iterator(function()  {
	        var step = iterator.next();
	        return step.done ? step :
	          iteratorValue(type, reverse ? --ii : ii++, step.value, step);
	      });
	    };
	
	  ToKeyedSequence.prototype[IS_ORDERED_SENTINEL] = true;
	
	
	  createClass(ToIndexedSequence, IndexedSeq);
	    function ToIndexedSequence(iter) {
	      this._iter = iter;
	      this.size = iter.size;
	    }
	
	    ToIndexedSequence.prototype.includes = function(value) {
	      return this._iter.includes(value);
	    };
	
	    ToIndexedSequence.prototype.__iterate = function(fn, reverse) {var this$0 = this;
	      var iterations = 0;
	      return this._iter.__iterate(function(v ) {return fn(v, iterations++, this$0)}, reverse);
	    };
	
	    ToIndexedSequence.prototype.__iterator = function(type, reverse) {
	      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);
	      var iterations = 0;
	      return new Iterator(function()  {
	        var step = iterator.next();
	        return step.done ? step :
	          iteratorValue(type, iterations++, step.value, step)
	      });
	    };
	
	
	
	  createClass(ToSetSequence, SetSeq);
	    function ToSetSequence(iter) {
	      this._iter = iter;
	      this.size = iter.size;
	    }
	
	    ToSetSequence.prototype.has = function(key) {
	      return this._iter.includes(key);
	    };
	
	    ToSetSequence.prototype.__iterate = function(fn, reverse) {var this$0 = this;
	      return this._iter.__iterate(function(v ) {return fn(v, v, this$0)}, reverse);
	    };
	
	    ToSetSequence.prototype.__iterator = function(type, reverse) {
	      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);
	      return new Iterator(function()  {
	        var step = iterator.next();
	        return step.done ? step :
	          iteratorValue(type, step.value, step.value, step);
	      });
	    };
	
	
	
	  createClass(FromEntriesSequence, KeyedSeq);
	    function FromEntriesSequence(entries) {
	      this._iter = entries;
	      this.size = entries.size;
	    }
	
	    FromEntriesSequence.prototype.entrySeq = function() {
	      return this._iter.toSeq();
	    };
	
	    FromEntriesSequence.prototype.__iterate = function(fn, reverse) {var this$0 = this;
	      return this._iter.__iterate(function(entry ) {
	        // Check if entry exists first so array access doesn't throw for holes
	        // in the parent iteration.
	        if (entry) {
	          validateEntry(entry);
	          var indexedIterable = isIterable(entry);
	          return fn(
	            indexedIterable ? entry.get(1) : entry[1],
	            indexedIterable ? entry.get(0) : entry[0],
	            this$0
	          );
	        }
	      }, reverse);
	    };
	
	    FromEntriesSequence.prototype.__iterator = function(type, reverse) {
	      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);
	      return new Iterator(function()  {
	        while (true) {
	          var step = iterator.next();
	          if (step.done) {
	            return step;
	          }
	          var entry = step.value;
	          // Check if entry exists first so array access doesn't throw for holes
	          // in the parent iteration.
	          if (entry) {
	            validateEntry(entry);
	            var indexedIterable = isIterable(entry);
	            return iteratorValue(
	              type,
	              indexedIterable ? entry.get(0) : entry[0],
	              indexedIterable ? entry.get(1) : entry[1],
	              step
	            );
	          }
	        }
	      });
	    };
	
	
	  ToIndexedSequence.prototype.cacheResult =
	  ToKeyedSequence.prototype.cacheResult =
	  ToSetSequence.prototype.cacheResult =
	  FromEntriesSequence.prototype.cacheResult =
	    cacheResultThrough;
	
	
	  function flipFactory(iterable) {
	    var flipSequence = makeSequence(iterable);
	    flipSequence._iter = iterable;
	    flipSequence.size = iterable.size;
	    flipSequence.flip = function()  {return iterable};
	    flipSequence.reverse = function () {
	      var reversedSequence = iterable.reverse.apply(this); // super.reverse()
	      reversedSequence.flip = function()  {return iterable.reverse()};
	      return reversedSequence;
	    };
	    flipSequence.has = function(key ) {return iterable.includes(key)};
	    flipSequence.includes = function(key ) {return iterable.has(key)};
	    flipSequence.cacheResult = cacheResultThrough;
	    flipSequence.__iterateUncached = function (fn, reverse) {var this$0 = this;
	      return iterable.__iterate(function(v, k)  {return fn(k, v, this$0) !== false}, reverse);
	    }
	    flipSequence.__iteratorUncached = function(type, reverse) {
	      if (type === ITERATE_ENTRIES) {
	        var iterator = iterable.__iterator(type, reverse);
	        return new Iterator(function()  {
	          var step = iterator.next();
	          if (!step.done) {
	            var k = step.value[0];
	            step.value[0] = step.value[1];
	            step.value[1] = k;
	          }
	          return step;
	        });
	      }
	      return iterable.__iterator(
	        type === ITERATE_VALUES ? ITERATE_KEYS : ITERATE_VALUES,
	        reverse
	      );
	    }
	    return flipSequence;
	  }
	
	
	  function mapFactory(iterable, mapper, context) {
	    var mappedSequence = makeSequence(iterable);
	    mappedSequence.size = iterable.size;
	    mappedSequence.has = function(key ) {return iterable.has(key)};
	    mappedSequence.get = function(key, notSetValue)  {
	      var v = iterable.get(key, NOT_SET);
	      return v === NOT_SET ?
	        notSetValue :
	        mapper.call(context, v, key, iterable);
	    };
	    mappedSequence.__iterateUncached = function (fn, reverse) {var this$0 = this;
	      return iterable.__iterate(
	        function(v, k, c)  {return fn(mapper.call(context, v, k, c), k, this$0) !== false},
	        reverse
	      );
	    }
	    mappedSequence.__iteratorUncached = function (type, reverse) {
	      var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse);
	      return new Iterator(function()  {
	        var step = iterator.next();
	        if (step.done) {
	          return step;
	        }
	        var entry = step.value;
	        var key = entry[0];
	        return iteratorValue(
	          type,
	          key,
	          mapper.call(context, entry[1], key, iterable),
	          step
	        );
	      });
	    }
	    return mappedSequence;
	  }
	
	
	  function reverseFactory(iterable, useKeys) {
	    var reversedSequence = makeSequence(iterable);
	    reversedSequence._iter = iterable;
	    reversedSequence.size = iterable.size;
	    reversedSequence.reverse = function()  {return iterable};
	    if (iterable.flip) {
	      reversedSequence.flip = function () {
	        var flipSequence = flipFactory(iterable);
	        flipSequence.reverse = function()  {return iterable.flip()};
	        return flipSequence;
	      };
	    }
	    reversedSequence.get = function(key, notSetValue) 
	      {return iterable.get(useKeys ? key : -1 - key, notSetValue)};
	    reversedSequence.has = function(key )
	      {return iterable.has(useKeys ? key : -1 - key)};
	    reversedSequence.includes = function(value ) {return iterable.includes(value)};
	    reversedSequence.cacheResult = cacheResultThrough;
	    reversedSequence.__iterate = function (fn, reverse) {var this$0 = this;
	      return iterable.__iterate(function(v, k)  {return fn(v, k, this$0)}, !reverse);
	    };
	    reversedSequence.__iterator =
	      function(type, reverse)  {return iterable.__iterator(type, !reverse)};
	    return reversedSequence;
	  }
	
	
	  function filterFactory(iterable, predicate, context, useKeys) {
	    var filterSequence = makeSequence(iterable);
	    if (useKeys) {
	      filterSequence.has = function(key ) {
	        var v = iterable.get(key, NOT_SET);
	        return v !== NOT_SET && !!predicate.call(context, v, key, iterable);
	      };
	      filterSequence.get = function(key, notSetValue)  {
	        var v = iterable.get(key, NOT_SET);
	        return v !== NOT_SET && predicate.call(context, v, key, iterable) ?
	          v : notSetValue;
	      };
	    }
	    filterSequence.__iterateUncached = function (fn, reverse) {var this$0 = this;
	      var iterations = 0;
	      iterable.__iterate(function(v, k, c)  {
	        if (predicate.call(context, v, k, c)) {
	          iterations++;
	          return fn(v, useKeys ? k : iterations - 1, this$0);
	        }
	      }, reverse);
	      return iterations;
	    };
	    filterSequence.__iteratorUncached = function (type, reverse) {
	      var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse);
	      var iterations = 0;
	      return new Iterator(function()  {
	        while (true) {
	          var step = iterator.next();
	          if (step.done) {
	            return step;
	          }
	          var entry = step.value;
	          var key = entry[0];
	          var value = entry[1];
	          if (predicate.call(context, value, key, iterable)) {
	            return iteratorValue(type, useKeys ? key : iterations++, value, step);
	          }
	        }
	      });
	    }
	    return filterSequence;
	  }
	
	
	  function countByFactory(iterable, grouper, context) {
	    var groups = Map().asMutable();
	    iterable.__iterate(function(v, k)  {
	      groups.update(
	        grouper.call(context, v, k, iterable),
	        0,
	        function(a ) {return a + 1}
	      );
	    });
	    return groups.asImmutable();
	  }
	
	
	  function groupByFactory(iterable, grouper, context) {
	    var isKeyedIter = isKeyed(iterable);
	    var groups = (isOrdered(iterable) ? OrderedMap() : Map()).asMutable();
	    iterable.__iterate(function(v, k)  {
	      groups.update(
	        grouper.call(context, v, k, iterable),
	        function(a ) {return (a = a || [], a.push(isKeyedIter ? [k, v] : v), a)}
	      );
	    });
	    var coerce = iterableClass(iterable);
	    return groups.map(function(arr ) {return reify(iterable, coerce(arr))});
	  }
	
	
	  function sliceFactory(iterable, begin, end, useKeys) {
	    var originalSize = iterable.size;
	
	    // Sanitize begin & end using this shorthand for ToInt32(argument)
	    // http://www.ecma-international.org/ecma-262/6.0/#sec-toint32
	    if (begin !== undefined) {
	      begin = begin | 0;
	    }
	    if (end !== undefined) {
	      end = end | 0;
	    }
	
	    if (wholeSlice(begin, end, originalSize)) {
	      return iterable;
	    }
	
	    var resolvedBegin = resolveBegin(begin, originalSize);
	    var resolvedEnd = resolveEnd(end, originalSize);
	
	    // begin or end will be NaN if they were provided as negative numbers and
	    // this iterable's size is unknown. In that case, cache first so there is
	    // a known size and these do not resolve to NaN.
	    if (resolvedBegin !== resolvedBegin || resolvedEnd !== resolvedEnd) {
	      return sliceFactory(iterable.toSeq().cacheResult(), begin, end, useKeys);
	    }
	
	    // Note: resolvedEnd is undefined when the original sequence's length is
	    // unknown and this slice did not supply an end and should contain all
	    // elements after resolvedBegin.
	    // In that case, resolvedSize will be NaN and sliceSize will remain undefined.
	    var resolvedSize = resolvedEnd - resolvedBegin;
	    var sliceSize;
	    if (resolvedSize === resolvedSize) {
	      sliceSize = resolvedSize < 0 ? 0 : resolvedSize;
	    }
	
	    var sliceSeq = makeSequence(iterable);
	
	    // If iterable.size is undefined, the size of the realized sliceSeq is
	    // unknown at this point unless the number of items to slice is 0
	    sliceSeq.size = sliceSize === 0 ? sliceSize : iterable.size && sliceSize || undefined;
	
	    if (!useKeys && isSeq(iterable) && sliceSize >= 0) {
	      sliceSeq.get = function (index, notSetValue) {
	        index = wrapIndex(this, index);
	        return index >= 0 && index < sliceSize ?
	          iterable.get(index + resolvedBegin, notSetValue) :
	          notSetValue;
	      }
	    }
	
	    sliceSeq.__iterateUncached = function(fn, reverse) {var this$0 = this;
	      if (sliceSize === 0) {
	        return 0;
	      }
	      if (reverse) {
	        return this.cacheResult().__iterate(fn, reverse);
	      }
	      var skipped = 0;
	      var isSkipping = true;
	      var iterations = 0;
	      iterable.__iterate(function(v, k)  {
	        if (!(isSkipping && (isSkipping = skipped++ < resolvedBegin))) {
	          iterations++;
	          return fn(v, useKeys ? k : iterations - 1, this$0) !== false &&
	                 iterations !== sliceSize;
	        }
	      });
	      return iterations;
	    };
	
	    sliceSeq.__iteratorUncached = function(type, reverse) {
	      if (sliceSize !== 0 && reverse) {
	        return this.cacheResult().__iterator(type, reverse);
	      }
	      // Don't bother instantiating parent iterator if taking 0.
	      var iterator = sliceSize !== 0 && iterable.__iterator(type, reverse);
	      var skipped = 0;
	      var iterations = 0;
	      return new Iterator(function()  {
	        while (skipped++ < resolvedBegin) {
	          iterator.next();
	        }
	        if (++iterations > sliceSize) {
	          return iteratorDone();
	        }
	        var step = iterator.next();
	        if (useKeys || type === ITERATE_VALUES) {
	          return step;
	        } else if (type === ITERATE_KEYS) {
	          return iteratorValue(type, iterations - 1, undefined, step);
	        } else {
	          return iteratorValue(type, iterations - 1, step.value[1], step);
	        }
	      });
	    }
	
	    return sliceSeq;
	  }
	
	
	  function takeWhileFactory(iterable, predicate, context) {
	    var takeSequence = makeSequence(iterable);
	    takeSequence.__iterateUncached = function(fn, reverse) {var this$0 = this;
	      if (reverse) {
	        return this.cacheResult().__iterate(fn, reverse);
	      }
	      var iterations = 0;
	      iterable.__iterate(function(v, k, c) 
	        {return predicate.call(context, v, k, c) && ++iterations && fn(v, k, this$0)}
	      );
	      return iterations;
	    };
	    takeSequence.__iteratorUncached = function(type, reverse) {var this$0 = this;
	      if (reverse) {
	        return this.cacheResult().__iterator(type, reverse);
	      }
	      var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse);
	      var iterating = true;
	      return new Iterator(function()  {
	        if (!iterating) {
	          return iteratorDone();
	        }
	        var step = iterator.next();
	        if (step.done) {
	          return step;
	        }
	        var entry = step.value;
	        var k = entry[0];
	        var v = entry[1];
	        if (!predicate.call(context, v, k, this$0)) {
	          iterating = false;
	          return iteratorDone();
	        }
	        return type === ITERATE_ENTRIES ? step :
	          iteratorValue(type, k, v, step);
	      });
	    };
	    return takeSequence;
	  }
	
	
	  function skipWhileFactory(iterable, predicate, context, useKeys) {
	    var skipSequence = makeSequence(iterable);
	    skipSequence.__iterateUncached = function (fn, reverse) {var this$0 = this;
	      if (reverse) {
	        return this.cacheResult().__iterate(fn, reverse);
	      }
	      var isSkipping = true;
	      var iterations = 0;
	      iterable.__iterate(function(v, k, c)  {
	        if (!(isSkipping && (isSkipping = predicate.call(context, v, k, c)))) {
	          iterations++;
	          return fn(v, useKeys ? k : iterations - 1, this$0);
	        }
	      });
	      return iterations;
	    };
	    skipSequence.__iteratorUncached = function(type, reverse) {var this$0 = this;
	      if (reverse) {
	        return this.cacheResult().__iterator(type, reverse);
	      }
	      var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse);
	      var skipping = true;
	      var iterations = 0;
	      return new Iterator(function()  {
	        var step, k, v;
	        do {
	          step = iterator.next();
	          if (step.done) {
	            if (useKeys || type === ITERATE_VALUES) {
	              return step;
	            } else if (type === ITERATE_KEYS) {
	              return iteratorValue(type, iterations++, undefined, step);
	            } else {
	              return iteratorValue(type, iterations++, step.value[1], step);
	            }
	          }
	          var entry = step.value;
	          k = entry[0];
	          v = entry[1];
	          skipping && (skipping = predicate.call(context, v, k, this$0));
	        } while (skipping);
	        return type === ITERATE_ENTRIES ? step :
	          iteratorValue(type, k, v, step);
	      });
	    };
	    return skipSequence;
	  }
	
	
	  function concatFactory(iterable, values) {
	    var isKeyedIterable = isKeyed(iterable);
	    var iters = [iterable].concat(values).map(function(v ) {
	      if (!isIterable(v)) {
	        v = isKeyedIterable ?
	          keyedSeqFromValue(v) :
	          indexedSeqFromValue(Array.isArray(v) ? v : [v]);
	      } else if (isKeyedIterable) {
	        v = KeyedIterable(v);
	      }
	      return v;
	    }).filter(function(v ) {return v.size !== 0});
	
	    if (iters.length === 0) {
	      return iterable;
	    }
	
	    if (iters.length === 1) {
	      var singleton = iters[0];
	      if (singleton === iterable ||
	          isKeyedIterable && isKeyed(singleton) ||
	          isIndexed(iterable) && isIndexed(singleton)) {
	        return singleton;
	      }
	    }
	
	    var concatSeq = new ArraySeq(iters);
	    if (isKeyedIterable) {
	      concatSeq = concatSeq.toKeyedSeq();
	    } else if (!isIndexed(iterable)) {
	      concatSeq = concatSeq.toSetSeq();
	    }
	    concatSeq = concatSeq.flatten(true);
	    concatSeq.size = iters.reduce(
	      function(sum, seq)  {
	        if (sum !== undefined) {
	          var size = seq.size;
	          if (size !== undefined) {
	            return sum + size;
	          }
	        }
	      },
	      0
	    );
	    return concatSeq;
	  }
	
	
	  function flattenFactory(iterable, depth, useKeys) {
	    var flatSequence = makeSequence(iterable);
	    flatSequence.__iterateUncached = function(fn, reverse) {
	      var iterations = 0;
	      var stopped = false;
	      function flatDeep(iter, currentDepth) {var this$0 = this;
	        iter.__iterate(function(v, k)  {
	          if ((!depth || currentDepth < depth) && isIterable(v)) {
	            flatDeep(v, currentDepth + 1);
	          } else if (fn(v, useKeys ? k : iterations++, this$0) === false) {
	            stopped = true;
	          }
	          return !stopped;
	        }, reverse);
	      }
	      flatDeep(iterable, 0);
	      return iterations;
	    }
	    flatSequence.__iteratorUncached = function(type, reverse) {
	      var iterator = iterable.__iterator(type, reverse);
	      var stack = [];
	      var iterations = 0;
	      return new Iterator(function()  {
	        while (iterator) {
	          var step = iterator.next();
	          if (step.done !== false) {
	            iterator = stack.pop();
	            continue;
	          }
	          var v = step.value;
	          if (type === ITERATE_ENTRIES) {
	            v = v[1];
	          }
	          if ((!depth || stack.length < depth) && isIterable(v)) {
	            stack.push(iterator);
	            iterator = v.__iterator(type, reverse);
	          } else {
	            return useKeys ? step : iteratorValue(type, iterations++, v, step);
	          }
	        }
	        return iteratorDone();
	      });
	    }
	    return flatSequence;
	  }
	
	
	  function flatMapFactory(iterable, mapper, context) {
	    var coerce = iterableClass(iterable);
	    return iterable.toSeq().map(
	      function(v, k)  {return coerce(mapper.call(context, v, k, iterable))}
	    ).flatten(true);
	  }
	
	
	  function interposeFactory(iterable, separator) {
	    var interposedSequence = makeSequence(iterable);
	    interposedSequence.size = iterable.size && iterable.size * 2 -1;
	    interposedSequence.__iterateUncached = function(fn, reverse) {var this$0 = this;
	      var iterations = 0;
	      iterable.__iterate(function(v, k) 
	        {return (!iterations || fn(separator, iterations++, this$0) !== false) &&
	        fn(v, iterations++, this$0) !== false},
	        reverse
	      );
	      return iterations;
	    };
	    interposedSequence.__iteratorUncached = function(type, reverse) {
	      var iterator = iterable.__iterator(ITERATE_VALUES, reverse);
	      var iterations = 0;
	      var step;
	      return new Iterator(function()  {
	        if (!step || iterations % 2) {
	          step = iterator.next();
	          if (step.done) {
	            return step;
	          }
	        }
	        return iterations % 2 ?
	          iteratorValue(type, iterations++, separator) :
	          iteratorValue(type, iterations++, step.value, step);
	      });
	    };
	    return interposedSequence;
	  }
	
	
	  function sortFactory(iterable, comparator, mapper) {
	    if (!comparator) {
	      comparator = defaultComparator;
	    }
	    var isKeyedIterable = isKeyed(iterable);
	    var index = 0;
	    var entries = iterable.toSeq().map(
	      function(v, k)  {return [k, v, index++, mapper ? mapper(v, k, iterable) : v]}
	    ).toArray();
	    entries.sort(function(a, b)  {return comparator(a[3], b[3]) || a[2] - b[2]}).forEach(
	      isKeyedIterable ?
	      function(v, i)  { entries[i].length = 2; } :
	      function(v, i)  { entries[i] = v[1]; }
	    );
	    return isKeyedIterable ? KeyedSeq(entries) :
	      isIndexed(iterable) ? IndexedSeq(entries) :
	      SetSeq(entries);
	  }
	
	
	  function maxFactory(iterable, comparator, mapper) {
	    if (!comparator) {
	      comparator = defaultComparator;
	    }
	    if (mapper) {
	      var entry = iterable.toSeq()
	        .map(function(v, k)  {return [v, mapper(v, k, iterable)]})
	        .reduce(function(a, b)  {return maxCompare(comparator, a[1], b[1]) ? b : a});
	      return entry && entry[0];
	    } else {
	      return iterable.reduce(function(a, b)  {return maxCompare(comparator, a, b) ? b : a});
	    }
	  }
	
	  function maxCompare(comparator, a, b) {
	    var comp = comparator(b, a);
	    // b is considered the new max if the comparator declares them equal, but
	    // they are not equal and b is in fact a nullish value.
	    return (comp === 0 && b !== a && (b === undefined || b === null || b !== b)) || comp > 0;
	  }
	
	
	  function zipWithFactory(keyIter, zipper, iters) {
	    var zipSequence = makeSequence(keyIter);
	    zipSequence.size = new ArraySeq(iters).map(function(i ) {return i.size}).min();
	    // Note: this a generic base implementation of __iterate in terms of
	    // __iterator which may be more generically useful in the future.
	    zipSequence.__iterate = function(fn, reverse) {
	      /* generic:
	      var iterator = this.__iterator(ITERATE_ENTRIES, reverse);
	      var step;
	      var iterations = 0;
	      while (!(step = iterator.next()).done) {
	        iterations++;
	        if (fn(step.value[1], step.value[0], this) === false) {
	          break;
	        }
	      }
	      return iterations;
	      */
	      // indexed:
	      var iterator = this.__iterator(ITERATE_VALUES, reverse);
	      var step;
	      var iterations = 0;
	      while (!(step = iterator.next()).done) {
	        if (fn(step.value, iterations++, this) === false) {
	          break;
	        }
	      }
	      return iterations;
	    };
	    zipSequence.__iteratorUncached = function(type, reverse) {
	      var iterators = iters.map(function(i )
	        {return (i = Iterable(i), getIterator(reverse ? i.reverse() : i))}
	      );
	      var iterations = 0;
	      var isDone = false;
	      return new Iterator(function()  {
	        var steps;
	        if (!isDone) {
	          steps = iterators.map(function(i ) {return i.next()});
	          isDone = steps.some(function(s ) {return s.done});
	        }
	        if (isDone) {
	          return iteratorDone();
	        }
	        return iteratorValue(
	          type,
	          iterations++,
	          zipper.apply(null, steps.map(function(s ) {return s.value}))
	        );
	      });
	    };
	    return zipSequence
	  }
	
	
	  // #pragma Helper Functions
	
	  function reify(iter, seq) {
	    return isSeq(iter) ? seq : iter.constructor(seq);
	  }
	
	  function validateEntry(entry) {
	    if (entry !== Object(entry)) {
	      throw new TypeError('Expected [K, V] tuple: ' + entry);
	    }
	  }
	
	  function resolveSize(iter) {
	    assertNotInfinite(iter.size);
	    return ensureSize(iter);
	  }
	
	  function iterableClass(iterable) {
	    return isKeyed(iterable) ? KeyedIterable :
	      isIndexed(iterable) ? IndexedIterable :
	      SetIterable;
	  }
	
	  function makeSequence(iterable) {
	    return Object.create(
	      (
	        isKeyed(iterable) ? KeyedSeq :
	        isIndexed(iterable) ? IndexedSeq :
	        SetSeq
	      ).prototype
	    );
	  }
	
	  function cacheResultThrough() {
	    if (this._iter.cacheResult) {
	      this._iter.cacheResult();
	      this.size = this._iter.size;
	      return this;
	    } else {
	      return Seq.prototype.cacheResult.call(this);
	    }
	  }
	
	  function defaultComparator(a, b) {
	    return a > b ? 1 : a < b ? -1 : 0;
	  }
	
	  function forceIterator(keyPath) {
	    var iter = getIterator(keyPath);
	    if (!iter) {
	      // Array might not be iterable in this environment, so we need a fallback
	      // to our wrapped type.
	      if (!isArrayLike(keyPath)) {
	        throw new TypeError('Expected iterable or array-like: ' + keyPath);
	      }
	      iter = getIterator(Iterable(keyPath));
	    }
	    return iter;
	  }
	
	  createClass(Record, KeyedCollection);
	
	    function Record(defaultValues, name) {
	      var hasInitialized;
	
	      var RecordType = function Record(values) {
	        if (values instanceof RecordType) {
	          return values;
	        }
	        if (!(this instanceof RecordType)) {
	          return new RecordType(values);
	        }
	        if (!hasInitialized) {
	          hasInitialized = true;
	          var keys = Object.keys(defaultValues);
	          setProps(RecordTypePrototype, keys);
	          RecordTypePrototype.size = keys.length;
	          RecordTypePrototype._name = name;
	          RecordTypePrototype._keys = keys;
	          RecordTypePrototype._defaultValues = defaultValues;
	        }
	        this._map = Map(values);
	      };
	
	      var RecordTypePrototype = RecordType.prototype = Object.create(RecordPrototype);
	      RecordTypePrototype.constructor = RecordType;
	
	      return RecordType;
	    }
	
	    Record.prototype.toString = function() {
	      return this.__toString(recordName(this) + ' {', '}');
	    };
	
	    // @pragma Access
	
	    Record.prototype.has = function(k) {
	      return this._defaultValues.hasOwnProperty(k);
	    };
	
	    Record.prototype.get = function(k, notSetValue) {
	      if (!this.has(k)) {
	        return notSetValue;
	      }
	      var defaultVal = this._defaultValues[k];
	      return this._map ? this._map.get(k, defaultVal) : defaultVal;
	    };
	
	    // @pragma Modification
	
	    Record.prototype.clear = function() {
	      if (this.__ownerID) {
	        this._map && this._map.clear();
	        return this;
	      }
	      var RecordType = this.constructor;
	      return RecordType._empty || (RecordType._empty = makeRecord(this, emptyMap()));
	    };
	
	    Record.prototype.set = function(k, v) {
	      if (!this.has(k)) {
	        throw new Error('Cannot set unknown key "' + k + '" on ' + recordName(this));
	      }
	      var newMap = this._map && this._map.set(k, v);
	      if (this.__ownerID || newMap === this._map) {
	        return this;
	      }
	      return makeRecord(this, newMap);
	    };
	
	    Record.prototype.remove = function(k) {
	      if (!this.has(k)) {
	        return this;
	      }
	      var newMap = this._map && this._map.remove(k);
	      if (this.__ownerID || newMap === this._map) {
	        return this;
	      }
	      return makeRecord(this, newMap);
	    };
	
	    Record.prototype.wasAltered = function() {
	      return this._map.wasAltered();
	    };
	
	    Record.prototype.__iterator = function(type, reverse) {var this$0 = this;
	      return KeyedIterable(this._defaultValues).map(function(_, k)  {return this$0.get(k)}).__iterator(type, reverse);
	    };
	
	    Record.prototype.__iterate = function(fn, reverse) {var this$0 = this;
	      return KeyedIterable(this._defaultValues).map(function(_, k)  {return this$0.get(k)}).__iterate(fn, reverse);
	    };
	
	    Record.prototype.__ensureOwner = function(ownerID) {
	      if (ownerID === this.__ownerID) {
	        return this;
	      }
	      var newMap = this._map && this._map.__ensureOwner(ownerID);
	      if (!ownerID) {
	        this.__ownerID = ownerID;
	        this._map = newMap;
	        return this;
	      }
	      return makeRecord(this, newMap, ownerID);
	    };
	
	
	  var RecordPrototype = Record.prototype;
	  RecordPrototype[DELETE] = RecordPrototype.remove;
	  RecordPrototype.deleteIn =
	  RecordPrototype.removeIn = MapPrototype.removeIn;
	  RecordPrototype.merge = MapPrototype.merge;
	  RecordPrototype.mergeWith = MapPrototype.mergeWith;
	  RecordPrototype.mergeIn = MapPrototype.mergeIn;
	  RecordPrototype.mergeDeep = MapPrototype.mergeDeep;
	  RecordPrototype.mergeDeepWith = MapPrototype.mergeDeepWith;
	  RecordPrototype.mergeDeepIn = MapPrototype.mergeDeepIn;
	  RecordPrototype.setIn = MapPrototype.setIn;
	  RecordPrototype.update = MapPrototype.update;
	  RecordPrototype.updateIn = MapPrototype.updateIn;
	  RecordPrototype.withMutations = MapPrototype.withMutations;
	  RecordPrototype.asMutable = MapPrototype.asMutable;
	  RecordPrototype.asImmutable = MapPrototype.asImmutable;
	
	
	  function makeRecord(likeRecord, map, ownerID) {
	    var record = Object.create(Object.getPrototypeOf(likeRecord));
	    record._map = map;
	    record.__ownerID = ownerID;
	    return record;
	  }
	
	  function recordName(record) {
	    return record._name || record.constructor.name || 'Record';
	  }
	
	  function setProps(prototype, names) {
	    try {
	      names.forEach(setProp.bind(undefined, prototype));
	    } catch (error) {
	      // Object.defineProperty failed. Probably IE8.
	    }
	  }
	
	  function setProp(prototype, name) {
	    Object.defineProperty(prototype, name, {
	      get: function() {
	        return this.get(name);
	      },
	      set: function(value) {
	        invariant(this.__ownerID, 'Cannot set on an immutable record.');
	        this.set(name, value);
	      }
	    });
	  }
	
	  createClass(Set, SetCollection);
	
	    // @pragma Construction
	
	    function Set(value) {
	      return value === null || value === undefined ? emptySet() :
	        isSet(value) && !isOrdered(value) ? value :
	        emptySet().withMutations(function(set ) {
	          var iter = SetIterable(value);
	          assertNotInfinite(iter.size);
	          iter.forEach(function(v ) {return set.add(v)});
	        });
	    }
	
	    Set.of = function(/*...values*/) {
	      return this(arguments);
	    };
	
	    Set.fromKeys = function(value) {
	      return this(KeyedIterable(value).keySeq());
	    };
	
	    Set.prototype.toString = function() {
	      return this.__toString('Set {', '}');
	    };
	
	    // @pragma Access
	
	    Set.prototype.has = function(value) {
	      return this._map.has(value);
	    };
	
	    // @pragma Modification
	
	    Set.prototype.add = function(value) {
	      return updateSet(this, this._map.set(value, true));
	    };
	
	    Set.prototype.remove = function(value) {
	      return updateSet(this, this._map.remove(value));
	    };
	
	    Set.prototype.clear = function() {
	      return updateSet(this, this._map.clear());
	    };
	
	    // @pragma Composition
	
	    Set.prototype.union = function() {var iters = SLICE$0.call(arguments, 0);
	      iters = iters.filter(function(x ) {return x.size !== 0});
	      if (iters.length === 0) {
	        return this;
	      }
	      if (this.size === 0 && !this.__ownerID && iters.length === 1) {
	        return this.constructor(iters[0]);
	      }
	      return this.withMutations(function(set ) {
	        for (var ii = 0; ii < iters.length; ii++) {
	          SetIterable(iters[ii]).forEach(function(value ) {return set.add(value)});
	        }
	      });
	    };
	
	    Set.prototype.intersect = function() {var iters = SLICE$0.call(arguments, 0);
	      if (iters.length === 0) {
	        return this;
	      }
	      iters = iters.map(function(iter ) {return SetIterable(iter)});
	      var originalSet = this;
	      return this.withMutations(function(set ) {
	        originalSet.forEach(function(value ) {
	          if (!iters.every(function(iter ) {return iter.includes(value)})) {
	            set.remove(value);
	          }
	        });
	      });
	    };
	
	    Set.prototype.subtract = function() {var iters = SLICE$0.call(arguments, 0);
	      if (iters.length === 0) {
	        return this;
	      }
	      iters = iters.map(function(iter ) {return SetIterable(iter)});
	      var originalSet = this;
	      return this.withMutations(function(set ) {
	        originalSet.forEach(function(value ) {
	          if (iters.some(function(iter ) {return iter.includes(value)})) {
	            set.remove(value);
	          }
	        });
	      });
	    };
	
	    Set.prototype.merge = function() {
	      return this.union.apply(this, arguments);
	    };
	
	    Set.prototype.mergeWith = function(merger) {var iters = SLICE$0.call(arguments, 1);
	      return this.union.apply(this, iters);
	    };
	
	    Set.prototype.sort = function(comparator) {
	      // Late binding
	      return OrderedSet(sortFactory(this, comparator));
	    };
	
	    Set.prototype.sortBy = function(mapper, comparator) {
	      // Late binding
	      return OrderedSet(sortFactory(this, comparator, mapper));
	    };
	
	    Set.prototype.wasAltered = function() {
	      return this._map.wasAltered();
	    };
	
	    Set.prototype.__iterate = function(fn, reverse) {var this$0 = this;
	      return this._map.__iterate(function(_, k)  {return fn(k, k, this$0)}, reverse);
	    };
	
	    Set.prototype.__iterator = function(type, reverse) {
	      return this._map.map(function(_, k)  {return k}).__iterator(type, reverse);
	    };
	
	    Set.prototype.__ensureOwner = function(ownerID) {
	      if (ownerID === this.__ownerID) {
	        return this;
	      }
	      var newMap = this._map.__ensureOwner(ownerID);
	      if (!ownerID) {
	        this.__ownerID = ownerID;
	        this._map = newMap;
	        return this;
	      }
	      return this.__make(newMap, ownerID);
	    };
	
	
	  function isSet(maybeSet) {
	    return !!(maybeSet && maybeSet[IS_SET_SENTINEL]);
	  }
	
	  Set.isSet = isSet;
	
	  var IS_SET_SENTINEL = '@@__IMMUTABLE_SET__@@';
	
	  var SetPrototype = Set.prototype;
	  SetPrototype[IS_SET_SENTINEL] = true;
	  SetPrototype[DELETE] = SetPrototype.remove;
	  SetPrototype.mergeDeep = SetPrototype.merge;
	  SetPrototype.mergeDeepWith = SetPrototype.mergeWith;
	  SetPrototype.withMutations = MapPrototype.withMutations;
	  SetPrototype.asMutable = MapPrototype.asMutable;
	  SetPrototype.asImmutable = MapPrototype.asImmutable;
	
	  SetPrototype.__empty = emptySet;
	  SetPrototype.__make = makeSet;
	
	  function updateSet(set, newMap) {
	    if (set.__ownerID) {
	      set.size = newMap.size;
	      set._map = newMap;
	      return set;
	    }
	    return newMap === set._map ? set :
	      newMap.size === 0 ? set.__empty() :
	      set.__make(newMap);
	  }
	
	  function makeSet(map, ownerID) {
	    var set = Object.create(SetPrototype);
	    set.size = map ? map.size : 0;
	    set._map = map;
	    set.__ownerID = ownerID;
	    return set;
	  }
	
	  var EMPTY_SET;
	  function emptySet() {
	    return EMPTY_SET || (EMPTY_SET = makeSet(emptyMap()));
	  }
	
	  createClass(OrderedSet, Set);
	
	    // @pragma Construction
	
	    function OrderedSet(value) {
	      return value === null || value === undefined ? emptyOrderedSet() :
	        isOrderedSet(value) ? value :
	        emptyOrderedSet().withMutations(function(set ) {
	          var iter = SetIterable(value);
	          assertNotInfinite(iter.size);
	          iter.forEach(function(v ) {return set.add(v)});
	        });
	    }
	
	    OrderedSet.of = function(/*...values*/) {
	      return this(arguments);
	    };
	
	    OrderedSet.fromKeys = function(value) {
	      return this(KeyedIterable(value).keySeq());
	    };
	
	    OrderedSet.prototype.toString = function() {
	      return this.__toString('OrderedSet {', '}');
	    };
	
	
	  function isOrderedSet(maybeOrderedSet) {
	    return isSet(maybeOrderedSet) && isOrdered(maybeOrderedSet);
	  }
	
	  OrderedSet.isOrderedSet = isOrderedSet;
	
	  var OrderedSetPrototype = OrderedSet.prototype;
	  OrderedSetPrototype[IS_ORDERED_SENTINEL] = true;
	
	  OrderedSetPrototype.__empty = emptyOrderedSet;
	  OrderedSetPrototype.__make = makeOrderedSet;
	
	  function makeOrderedSet(map, ownerID) {
	    var set = Object.create(OrderedSetPrototype);
	    set.size = map ? map.size : 0;
	    set._map = map;
	    set.__ownerID = ownerID;
	    return set;
	  }
	
	  var EMPTY_ORDERED_SET;
	  function emptyOrderedSet() {
	    return EMPTY_ORDERED_SET || (EMPTY_ORDERED_SET = makeOrderedSet(emptyOrderedMap()));
	  }
	
	  createClass(Stack, IndexedCollection);
	
	    // @pragma Construction
	
	    function Stack(value) {
	      return value === null || value === undefined ? emptyStack() :
	        isStack(value) ? value :
	        emptyStack().unshiftAll(value);
	    }
	
	    Stack.of = function(/*...values*/) {
	      return this(arguments);
	    };
	
	    Stack.prototype.toString = function() {
	      return this.__toString('Stack [', ']');
	    };
	
	    // @pragma Access
	
	    Stack.prototype.get = function(index, notSetValue) {
	      var head = this._head;
	      index = wrapIndex(this, index);
	      while (head && index--) {
	        head = head.next;
	      }
	      return head ? head.value : notSetValue;
	    };
	
	    Stack.prototype.peek = function() {
	      return this._head && this._head.value;
	    };
	
	    // @pragma Modification
	
	    Stack.prototype.push = function(/*...values*/) {
	      if (arguments.length === 0) {
	        return this;
	      }
	      var newSize = this.size + arguments.length;
	      var head = this._head;
	      for (var ii = arguments.length - 1; ii >= 0; ii--) {
	        head = {
	          value: arguments[ii],
	          next: head
	        };
	      }
	      if (this.__ownerID) {
	        this.size = newSize;
	        this._head = head;
	        this.__hash = undefined;
	        this.__altered = true;
	        return this;
	      }
	      return makeStack(newSize, head);
	    };
	
	    Stack.prototype.pushAll = function(iter) {
	      iter = IndexedIterable(iter);
	      if (iter.size === 0) {
	        return this;
	      }
	      assertNotInfinite(iter.size);
	      var newSize = this.size;
	      var head = this._head;
	      iter.reverse().forEach(function(value ) {
	        newSize++;
	        head = {
	          value: value,
	          next: head
	        };
	      });
	      if (this.__ownerID) {
	        this.size = newSize;
	        this._head = head;
	        this.__hash = undefined;
	        this.__altered = true;
	        return this;
	      }
	      return makeStack(newSize, head);
	    };
	
	    Stack.prototype.pop = function() {
	      return this.slice(1);
	    };
	
	    Stack.prototype.unshift = function(/*...values*/) {
	      return this.push.apply(this, arguments);
	    };
	
	    Stack.prototype.unshiftAll = function(iter) {
	      return this.pushAll(iter);
	    };
	
	    Stack.prototype.shift = function() {
	      return this.pop.apply(this, arguments);
	    };
	
	    Stack.prototype.clear = function() {
	      if (this.size === 0) {
	        return this;
	      }
	      if (this.__ownerID) {
	        this.size = 0;
	        this._head = undefined;
	        this.__hash = undefined;
	        this.__altered = true;
	        return this;
	      }
	      return emptyStack();
	    };
	
	    Stack.prototype.slice = function(begin, end) {
	      if (wholeSlice(begin, end, this.size)) {
	        return this;
	      }
	      var resolvedBegin = resolveBegin(begin, this.size);
	      var resolvedEnd = resolveEnd(end, this.size);
	      if (resolvedEnd !== this.size) {
	        // super.slice(begin, end);
	        return IndexedCollection.prototype.slice.call(this, begin, end);
	      }
	      var newSize = this.size - resolvedBegin;
	      var head = this._head;
	      while (resolvedBegin--) {
	        head = head.next;
	      }
	      if (this.__ownerID) {
	        this.size = newSize;
	        this._head = head;
	        this.__hash = undefined;
	        this.__altered = true;
	        return this;
	      }
	      return makeStack(newSize, head);
	    };
	
	    // @pragma Mutability
	
	    Stack.prototype.__ensureOwner = function(ownerID) {
	      if (ownerID === this.__ownerID) {
	        return this;
	      }
	      if (!ownerID) {
	        this.__ownerID = ownerID;
	        this.__altered = false;
	        return this;
	      }
	      return makeStack(this.size, this._head, ownerID, this.__hash);
	    };
	
	    // @pragma Iteration
	
	    Stack.prototype.__iterate = function(fn, reverse) {
	      if (reverse) {
	        return this.reverse().__iterate(fn);
	      }
	      var iterations = 0;
	      var node = this._head;
	      while (node) {
	        if (fn(node.value, iterations++, this) === false) {
	          break;
	        }
	        node = node.next;
	      }
	      return iterations;
	    };
	
	    Stack.prototype.__iterator = function(type, reverse) {
	      if (reverse) {
	        return this.reverse().__iterator(type);
	      }
	      var iterations = 0;
	      var node = this._head;
	      return new Iterator(function()  {
	        if (node) {
	          var value = node.value;
	          node = node.next;
	          return iteratorValue(type, iterations++, value);
	        }
	        return iteratorDone();
	      });
	    };
	
	
	  function isStack(maybeStack) {
	    return !!(maybeStack && maybeStack[IS_STACK_SENTINEL]);
	  }
	
	  Stack.isStack = isStack;
	
	  var IS_STACK_SENTINEL = '@@__IMMUTABLE_STACK__@@';
	
	  var StackPrototype = Stack.prototype;
	  StackPrototype[IS_STACK_SENTINEL] = true;
	  StackPrototype.withMutations = MapPrototype.withMutations;
	  StackPrototype.asMutable = MapPrototype.asMutable;
	  StackPrototype.asImmutable = MapPrototype.asImmutable;
	  StackPrototype.wasAltered = MapPrototype.wasAltered;
	
	
	  function makeStack(size, head, ownerID, hash) {
	    var map = Object.create(StackPrototype);
	    map.size = size;
	    map._head = head;
	    map.__ownerID = ownerID;
	    map.__hash = hash;
	    map.__altered = false;
	    return map;
	  }
	
	  var EMPTY_STACK;
	  function emptyStack() {
	    return EMPTY_STACK || (EMPTY_STACK = makeStack(0));
	  }
	
	  /**
	   * Contributes additional methods to a constructor
	   */
	  function mixin(ctor, methods) {
	    var keyCopier = function(key ) { ctor.prototype[key] = methods[key]; };
	    Object.keys(methods).forEach(keyCopier);
	    Object.getOwnPropertySymbols &&
	      Object.getOwnPropertySymbols(methods).forEach(keyCopier);
	    return ctor;
	  }
	
	  Iterable.Iterator = Iterator;
	
	  mixin(Iterable, {
	
	    // ### Conversion to other types
	
	    toArray: function() {
	      assertNotInfinite(this.size);
	      var array = new Array(this.size || 0);
	      this.valueSeq().__iterate(function(v, i)  { array[i] = v; });
	      return array;
	    },
	
	    toIndexedSeq: function() {
	      return new ToIndexedSequence(this);
	    },
	
	    toJS: function() {
	      return this.toSeq().map(
	        function(value ) {return value && typeof value.toJS === 'function' ? value.toJS() : value}
	      ).__toJS();
	    },
	
	    toJSON: function() {
	      return this.toSeq().map(
	        function(value ) {return value && typeof value.toJSON === 'function' ? value.toJSON() : value}
	      ).__toJS();
	    },
	
	    toKeyedSeq: function() {
	      return new ToKeyedSequence(this, true);
	    },
	
	    toMap: function() {
	      // Use Late Binding here to solve the circular dependency.
	      return Map(this.toKeyedSeq());
	    },
	
	    toObject: function() {
	      assertNotInfinite(this.size);
	      var object = {};
	      this.__iterate(function(v, k)  { object[k] = v; });
	      return object;
	    },
	
	    toOrderedMap: function() {
	      // Use Late Binding here to solve the circular dependency.
	      return OrderedMap(this.toKeyedSeq());
	    },
	
	    toOrderedSet: function() {
	      // Use Late Binding here to solve the circular dependency.
	      return OrderedSet(isKeyed(this) ? this.valueSeq() : this);
	    },
	
	    toSet: function() {
	      // Use Late Binding here to solve the circular dependency.
	      return Set(isKeyed(this) ? this.valueSeq() : this);
	    },
	
	    toSetSeq: function() {
	      return new ToSetSequence(this);
	    },
	
	    toSeq: function() {
	      return isIndexed(this) ? this.toIndexedSeq() :
	        isKeyed(this) ? this.toKeyedSeq() :
	        this.toSetSeq();
	    },
	
	    toStack: function() {
	      // Use Late Binding here to solve the circular dependency.
	      return Stack(isKeyed(this) ? this.valueSeq() : this);
	    },
	
	    toList: function() {
	      // Use Late Binding here to solve the circular dependency.
	      return List(isKeyed(this) ? this.valueSeq() : this);
	    },
	
	
	    // ### Common JavaScript methods and properties
	
	    toString: function() {
	      return '[Iterable]';
	    },
	
	    __toString: function(head, tail) {
	      if (this.size === 0) {
	        return head + tail;
	      }
	      return head + ' ' + this.toSeq().map(this.__toStringMapper).join(', ') + ' ' + tail;
	    },
	
	
	    // ### ES6 Collection methods (ES6 Array and Map)
	
	    concat: function() {var values = SLICE$0.call(arguments, 0);
	      return reify(this, concatFactory(this, values));
	    },
	
	    includes: function(searchValue) {
	      return this.some(function(value ) {return is(value, searchValue)});
	    },
	
	    entries: function() {
	      return this.__iterator(ITERATE_ENTRIES);
	    },
	
	    every: function(predicate, context) {
	      assertNotInfinite(this.size);
	      var returnValue = true;
	      this.__iterate(function(v, k, c)  {
	        if (!predicate.call(context, v, k, c)) {
	          returnValue = false;
	          return false;
	        }
	      });
	      return returnValue;
	    },
	
	    filter: function(predicate, context) {
	      return reify(this, filterFactory(this, predicate, context, true));
	    },
	
	    find: function(predicate, context, notSetValue) {
	      var entry = this.findEntry(predicate, context);
	      return entry ? entry[1] : notSetValue;
	    },
	
	    findEntry: function(predicate, context) {
	      var found;
	      this.__iterate(function(v, k, c)  {
	        if (predicate.call(context, v, k, c)) {
	          found = [k, v];
	          return false;
	        }
	      });
	      return found;
	    },
	
	    findLastEntry: function(predicate, context) {
	      return this.toSeq().reverse().findEntry(predicate, context);
	    },
	
	    forEach: function(sideEffect, context) {
	      assertNotInfinite(this.size);
	      return this.__iterate(context ? sideEffect.bind(context) : sideEffect);
	    },
	
	    join: function(separator) {
	      assertNotInfinite(this.size);
	      separator = separator !== undefined ? '' + separator : ',';
	      var joined = '';
	      var isFirst = true;
	      this.__iterate(function(v ) {
	        isFirst ? (isFirst = false) : (joined += separator);
	        joined += v !== null && v !== undefined ? v.toString() : '';
	      });
	      return joined;
	    },
	
	    keys: function() {
	      return this.__iterator(ITERATE_KEYS);
	    },
	
	    map: function(mapper, context) {
	      return reify(this, mapFactory(this, mapper, context));
	    },
	
	    reduce: function(reducer, initialReduction, context) {
	      assertNotInfinite(this.size);
	      var reduction;
	      var useFirst;
	      if (arguments.length < 2) {
	        useFirst = true;
	      } else {
	        reduction = initialReduction;
	      }
	      this.__iterate(function(v, k, c)  {
	        if (useFirst) {
	          useFirst = false;
	          reduction = v;
	        } else {
	          reduction = reducer.call(context, reduction, v, k, c);
	        }
	      });
	      return reduction;
	    },
	
	    reduceRight: function(reducer, initialReduction, context) {
	      var reversed = this.toKeyedSeq().reverse();
	      return reversed.reduce.apply(reversed, arguments);
	    },
	
	    reverse: function() {
	      return reify(this, reverseFactory(this, true));
	    },
	
	    slice: function(begin, end) {
	      return reify(this, sliceFactory(this, begin, end, true));
	    },
	
	    some: function(predicate, context) {
	      return !this.every(not(predicate), context);
	    },
	
	    sort: function(comparator) {
	      return reify(this, sortFactory(this, comparator));
	    },
	
	    values: function() {
	      return this.__iterator(ITERATE_VALUES);
	    },
	
	
	    // ### More sequential methods
	
	    butLast: function() {
	      return this.slice(0, -1);
	    },
	
	    isEmpty: function() {
	      return this.size !== undefined ? this.size === 0 : !this.some(function()  {return true});
	    },
	
	    count: function(predicate, context) {
	      return ensureSize(
	        predicate ? this.toSeq().filter(predicate, context) : this
	      );
	    },
	
	    countBy: function(grouper, context) {
	      return countByFactory(this, grouper, context);
	    },
	
	    equals: function(other) {
	      return deepEqual(this, other);
	    },
	
	    entrySeq: function() {
	      var iterable = this;
	      if (iterable._cache) {
	        // We cache as an entries array, so we can just return the cache!
	        return new ArraySeq(iterable._cache);
	      }
	      var entriesSequence = iterable.toSeq().map(entryMapper).toIndexedSeq();
	      entriesSequence.fromEntrySeq = function()  {return iterable.toSeq()};
	      return entriesSequence;
	    },
	
	    filterNot: function(predicate, context) {
	      return this.filter(not(predicate), context);
	    },
	
	    findLast: function(predicate, context, notSetValue) {
	      return this.toKeyedSeq().reverse().find(predicate, context, notSetValue);
	    },
	
	    first: function() {
	      return this.find(returnTrue);
	    },
	
	    flatMap: function(mapper, context) {
	      return reify(this, flatMapFactory(this, mapper, context));
	    },
	
	    flatten: function(depth) {
	      return reify(this, flattenFactory(this, depth, true));
	    },
	
	    fromEntrySeq: function() {
	      return new FromEntriesSequence(this);
	    },
	
	    get: function(searchKey, notSetValue) {
	      return this.find(function(_, key)  {return is(key, searchKey)}, undefined, notSetValue);
	    },
	
	    getIn: function(searchKeyPath, notSetValue) {
	      var nested = this;
	      // Note: in an ES6 environment, we would prefer:
	      // for (var key of searchKeyPath) {
	      var iter = forceIterator(searchKeyPath);
	      var step;
	      while (!(step = iter.next()).done) {
	        var key = step.value;
	        nested = nested && nested.get ? nested.get(key, NOT_SET) : NOT_SET;
	        if (nested === NOT_SET) {
	          return notSetValue;
	        }
	      }
	      return nested;
	    },
	
	    groupBy: function(grouper, context) {
	      return groupByFactory(this, grouper, context);
	    },
	
	    has: function(searchKey) {
	      return this.get(searchKey, NOT_SET) !== NOT_SET;
	    },
	
	    hasIn: function(searchKeyPath) {
	      return this.getIn(searchKeyPath, NOT_SET) !== NOT_SET;
	    },
	
	    isSubset: function(iter) {
	      iter = typeof iter.includes === 'function' ? iter : Iterable(iter);
	      return this.every(function(value ) {return iter.includes(value)});
	    },
	
	    isSuperset: function(iter) {
	      iter = typeof iter.isSubset === 'function' ? iter : Iterable(iter);
	      return iter.isSubset(this);
	    },
	
	    keySeq: function() {
	      return this.toSeq().map(keyMapper).toIndexedSeq();
	    },
	
	    last: function() {
	      return this.toSeq().reverse().first();
	    },
	
	    max: function(comparator) {
	      return maxFactory(this, comparator);
	    },
	
	    maxBy: function(mapper, comparator) {
	      return maxFactory(this, comparator, mapper);
	    },
	
	    min: function(comparator) {
	      return maxFactory(this, comparator ? neg(comparator) : defaultNegComparator);
	    },
	
	    minBy: function(mapper, comparator) {
	      return maxFactory(this, comparator ? neg(comparator) : defaultNegComparator, mapper);
	    },
	
	    rest: function() {
	      return this.slice(1);
	    },
	
	    skip: function(amount) {
	      return this.slice(Math.max(0, amount));
	    },
	
	    skipLast: function(amount) {
	      return reify(this, this.toSeq().reverse().skip(amount).reverse());
	    },
	
	    skipWhile: function(predicate, context) {
	      return reify(this, skipWhileFactory(this, predicate, context, true));
	    },
	
	    skipUntil: function(predicate, context) {
	      return this.skipWhile(not(predicate), context);
	    },
	
	    sortBy: function(mapper, comparator) {
	      return reify(this, sortFactory(this, comparator, mapper));
	    },
	
	    take: function(amount) {
	      return this.slice(0, Math.max(0, amount));
	    },
	
	    takeLast: function(amount) {
	      return reify(this, this.toSeq().reverse().take(amount).reverse());
	    },
	
	    takeWhile: function(predicate, context) {
	      return reify(this, takeWhileFactory(this, predicate, context));
	    },
	
	    takeUntil: function(predicate, context) {
	      return this.takeWhile(not(predicate), context);
	    },
	
	    valueSeq: function() {
	      return this.toIndexedSeq();
	    },
	
	
	    // ### Hashable Object
	
	    hashCode: function() {
	      return this.__hash || (this.__hash = hashIterable(this));
	    }
	
	
	    // ### Internal
	
	    // abstract __iterate(fn, reverse)
	
	    // abstract __iterator(type, reverse)
	  });
	
	  // var IS_ITERABLE_SENTINEL = '@@__IMMUTABLE_ITERABLE__@@';
	  // var IS_KEYED_SENTINEL = '@@__IMMUTABLE_KEYED__@@';
	  // var IS_INDEXED_SENTINEL = '@@__IMMUTABLE_INDEXED__@@';
	  // var IS_ORDERED_SENTINEL = '@@__IMMUTABLE_ORDERED__@@';
	
	  var IterablePrototype = Iterable.prototype;
	  IterablePrototype[IS_ITERABLE_SENTINEL] = true;
	  IterablePrototype[ITERATOR_SYMBOL] = IterablePrototype.values;
	  IterablePrototype.__toJS = IterablePrototype.toArray;
	  IterablePrototype.__toStringMapper = quoteString;
	  IterablePrototype.inspect =
	  IterablePrototype.toSource = function() { return this.toString(); };
	  IterablePrototype.chain = IterablePrototype.flatMap;
	  IterablePrototype.contains = IterablePrototype.includes;
	
	  // Temporary warning about using length
	  (function () {
	    try {
	      Object.defineProperty(IterablePrototype, 'length', {
	        get: function () {
	          if (!Iterable.noLengthWarning) {
	            var stack;
	            try {
	              throw new Error();
	            } catch (error) {
	              stack = error.stack;
	            }
	            if (stack.indexOf('_wrapObject') === -1) {
	              console && console.warn && console.warn(
	                'iterable.length has been deprecated, '+
	                'use iterable.size or iterable.count(). '+
	                'This warning will become a silent error in a future version. ' +
	                stack
	              );
	              return this.size;
	            }
	          }
	        }
	      });
	    } catch (e) {}
	  })();
	
	
	
	  mixin(KeyedIterable, {
	
	    // ### More sequential methods
	
	    flip: function() {
	      return reify(this, flipFactory(this));
	    },
	
	    findKey: function(predicate, context) {
	      var entry = this.findEntry(predicate, context);
	      return entry && entry[0];
	    },
	
	    findLastKey: function(predicate, context) {
	      return this.toSeq().reverse().findKey(predicate, context);
	    },
	
	    keyOf: function(searchValue) {
	      return this.findKey(function(value ) {return is(value, searchValue)});
	    },
	
	    lastKeyOf: function(searchValue) {
	      return this.findLastKey(function(value ) {return is(value, searchValue)});
	    },
	
	    mapEntries: function(mapper, context) {var this$0 = this;
	      var iterations = 0;
	      return reify(this,
	        this.toSeq().map(
	          function(v, k)  {return mapper.call(context, [k, v], iterations++, this$0)}
	        ).fromEntrySeq()
	      );
	    },
	
	    mapKeys: function(mapper, context) {var this$0 = this;
	      return reify(this,
	        this.toSeq().flip().map(
	          function(k, v)  {return mapper.call(context, k, v, this$0)}
	        ).flip()
	      );
	    }
	
	  });
	
	  var KeyedIterablePrototype = KeyedIterable.prototype;
	  KeyedIterablePrototype[IS_KEYED_SENTINEL] = true;
	  KeyedIterablePrototype[ITERATOR_SYMBOL] = IterablePrototype.entries;
	  KeyedIterablePrototype.__toJS = IterablePrototype.toObject;
	  KeyedIterablePrototype.__toStringMapper = function(v, k)  {return JSON.stringify(k) + ': ' + quoteString(v)};
	
	
	
	  mixin(IndexedIterable, {
	
	    // ### Conversion to other types
	
	    toKeyedSeq: function() {
	      return new ToKeyedSequence(this, false);
	    },
	
	
	    // ### ES6 Collection methods (ES6 Array and Map)
	
	    filter: function(predicate, context) {
	      return reify(this, filterFactory(this, predicate, context, false));
	    },
	
	    findIndex: function(predicate, context) {
	      var entry = this.findEntry(predicate, context);
	      return entry ? entry[0] : -1;
	    },
	
	    indexOf: function(searchValue) {
	      var key = this.toKeyedSeq().keyOf(searchValue);
	      return key === undefined ? -1 : key;
	    },
	
	    lastIndexOf: function(searchValue) {
	      var key = this.toKeyedSeq().reverse().keyOf(searchValue);
	      return key === undefined ? -1 : key;
	
	      // var index =
	      // return this.toSeq().reverse().indexOf(searchValue);
	    },
	
	    reverse: function() {
	      return reify(this, reverseFactory(this, false));
	    },
	
	    slice: function(begin, end) {
	      return reify(this, sliceFactory(this, begin, end, false));
	    },
	
	    splice: function(index, removeNum /*, ...values*/) {
	      var numArgs = arguments.length;
	      removeNum = Math.max(removeNum | 0, 0);
	      if (numArgs === 0 || (numArgs === 2 && !removeNum)) {
	        return this;
	      }
	      // If index is negative, it should resolve relative to the size of the
	      // collection. However size may be expensive to compute if not cached, so
	      // only call count() if the number is in fact negative.
	      index = resolveBegin(index, index < 0 ? this.count() : this.size);
	      var spliced = this.slice(0, index);
	      return reify(
	        this,
	        numArgs === 1 ?
	          spliced :
	          spliced.concat(arrCopy(arguments, 2), this.slice(index + removeNum))
	      );
	    },
	
	
	    // ### More collection methods
	
	    findLastIndex: function(predicate, context) {
	      var key = this.toKeyedSeq().findLastKey(predicate, context);
	      return key === undefined ? -1 : key;
	    },
	
	    first: function() {
	      return this.get(0);
	    },
	
	    flatten: function(depth) {
	      return reify(this, flattenFactory(this, depth, false));
	    },
	
	    get: function(index, notSetValue) {
	      index = wrapIndex(this, index);
	      return (index < 0 || (this.size === Infinity ||
	          (this.size !== undefined && index > this.size))) ?
	        notSetValue :
	        this.find(function(_, key)  {return key === index}, undefined, notSetValue);
	    },
	
	    has: function(index) {
	      index = wrapIndex(this, index);
	      return index >= 0 && (this.size !== undefined ?
	        this.size === Infinity || index < this.size :
	        this.indexOf(index) !== -1
	      );
	    },
	
	    interpose: function(separator) {
	      return reify(this, interposeFactory(this, separator));
	    },
	
	    interleave: function(/*...iterables*/) {
	      var iterables = [this].concat(arrCopy(arguments));
	      var zipped = zipWithFactory(this.toSeq(), IndexedSeq.of, iterables);
	      var interleaved = zipped.flatten(true);
	      if (zipped.size) {
	        interleaved.size = zipped.size * iterables.length;
	      }
	      return reify(this, interleaved);
	    },
	
	    last: function() {
	      return this.get(-1);
	    },
	
	    skipWhile: function(predicate, context) {
	      return reify(this, skipWhileFactory(this, predicate, context, false));
	    },
	
	    zip: function(/*, ...iterables */) {
	      var iterables = [this].concat(arrCopy(arguments));
	      return reify(this, zipWithFactory(this, defaultZipper, iterables));
	    },
	
	    zipWith: function(zipper/*, ...iterables */) {
	      var iterables = arrCopy(arguments);
	      iterables[0] = this;
	      return reify(this, zipWithFactory(this, zipper, iterables));
	    }
	
	  });
	
	  IndexedIterable.prototype[IS_INDEXED_SENTINEL] = true;
	  IndexedIterable.prototype[IS_ORDERED_SENTINEL] = true;
	
	
	
	  mixin(SetIterable, {
	
	    // ### ES6 Collection methods (ES6 Array and Map)
	
	    get: function(value, notSetValue) {
	      return this.has(value) ? value : notSetValue;
	    },
	
	    includes: function(value) {
	      return this.has(value);
	    },
	
	
	    // ### More sequential methods
	
	    keySeq: function() {
	      return this.valueSeq();
	    }
	
	  });
	
	  SetIterable.prototype.has = IterablePrototype.includes;
	
	
	  // Mixin subclasses
	
	  mixin(KeyedSeq, KeyedIterable.prototype);
	  mixin(IndexedSeq, IndexedIterable.prototype);
	  mixin(SetSeq, SetIterable.prototype);
	
	  mixin(KeyedCollection, KeyedIterable.prototype);
	  mixin(IndexedCollection, IndexedIterable.prototype);
	  mixin(SetCollection, SetIterable.prototype);
	
	
	  // #pragma Helper functions
	
	  function keyMapper(v, k) {
	    return k;
	  }
	
	  function entryMapper(v, k) {
	    return [k, v];
	  }
	
	  function not(predicate) {
	    return function() {
	      return !predicate.apply(this, arguments);
	    }
	  }
	
	  function neg(predicate) {
	    return function() {
	      return -predicate.apply(this, arguments);
	    }
	  }
	
	  function quoteString(value) {
	    return typeof value === 'string' ? JSON.stringify(value) : value;
	  }
	
	  function defaultZipper() {
	    return arrCopy(arguments);
	  }
	
	  function defaultNegComparator(a, b) {
	    return a < b ? 1 : a > b ? -1 : 0;
	  }
	
	  function hashIterable(iterable) {
	    if (iterable.size === Infinity) {
	      return 0;
	    }
	    var ordered = isOrdered(iterable);
	    var keyed = isKeyed(iterable);
	    var h = ordered ? 1 : 0;
	    var size = iterable.__iterate(
	      keyed ?
	        ordered ?
	          function(v, k)  { h = 31 * h + hashMerge(hash(v), hash(k)) | 0; } :
	          function(v, k)  { h = h + hashMerge(hash(v), hash(k)) | 0; } :
	        ordered ?
	          function(v ) { h = 31 * h + hash(v) | 0; } :
	          function(v ) { h = h + hash(v) | 0; }
	    );
	    return murmurHashOfSize(size, h);
	  }
	
	  function murmurHashOfSize(size, h) {
	    h = imul(h, 0xCC9E2D51);
	    h = imul(h << 15 | h >>> -15, 0x1B873593);
	    h = imul(h << 13 | h >>> -13, 5);
	    h = (h + 0xE6546B64 | 0) ^ size;
	    h = imul(h ^ h >>> 16, 0x85EBCA6B);
	    h = imul(h ^ h >>> 13, 0xC2B2AE35);
	    h = smi(h ^ h >>> 16);
	    return h;
	  }
	
	  function hashMerge(a, b) {
	    return a ^ b + 0x9E3779B9 + (a << 6) + (a >> 2) | 0; // int
	  }
	
	  var Immutable = {
	
	    Iterable: Iterable,
	
	    Seq: Seq,
	    Collection: Collection,
	    Map: Map,
	    OrderedMap: OrderedMap,
	    List: List,
	    Stack: Stack,
	    Set: Set,
	    OrderedSet: OrderedSet,
	
	    Record: Record,
	    Range: Range,
	    Repeat: Repeat,
	
	    is: is,
	    fromJS: fromJS
	
	  };
	
	  return Immutable;
	
	}));

/***/ }),
/* 12 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 */
	
	'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 (true) {
	  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;

/***/ }),
/* 13 */
/***/ (function(module, exports, __webpack_require__) {

	var require;/* WEBPACK VAR INJECTION */(function(module) {//! moment.js
	
	;(function (global, factory) {
	     true ? 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) {
	        if (Object.getOwnPropertyNames) {
	            return (Object.getOwnPropertyNames(obj).length === 0);
	        } else {
	            var k;
	            for (k in obj) {
	                if (obj.hasOwnProperty(k)) {
	                    return false;
	                }
	            }
	            return true;
	        }
	    }
	
	    function isUndefined(input) {
	        return input === void 0;
	    }
	
	    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,
	            rfc2822         : false,
	            weekdayMismatch : false
	        };
	    }
	
	    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;
	        };
	    }
	
	    function isValid(m) {
	        if (m._isValid == null) {
	            var flags = getParsingFlags(m);
	            var parsedParts = some.call(flags.parsedDateParts, function (i) {
	                return i != null;
	            });
	            var isNowValid = !isNaN(m._d.getTime()) &&
	                flags.overflow < 0 &&
	                !flags.empty &&
	                !flags.invalidMonth &&
	                !flags.invalidWeekday &&
	                !flags.weekdayMismatch &&
	                !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;
	    }
	
	    // 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 = 0; i < momentProperties.length; i++) {
	                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 _dayOfMonthOrdinalParse.
	        // TODO: Remove "ordinalParse" fallback in next major release.
	        this._dayOfMonthOrdinalParseLenient = new RegExp(
	            (this._dayOfMonthOrdinalParse.source || 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 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 defaultDayOfMonthOrdinalParse = /\d{1,2}/;
	
	    function ordinal (number) {
	        return this._ordinal.replace('%d', number);
	    }
	
	    var defaultRelativeTime = {
	        future : 'in %s',
	        past   : '%s ago',
	        s  : 'a few seconds',
	        ss : '%d 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 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 += isFunction(array[i]) ? 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]{0,256}['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFF07\uFF10-\uFFEF]{1,256}|[\u0600-\u06FF\/]{1,256}(\s*?[\u0600-\u06FF]{1,256}){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;
	
	    // 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 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() && !isNaN(value)) {
	            if (unit === 'FullYear' && isLeapYear(mom.year()) && mom.month() === 1 && mom.date() === 29) {
	                mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value, mom.month(), daysInMonth(value, mom.month()));
	            }
	            else {
	                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 mod(n, x) {
	        return ((n % x) + x) % x;
	    }
	
	    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;
	        };
	    }
	
	    function daysInMonth(year, month) {
	        if (isNaN(year) || isNaN(month)) {
	            return NaN;
	        }
	        var modMonth = mod(month, 12);
	        year += (month - modMonth) / 12;
	        return modMonth === 1 ? (isLeapYear(year) ? 29 : 28) : (31 - modMonth % 7 % 2);
	    }
	
	    // 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 isArray(this._months) ? this._months :
	                this._months['standalone'];
	        }
	        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 isArray(this._monthsShort) ? this._monthsShort :
	                this._monthsShort['standalone'];
	        }
	        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.call(this._shortMonthsParse, llc);
	                return ii !== -1 ? ii : null;
	            } else {
	                ii = indexOf.call(this._longMonthsParse, llc);
	                return ii !== -1 ? ii : null;
	            }
	        } else {
	            if (format === 'MMM') {
	                ii = indexOf.call(this._shortMonthsParse, llc);
	                if (ii !== -1) {
	                    return ii;
	                }
	                ii = indexOf.call(this._longMonthsParse, llc);
	                return ii !== -1 ? ii : null;
	            } else {
	                ii = indexOf.call(this._longMonthsParse, llc);
	                if (ii !== -1) {
	                    return ii;
	                }
	                ii = indexOf.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');
	    }
	
	    function createDate (y, m, d, h, M, s, ms) {
	        // can't just apply() to create a date:
	        // https://stackoverflow.com/q/181348
	        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;
	    }
	
	    // https://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 isArray(this._weekdays) ? this._weekdays :
	                this._weekdays['standalone'];
	        }
	        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.call(this._weekdaysParse, llc);
	                return ii !== -1 ? ii : null;
	            } else if (format === 'ddd') {
	                ii = indexOf.call(this._shortWeekdaysParse, llc);
	                return ii !== -1 ? ii : null;
	            } else {
	                ii = indexOf.call(this._minWeekdaysParse, llc);
	                return ii !== -1 ? ii : null;
	            }
	        } else {
	            if (format === 'dddd') {
	                ii = indexOf.call(this._weekdaysParse, llc);
	                if (ii !== -1) {
	                    return ii;
	                }
	                ii = indexOf.call(this._shortWeekdaysParse, llc);
	                if (ii !== -1) {
	                    return ii;
	                }
	                ii = indexOf.call(this._minWeekdaysParse, llc);
	                return ii !== -1 ? ii : null;
	            } else if (format === 'ddd') {
	                ii = indexOf.call(this._shortWeekdaysParse, llc);
	                if (ii !== -1) {
	                    return ii;
	                }
	                ii = indexOf.call(this._weekdaysParse, llc);
	                if (ii !== -1) {
	                    return ii;
	                }
	                ii = indexOf.call(this._minWeekdaysParse, llc);
	                return ii !== -1 ? ii : null;
	            } else {
	                ii = indexOf.call(this._minWeekdaysParse, llc);
	                if (ii !== -1) {
	                    return ii;
	                }
	                ii = indexOf.call(this._weekdaysParse, llc);
	                if (ii !== -1) {
	                    return ii;
	                }
	                ii = indexOf.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('k',  match1to2);
	    addRegexToken('HH', match1to2, match2);
	    addRegexToken('hh', match1to2, match2);
	    addRegexToken('kk', match1to2, match2);
	
	    addRegexToken('hmm', match3to4);
	    addRegexToken('hmmss', match5to6);
	    addRegexToken('Hmm', match3to4);
	    addRegexToken('Hmmss', match5to6);
	
	    addParseToken(['H', 'HH'], HOUR);
	    addParseToken(['k', 'kk'], function (input, array, config) {
	        var kInput = toInt(input);
	        array[HOUR] = kInput === 24 ? 0 : kInput;
	    });
	    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 they want. 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);
	
	    var baseConfig = {
	        calendar: defaultCalendar,
	        longDateFormat: defaultLongDateFormat,
	        invalidDate: defaultInvalidDate,
	        ordinal: defaultOrdinal,
	        dayOfMonthOrdinalParse: defaultDayOfMonthOrdinalParse,
	        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 globalLocale;
	    }
	
	    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;
	                var aliasedRequire = require;
	                !(function webpackMissingModule() { var e = new Error("Cannot find module \"./locale\""); e.code = 'MODULE_NOT_FOUND'; throw e; }());
	                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;
	            }
	            else {
	                if ((typeof console !==  'undefined') && console.warn) {
	                    //warn user if arguments are passed but the locale could not be set
	                    console.warn('Locale ' + key +  ' not found. Did you forget to load it?');
	                }
	            }
	        }
	
	        return globalLocale._abbr;
	    }
	
	    function defineLocale (name, config) {
	        if (config !== null) {
	            var locale, 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 {
	                    locale = loadLocale(config.parentLocale);
	                    if (locale != null) {
	                        parentConfig = locale._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, tmpLocale, parentConfig = baseConfig;
	            // MERGE
	            tmpLocale = loadLocale(name);
	            if (tmpLocale != null) {
	                parentConfig = tmpLocale._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(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;
	    }
	
	    // 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, expectedWeekday, 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 != null) {
	            yearToUse = defaults(config._a[YEAR], currentDate[YEAR]);
	
	            if (config._dayOfYear > daysInYear(yearToUse) || config._dayOfYear === 0) {
	                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);
	        expectedWeekday = config._useUTC ? config._d.getUTCDay() : config._d.getDay();
	
	        // 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;
	        }
	
	        // check for mismatching day of week
	        if (config._w && typeof config._w.d !== 'undefined' && config._w.d !== expectedWeekday) {
	            getParsingFlags(config).weekdayMismatch = true;
	        }
	    }
	
	    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;
	        }
	    }
	
	    // 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;
	        }
	    }
	
	    // RFC 2822 regex: For details see https://tools.ietf.org/html/rfc2822#section-3.3
	    var rfc2822 = /^(?:(Mon|Tue|Wed|Thu|Fri|Sat|Sun),?\s)?(\d{1,2})\s(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s(\d{2,4})\s(\d\d):(\d\d)(?::(\d\d))?\s(?:(UT|GMT|[ECMP][SD]T)|([Zz])|([+-]\d{4}))$/;
	
	    function extractFromRFC2822Strings(yearStr, monthStr, dayStr, hourStr, minuteStr, secondStr) {
	        var result = [
	            untruncateYear(yearStr),
	            defaultLocaleMonthsShort.indexOf(monthStr),
	            parseInt(dayStr, 10),
	            parseInt(hourStr, 10),
	            parseInt(minuteStr, 10)
	        ];
	
	        if (secondStr) {
	            result.push(parseInt(secondStr, 10));
	        }
	
	        return result;
	    }
	
	    function untruncateYear(yearStr) {
	        var year = parseInt(yearStr, 10);
	        if (year <= 49) {
	            return 2000 + year;
	        } else if (year <= 999) {
	            return 1900 + year;
	        }
	        return year;
	    }
	
	    function preprocessRFC2822(s) {
	        // Remove comments and folding whitespace and replace multiple-spaces with a single space
	        return s.replace(/\([^)]*\)|[\n\t]/g, ' ').replace(/(\s\s+)/g, ' ').trim();
	    }
	
	    function checkWeekday(weekdayStr, parsedInput, config) {
	        if (weekdayStr) {
	            // TODO: Replace the vanilla JS Date object with an indepentent day-of-week check.
	            var weekdayProvided = defaultLocaleWeekdaysShort.indexOf(weekdayStr),
	                weekdayActual = new Date(parsedInput[0], parsedInput[1], parsedInput[2]).getDay();
	            if (weekdayProvided !== weekdayActual) {
	                getParsingFlags(config).weekdayMismatch = true;
	                config._isValid = false;
	                return false;
	            }
	        }
	        return true;
	    }
	
	    var obsOffsets = {
	        UT: 0,
	        GMT: 0,
	        EDT: -4 * 60,
	        EST: -5 * 60,
	        CDT: -5 * 60,
	        CST: -6 * 60,
	        MDT: -6 * 60,
	        MST: -7 * 60,
	        PDT: -7 * 60,
	        PST: -8 * 60
	    };
	
	    function calculateOffset(obsOffset, militaryOffset, numOffset) {
	        if (obsOffset) {
	            return obsOffsets[obsOffset];
	        } else if (militaryOffset) {
	            // the only allowed military tz is Z
	            return 0;
	        } else {
	            var hm = parseInt(numOffset, 10);
	            var m = hm % 100, h = (hm - m) / 100;
	            return h * 60 + m;
	        }
	    }
	
	    // date and time from ref 2822 format
	    function configFromRFC2822(config) {
	        var match = rfc2822.exec(preprocessRFC2822(config._i));
	        if (match) {
	            var parsedArray = extractFromRFC2822Strings(match[4], match[3], match[2], match[5], match[6], match[7]);
	            if (!checkWeekday(match[1], parsedArray, config)) {
	                return;
	            }
	
	            config._a = parsedArray;
	            config._tzm = calculateOffset(match[8], match[9], match[10]);
	
	            config._d = createUTCDate.apply(null, config._a);
	            config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);
	
	            getParsingFlags(config).rfc2822 = true;
	        } 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;
	        } else {
	            return;
	        }
	
	        configFromRFC2822(config);
	        if (config._isValid === false) {
	            delete config._isValid;
	        } else {
	            return;
	        }
	
	        // Final attempt, use Input Fallback
	        hooks.createFromInputFallback(config);
	    }
	
	    hooks.createFromInputFallback = deprecate(
	        'value provided is not in a recognized RFC2822 or ISO format. moment construction falls back to js Date(), ' +
	        'which is not reliable across all browsers and versions. Non RFC2822/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' : ''));
	        }
	    );
	
	    // constant that refers to the ISO standard
	    hooks.ISO_8601 = function () {};
	
	    // constant that refers to the RFC 2822 form
	    hooks.RFC_2822 = 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;
	        }
	        if (config._f === hooks.RFC_2822) {
	            configFromRFC2822(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 (isUndefined(input)) {
	            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 (isObject(input)) {
	            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());
	    };
	
	    var ordering = ['year', 'quarter', 'month', 'week', 'day', 'hour', 'minute', 'second', 'millisecond'];
	
	    function isDurationValid(m) {
	        for (var key in m) {
	            if (!(indexOf.call(ordering, key) !== -1 && (m[key] == null || !isNaN(m[key])))) {
	                return false;
	            }
	        }
	
	        var unitHasDecimal = false;
	        for (var i = 0; i < ordering.length; ++i) {
	            if (m[ordering[i]]) {
	                if (unitHasDecimal) {
	                    return false; // only allow non-integers for smallest unit
	                }
	                if (parseFloat(m[ordering[i]]) !== toInt(m[ordering[i]])) {
	                    unitHasDecimal = true;
	                }
	            }
	        }
	
	        return true;
	    }
	
	    function isValid$1() {
	        return this._isValid;
	    }
	
	    function createInvalid$1() {
	        return createDuration(NaN);
	    }
	
	    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;
	
	        this._isValid = isDurationValid(normalizedInput);
	
	        // 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 to 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, keepMinutes) {
	        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 && !keepMinutes) {
	                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, false, true);
	        } 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 : (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;
	    createDuration.invalid = createInvalid$1;
	
	    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 (months) {
	            setMonth(mom, get(mom, 'Month') + months * isAdding);
	        }
	        if (days) {
	            set$1(mom, 'Date', get(mom, 'Date') + days * isAdding);
	        }
	        if (milliseconds) {
	            mom._d.setTime(mom._d.valueOf() + milliseconds * 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,
	            output;
	
	        if (!this.isValid()) {
	            return NaN;
	        }
	
	        that = cloneWithOffset(input, this);
	
	        if (!that.isValid()) {
	            return NaN;
	        }
	
	        zoneDelta = (that.utcOffset() - this.utcOffset()) * 6e4;
	
	        units = normalizeUnits(units);
	
	        switch (units) {
	            case 'year': output = monthDiff(this, that) / 12; break;
	            case 'month': output = monthDiff(this, that); break;
	            case 'quarter': output = monthDiff(this, that) / 3; break;
	            case 'second': output = (this - that) / 1e3; break; // 1000
	            case 'minute': output = (this - that) / 6e4; break; // 1000 * 60
	            case 'hour': output = (this - that) / 36e5; break; // 1000 * 60 * 60
	            case 'day': output = (this - that - zoneDelta) / 864e5; break; // 1000 * 60 * 60 * 24, negate dst
	            case 'week': output = (this - that - zoneDelta) / 6048e5; break; // 1000 * 60 * 60 * 24 * 7, negate dst
	            default: output = this - that;
	        }
	
	        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(keepOffset) {
	        if (!this.isValid()) {
	            return null;
	        }
	        var utc = keepOffset !== true;
	        var m = utc ? this.clone().utc() : this;
	        if (m.year() < 0 || m.year() > 9999) {
	            return formatMoment(m, utc ? 'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]' : 'YYYYYY-MM-DD[T]HH:mm:ss.SSSZ');
	        }
	        if (isFunction(Date.prototype.toISOString)) {
	            // native implementation is ~50x faster, use it when we can
	            if (utc) {
	                return this.toDate().toISOString();
	            } else {
	                return new Date(this.valueOf() + this.utcOffset() * 60 * 1000).toISOString().replace('Z', formatMoment(m, 'Z'));
	            }
	        }
	        return formatMoment(m, utc ? 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]' : 'YYYY-MM-DD[T]HH:mm:ss.SSSZ');
	    }
	
	    /**
	     * 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$2 () {
	        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');
	
	    // PRIORITY
	    addUnitPriority('date', 9);
	
	    // PARSING
	
	    addRegexToken('D',  match1to2);
	    addRegexToken('DD', match1to2, match2);
	    addRegexToken('Do', function (isStrict, locale) {
	        // TODO: Remove "ordinalParse" fallback in next major release.
	        return isStrict ?
	          (locale._dayOfMonthOrdinalParse || locale._ordinalParse) :
	          locale._dayOfMonthOrdinalParseLenient;
	    });
	
	    addParseToken(['D', 'DD'], DATE);
	    addParseToken('Do', function (input, array) {
	        array[DATE] = toInt(input.match(match1to2)[0]);
	    });
	
	    // 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$2;
	    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;
	    proto.year       = getSetYear;
	    proto.isLeapYear = getIsLeapYear;
	    proto.weekYear    = getSetWeekYear;
	    proto.isoWeekYear = getSetISOWeekYear;
	    proto.quarter = proto.quarters = getSetQuarter;
	    proto.month       = getSetMonth;
	    proto.daysInMonth = getDaysInMonth;
	    proto.week           = proto.weeks        = getSetWeek;
	    proto.isoWeek        = proto.isoWeeks     = getSetISOWeek;
	    proto.weeksInYear    = getWeeksInYear;
	    proto.isoWeeksInYear = getISOWeeksInYear;
	    proto.date       = getSetDayOfMonth;
	    proto.day        = proto.days             = getSetDayOfWeek;
	    proto.weekday    = getSetLocaleDayOfWeek;
	    proto.isoWeekday = getSetISODayOfWeek;
	    proto.dayOfYear  = getSetDayOfYear;
	    proto.hour = proto.hours = getSetHour;
	    proto.minute = proto.minutes = getSetMinute;
	    proto.second = proto.seconds = getSetSecond;
	    proto.millisecond = proto.milliseconds = getSetMillisecond;
	    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;
	    proto.zoneAbbr = getZoneAbbr;
	    proto.zoneName = getZoneName;
	    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;
	
	    proto$1.months            =        localeMonths;
	    proto$1.monthsShort       =        localeMonthsShort;
	    proto$1.monthsParse       =        localeMonthsParse;
	    proto$1.monthsRegex       = monthsRegex;
	    proto$1.monthsShortRegex  = monthsShortRegex;
	    proto$1.week = localeWeek;
	    proto$1.firstDayOfYear = localeFirstDayOfYear;
	    proto$1.firstDayOfWeek = localeFirstDayOfWeek;
	
	    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;
	
	    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', {
	        dayOfMonthOrdinalParse: /\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) {
	        if (!this.isValid()) {
	            return NaN;
	        }
	        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 () {
	        if (!this.isValid()) {
	            return NaN;
	        }
	        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 clone$1 () {
	        return createDuration(this);
	    }
	
	    function get$2 (units) {
	        units = normalizeUnits(units);
	        return this.isValid() ? this[units + 's']() : NaN;
	    }
	
	    function makeGetter(name) {
	        return function () {
	            return this.isValid() ? this._data[name] : NaN;
	        };
	    }
	
	    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 = {
	        ss: 44,         // a few seconds to seconds
	        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.ss && ['s', seconds]  ||
	                seconds < thresholds.s   && ['ss', 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;
	        if (threshold === 's') {
	            thresholds.ss = limit - 1;
	        }
	        return true;
	    }
	
	    function humanize (withSuffix) {
	        if (!this.isValid()) {
	            return this.localeData().invalidDate();
	        }
	
	        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 sign(x) {
	        return ((x > 0) - (x < 0)) || +x;
	    }
	
	    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)
	        if (!this.isValid()) {
	            return this.localeData().invalidDate();
	        }
	
	        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 ? seconds.toFixed(3).replace(/\.?0+$/, '') : '';
	        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';
	        }
	
	        var totalSign = total < 0 ? '-' : '';
	        var ymSign = sign(this._months) !== sign(total) ? '-' : '';
	        var daysSign = sign(this._days) !== sign(total) ? '-' : '';
	        var hmsSign = sign(this._milliseconds) !== sign(total) ? '-' : '';
	
	        return totalSign + 'P' +
	            (Y ? ymSign + Y + 'Y' : '') +
	            (M ? ymSign + M + 'M' : '') +
	            (D ? daysSign + D + 'D' : '') +
	            ((h || m || s) ? 'T' : '') +
	            (h ? hmsSign + h + 'H' : '') +
	            (m ? hmsSign + m + 'M' : '') +
	            (s ? hmsSign + s + 'S' : '');
	    }
	
	    var proto$2 = Duration.prototype;
	
	    proto$2.isValid        = isValid$1;
	    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.clone          = clone$1;
	    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;
	
	    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.22.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;
	
	    // currently HTML5 input type only supports 24-hour formats
	    hooks.HTML5_FMT = {
	        DATETIME_LOCAL: 'YYYY-MM-DDTHH:mm',             // <input type="datetime-local" />
	        DATETIME_LOCAL_SECONDS: 'YYYY-MM-DDTHH:mm:ss',  // <input type="datetime-local" step="1" />
	        DATETIME_LOCAL_MS: 'YYYY-MM-DDTHH:mm:ss.SSS',   // <input type="datetime-local" step="0.001" />
	        DATE: 'YYYY-MM-DD',                             // <input type="date" />
	        TIME: 'HH:mm',                                  // <input type="time" />
	        TIME_SECONDS: 'HH:mm:ss',                       // <input type="time" step="1" />
	        TIME_MS: 'HH:mm:ss.SSS',                        // <input type="time" step="0.001" />
	        WEEK: 'YYYY-[W]WW',                             // <input type="week" />
	        MONTH: 'YYYY-MM'                                // <input type="month" />
	    };
	
	    return hooks;
	
	})));
	
	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(98)(module)))

/***/ }),
/* 14 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 */
	
	'use strict';
	
	var React = __webpack_require__(1);
	var factory = __webpack_require__(466);
	
	if (typeof React === 'undefined') {
	  throw Error(
	    'create-react-class could not find the React object. If you are using script tags, ' +
	      'make sure that React is being loaded before create-react-class.'
	  );
	}
	
	// Hack to grab NoopUpdateQueue from isomorphic React
	var ReactNoopUpdateQueue = new React.Component().updater;
	
	module.exports = factory(
	  React.Component,
	  React.isValidElement,
	  ReactNoopUpdateQueue
	);


/***/ }),
/* 15 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule EditorState
	 * @format
	 * 
	 */
	
	'use strict';
	
	var _assign = __webpack_require__(18);
	
	var _extends = _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; };
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	var BlockTree = __webpack_require__(201);
	var ContentState = __webpack_require__(123);
	var EditorBidiService = __webpack_require__(497);
	var Immutable = __webpack_require__(11);
	var SelectionState = __webpack_require__(62);
	
	var OrderedSet = Immutable.OrderedSet,
	    Record = Immutable.Record,
	    Stack = Immutable.Stack;
	
	
	var defaultRecord = {
	  allowUndo: true,
	  currentContent: null,
	  decorator: null,
	  directionMap: null,
	  forceSelection: false,
	  inCompositionMode: false,
	  inlineStyleOverride: null,
	  lastChangeType: null,
	  nativelyRenderedContent: null,
	  redoStack: Stack(),
	  selection: null,
	  treeMap: null,
	  undoStack: Stack()
	};
	
	var EditorStateRecord = Record(defaultRecord);
	
	var EditorState = function () {
	  EditorState.createEmpty = function createEmpty(decorator) {
	    return EditorState.createWithContent(ContentState.createFromText(''), decorator);
	  };
	
	  EditorState.createWithContent = function createWithContent(contentState, decorator) {
	    var firstKey = contentState.getBlockMap().first().getKey();
	    return EditorState.create({
	      currentContent: contentState,
	      undoStack: Stack(),
	      redoStack: Stack(),
	      decorator: decorator || null,
	      selection: SelectionState.createEmpty(firstKey)
	    });
	  };
	
	  EditorState.create = function create(config) {
	    var currentContent = config.currentContent,
	        decorator = config.decorator;
	
	    var recordConfig = _extends({}, config, {
	      treeMap: generateNewTreeMap(currentContent, decorator),
	      directionMap: EditorBidiService.getDirectionMap(currentContent)
	    });
	    return new EditorState(new EditorStateRecord(recordConfig));
	  };
	
	  EditorState.set = function set(editorState, put) {
	    var map = editorState.getImmutable().withMutations(function (state) {
	      var existingDecorator = state.get('decorator');
	      var decorator = existingDecorator;
	      if (put.decorator === null) {
	        decorator = null;
	      } else if (put.decorator) {
	        decorator = put.decorator;
	      }
	
	      var newContent = put.currentContent || editorState.getCurrentContent();
	
	      if (decorator !== existingDecorator) {
	        var treeMap = state.get('treeMap');
	        var newTreeMap;
	        if (decorator && existingDecorator) {
	          newTreeMap = regenerateTreeForNewDecorator(newContent, newContent.getBlockMap(), treeMap, decorator, existingDecorator);
	        } else {
	          newTreeMap = generateNewTreeMap(newContent, decorator);
	        }
	
	        state.merge({
	          decorator: decorator,
	          treeMap: newTreeMap,
	          nativelyRenderedContent: null
	        });
	        return;
	      }
	
	      var existingContent = editorState.getCurrentContent();
	      if (newContent !== existingContent) {
	        state.set('treeMap', regenerateTreeForNewBlocks(editorState, newContent.getBlockMap(), newContent.getEntityMap(), decorator));
	      }
	
	      state.merge(put);
	    });
	
	    return new EditorState(map);
	  };
	
	  EditorState.prototype.toJS = function toJS() {
	    return this.getImmutable().toJS();
	  };
	
	  EditorState.prototype.getAllowUndo = function getAllowUndo() {
	    return this.getImmutable().get('allowUndo');
	  };
	
	  EditorState.prototype.getCurrentContent = function getCurrentContent() {
	    return this.getImmutable().get('currentContent');
	  };
	
	  EditorState.prototype.getUndoStack = function getUndoStack() {
	    return this.getImmutable().get('undoStack');
	  };
	
	  EditorState.prototype.getRedoStack = function getRedoStack() {
	    return this.getImmutable().get('redoStack');
	  };
	
	  EditorState.prototype.getSelection = function getSelection() {
	    return this.getImmutable().get('selection');
	  };
	
	  EditorState.prototype.getDecorator = function getDecorator() {
	    return this.getImmutable().get('decorator');
	  };
	
	  EditorState.prototype.isInCompositionMode = function isInCompositionMode() {
	    return this.getImmutable().get('inCompositionMode');
	  };
	
	  EditorState.prototype.mustForceSelection = function mustForceSelection() {
	    return this.getImmutable().get('forceSelection');
	  };
	
	  EditorState.prototype.getNativelyRenderedContent = function getNativelyRenderedContent() {
	    return this.getImmutable().get('nativelyRenderedContent');
	  };
	
	  EditorState.prototype.getLastChangeType = function getLastChangeType() {
	    return this.getImmutable().get('lastChangeType');
	  };
	
	  /**
	   * While editing, the user may apply inline style commands with a collapsed
	   * cursor, intending to type text that adopts the specified style. In this
	   * case, we track the specified style as an "override" that takes precedence
	   * over the inline style of the text adjacent to the cursor.
	   *
	   * If null, there is no override in place.
	   */
	
	
	  EditorState.prototype.getInlineStyleOverride = function getInlineStyleOverride() {
	    return this.getImmutable().get('inlineStyleOverride');
	  };
	
	  EditorState.setInlineStyleOverride = function setInlineStyleOverride(editorState, inlineStyleOverride) {
	    return EditorState.set(editorState, { inlineStyleOverride: inlineStyleOverride });
	  };
	
	  /**
	   * Get the appropriate inline style for the editor state. If an
	   * override is in place, use it. Otherwise, the current style is
	   * based on the location of the selection state.
	   */
	
	
	  EditorState.prototype.getCurrentInlineStyle = function getCurrentInlineStyle() {
	    var override = this.getInlineStyleOverride();
	    if (override != null) {
	      return override;
	    }
	
	    var content = this.getCurrentContent();
	    var selection = this.getSelection();
	
	    if (selection.isCollapsed()) {
	      return getInlineStyleForCollapsedSelection(content, selection);
	    }
	
	    return getInlineStyleForNonCollapsedSelection(content, selection);
	  };
	
	  EditorState.prototype.getBlockTree = function getBlockTree(blockKey) {
	    return this.getImmutable().getIn(['treeMap', blockKey]);
	  };
	
	  EditorState.prototype.isSelectionAtStartOfContent = function isSelectionAtStartOfContent() {
	    var firstKey = this.getCurrentContent().getBlockMap().first().getKey();
	    return this.getSelection().hasEdgeWithin(firstKey, 0, 0);
	  };
	
	  EditorState.prototype.isSelectionAtEndOfContent = function isSelectionAtEndOfContent() {
	    var content = this.getCurrentContent();
	    var blockMap = content.getBlockMap();
	    var last = blockMap.last();
	    var end = last.getLength();
	    return this.getSelection().hasEdgeWithin(last.getKey(), end, end);
	  };
	
	  EditorState.prototype.getDirectionMap = function getDirectionMap() {
	    return this.getImmutable().get('directionMap');
	  };
	
	  /**
	   * Incorporate native DOM selection changes into the EditorState. This
	   * method can be used when we simply want to accept whatever the DOM
	   * has given us to represent selection, and we do not need to re-render
	   * the editor.
	   *
	   * To forcibly move the DOM selection, see `EditorState.forceSelection`.
	   */
	
	
	  EditorState.acceptSelection = function acceptSelection(editorState, selection) {
	    return updateSelection(editorState, selection, false);
	  };
	
	  /**
	   * At times, we need to force the DOM selection to be where we
	   * need it to be. This can occur when the anchor or focus nodes
	   * are non-text nodes, for instance. In this case, we want to trigger
	   * a re-render of the editor, which in turn forces selection into
	   * the correct place in the DOM. The `forceSelection` method
	   * accomplishes this.
	   *
	   * This method should be used in cases where you need to explicitly
	   * move the DOM selection from one place to another without a change
	   * in ContentState.
	   */
	
	
	  EditorState.forceSelection = function forceSelection(editorState, selection) {
	    if (!selection.getHasFocus()) {
	      selection = selection.set('hasFocus', true);
	    }
	    return updateSelection(editorState, selection, true);
	  };
	
	  /**
	   * Move selection to the end of the editor without forcing focus.
	   */
	
	
	  EditorState.moveSelectionToEnd = function moveSelectionToEnd(editorState) {
	    var content = editorState.getCurrentContent();
	    var lastBlock = content.getLastBlock();
	    var lastKey = lastBlock.getKey();
	    var length = lastBlock.getLength();
	
	    return EditorState.acceptSelection(editorState, new SelectionState({
	      anchorKey: lastKey,
	      anchorOffset: length,
	      focusKey: lastKey,
	      focusOffset: length,
	      isBackward: false
	    }));
	  };
	
	  /**
	   * Force focus to the end of the editor. This is useful in scenarios
	   * where we want to programmatically focus the input and it makes sense
	   * to allow the user to continue working seamlessly.
	   */
	
	
	  EditorState.moveFocusToEnd = function moveFocusToEnd(editorState) {
	    var afterSelectionMove = EditorState.moveSelectionToEnd(editorState);
	    return EditorState.forceSelection(afterSelectionMove, afterSelectionMove.getSelection());
	  };
	
	  /**
	   * Push the current ContentState onto the undo stack if it should be
	   * considered a boundary state, and set the provided ContentState as the
	   * new current content.
	   */
	
	
	  EditorState.push = function push(editorState, contentState, changeType) {
	    if (editorState.getCurrentContent() === contentState) {
	      return editorState;
	    }
	
	    var forceSelection = changeType !== 'insert-characters';
	    var directionMap = EditorBidiService.getDirectionMap(contentState, editorState.getDirectionMap());
	
	    if (!editorState.getAllowUndo()) {
	      return EditorState.set(editorState, {
	        currentContent: contentState,
	        directionMap: directionMap,
	        lastChangeType: changeType,
	        selection: contentState.getSelectionAfter(),
	        forceSelection: forceSelection,
	        inlineStyleOverride: null
	      });
	    }
	
	    var selection = editorState.getSelection();
	    var currentContent = editorState.getCurrentContent();
	    var undoStack = editorState.getUndoStack();
	    var newContent = contentState;
	
	    if (selection !== currentContent.getSelectionAfter() || mustBecomeBoundary(editorState, changeType)) {
	      undoStack = undoStack.push(currentContent);
	      newContent = newContent.set('selectionBefore', selection);
	    } else if (changeType === 'insert-characters' || changeType === 'backspace-character' || changeType === 'delete-character') {
	      // Preserve the previous selection.
	      newContent = newContent.set('selectionBefore', currentContent.getSelectionBefore());
	    }
	
	    var inlineStyleOverride = editorState.getInlineStyleOverride();
	
	    // Don't discard inline style overrides for the following change types:
	    var overrideChangeTypes = ['adjust-depth', 'change-block-type', 'split-block'];
	
	    if (overrideChangeTypes.indexOf(changeType) === -1) {
	      inlineStyleOverride = null;
	    }
	
	    var editorStateChanges = {
	      currentContent: newContent,
	      directionMap: directionMap,
	      undoStack: undoStack,
	      redoStack: Stack(),
	      lastChangeType: changeType,
	      selection: contentState.getSelectionAfter(),
	      forceSelection: forceSelection,
	      inlineStyleOverride: inlineStyleOverride
	    };
	
	    return EditorState.set(editorState, editorStateChanges);
	  };
	
	  /**
	   * Make the top ContentState in the undo stack the new current content and
	   * push the current content onto the redo stack.
	   */
	
	
	  EditorState.undo = function undo(editorState) {
	    if (!editorState.getAllowUndo()) {
	      return editorState;
	    }
	
	    var undoStack = editorState.getUndoStack();
	    var newCurrentContent = undoStack.peek();
	    if (!newCurrentContent) {
	      return editorState;
	    }
	
	    var currentContent = editorState.getCurrentContent();
	    var directionMap = EditorBidiService.getDirectionMap(newCurrentContent, editorState.getDirectionMap());
	
	    return EditorState.set(editorState, {
	      currentContent: newCurrentContent,
	      directionMap: directionMap,
	      undoStack: undoStack.shift(),
	      redoStack: editorState.getRedoStack().push(currentContent),
	      forceSelection: true,
	      inlineStyleOverride: null,
	      lastChangeType: 'undo',
	      nativelyRenderedContent: null,
	      selection: currentContent.getSelectionBefore()
	    });
	  };
	
	  /**
	   * Make the top ContentState in the redo stack the new current content and
	   * push the current content onto the undo stack.
	   */
	
	
	  EditorState.redo = function redo(editorState) {
	    if (!editorState.getAllowUndo()) {
	      return editorState;
	    }
	
	    var redoStack = editorState.getRedoStack();
	    var newCurrentContent = redoStack.peek();
	    if (!newCurrentContent) {
	      return editorState;
	    }
	
	    var currentContent = editorState.getCurrentContent();
	    var directionMap = EditorBidiService.getDirectionMap(newCurrentContent, editorState.getDirectionMap());
	
	    return EditorState.set(editorState, {
	      currentContent: newCurrentContent,
	      directionMap: directionMap,
	      undoStack: editorState.getUndoStack().push(currentContent),
	      redoStack: redoStack.shift(),
	      forceSelection: true,
	      inlineStyleOverride: null,
	      lastChangeType: 'redo',
	      nativelyRenderedContent: null,
	      selection: newCurrentContent.getSelectionAfter()
	    });
	  };
	
	  /**
	   * Not for public consumption.
	   */
	
	
	  function EditorState(immutable) {
	    _classCallCheck(this, EditorState);
	
	    this._immutable = immutable;
	  }
	
	  /**
	   * Not for public consumption.
	   */
	
	
	  EditorState.prototype.getImmutable = function getImmutable() {
	    return this._immutable;
	  };
	
	  return EditorState;
	}();
	
	/**
	 * Set the supplied SelectionState as the new current selection, and set
	 * the `force` flag to trigger manual selection placement by the view.
	 */
	
	
	function updateSelection(editorState, selection, forceSelection) {
	  return EditorState.set(editorState, {
	    selection: selection,
	    forceSelection: forceSelection,
	    nativelyRenderedContent: null,
	    inlineStyleOverride: null
	  });
	}
	
	/**
	 * Regenerate the entire tree map for a given ContentState and decorator.
	 * Returns an OrderedMap that maps all available ContentBlock objects.
	 */
	function generateNewTreeMap(contentState, decorator) {
	  return contentState.getBlockMap().map(function (block) {
	    return BlockTree.generate(contentState, block, decorator);
	  }).toOrderedMap();
	}
	
	/**
	 * Regenerate tree map objects for all ContentBlocks that have changed
	 * between the current editorState and newContent. Returns an OrderedMap
	 * with only changed regenerated tree map objects.
	 */
	function regenerateTreeForNewBlocks(editorState, newBlockMap, newEntityMap, decorator) {
	  var contentState = editorState.getCurrentContent().set('entityMap', newEntityMap);
	  var prevBlockMap = contentState.getBlockMap();
	  var prevTreeMap = editorState.getImmutable().get('treeMap');
	  return prevTreeMap.merge(newBlockMap.toSeq().filter(function (block, key) {
	    return block !== prevBlockMap.get(key);
	  }).map(function (block) {
	    return BlockTree.generate(contentState, block, decorator);
	  }));
	}
	
	/**
	 * Generate tree map objects for a new decorator object, preserving any
	 * decorations that are unchanged from the previous decorator.
	 *
	 * Note that in order for this to perform optimally, decoration Lists for
	 * decorators should be preserved when possible to allow for direct immutable
	 * List comparison.
	 */
	function regenerateTreeForNewDecorator(content, blockMap, previousTreeMap, decorator, existingDecorator) {
	  return previousTreeMap.merge(blockMap.toSeq().filter(function (block) {
	    return decorator.getDecorations(block, content) !== existingDecorator.getDecorations(block, content);
	  }).map(function (block) {
	    return BlockTree.generate(content, block, decorator);
	  }));
	}
	
	/**
	 * Return whether a change should be considered a boundary state, given
	 * the previous change type. Allows us to discard potential boundary states
	 * during standard typing or deletion behavior.
	 */
	function mustBecomeBoundary(editorState, changeType) {
	  var lastChangeType = editorState.getLastChangeType();
	  return changeType !== lastChangeType || changeType !== 'insert-characters' && changeType !== 'backspace-character' && changeType !== 'delete-character';
	}
	
	function getInlineStyleForCollapsedSelection(content, selection) {
	  var startKey = selection.getStartKey();
	  var startOffset = selection.getStartOffset();
	  var startBlock = content.getBlockForKey(startKey);
	
	  // If the cursor is not at the start of the block, look backward to
	  // preserve the style of the preceding character.
	  if (startOffset > 0) {
	    return startBlock.getInlineStyleAt(startOffset - 1);
	  }
	
	  // The caret is at position zero in this block. If the block has any
	  // text at all, use the style of the first character.
	  if (startBlock.getLength()) {
	    return startBlock.getInlineStyleAt(0);
	  }
	
	  // Otherwise, look upward in the document to find the closest character.
	  return lookUpwardForInlineStyle(content, startKey);
	}
	
	function getInlineStyleForNonCollapsedSelection(content, selection) {
	  var startKey = selection.getStartKey();
	  var startOffset = selection.getStartOffset();
	  var startBlock = content.getBlockForKey(startKey);
	
	  // If there is a character just inside the selection, use its style.
	  if (startOffset < startBlock.getLength()) {
	    return startBlock.getInlineStyleAt(startOffset);
	  }
	
	  // Check if the selection at the end of a non-empty block. Use the last
	  // style in the block.
	  if (startOffset > 0) {
	    return startBlock.getInlineStyleAt(startOffset - 1);
	  }
	
	  // Otherwise, look upward in the document to find the closest character.
	  return lookUpwardForInlineStyle(content, startKey);
	}
	
	function lookUpwardForInlineStyle(content, fromKey) {
	  var lastNonEmpty = content.getBlockMap().reverse().skipUntil(function (_, k) {
	    return k === fromKey;
	  }).skip(1).skipUntil(function (block, _) {
	    return block.getLength();
	  }).first();
	
	  if (lastNonEmpty) return lastNonEmpty.getInlineStyleAt(lastNonEmpty.getLength() - 1);
	  return OrderedSet();
	}
	
	module.exports = EditorState;

/***/ }),
/* 16 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _omit = __webpack_require__(28);
	
	var _omit2 = _interopRequireDefault(_omit);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var Icon = function Icon(props) {
	    var type = props.type,
	        _props$className = props.className,
	        className = _props$className === undefined ? '' : _props$className,
	        spin = props.spin;
	
	    var classString = (0, _classnames2['default'])((0, _defineProperty3['default'])({
	        anticon: true,
	        'anticon-spin': !!spin || type === 'loading'
	    }, 'anticon-' + type, true), className);
	    return _react2['default'].createElement('i', (0, _extends3['default'])({}, (0, _omit2['default'])(props, ['type', 'spin']), { className: classString }));
	};
	exports['default'] = Icon;
	module.exports = exports['default'];

/***/ }),
/* 17 */
/***/ (function(module, exports) {

	// removed by extract-text-webpack-plugin

/***/ }),
/* 18 */
/***/ (function(module, exports) {

	/*
	object-assign
	(c) Sindre Sorhus
	@license MIT
	*/
	
	'use strict';
	/* eslint-disable no-unused-vars */
	var getOwnPropertySymbols = Object.getOwnPropertySymbols;
	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 no-new-wrappers
			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 (err) {
			// 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 (getOwnPropertySymbols) {
				symbols = getOwnPropertySymbols(from);
				for (var i = 0; i < symbols.length; i++) {
					if (propIsEnumerable.call(from, symbols[i])) {
						to[symbols[i]] = from[symbols[i]];
					}
				}
			}
		}
	
		return to;
	};


/***/ }),
/* 19 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.warning = undefined;
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _typeof2 = __webpack_require__(21);
	
	var _typeof3 = _interopRequireDefault(_typeof2);
	
	exports.format = format;
	exports.isEmptyValue = isEmptyValue;
	exports.isEmptyObject = isEmptyObject;
	exports.asyncMap = asyncMap;
	exports.complementError = complementError;
	exports.deepMerge = deepMerge;
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var formatRegExp = /%[sdj%]/g;
	
	var warning = exports.warning = function warning() {};
	
	// don't print warning message when in production env or node runtime
	if (("development") !== 'production' && typeof window !== 'undefined' && typeof document !== 'undefined') {
	  exports.warning = warning = function warning(type, errors) {
	    if (typeof console !== 'undefined' && console.warn) {
	      if (errors.every(function (e) {
	        return typeof e === 'string';
	      })) {
	        console.warn(type, errors);
	      }
	    }
	  };
	}
	
	function format() {
	  for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
	    args[_key] = arguments[_key];
	  }
	
	  var i = 1;
	  var f = args[0];
	  var len = args.length;
	  if (typeof f === 'function') {
	    return f.apply(null, args.slice(1));
	  }
	  if (typeof f === 'string') {
	    var str = String(f).replace(formatRegExp, function (x) {
	      if (x === '%%') {
	        return '%';
	      }
	      if (i >= len) {
	        return x;
	      }
	      switch (x) {
	        case '%s':
	          return String(args[i++]);
	        case '%d':
	          return Number(args[i++]);
	        case '%j':
	          try {
	            return JSON.stringify(args[i++]);
	          } catch (_) {
	            return '[Circular]';
	          }
	          break;
	        default:
	          return x;
	      }
	    });
	    for (var arg = args[i]; i < len; arg = args[++i]) {
	      str += ' ' + arg;
	    }
	    return str;
	  }
	  return f;
	}
	
	function isNativeStringType(type) {
	  return type === 'string' || type === 'url' || type === 'hex' || type === 'email' || type === 'pattern';
	}
	
	function isEmptyValue(value, type) {
	  if (value === undefined || value === null) {
	    return true;
	  }
	  if (type === 'array' && Array.isArray(value) && !value.length) {
	    return true;
	  }
	  if (isNativeStringType(type) && typeof value === 'string' && !value) {
	    return true;
	  }
	  return false;
	}
	
	function isEmptyObject(obj) {
	  return Object.keys(obj).length === 0;
	}
	
	function asyncParallelArray(arr, func, callback) {
	  var results = [];
	  var total = 0;
	  var arrLength = arr.length;
	
	  function count(errors) {
	    results.push.apply(results, errors);
	    total++;
	    if (total === arrLength) {
	      callback(results);
	    }
	  }
	
	  arr.forEach(function (a) {
	    func(a, count);
	  });
	}
	
	function asyncSerialArray(arr, func, callback) {
	  var index = 0;
	  var arrLength = arr.length;
	
	  function next(errors) {
	    if (errors && errors.length) {
	      callback(errors);
	      return;
	    }
	    var original = index;
	    index = index + 1;
	    if (original < arrLength) {
	      func(arr[original], next);
	    } else {
	      callback([]);
	    }
	  }
	
	  next([]);
	}
	
	function flattenObjArr(objArr) {
	  var ret = [];
	  Object.keys(objArr).forEach(function (k) {
	    ret.push.apply(ret, objArr[k]);
	  });
	  return ret;
	}
	
	function asyncMap(objArr, option, func, callback) {
	  if (option.first) {
	    var flattenArr = flattenObjArr(objArr);
	    return asyncSerialArray(flattenArr, func, callback);
	  }
	  var firstFields = option.firstFields || [];
	  if (firstFields === true) {
	    firstFields = Object.keys(objArr);
	  }
	  var objArrKeys = Object.keys(objArr);
	  var objArrLength = objArrKeys.length;
	  var total = 0;
	  var results = [];
	  var next = function next(errors) {
	    results.push.apply(results, errors);
	    total++;
	    if (total === objArrLength) {
	      callback(results);
	    }
	  };
	  objArrKeys.forEach(function (key) {
	    var arr = objArr[key];
	    if (firstFields.indexOf(key) !== -1) {
	      asyncSerialArray(arr, func, next);
	    } else {
	      asyncParallelArray(arr, func, next);
	    }
	  });
	}
	
	function complementError(rule) {
	  return function (oe) {
	    if (oe && oe.message) {
	      oe.field = oe.field || rule.fullField;
	      return oe;
	    }
	    return {
	      message: oe,
	      field: oe.field || rule.fullField
	    };
	  };
	}
	
	function deepMerge(target, source) {
	  if (source) {
	    for (var s in source) {
	      if (source.hasOwnProperty(s)) {
	        var value = source[s];
	        if ((typeof value === 'undefined' ? 'undefined' : (0, _typeof3['default'])(value)) === 'object' && (0, _typeof3['default'])(target[s]) === 'object') {
	          target[s] = (0, _extends3['default'])({}, target[s], value);
	        } else {
	          target[s] = value;
	        }
	      }
	    }
	  }
	  return target;
	}

/***/ }),
/* 20 */
/***/ (function(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;
	};

/***/ }),
/* 21 */
/***/ (function(module, exports, __webpack_require__) {

	"use strict";
	
	exports.__esModule = true;
	
	var _iterator = __webpack_require__(419);
	
	var _iterator2 = _interopRequireDefault(_iterator);
	
	var _symbol = __webpack_require__(418);
	
	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);
	};

/***/ }),
/* 22 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _ChildrenUtils = __webpack_require__(659);
	
	var _AnimateChild = __webpack_require__(658);
	
	var _AnimateChild2 = _interopRequireDefault(_AnimateChild);
	
	var _util = __webpack_require__(240);
	
	var _util2 = _interopRequireDefault(_util);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var defaultKey = 'rc_animate_' + Date.now();
	
	
	function getChildrenFromProps(props) {
	  var children = props.children;
	  if (_react2['default'].isValidElement(children)) {
	    if (!children.key) {
	      return _react2['default'].cloneElement(children, {
	        key: defaultKey
	      });
	    }
	  }
	  return children;
	}
	
	function noop() {}
	
	var Animate = function (_React$Component) {
	  (0, _inherits3['default'])(Animate, _React$Component);
	
	  // eslint-disable-line
	
	  function Animate(props) {
	    (0, _classCallCheck3['default'])(this, Animate);
	
	    var _this = (0, _possibleConstructorReturn3['default'])(this, (Animate.__proto__ || Object.getPrototypeOf(Animate)).call(this, props));
	
	    _initialiseProps.call(_this);
	
	    _this.currentlyAnimatingKeys = {};
	    _this.keysToEnter = [];
	    _this.keysToLeave = [];
	
	    _this.state = {
	      children: (0, _ChildrenUtils.toArrayChildren)(getChildrenFromProps(props))
	    };
	
	    _this.childrenRefs = {};
	    return _this;
	  }
	
	  (0, _createClass3['default'])(Animate, [{
	    key: 'componentDidMount',
	    value: function componentDidMount() {
	      var _this2 = this;
	
	      var showProp = this.props.showProp;
	      var children = this.state.children;
	      if (showProp) {
	        children = children.filter(function (child) {
	          return !!child.props[showProp];
	        });
	      }
	      children.forEach(function (child) {
	        if (child) {
	          _this2.performAppear(child.key);
	        }
	      });
	    }
	  }, {
	    key: 'componentWillReceiveProps',
	    value: function componentWillReceiveProps(nextProps) {
	      var _this3 = this;
	
	      this.nextProps = nextProps;
	      var nextChildren = (0, _ChildrenUtils.toArrayChildren)(getChildrenFromProps(nextProps));
	      var props = this.props;
	      // exclusive needs immediate response
	      if (props.exclusive) {
	        Object.keys(this.currentlyAnimatingKeys).forEach(function (key) {
	          _this3.stop(key);
	        });
	      }
	      var showProp = props.showProp;
	      var currentlyAnimatingKeys = this.currentlyAnimatingKeys;
	      // last props children if exclusive
	      var currentChildren = props.exclusive ? (0, _ChildrenUtils.toArrayChildren)(getChildrenFromProps(props)) : this.state.children;
	      // in case destroy in showProp mode
	      var newChildren = [];
	      if (showProp) {
	        currentChildren.forEach(function (currentChild) {
	          var nextChild = currentChild && (0, _ChildrenUtils.findChildInChildrenByKey)(nextChildren, currentChild.key);
	          var newChild = void 0;
	          if ((!nextChild || !nextChild.props[showProp]) && currentChild.props[showProp]) {
	            newChild = _react2['default'].cloneElement(nextChild || currentChild, (0, _defineProperty3['default'])({}, showProp, true));
	          } else {
	            newChild = nextChild;
	          }
	          if (newChild) {
	            newChildren.push(newChild);
	          }
	        });
	        nextChildren.forEach(function (nextChild) {
	          if (!nextChild || !(0, _ChildrenUtils.findChildInChildrenByKey)(currentChildren, nextChild.key)) {
	            newChildren.push(nextChild);
	          }
	        });
	      } else {
	        newChildren = (0, _ChildrenUtils.mergeChildren)(currentChildren, nextChildren);
	      }
	
	      // need render to avoid update
	      this.setState({
	        children: newChildren
	      });
	
	      nextChildren.forEach(function (child) {
	        var key = child && child.key;
	        if (child && currentlyAnimatingKeys[key]) {
	          return;
	        }
	        var hasPrev = child && (0, _ChildrenUtils.findChildInChildrenByKey)(currentChildren, key);
	        if (showProp) {
	          var showInNext = child.props[showProp];
	          if (hasPrev) {
	            var showInNow = (0, _ChildrenUtils.findShownChildInChildrenByKey)(currentChildren, key, showProp);
	            if (!showInNow && showInNext) {
	              _this3.keysToEnter.push(key);
	            }
	          } else if (showInNext) {
	            _this3.keysToEnter.push(key);
	          }
	        } else if (!hasPrev) {
	          _this3.keysToEnter.push(key);
	        }
	      });
	
	      currentChildren.forEach(function (child) {
	        var key = child && child.key;
	        if (child && currentlyAnimatingKeys[key]) {
	          return;
	        }
	        var hasNext = child && (0, _ChildrenUtils.findChildInChildrenByKey)(nextChildren, key);
	        if (showProp) {
	          var showInNow = child.props[showProp];
	          if (hasNext) {
	            var showInNext = (0, _ChildrenUtils.findShownChildInChildrenByKey)(nextChildren, key, showProp);
	            if (!showInNext && showInNow) {
	              _this3.keysToLeave.push(key);
	            }
	          } else if (showInNow) {
	            _this3.keysToLeave.push(key);
	          }
	        } else if (!hasNext) {
	          _this3.keysToLeave.push(key);
	        }
	      });
	    }
	  }, {
	    key: 'componentDidUpdate',
	    value: function componentDidUpdate() {
	      var keysToEnter = this.keysToEnter;
	      this.keysToEnter = [];
	      keysToEnter.forEach(this.performEnter);
	      var keysToLeave = this.keysToLeave;
	      this.keysToLeave = [];
	      keysToLeave.forEach(this.performLeave);
	    }
	  }, {
	    key: 'isValidChildByKey',
	    value: function isValidChildByKey(currentChildren, key) {
	      var showProp = this.props.showProp;
	      if (showProp) {
	        return (0, _ChildrenUtils.findShownChildInChildrenByKey)(currentChildren, key, showProp);
	      }
	      return (0, _ChildrenUtils.findChildInChildrenByKey)(currentChildren, key);
	    }
	  }, {
	    key: 'stop',
	    value: function stop(key) {
	      delete this.currentlyAnimatingKeys[key];
	      var component = this.childrenRefs[key];
	      if (component) {
	        component.stop();
	      }
	    }
	  }, {
	    key: 'render',
	    value: function render() {
	      var _this4 = this;
	
	      var props = this.props;
	      this.nextProps = props;
	      var stateChildren = this.state.children;
	      var children = null;
	      if (stateChildren) {
	        children = stateChildren.map(function (child) {
	          if (child === null || child === undefined) {
	            return child;
	          }
	          if (!child.key) {
	            throw new Error('must set key for <rc-animate> children');
	          }
	          return _react2['default'].createElement(
	            _AnimateChild2['default'],
	            {
	              key: child.key,
	              ref: function ref(node) {
	                return _this4.childrenRefs[child.key] = node;
	              },
	              animation: props.animation,
	              transitionName: props.transitionName,
	              transitionEnter: props.transitionEnter,
	              transitionAppear: props.transitionAppear,
	              transitionLeave: props.transitionLeave
	            },
	            child
	          );
	        });
	      }
	      var Component = props.component;
	      if (Component) {
	        var passedProps = props;
	        if (typeof Component === 'string') {
	          passedProps = (0, _extends3['default'])({
	            className: props.className,
	            style: props.style
	          }, props.componentProps);
	        }
	        return _react2['default'].createElement(
	          Component,
	          passedProps,
	          children
	        );
	      }
	      return children[0] || null;
	    }
	  }]);
	  return Animate;
	}(_react2['default'].Component);
	
	Animate.isAnimate = true;
	Animate.propTypes = {
	  component: _propTypes2['default'].any,
	  componentProps: _propTypes2['default'].object,
	  animation: _propTypes2['default'].object,
	  transitionName: _propTypes2['default'].oneOfType([_propTypes2['default'].string, _propTypes2['default'].object]),
	  transitionEnter: _propTypes2['default'].bool,
	  transitionAppear: _propTypes2['default'].bool,
	  exclusive: _propTypes2['default'].bool,
	  transitionLeave: _propTypes2['default'].bool,
	  onEnd: _propTypes2['default'].func,
	  onEnter: _propTypes2['default'].func,
	  onLeave: _propTypes2['default'].func,
	  onAppear: _propTypes2['default'].func,
	  showProp: _propTypes2['default'].string
	};
	Animate.defaultProps = {
	  animation: {},
	  component: 'span',
	  componentProps: {},
	  transitionEnter: true,
	  transitionLeave: true,
	  transitionAppear: false,
	  onEnd: noop,
	  onEnter: noop,
	  onLeave: noop,
	  onAppear: noop
	};
	
	var _initialiseProps = function _initialiseProps() {
	  var _this5 = this;
	
	  this.performEnter = function (key) {
	    // may already remove by exclusive
	    if (_this5.childrenRefs[key]) {
	      _this5.currentlyAnimatingKeys[key] = true;
	      _this5.childrenRefs[key].componentWillEnter(_this5.handleDoneAdding.bind(_this5, key, 'enter'));
	    }
	  };
	
	  this.performAppear = function (key) {
	    if (_this5.childrenRefs[key]) {
	      _this5.currentlyAnimatingKeys[key] = true;
	      _this5.childrenRefs[key].componentWillAppear(_this5.handleDoneAdding.bind(_this5, key, 'appear'));
	    }
	  };
	
	  this.handleDoneAdding = function (key, type) {
	    var props = _this5.props;
	    delete _this5.currentlyAnimatingKeys[key];
	    // if update on exclusive mode, skip check
	    if (props.exclusive && props !== _this5.nextProps) {
	      return;
	    }
	    var currentChildren = (0, _ChildrenUtils.toArrayChildren)(getChildrenFromProps(props));
	    if (!_this5.isValidChildByKey(currentChildren, key)) {
	      // exclusive will not need this
	      _this5.performLeave(key);
	    } else {
	      if (type === 'appear') {
	        if (_util2['default'].allowAppearCallback(props)) {
	          props.onAppear(key);
	          props.onEnd(key, true);
	        }
	      } else {
	        if (_util2['default'].allowEnterCallback(props)) {
	          props.onEnter(key);
	          props.onEnd(key, true);
	        }
	      }
	    }
	  };
	
	  this.performLeave = function (key) {
	    // may already remove by exclusive
	    if (_this5.childrenRefs[key]) {
	      _this5.currentlyAnimatingKeys[key] = true;
	      _this5.childrenRefs[key].componentWillLeave(_this5.handleDoneLeaving.bind(_this5, key));
	    }
	  };
	
	  this.handleDoneLeaving = function (key) {
	    var props = _this5.props;
	    delete _this5.currentlyAnimatingKeys[key];
	    // if update on exclusive mode, skip check
	    if (props.exclusive && props !== _this5.nextProps) {
	      return;
	    }
	    var currentChildren = (0, _ChildrenUtils.toArrayChildren)(getChildrenFromProps(props));
	    // in case state change is too fast
	    if (_this5.isValidChildByKey(currentChildren, key)) {
	      _this5.performEnter(key);
	    } else {
	      var end = function end() {
	        if (_util2['default'].allowLeaveCallback(props)) {
	          props.onLeave(key);
	          props.onEnd(key, false);
	        }
	      };
	      if (!(0, _ChildrenUtils.isSameChildren)(_this5.state.children, currentChildren, props.showProp)) {
	        _this5.setState({
	          children: currentChildren
	        }, end);
	      } else {
	        end();
	      }
	    }
	  };
	};
	
	exports['default'] = Animate;
	module.exports = exports['default'];

/***/ }),
/* 23 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _required = __webpack_require__(157);
	
	var _required2 = _interopRequireDefault(_required);
	
	var _whitespace = __webpack_require__(298);
	
	var _whitespace2 = _interopRequireDefault(_whitespace);
	
	var _type = __webpack_require__(297);
	
	var _type2 = _interopRequireDefault(_type);
	
	var _range = __webpack_require__(296);
	
	var _range2 = _interopRequireDefault(_range);
	
	var _enum = __webpack_require__(294);
	
	var _enum2 = _interopRequireDefault(_enum);
	
	var _pattern = __webpack_require__(295);
	
	var _pattern2 = _interopRequireDefault(_pattern);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	exports['default'] = {
	  required: _required2['default'],
	  whitespace: _whitespace2['default'],
	  type: _type2['default'],
	  range: _range2['default'],
	  'enum': _enum2['default'],
	  pattern: _pattern2['default']
	};
	module.exports = exports['default'];

/***/ }),
/* 24 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _warning = __webpack_require__(35);
	
	var _warning2 = _interopRequireDefault(_warning);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var warned = {};
	
	exports['default'] = function (valid, message) {
	    if (!valid && !warned[message]) {
	        (0, _warning2['default'])(false, message);
	        warned[message] = true;
	    }
	};
	
	module.exports = exports['default'];

/***/ }),
/* 25 */
/***/ (function(module, exports) {

	var core = module.exports = { version: '2.5.5' };
	if (typeof __e == 'number') __e = core; // eslint-disable-line no-undef


/***/ }),
/* 26 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule DraftModifier
	 * @format
	 * 
	 */
	
	'use strict';
	
	var CharacterMetadata = __webpack_require__(27);
	var ContentStateInlineStyle = __webpack_require__(482);
	var DraftFeatureFlags = __webpack_require__(42);
	var Immutable = __webpack_require__(11);
	
	var applyEntityToContentState = __webpack_require__(501);
	var getCharacterRemovalRange = __webpack_require__(522);
	var getContentStateFragment = __webpack_require__(90);
	var insertFragmentIntoContentState = __webpack_require__(527);
	var insertTextIntoContentState = __webpack_require__(528);
	var invariant = __webpack_require__(12);
	var modifyBlockForContentState = __webpack_require__(539);
	var removeEntitiesAtEdges = __webpack_require__(222);
	var removeRangeFromContentState = __webpack_require__(541);
	var splitBlockInContentState = __webpack_require__(543);
	
	var OrderedSet = Immutable.OrderedSet;
	
	/**
	 * `DraftModifier` provides a set of convenience methods that apply
	 * modifications to a `ContentState` object based on a target `SelectionState`.
	 *
	 * Any change to a `ContentState` should be decomposable into a series of
	 * transaction functions that apply the required changes and return output
	 * `ContentState` objects.
	 *
	 * These functions encapsulate some of the most common transaction sequences.
	 */
	
	var DraftModifier = {
	  replaceText: function replaceText(contentState, rangeToReplace, text, inlineStyle, entityKey) {
	    var withoutEntities = removeEntitiesAtEdges(contentState, rangeToReplace);
	    var withoutText = removeRangeFromContentState(withoutEntities, rangeToReplace);
	
	    var character = CharacterMetadata.create({
	      style: inlineStyle || OrderedSet(),
	      entity: entityKey || null
	    });
	
	    return insertTextIntoContentState(withoutText, withoutText.getSelectionAfter(), text, character);
	  },
	
	  insertText: function insertText(contentState, targetRange, text, inlineStyle, entityKey) {
	    !targetRange.isCollapsed() ?  true ? invariant(false, 'Target range must be collapsed for `insertText`.') : invariant(false) : void 0;
	    return DraftModifier.replaceText(contentState, targetRange, text, inlineStyle, entityKey);
	  },
	
	  moveText: function moveText(contentState, removalRange, targetRange) {
	    var movedFragment = getContentStateFragment(contentState, removalRange);
	
	    var afterRemoval = DraftModifier.removeRange(contentState, removalRange, 'backward');
	
	    return DraftModifier.replaceWithFragment(afterRemoval, targetRange, movedFragment);
	  },
	
	  replaceWithFragment: function replaceWithFragment(contentState, targetRange, fragment) {
	    var withoutEntities = removeEntitiesAtEdges(contentState, targetRange);
	    var withoutText = removeRangeFromContentState(withoutEntities, targetRange);
	
	    return insertFragmentIntoContentState(withoutText, withoutText.getSelectionAfter(), fragment);
	  },
	
	  removeRange: function removeRange(contentState, rangeToRemove, removalDirection) {
	    var startKey = void 0,
	        endKey = void 0,
	        startBlock = void 0,
	        endBlock = void 0;
	    if (rangeToRemove.getIsBackward()) {
	      rangeToRemove = rangeToRemove.merge({
	        anchorKey: rangeToRemove.getFocusKey(),
	        anchorOffset: rangeToRemove.getFocusOffset(),
	        focusKey: rangeToRemove.getAnchorKey(),
	        focusOffset: rangeToRemove.getAnchorOffset(),
	        isBackward: false
	      });
	    }
	    startKey = rangeToRemove.getAnchorKey();
	    endKey = rangeToRemove.getFocusKey();
	    startBlock = contentState.getBlockForKey(startKey);
	    endBlock = contentState.getBlockForKey(endKey);
	    var startOffset = rangeToRemove.getStartOffset();
	    var endOffset = rangeToRemove.getEndOffset();
	
	    var startEntityKey = startBlock.getEntityAt(startOffset);
	    var endEntityKey = endBlock.getEntityAt(endOffset - 1);
	
	    // Check whether the selection state overlaps with a single entity.
	    // If so, try to remove the appropriate substring of the entity text.
	    if (startKey === endKey) {
	      if (startEntityKey && startEntityKey === endEntityKey) {
	        var _adjustedRemovalRange = getCharacterRemovalRange(contentState.getEntityMap(), startBlock, endBlock, rangeToRemove, removalDirection);
	        return removeRangeFromContentState(contentState, _adjustedRemovalRange);
	      }
	    }
	    var adjustedRemovalRange = rangeToRemove;
	    if (DraftFeatureFlags.draft_segmented_entities_behavior) {
	      // Adjust the selection to properly delete segemented and immutable
	      // entities
	      adjustedRemovalRange = getCharacterRemovalRange(contentState.getEntityMap(), startBlock, endBlock, rangeToRemove, removalDirection);
	    }
	
	    var withoutEntities = removeEntitiesAtEdges(contentState, adjustedRemovalRange);
	    return removeRangeFromContentState(withoutEntities, adjustedRemovalRange);
	  },
	
	  splitBlock: function splitBlock(contentState, selectionState) {
	    var withoutEntities = removeEntitiesAtEdges(contentState, selectionState);
	    var withoutText = removeRangeFromContentState(withoutEntities, selectionState);
	
	    return splitBlockInContentState(withoutText, withoutText.getSelectionAfter());
	  },
	
	  applyInlineStyle: function applyInlineStyle(contentState, selectionState, inlineStyle) {
	    return ContentStateInlineStyle.add(contentState, selectionState, inlineStyle);
	  },
	
	  removeInlineStyle: function removeInlineStyle(contentState, selectionState, inlineStyle) {
	    return ContentStateInlineStyle.remove(contentState, selectionState, inlineStyle);
	  },
	
	  setBlockType: function setBlockType(contentState, selectionState, blockType) {
	    return modifyBlockForContentState(contentState, selectionState, function (block) {
	      return block.merge({ type: blockType, depth: 0 });
	    });
	  },
	
	  setBlockData: function setBlockData(contentState, selectionState, blockData) {
	    return modifyBlockForContentState(contentState, selectionState, function (block) {
	      return block.merge({ data: blockData });
	    });
	  },
	
	  mergeBlockData: function mergeBlockData(contentState, selectionState, blockData) {
	    return modifyBlockForContentState(contentState, selectionState, function (block) {
	      return block.merge({ data: block.getData().merge(blockData) });
	    });
	  },
	
	  applyEntity: function applyEntity(contentState, selectionState, entityKey) {
	    var withoutEntities = removeEntitiesAtEdges(contentState, selectionState);
	    return applyEntityToContentState(withoutEntities, selectionState, entityKey);
	  }
	};
	
	module.exports = DraftModifier;

/***/ }),
/* 27 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule CharacterMetadata
	 * @format
	 * 
	 */
	
	'use strict';
	
	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 _require = __webpack_require__(11),
	    Map = _require.Map,
	    OrderedSet = _require.OrderedSet,
	    Record = _require.Record;
	
	// Immutable.map is typed such that the value for every key in the map
	// must be the same type
	
	
	var EMPTY_SET = OrderedSet();
	
	var defaultRecord = {
	  style: EMPTY_SET,
	  entity: null
	};
	
	var CharacterMetadataRecord = Record(defaultRecord);
	
	var CharacterMetadata = function (_CharacterMetadataRec) {
	  _inherits(CharacterMetadata, _CharacterMetadataRec);
	
	  function CharacterMetadata() {
	    _classCallCheck(this, CharacterMetadata);
	
	    return _possibleConstructorReturn(this, _CharacterMetadataRec.apply(this, arguments));
	  }
	
	  CharacterMetadata.prototype.getStyle = function getStyle() {
	    return this.get('style');
	  };
	
	  CharacterMetadata.prototype.getEntity = function getEntity() {
	    return this.get('entity');
	  };
	
	  CharacterMetadata.prototype.hasStyle = function hasStyle(style) {
	    return this.getStyle().includes(style);
	  };
	
	  CharacterMetadata.applyStyle = function applyStyle(record, style) {
	    var withStyle = record.set('style', record.getStyle().add(style));
	    return CharacterMetadata.create(withStyle);
	  };
	
	  CharacterMetadata.removeStyle = function removeStyle(record, style) {
	    var withoutStyle = record.set('style', record.getStyle().remove(style));
	    return CharacterMetadata.create(withoutStyle);
	  };
	
	  CharacterMetadata.applyEntity = function applyEntity(record, entityKey) {
	    var withEntity = record.getEntity() === entityKey ? record : record.set('entity', entityKey);
	    return CharacterMetadata.create(withEntity);
	  };
	
	  /**
	   * Use this function instead of the `CharacterMetadata` constructor.
	   * Since most content generally uses only a very small number of
	   * style/entity permutations, we can reuse these objects as often as
	   * possible.
	   */
	
	
	  CharacterMetadata.create = function create(config) {
	    if (!config) {
	      return EMPTY;
	    }
	
	    var defaultConfig = {
	      style: EMPTY_SET,
	      entity: null
	    };
	
	    // Fill in unspecified properties, if necessary.
	    var configMap = Map(defaultConfig).merge(config);
	
	    var existing = pool.get(configMap);
	    if (existing) {
	      return existing;
	    }
	
	    var newCharacter = new CharacterMetadata(configMap);
	    pool = pool.set(configMap, newCharacter);
	    return newCharacter;
	  };
	
	  return CharacterMetadata;
	}(CharacterMetadataRecord);
	
	var EMPTY = new CharacterMetadata();
	var pool = Map([[Map(defaultRecord), EMPTY]]);
	
	CharacterMetadata.EMPTY = EMPTY;
	
	module.exports = CharacterMetadata;

/***/ }),
/* 28 */
/***/ (function(module, exports, __webpack_require__) {

	"use strict";
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
	
	function omit(obj, fields) {
	  var shallowCopy = (0, _extends3["default"])({}, obj);
	  for (var i = 0; i < fields.length; i++) {
	    var key = fields[i];
	    delete shallowCopy[key];
	  }
	  return shallowCopy;
	}
	
	exports["default"] = omit;
	module.exports = exports['default'];

/***/ }),
/* 29 */
/***/ (function(module, exports) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	/**
	 * @ignore
	 * some key-codes definition and utils from closure-library
	 * @author yiminghe@gmail.com
	 */
	
	var KeyCode = {
	  /**
	   * MAC_ENTER
	   */
	  MAC_ENTER: 3,
	  /**
	   * BACKSPACE
	   */
	  BACKSPACE: 8,
	  /**
	   * TAB
	   */
	  TAB: 9,
	  /**
	   * NUMLOCK on FF/Safari Mac
	   */
	  NUM_CENTER: 12, // NUMLOCK on FF/Safari Mac
	  /**
	   * ENTER
	   */
	  ENTER: 13,
	  /**
	   * SHIFT
	   */
	  SHIFT: 16,
	  /**
	   * CTRL
	   */
	  CTRL: 17,
	  /**
	   * ALT
	   */
	  ALT: 18,
	  /**
	   * PAUSE
	   */
	  PAUSE: 19,
	  /**
	   * CAPS_LOCK
	   */
	  CAPS_LOCK: 20,
	  /**
	   * ESC
	   */
	  ESC: 27,
	  /**
	   * SPACE
	   */
	  SPACE: 32,
	  /**
	   * PAGE_UP
	   */
	  PAGE_UP: 33, // also NUM_NORTH_EAST
	  /**
	   * PAGE_DOWN
	   */
	  PAGE_DOWN: 34, // also NUM_SOUTH_EAST
	  /**
	   * END
	   */
	  END: 35, // also NUM_SOUTH_WEST
	  /**
	   * HOME
	   */
	  HOME: 36, // also NUM_NORTH_WEST
	  /**
	   * LEFT
	   */
	  LEFT: 37, // also NUM_WEST
	  /**
	   * UP
	   */
	  UP: 38, // also NUM_NORTH
	  /**
	   * RIGHT
	   */
	  RIGHT: 39, // also NUM_EAST
	  /**
	   * DOWN
	   */
	  DOWN: 40, // also NUM_SOUTH
	  /**
	   * PRINT_SCREEN
	   */
	  PRINT_SCREEN: 44,
	  /**
	   * INSERT
	   */
	  INSERT: 45, // also NUM_INSERT
	  /**
	   * DELETE
	   */
	  DELETE: 46, // also NUM_DELETE
	  /**
	   * ZERO
	   */
	  ZERO: 48,
	  /**
	   * ONE
	   */
	  ONE: 49,
	  /**
	   * TWO
	   */
	  TWO: 50,
	  /**
	   * THREE
	   */
	  THREE: 51,
	  /**
	   * FOUR
	   */
	  FOUR: 52,
	  /**
	   * FIVE
	   */
	  FIVE: 53,
	  /**
	   * SIX
	   */
	  SIX: 54,
	  /**
	   * SEVEN
	   */
	  SEVEN: 55,
	  /**
	   * EIGHT
	   */
	  EIGHT: 56,
	  /**
	   * NINE
	   */
	  NINE: 57,
	  /**
	   * QUESTION_MARK
	   */
	  QUESTION_MARK: 63, // needs localization
	  /**
	   * A
	   */
	  A: 65,
	  /**
	   * B
	   */
	  B: 66,
	  /**
	   * C
	   */
	  C: 67,
	  /**
	   * D
	   */
	  D: 68,
	  /**
	   * E
	   */
	  E: 69,
	  /**
	   * F
	   */
	  F: 70,
	  /**
	   * G
	   */
	  G: 71,
	  /**
	   * H
	   */
	  H: 72,
	  /**
	   * I
	   */
	  I: 73,
	  /**
	   * J
	   */
	  J: 74,
	  /**
	   * K
	   */
	  K: 75,
	  /**
	   * L
	   */
	  L: 76,
	  /**
	   * M
	   */
	  M: 77,
	  /**
	   * N
	   */
	  N: 78,
	  /**
	   * O
	   */
	  O: 79,
	  /**
	   * P
	   */
	  P: 80,
	  /**
	   * Q
	   */
	  Q: 81,
	  /**
	   * R
	   */
	  R: 82,
	  /**
	   * S
	   */
	  S: 83,
	  /**
	   * T
	   */
	  T: 84,
	  /**
	   * U
	   */
	  U: 85,
	  /**
	   * V
	   */
	  V: 86,
	  /**
	   * W
	   */
	  W: 87,
	  /**
	   * X
	   */
	  X: 88,
	  /**
	   * Y
	   */
	  Y: 89,
	  /**
	   * Z
	   */
	  Z: 90,
	  /**
	   * META
	   */
	  META: 91, // WIN_KEY_LEFT
	  /**
	   * WIN_KEY_RIGHT
	   */
	  WIN_KEY_RIGHT: 92,
	  /**
	   * CONTEXT_MENU
	   */
	  CONTEXT_MENU: 93,
	  /**
	   * NUM_ZERO
	   */
	  NUM_ZERO: 96,
	  /**
	   * NUM_ONE
	   */
	  NUM_ONE: 97,
	  /**
	   * NUM_TWO
	   */
	  NUM_TWO: 98,
	  /**
	   * NUM_THREE
	   */
	  NUM_THREE: 99,
	  /**
	   * NUM_FOUR
	   */
	  NUM_FOUR: 100,
	  /**
	   * NUM_FIVE
	   */
	  NUM_FIVE: 101,
	  /**
	   * NUM_SIX
	   */
	  NUM_SIX: 102,
	  /**
	   * NUM_SEVEN
	   */
	  NUM_SEVEN: 103,
	  /**
	   * NUM_EIGHT
	   */
	  NUM_EIGHT: 104,
	  /**
	   * NUM_NINE
	   */
	  NUM_NINE: 105,
	  /**
	   * NUM_MULTIPLY
	   */
	  NUM_MULTIPLY: 106,
	  /**
	   * NUM_PLUS
	   */
	  NUM_PLUS: 107,
	  /**
	   * NUM_MINUS
	   */
	  NUM_MINUS: 109,
	  /**
	   * NUM_PERIOD
	   */
	  NUM_PERIOD: 110,
	  /**
	   * NUM_DIVISION
	   */
	  NUM_DIVISION: 111,
	  /**
	   * F1
	   */
	  F1: 112,
	  /**
	   * F2
	   */
	  F2: 113,
	  /**
	   * F3
	   */
	  F3: 114,
	  /**
	   * F4
	   */
	  F4: 115,
	  /**
	   * F5
	   */
	  F5: 116,
	  /**
	   * F6
	   */
	  F6: 117,
	  /**
	   * F7
	   */
	  F7: 118,
	  /**
	   * F8
	   */
	  F8: 119,
	  /**
	   * F9
	   */
	  F9: 120,
	  /**
	   * F10
	   */
	  F10: 121,
	  /**
	   * F11
	   */
	  F11: 122,
	  /**
	   * F12
	   */
	  F12: 123,
	  /**
	   * NUMLOCK
	   */
	  NUMLOCK: 144,
	  /**
	   * SEMICOLON
	   */
	  SEMICOLON: 186, // needs localization
	  /**
	   * DASH
	   */
	  DASH: 189, // needs localization
	  /**
	   * EQUALS
	   */
	  EQUALS: 187, // needs localization
	  /**
	   * COMMA
	   */
	  COMMA: 188, // needs localization
	  /**
	   * PERIOD
	   */
	  PERIOD: 190, // needs localization
	  /**
	   * SLASH
	   */
	  SLASH: 191, // needs localization
	  /**
	   * APOSTROPHE
	   */
	  APOSTROPHE: 192, // needs localization
	  /**
	   * SINGLE_QUOTE
	   */
	  SINGLE_QUOTE: 222, // needs localization
	  /**
	   * OPEN_SQUARE_BRACKET
	   */
	  OPEN_SQUARE_BRACKET: 219, // needs localization
	  /**
	   * BACKSLASH
	   */
	  BACKSLASH: 220, // needs localization
	  /**
	   * CLOSE_SQUARE_BRACKET
	   */
	  CLOSE_SQUARE_BRACKET: 221, // needs localization
	  /**
	   * WIN_KEY
	   */
	  WIN_KEY: 224,
	  /**
	   * MAC_FF_META
	   */
	  MAC_FF_META: 224, // Firefox (Gecko) fires this for the meta key instead of 91
	  /**
	   * WIN_IME
	   */
	  WIN_IME: 229
	};
	
	/*
	 whether text and modified key is entered at the same time.
	 */
	KeyCode.isTextModifyingKeyEvent = function isTextModifyingKeyEvent(e) {
	  var keyCode = e.keyCode;
	  if (e.altKey && !e.ctrlKey || e.metaKey ||
	  // Function keys don't generate text
	  keyCode >= KeyCode.F1 && keyCode <= KeyCode.F12) {
	    return false;
	  }
	
	  // The following keys are quite harmless, even in combination with
	  // CTRL, ALT or SHIFT.
	  switch (keyCode) {
	    case KeyCode.ALT:
	    case KeyCode.CAPS_LOCK:
	    case KeyCode.CONTEXT_MENU:
	    case KeyCode.CTRL:
	    case KeyCode.DOWN:
	    case KeyCode.END:
	    case KeyCode.ESC:
	    case KeyCode.HOME:
	    case KeyCode.INSERT:
	    case KeyCode.LEFT:
	    case KeyCode.MAC_FF_META:
	    case KeyCode.META:
	    case KeyCode.NUMLOCK:
	    case KeyCode.NUM_CENTER:
	    case KeyCode.PAGE_DOWN:
	    case KeyCode.PAGE_UP:
	    case KeyCode.PAUSE:
	    case KeyCode.PRINT_SCREEN:
	    case KeyCode.RIGHT:
	    case KeyCode.SHIFT:
	    case KeyCode.UP:
	    case KeyCode.WIN_KEY:
	    case KeyCode.WIN_KEY_RIGHT:
	      return false;
	    default:
	      return true;
	  }
	};
	
	/*
	 whether character is entered.
	 */
	KeyCode.isCharacterKey = function isCharacterKey(keyCode) {
	  if (keyCode >= KeyCode.ZERO && keyCode <= KeyCode.NINE) {
	    return true;
	  }
	
	  if (keyCode >= KeyCode.NUM_ZERO && keyCode <= KeyCode.NUM_MULTIPLY) {
	    return true;
	  }
	
	  if (keyCode >= KeyCode.A && keyCode <= KeyCode.Z) {
	    return true;
	  }
	
	  // Safari sends zero key code for non-latin characters.
	  if (window.navigation.userAgent.indexOf('WebKit') !== -1 && keyCode === 0) {
	    return true;
	  }
	
	  switch (keyCode) {
	    case KeyCode.SPACE:
	    case KeyCode.QUESTION_MARK:
	    case KeyCode.NUM_PLUS:
	    case KeyCode.NUM_MINUS:
	    case KeyCode.NUM_PERIOD:
	    case KeyCode.NUM_DIVISION:
	    case KeyCode.SEMICOLON:
	    case KeyCode.DASH:
	    case KeyCode.EQUALS:
	    case KeyCode.COMMA:
	    case KeyCode.PERIOD:
	    case KeyCode.SLASH:
	    case KeyCode.APOSTROPHE:
	    case KeyCode.SINGLE_QUOTE:
	    case KeyCode.OPEN_SQUARE_BRACKET:
	    case KeyCode.BACKSLASH:
	    case KeyCode.CLOSE_SQUARE_BRACKET:
	      return true;
	    default:
	      return false;
	  }
	};
	
	exports['default'] = KeyCode;
	module.exports = exports['default'];

/***/ }),
/* 30 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule ContentBlockNode
	 * @format
	 * 
	 *
	 * This file is a fork of ContentBlock adding support for nesting references by
	 * providing links to children, parent, prevSibling, and nextSibling.
	 *
	 * This is unstable and not part of the public API and should not be used by
	 * production systems. This file may be update/removed without notice.
	 */
	
	'use strict';
	
	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 CharacterMetadata = __webpack_require__(27);
	var Immutable = __webpack_require__(11);
	
	var findRangesImmutable = __webpack_require__(72);
	
	var List = Immutable.List,
	    Map = Immutable.Map,
	    OrderedSet = Immutable.OrderedSet,
	    Record = Immutable.Record,
	    Repeat = Immutable.Repeat;
	
	
	var EMPTY_SET = OrderedSet();
	
	var defaultRecord = {
	  parent: null,
	  characterList: List(),
	  data: Map(),
	  depth: 0,
	  key: '',
	  text: '',
	  type: 'unstyled',
	  children: List(),
	  prevSibling: null,
	  nextSibling: null
	};
	
	var haveEqualStyle = function haveEqualStyle(charA, charB) {
	  return charA.getStyle() === charB.getStyle();
	};
	
	var haveEqualEntity = function haveEqualEntity(charA, charB) {
	  return charA.getEntity() === charB.getEntity();
	};
	
	var decorateCharacterList = function decorateCharacterList(config) {
	  if (!config) {
	    return config;
	  }
	
	  var characterList = config.characterList,
	      text = config.text;
	
	
	  if (text && !characterList) {
	    config.characterList = List(Repeat(CharacterMetadata.EMPTY, text.length));
	  }
	
	  return config;
	};
	
	var ContentBlockNode = function (_Record) {
	  _inherits(ContentBlockNode, _Record);
	
	  function ContentBlockNode() {
	    var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultRecord;
	
	    _classCallCheck(this, ContentBlockNode);
	
	    return _possibleConstructorReturn(this, _Record.call(this, decorateCharacterList(props)));
	  }
	
	  ContentBlockNode.prototype.getKey = function getKey() {
	    return this.get('key');
	  };
	
	  ContentBlockNode.prototype.getType = function getType() {
	    return this.get('type');
	  };
	
	  ContentBlockNode.prototype.getText = function getText() {
	    return this.get('text');
	  };
	
	  ContentBlockNode.prototype.getCharacterList = function getCharacterList() {
	    return this.get('characterList');
	  };
	
	  ContentBlockNode.prototype.getLength = function getLength() {
	    return this.getText().length;
	  };
	
	  ContentBlockNode.prototype.getDepth = function getDepth() {
	    return this.get('depth');
	  };
	
	  ContentBlockNode.prototype.getData = function getData() {
	    return this.get('data');
	  };
	
	  ContentBlockNode.prototype.getInlineStyleAt = function getInlineStyleAt(offset) {
	    var character = this.getCharacterList().get(offset);
	    return character ? character.getStyle() : EMPTY_SET;
	  };
	
	  ContentBlockNode.prototype.getEntityAt = function getEntityAt(offset) {
	    var character = this.getCharacterList().get(offset);
	    return character ? character.getEntity() : null;
	  };
	
	  ContentBlockNode.prototype.getChildKeys = function getChildKeys() {
	    return this.get('children');
	  };
	
	  ContentBlockNode.prototype.getParentKey = function getParentKey() {
	    return this.get('parent');
	  };
	
	  ContentBlockNode.prototype.getPrevSiblingKey = function getPrevSiblingKey() {
	    return this.get('prevSibling');
	  };
	
	  ContentBlockNode.prototype.getNextSiblingKey = function getNextSiblingKey() {
	    return this.get('nextSibling');
	  };
	
	  ContentBlockNode.prototype.findStyleRanges = function findStyleRanges(filterFn, callback) {
	    findRangesImmutable(this.getCharacterList(), haveEqualStyle, filterFn, callback);
	  };
	
	  ContentBlockNode.prototype.findEntityRanges = function findEntityRanges(filterFn, callback) {
	    findRangesImmutable(this.getCharacterList(), haveEqualEntity, filterFn, callback);
	  };
	
	  return ContentBlockNode;
	}(Record(defaultRecord));
	
	module.exports = ContentBlockNode;

/***/ }),
/* 31 */
/***/ (function(module, exports, __webpack_require__) {

	"use strict";
	
	exports.__esModule = true;
	
	var _from = __webpack_require__(410);
	
	var _from2 = _interopRequireDefault(_from);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
	
	exports.default = function (arr) {
	  if (Array.isArray(arr)) {
	    for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) {
	      arr2[i] = arr[i];
	    }
	
	    return arr2;
	  } else {
	    return (0, _from2.default)(arr);
	  }
	};

/***/ }),
/* 32 */
/***/ (function(module, exports, __webpack_require__) {

	var store = __webpack_require__(116)('wks');
	var uid = __webpack_require__(86);
	var Symbol = __webpack_require__(39).Symbol;
	var 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;


/***/ }),
/* 33 */
/***/ (function(module, exports) {

	"use strict";
	
	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 * 
	 */
	
	var nullthrows = function nullthrows(x) {
	  if (x != null) {
	    return x;
	  }
	  throw new Error("Got unexpected null or undefined");
	};
	
	module.exports = nullthrows;

/***/ }),
/* 34 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports['default'] = addEventListenerWrap;
	
	var _addDomEventListener = __webpack_require__(291);
	
	var _addDomEventListener2 = _interopRequireDefault(_addDomEventListener);
	
	var _reactDom = __webpack_require__(10);
	
	var _reactDom2 = _interopRequireDefault(_reactDom);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function addEventListenerWrap(target, eventType, cb) {
	  /* eslint camelcase: 2 */
	  var callback = _reactDom2['default'].unstable_batchedUpdates ? function run(e) {
	    _reactDom2['default'].unstable_batchedUpdates(cb, e);
	  } : cb;
	  return (0, _addDomEventListener2['default'])(target, eventType, callback);
	}
	module.exports = exports['default'];

/***/ }),
/* 35 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * 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 (true) {
	  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;


/***/ }),
/* 36 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 */
	
	'use strict';
	
	var UserAgentData = __webpack_require__(555);
	var VersionRange = __webpack_require__(556);
	
	var mapObject = __webpack_require__(570);
	var memoizeStringOnly = __webpack_require__(571);
	
	/**
	 * Checks to see whether `name` and `version` satisfy `query`.
	 *
	 * @param {string} name Name of the browser, device, engine or platform
	 * @param {?string} version Version of the browser, engine or platform
	 * @param {string} query Query of form "Name [range expression]"
	 * @param {?function} normalizer Optional pre-processor for range expression
	 * @return {boolean}
	 */
	function compare(name, version, query, normalizer) {
	  // check for exact match with no version
	  if (name === query) {
	    return true;
	  }
	
	  // check for non-matching names
	  if (!query.startsWith(name)) {
	    return false;
	  }
	
	  // full comparison with version
	  var range = query.slice(name.length);
	  if (version) {
	    range = normalizer ? normalizer(range) : range;
	    return VersionRange.contains(range, version);
	  }
	
	  return false;
	}
	
	/**
	 * Normalizes `version` by stripping any "NT" prefix, but only on the Windows
	 * platform.
	 *
	 * Mimics the stripping performed by the `UserAgentWindowsPlatform` PHP class.
	 *
	 * @param {string} version
	 * @return {string}
	 */
	function normalizePlatformVersion(version) {
	  if (UserAgentData.platformName === 'Windows') {
	    return version.replace(/^\s*NT/, '');
	  }
	
	  return version;
	}
	
	/**
	 * Provides client-side access to the authoritative PHP-generated User Agent
	 * information supplied by the server.
	 */
	var UserAgent = {
	  /**
	   * Check if the User Agent browser matches `query`.
	   *
	   * `query` should be a string like "Chrome" or "Chrome > 33".
	   *
	   * Valid browser names include:
	   *
	   * - ACCESS NetFront
	   * - AOL
	   * - Amazon Silk
	   * - Android
	   * - BlackBerry
	   * - BlackBerry PlayBook
	   * - Chrome
	   * - Chrome for iOS
	   * - Chrome frame
	   * - Facebook PHP SDK
	   * - Facebook for iOS
	   * - Firefox
	   * - IE
	   * - IE Mobile
	   * - Mobile Safari
	   * - Motorola Internet Browser
	   * - Nokia
	   * - Openwave Mobile Browser
	   * - Opera
	   * - Opera Mini
	   * - Opera Mobile
	   * - Safari
	   * - UIWebView
	   * - Unknown
	   * - webOS
	   * - etc...
	   *
	   * An authoritative list can be found in the PHP `BrowserDetector` class and
	   * related classes in the same file (see calls to `new UserAgentBrowser` here:
	   * https://fburl.com/50728104).
	   *
	   * @note Function results are memoized
	   *
	   * @param {string} query Query of the form "Name [range expression]"
	   * @return {boolean}
	   */
	  isBrowser: function isBrowser(query) {
	    return compare(UserAgentData.browserName, UserAgentData.browserFullVersion, query);
	  },
	
	
	  /**
	   * Check if the User Agent browser uses a 32 or 64 bit architecture.
	   *
	   * @note Function results are memoized
	   *
	   * @param {string} query Query of the form "32" or "64".
	   * @return {boolean}
	   */
	  isBrowserArchitecture: function isBrowserArchitecture(query) {
	    return compare(UserAgentData.browserArchitecture, null, query);
	  },
	
	
	  /**
	   * Check if the User Agent device matches `query`.
	   *
	   * `query` should be a string like "iPhone" or "iPad".
	   *
	   * Valid device names include:
	   *
	   * - Kindle
	   * - Kindle Fire
	   * - Unknown
	   * - iPad
	   * - iPhone
	   * - iPod
	   * - etc...
	   *
	   * An authoritative list can be found in the PHP `DeviceDetector` class and
	   * related classes in the same file (see calls to `new UserAgentDevice` here:
	   * https://fburl.com/50728332).
	   *
	   * @note Function results are memoized
	   *
	   * @param {string} query Query of the form "Name"
	   * @return {boolean}
	   */
	  isDevice: function isDevice(query) {
	    return compare(UserAgentData.deviceName, null, query);
	  },
	
	
	  /**
	   * Check if the User Agent rendering engine matches `query`.
	   *
	   * `query` should be a string like "WebKit" or "WebKit >= 537".
	   *
	   * Valid engine names include:
	   *
	   * - Gecko
	   * - Presto
	   * - Trident
	   * - WebKit
	   * - etc...
	   *
	   * An authoritative list can be found in the PHP `RenderingEngineDetector`
	   * class related classes in the same file (see calls to `new
	   * UserAgentRenderingEngine` here: https://fburl.com/50728617).
	   *
	   * @note Function results are memoized
	   *
	   * @param {string} query Query of the form "Name [range expression]"
	   * @return {boolean}
	   */
	  isEngine: function isEngine(query) {
	    return compare(UserAgentData.engineName, UserAgentData.engineVersion, query);
	  },
	
	
	  /**
	   * Check if the User Agent platform matches `query`.
	   *
	   * `query` should be a string like "Windows" or "iOS 5 - 6".
	   *
	   * Valid platform names include:
	   *
	   * - Android
	   * - BlackBerry OS
	   * - Java ME
	   * - Linux
	   * - Mac OS X
	   * - Mac OS X Calendar
	   * - Mac OS X Internet Account
	   * - Symbian
	   * - SymbianOS
	   * - Windows
	   * - Windows Mobile
	   * - Windows Phone
	   * - iOS
	   * - iOS Facebook Integration Account
	   * - iOS Facebook Social Sharing UI
	   * - webOS
	   * - Chrome OS
	   * - etc...
	   *
	   * An authoritative list can be found in the PHP `PlatformDetector` class and
	   * related classes in the same file (see calls to `new UserAgentPlatform`
	   * here: https://fburl.com/50729226).
	   *
	   * @note Function results are memoized
	   *
	   * @param {string} query Query of the form "Name [range expression]"
	   * @return {boolean}
	   */
	  isPlatform: function isPlatform(query) {
	    return compare(UserAgentData.platformName, UserAgentData.platformFullVersion, query, normalizePlatformVersion);
	  },
	
	
	  /**
	   * Check if the User Agent platform is a 32 or 64 bit architecture.
	   *
	   * @note Function results are memoized
	   *
	   * @param {string} query Query of the form "32" or "64".
	   * @return {boolean}
	   */
	  isPlatformArchitecture: function isPlatformArchitecture(query) {
	    return compare(UserAgentData.platformArchitecture, null, query);
	  }
	};
	
	module.exports = mapObject(UserAgent, memoizeStringOnly);

/***/ }),
/* 37 */
/***/ (function(module, exports) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule generateRandomKey
	 * @format
	 * 
	 */
	
	'use strict';
	
	var seenKeys = {};
	var MULTIPLIER = Math.pow(2, 24);
	
	function generateRandomKey() {
	  var key = void 0;
	  while (key === undefined || seenKeys.hasOwnProperty(key) || !isNaN(+key)) {
	    key = Math.floor(Math.random() * MULTIPLIER).toString(32);
	  }
	  seenKeys[key] = true;
	  return key;
	}
	
	module.exports = generateRandomKey;

/***/ }),
/* 38 */
/***/ (function(module, exports, __webpack_require__) {

	var global = __webpack_require__(39);
	var core = __webpack_require__(25);
	var ctx = __webpack_require__(107);
	var hide = __webpack_require__(58);
	var has = __webpack_require__(48);
	var PROTOTYPE = 'prototype';
	
	var $export = function (type, name, source) {
	  var IS_FORCED = type & $export.F;
	  var IS_GLOBAL = type & $export.G;
	  var IS_STATIC = type & $export.S;
	  var IS_PROTO = type & $export.P;
	  var IS_BIND = type & $export.B;
	  var IS_WRAP = type & $export.W;
	  var exports = IS_GLOBAL ? core : core[name] || (core[name] = {});
	  var expProto = exports[PROTOTYPE];
	  var target = IS_GLOBAL ? global : IS_STATIC ? global[name] : (global[name] || {})[PROTOTYPE];
	  var key, own, out;
	  if (IS_GLOBAL) source = name;
	  for (key in source) {
	    // contains in native
	    own = !IS_FORCED && target && target[key] !== undefined;
	    if (own && has(exports, key)) 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;


/***/ }),
/* 39 */
/***/ (function(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
	  // eslint-disable-next-line no-new-func
	  : Function('return this')();
	if (typeof __g == 'number') __g = global; // eslint-disable-line no-undef


/***/ }),
/* 40 */
/***/ (function(module, exports, __webpack_require__) {

	var anObject = __webpack_require__(46);
	var IE8_DOM_DEFINE = __webpack_require__(190);
	var toPrimitive = __webpack_require__(118);
	var dP = Object.defineProperty;
	
	exports.f = __webpack_require__(47) ? 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;
	};


/***/ }),
/* 41 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule Draft
	 * @format
	 * 
	 */
	
	'use strict';
	
	var AtomicBlockUtils = __webpack_require__(480);
	var BlockMapBuilder = __webpack_require__(70);
	var CharacterMetadata = __webpack_require__(27);
	var CompositeDraftDecorator = __webpack_require__(481);
	var ContentBlock = __webpack_require__(50);
	var ContentState = __webpack_require__(123);
	var DefaultDraftBlockRenderMap = __webpack_require__(124);
	var DefaultDraftInlineStyle = __webpack_require__(202);
	var DraftEditor = __webpack_require__(483);
	var DraftEditorBlock = __webpack_require__(203);
	var DraftEntity = __webpack_require__(89);
	var DraftModifier = __webpack_require__(26);
	var DraftEntityInstance = __webpack_require__(204);
	var EditorState = __webpack_require__(15);
	var KeyBindingUtil = __webpack_require__(125);
	var RichTextEditorUtil = __webpack_require__(207);
	var SelectionState = __webpack_require__(62);
	
	var convertFromDraftStateToRaw = __webpack_require__(502);
	var convertFromHTMLToContentBlocks = __webpack_require__(208);
	var convertFromRawToDraftState = __webpack_require__(503);
	var generateRandomKey = __webpack_require__(37);
	var getDefaultKeyBinding = __webpack_require__(209);
	var getVisibleSelectionRect = __webpack_require__(526);
	
	var DraftPublic = {
	  Editor: DraftEditor,
	  EditorBlock: DraftEditorBlock,
	  EditorState: EditorState,
	
	  CompositeDecorator: CompositeDraftDecorator,
	  Entity: DraftEntity,
	  EntityInstance: DraftEntityInstance,
	
	  BlockMapBuilder: BlockMapBuilder,
	  CharacterMetadata: CharacterMetadata,
	  ContentBlock: ContentBlock,
	  ContentState: ContentState,
	  SelectionState: SelectionState,
	
	  AtomicBlockUtils: AtomicBlockUtils,
	  KeyBindingUtil: KeyBindingUtil,
	  Modifier: DraftModifier,
	  RichUtils: RichTextEditorUtil,
	
	  DefaultDraftBlockRenderMap: DefaultDraftBlockRenderMap,
	  DefaultDraftInlineStyle: DefaultDraftInlineStyle,
	
	  convertFromHTML: convertFromHTMLToContentBlocks,
	  convertFromRaw: convertFromRawToDraftState,
	  convertToRaw: convertFromDraftStateToRaw,
	  genKey: generateRandomKey,
	  getDefaultKeyBinding: getDefaultKeyBinding,
	  getVisibleSelectionRect: getVisibleSelectionRect
	};
	
	module.exports = DraftPublic;

/***/ }),
/* 42 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule DraftFeatureFlags
	 * @format
	 * 
	 */
	
	'use strict';
	
	var DraftFeatureFlags = __webpack_require__(493);
	
	module.exports = DraftFeatureFlags;

/***/ }),
/* 43 */
/***/ (function(module, exports, __webpack_require__) {

	var freeGlobal = __webpack_require__(231);
	
	/** 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;


/***/ }),
/* 44 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	exports.getTodayTime = getTodayTime;
	exports.getTitleString = getTitleString;
	exports.getTodayTimeStr = getTodayTimeStr;
	exports.getMonthName = getMonthName;
	exports.syncTime = syncTime;
	exports.getTimeConfig = getTimeConfig;
	exports.isTimeValidByConfig = isTimeValidByConfig;
	exports.isTimeValid = isTimeValid;
	exports.isAllowedDate = isAllowedDate;
	
	var _moment = __webpack_require__(13);
	
	var _moment2 = _interopRequireDefault(_moment);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var defaultDisabledTime = {
	  disabledHours: function disabledHours() {
	    return [];
	  },
	  disabledMinutes: function disabledMinutes() {
	    return [];
	  },
	  disabledSeconds: function disabledSeconds() {
	    return [];
	  }
	};
	
	function getTodayTime(value) {
	  var today = (0, _moment2['default'])();
	  today.locale(value.locale()).utcOffset(value.utcOffset());
	  return today;
	}
	
	function getTitleString(value) {
	  return value.format('L');
	}
	
	function getTodayTimeStr(value) {
	  var today = getTodayTime(value);
	  return getTitleString(today);
	}
	
	function getMonthName(month) {
	  var locale = month.locale();
	  var localeData = month.localeData();
	  return localeData[locale === 'zh-cn' ? 'months' : 'monthsShort'](month);
	}
	
	function syncTime(from, to) {
	  if (!_moment2['default'].isMoment(from) || !_moment2['default'].isMoment(to)) return;
	  to.hour(from.hour());
	  to.minute(from.minute());
	  to.second(from.second());
	}
	
	function getTimeConfig(value, disabledTime) {
	  var disabledTimeConfig = disabledTime ? disabledTime(value) : {};
	  disabledTimeConfig = (0, _extends3['default'])({}, defaultDisabledTime, disabledTimeConfig);
	  return disabledTimeConfig;
	}
	
	function isTimeValidByConfig(value, disabledTimeConfig) {
	  var invalidTime = false;
	  if (value) {
	    var hour = value.hour();
	    var minutes = value.minute();
	    var seconds = value.second();
	    var disabledHours = disabledTimeConfig.disabledHours();
	    if (disabledHours.indexOf(hour) === -1) {
	      var disabledMinutes = disabledTimeConfig.disabledMinutes(hour);
	      if (disabledMinutes.indexOf(minutes) === -1) {
	        var disabledSeconds = disabledTimeConfig.disabledSeconds(hour, minutes);
	        invalidTime = disabledSeconds.indexOf(seconds) !== -1;
	      } else {
	        invalidTime = true;
	      }
	    } else {
	      invalidTime = true;
	    }
	  }
	  return !invalidTime;
	}
	
	function isTimeValid(value, disabledTime) {
	  var disabledTimeConfig = getTimeConfig(value, disabledTime);
	  return isTimeValidByConfig(value, disabledTimeConfig);
	}
	
	function isAllowedDate(value, disabledDate, disabledTime) {
	  if (disabledDate) {
	    if (disabledDate(value)) {
	      return false;
	    }
	  }
	  if (disabledTime) {
	    if (!isTimeValid(value, disabledTime)) {
	      return false;
	    }
	  }
	  return true;
	}

/***/ }),
/* 45 */
/***/ (function(module, exports) {

	module.exports = function shallowEqual(objA, objB, compare, compareContext) {
	
	    var ret = compare ? compare.call(compareContext, objA, objB) : void 0;
	
	    if(ret !== void 0) {
	        return !!ret;
	    }
	
	    if(objA === objB) {
	        return true;
	    }
	
	    if(typeof objA !== 'object' || !objA ||
	       typeof objB !== 'object' || !objB) {
	        return false;
	    }
	
	    var keysA = Object.keys(objA);
	    var keysB = Object.keys(objB);
	
	    if(keysA.length !== keysB.length) {
	        return false;
	    }
	
	    var bHasOwnProperty = Object.prototype.hasOwnProperty.bind(objB);
	
	    // Test for A's keys different from B.
	    for(var idx = 0; idx < keysA.length; idx++) {
	
	        var key = keysA[idx];
	
	        if(!bHasOwnProperty(key)) {
	            return false;
	        }
	
	        var valueA = objA[key];
	        var valueB = objB[key];
	
	        ret = compare ? compare.call(compareContext, valueA, valueB, key) : void 0;
	
	        if(ret === false ||
	           ret === void 0 && valueA !== valueB) {
	            return false;
	        }
	
	    }
	
	    return true;
	
	};


/***/ }),
/* 46 */
/***/ (function(module, exports, __webpack_require__) {

	var isObject = __webpack_require__(59);
	module.exports = function (it) {
	  if (!isObject(it)) throw TypeError(it + ' is not an object!');
	  return it;
	};


/***/ }),
/* 47 */
/***/ (function(module, exports, __webpack_require__) {

	// Thank's IE8 for his funny defineProperty
	module.exports = !__webpack_require__(57)(function () {
	  return Object.defineProperty({}, 'a', { get: function () { return 7; } }).a != 7;
	});


/***/ }),
/* 48 */
/***/ (function(module, exports) {

	var hasOwnProperty = {}.hasOwnProperty;
	module.exports = function (it, key) {
	  return hasOwnProperty.call(it, key);
	};


/***/ }),
/* 49 */
/***/ (function(module, exports, __webpack_require__) {

	// to indexed object, toObject with fallback for non-array-like ES3 strings
	var IObject = __webpack_require__(191);
	var defined = __webpack_require__(108);
	module.exports = function (it) {
	  return IObject(defined(it));
	};


/***/ }),
/* 50 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule ContentBlock
	 * @format
	 * 
	 */
	
	'use strict';
	
	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 CharacterMetadata = __webpack_require__(27);
	var Immutable = __webpack_require__(11);
	
	var findRangesImmutable = __webpack_require__(72);
	
	var List = Immutable.List,
	    Map = Immutable.Map,
	    OrderedSet = Immutable.OrderedSet,
	    Record = Immutable.Record,
	    Repeat = Immutable.Repeat;
	
	
	var EMPTY_SET = OrderedSet();
	
	var defaultRecord = {
	  key: '',
	  type: 'unstyled',
	  text: '',
	  characterList: List(),
	  depth: 0,
	  data: Map()
	};
	
	var ContentBlockRecord = Record(defaultRecord);
	
	var decorateCharacterList = function decorateCharacterList(config) {
	  if (!config) {
	    return config;
	  }
	
	  var characterList = config.characterList,
	      text = config.text;
	
	
	  if (text && !characterList) {
	    config.characterList = List(Repeat(CharacterMetadata.EMPTY, text.length));
	  }
	
	  return config;
	};
	
	var ContentBlock = function (_ContentBlockRecord) {
	  _inherits(ContentBlock, _ContentBlockRecord);
	
	  function ContentBlock(config) {
	    _classCallCheck(this, ContentBlock);
	
	    return _possibleConstructorReturn(this, _ContentBlockRecord.call(this, decorateCharacterList(config)));
	  }
	
	  ContentBlock.prototype.getKey = function getKey() {
	    return this.get('key');
	  };
	
	  ContentBlock.prototype.getType = function getType() {
	    return this.get('type');
	  };
	
	  ContentBlock.prototype.getText = function getText() {
	    return this.get('text');
	  };
	
	  ContentBlock.prototype.getCharacterList = function getCharacterList() {
	    return this.get('characterList');
	  };
	
	  ContentBlock.prototype.getLength = function getLength() {
	    return this.getText().length;
	  };
	
	  ContentBlock.prototype.getDepth = function getDepth() {
	    return this.get('depth');
	  };
	
	  ContentBlock.prototype.getData = function getData() {
	    return this.get('data');
	  };
	
	  ContentBlock.prototype.getInlineStyleAt = function getInlineStyleAt(offset) {
	    var character = this.getCharacterList().get(offset);
	    return character ? character.getStyle() : EMPTY_SET;
	  };
	
	  ContentBlock.prototype.getEntityAt = function getEntityAt(offset) {
	    var character = this.getCharacterList().get(offset);
	    return character ? character.getEntity() : null;
	  };
	
	  /**
	   * Execute a callback for every contiguous range of styles within the block.
	   */
	
	
	  ContentBlock.prototype.findStyleRanges = function findStyleRanges(filterFn, callback) {
	    findRangesImmutable(this.getCharacterList(), haveEqualStyle, filterFn, callback);
	  };
	
	  /**
	   * Execute a callback for every contiguous range of entities within the block.
	   */
	
	
	  ContentBlock.prototype.findEntityRanges = function findEntityRanges(filterFn, callback) {
	    findRangesImmutable(this.getCharacterList(), haveEqualEntity, filterFn, callback);
	  };
	
	  return ContentBlock;
	}(ContentBlockRecord);
	
	function haveEqualStyle(charA, charB) {
	  return charA.getStyle() === charB.getStyle();
	}
	
	function haveEqualEntity(charA, charB) {
	  return charA.getEntity() === charB.getEntity();
	}
	
	module.exports = ContentBlock;

/***/ }),
/* 51 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 * @typechecks
	 */
	
	/**
	 * Unicode-enabled replacesments for basic String functions.
	 *
	 * All the functions in this module assume that the input string is a valid
	 * UTF-16 encoding of a Unicode sequence. If it's not the case, the behavior
	 * will be undefined.
	 *
	 * WARNING: Since this module is typechecks-enforced, you may find new bugs
	 * when replacing normal String functions with ones provided here.
	 */
	
	'use strict';
	
	var invariant = __webpack_require__(12);
	
	// These two ranges are consecutive so anything in [HIGH_START, LOW_END] is a
	// surrogate code unit.
	var SURROGATE_HIGH_START = 0xD800;
	var SURROGATE_HIGH_END = 0xDBFF;
	var SURROGATE_LOW_START = 0xDC00;
	var SURROGATE_LOW_END = 0xDFFF;
	var SURROGATE_UNITS_REGEX = /[\uD800-\uDFFF]/;
	
	/**
	 * @param {number} codeUnit   A Unicode code-unit, in range [0, 0x10FFFF]
	 * @return {boolean}          Whether code-unit is in a surrogate (hi/low) range
	 */
	function isCodeUnitInSurrogateRange(codeUnit) {
	  return SURROGATE_HIGH_START <= codeUnit && codeUnit <= SURROGATE_LOW_END;
	}
	
	/**
	 * Returns whether the two characters starting at `index` form a surrogate pair.
	 * For example, given the string s = "\uD83D\uDE0A", (s, 0) returns true and
	 * (s, 1) returns false.
	 *
	 * @param {string} str
	 * @param {number} index
	 * @return {boolean}
	 */
	function isSurrogatePair(str, index) {
	  !(0 <= index && index < str.length) ?  true ? invariant(false, 'isSurrogatePair: Invalid index %s for string length %s.', index, str.length) : invariant(false) : void 0;
	  if (index + 1 === str.length) {
	    return false;
	  }
	  var first = str.charCodeAt(index);
	  var second = str.charCodeAt(index + 1);
	  return SURROGATE_HIGH_START <= first && first <= SURROGATE_HIGH_END && SURROGATE_LOW_START <= second && second <= SURROGATE_LOW_END;
	}
	
	/**
	 * @param {string} str  Non-empty string
	 * @return {boolean}    True if the input includes any surrogate code units
	 */
	function hasSurrogateUnit(str) {
	  return SURROGATE_UNITS_REGEX.test(str);
	}
	
	/**
	 * Return the length of the original Unicode character at given position in the
	 * String by looking into the UTF-16 code unit; that is equal to 1 for any
	 * non-surrogate characters in BMP ([U+0000..U+D7FF] and [U+E000, U+FFFF]); and
	 * returns 2 for the hi/low surrogates ([U+D800..U+DFFF]), which are in fact
	 * representing non-BMP characters ([U+10000..U+10FFFF]).
	 *
	 * Examples:
	 * - '\u0020' => 1
	 * - '\u3020' => 1
	 * - '\uD835' => 2
	 * - '\uD835\uDDEF' => 2
	 * - '\uDDEF' => 2
	 *
	 * @param {string} str  Non-empty string
	 * @param {number} pos  Position in the string to look for one code unit
	 * @return {number}      Number 1 or 2
	 */
	function getUTF16Length(str, pos) {
	  return 1 + isCodeUnitInSurrogateRange(str.charCodeAt(pos));
	}
	
	/**
	 * Fully Unicode-enabled replacement for String#length
	 *
	 * @param {string} str  Valid Unicode string
	 * @return {number}     The number of Unicode characters in the string
	 */
	function strlen(str) {
	  // Call the native functions if there's no surrogate char
	  if (!hasSurrogateUnit(str)) {
	    return str.length;
	  }
	
	  var len = 0;
	  for (var pos = 0; pos < str.length; pos += getUTF16Length(str, pos)) {
	    len++;
	  }
	  return len;
	}
	
	/**
	 * Fully Unicode-enabled replacement for String#substr()
	 *
	 * @param {string} str      Valid Unicode string
	 * @param {number} start    Location in Unicode sequence to begin extracting
	 * @param {?number} length  The number of Unicode characters to extract
	 *                          (default: to the end of the string)
	 * @return {string}         Extracted sub-string
	 */
	function substr(str, start, length) {
	  start = start || 0;
	  length = length === undefined ? Infinity : length || 0;
	
	  // Call the native functions if there's no surrogate char
	  if (!hasSurrogateUnit(str)) {
	    return str.substr(start, length);
	  }
	
	  // Obvious cases
	  var size = str.length;
	  if (size <= 0 || start > size || length <= 0) {
	    return '';
	  }
	
	  // Find the actual starting position
	  var posA = 0;
	  if (start > 0) {
	    for (; start > 0 && posA < size; start--) {
	      posA += getUTF16Length(str, posA);
	    }
	    if (posA >= size) {
	      return '';
	    }
	  } else if (start < 0) {
	    for (posA = size; start < 0 && 0 < posA; start++) {
	      posA -= getUTF16Length(str, posA - 1);
	    }
	    if (posA < 0) {
	      posA = 0;
	    }
	  }
	
	  // Find the actual ending position
	  var posB = size;
	  if (length < size) {
	    for (posB = posA; length > 0 && posB < size; length--) {
	      posB += getUTF16Length(str, posB);
	    }
	  }
	
	  return str.substring(posA, posB);
	}
	
	/**
	 * Fully Unicode-enabled replacement for String#substring()
	 *
	 * @param {string} str    Valid Unicode string
	 * @param {number} start  Location in Unicode sequence to begin extracting
	 * @param {?number} end   Location in Unicode sequence to end extracting
	 *                        (default: end of the string)
	 * @return {string}       Extracted sub-string
	 */
	function substring(str, start, end) {
	  start = start || 0;
	  end = end === undefined ? Infinity : end || 0;
	
	  if (start < 0) {
	    start = 0;
	  }
	  if (end < 0) {
	    end = 0;
	  }
	
	  var length = Math.abs(end - start);
	  start = start < end ? start : end;
	  return substr(str, start, length);
	}
	
	/**
	 * Get a list of Unicode code-points from a String
	 *
	 * @param {string} str        Valid Unicode string
	 * @return {array<number>}    A list of code-points in [0..0x10FFFF]
	 */
	function getCodePoints(str) {
	  var codePoints = [];
	  for (var pos = 0; pos < str.length; pos += getUTF16Length(str, pos)) {
	    codePoints.push(str.codePointAt(pos));
	  }
	  return codePoints;
	}
	
	var UnicodeUtils = {
	  getCodePoints: getCodePoints,
	  getUTF16Length: getUTF16Length,
	  hasSurrogateUnit: hasSurrogateUnit,
	  isCodeUnitInSurrogateRange: isCodeUnitInSurrogateRange,
	  isSurrogatePair: isSurrogatePair,
	  strlen: strlen,
	  substring: substring,
	  substr: substr
	};
	
	module.exports = UnicodeUtils;

/***/ }),
/* 52 */
/***/ (function(module, exports, __webpack_require__) {

	var baseIsNative = __webpack_require__(596),
	    getValue = __webpack_require__(609);
	
	/**
	 * 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;


/***/ }),
/* 53 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _reactDom = __webpack_require__(10);
	
	var _createReactClass = __webpack_require__(14);
	
	var _createReactClass2 = _interopRequireDefault(_createReactClass);
	
	var _contains = __webpack_require__(283);
	
	var _contains2 = _interopRequireDefault(_contains);
	
	var _addEventListener = __webpack_require__(34);
	
	var _addEventListener2 = _interopRequireDefault(_addEventListener);
	
	var _Popup = __webpack_require__(780);
	
	var _Popup2 = _interopRequireDefault(_Popup);
	
	var _utils = __webpack_require__(280);
	
	var _getContainerRenderMixin = __webpack_require__(284);
	
	var _getContainerRenderMixin2 = _interopRequireDefault(_getContainerRenderMixin);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function noop() {}
	
	function returnEmptyString() {
	  return '';
	}
	
	function returnDocument() {
	  return window.document;
	}
	
	var isMobile = typeof navigator !== 'undefined' && !!navigator.userAgent.match(/(Android|iPhone|iPad|iPod|iOS|UCWEB)/i);
	
	var ALL_HANDLERS = ['onClick', 'onMouseDown', 'onTouchStart', 'onMouseEnter', 'onMouseLeave', 'onFocus', 'onBlur'];
	
	var Trigger = (0, _createReactClass2['default'])({
	  displayName: 'Trigger',
	  propTypes: {
	    children: _propTypes2['default'].any,
	    action: _propTypes2['default'].oneOfType([_propTypes2['default'].string, _propTypes2['default'].arrayOf(_propTypes2['default'].string)]),
	    showAction: _propTypes2['default'].any,
	    hideAction: _propTypes2['default'].any,
	    getPopupClassNameFromAlign: _propTypes2['default'].any,
	    onPopupVisibleChange: _propTypes2['default'].func,
	    afterPopupVisibleChange: _propTypes2['default'].func,
	    popup: _propTypes2['default'].oneOfType([_propTypes2['default'].node, _propTypes2['default'].func]).isRequired,
	    popupStyle: _propTypes2['default'].object,
	    prefixCls: _propTypes2['default'].string,
	    popupClassName: _propTypes2['default'].string,
	    popupPlacement: _propTypes2['default'].string,
	    builtinPlacements: _propTypes2['default'].object,
	    popupTransitionName: _propTypes2['default'].oneOfType([_propTypes2['default'].string, _propTypes2['default'].object]),
	    popupAnimation: _propTypes2['default'].any,
	    mouseEnterDelay: _propTypes2['default'].number,
	    mouseLeaveDelay: _propTypes2['default'].number,
	    zIndex: _propTypes2['default'].number,
	    focusDelay: _propTypes2['default'].number,
	    blurDelay: _propTypes2['default'].number,
	    getPopupContainer: _propTypes2['default'].func,
	    getDocument: _propTypes2['default'].func,
	    destroyPopupOnHide: _propTypes2['default'].bool,
	    mask: _propTypes2['default'].bool,
	    maskClosable: _propTypes2['default'].bool,
	    onPopupAlign: _propTypes2['default'].func,
	    popupAlign: _propTypes2['default'].object,
	    popupVisible: _propTypes2['default'].bool,
	    maskTransitionName: _propTypes2['default'].oneOfType([_propTypes2['default'].string, _propTypes2['default'].object]),
	    maskAnimation: _propTypes2['default'].string
	  },
	
	  mixins: [(0, _getContainerRenderMixin2['default'])({
	    autoMount: false,
	
	    isVisible: function isVisible(instance) {
	      return instance.state.popupVisible;
	    },
	    getContainer: function getContainer(instance) {
	      var props = instance.props;
	
	      var popupContainer = document.createElement('div');
	      // Make sure default popup container will never cause scrollbar appearing
	      // https://github.com/react-component/trigger/issues/41
	      popupContainer.style.position = 'absolute';
	      popupContainer.style.top = '0';
	      popupContainer.style.left = '0';
	      popupContainer.style.width = '100%';
	      var mountNode = props.getPopupContainer ? props.getPopupContainer((0, _reactDom.findDOMNode)(instance)) : props.getDocument().body;
	      mountNode.appendChild(popupContainer);
	      return popupContainer;
	    }
	  })],
	
	  getDefaultProps: function getDefaultProps() {
	    return {
	      prefixCls: 'rc-trigger-popup',
	      getPopupClassNameFromAlign: returnEmptyString,
	      getDocument: returnDocument,
	      onPopupVisibleChange: noop,
	      afterPopupVisibleChange: noop,
	      onPopupAlign: noop,
	      popupClassName: '',
	      mouseEnterDelay: 0,
	      mouseLeaveDelay: 0.1,
	      focusDelay: 0,
	      blurDelay: 0.15,
	      popupStyle: {},
	      destroyPopupOnHide: false,
	      popupAlign: {},
	      defaultPopupVisible: false,
	      mask: false,
	      maskClosable: true,
	      action: [],
	      showAction: [],
	      hideAction: []
	    };
	  },
	  getInitialState: function getInitialState() {
	    var props = this.props;
	    var popupVisible = void 0;
	    if ('popupVisible' in props) {
	      popupVisible = !!props.popupVisible;
	    } else {
	      popupVisible = !!props.defaultPopupVisible;
	    }
	    return {
	      popupVisible: popupVisible
	    };
	  },
	  componentWillMount: function componentWillMount() {
	    var _this = this;
	
	    ALL_HANDLERS.forEach(function (h) {
	      _this['fire' + h] = function (e) {
	        _this.fireEvents(h, e);
	      };
	    });
	  },
	  componentDidMount: function componentDidMount() {
	    this.componentDidUpdate({}, {
	      popupVisible: this.state.popupVisible
	    });
	  },
	  componentWillReceiveProps: function componentWillReceiveProps(_ref) {
	    var popupVisible = _ref.popupVisible;
	
	    if (popupVisible !== undefined) {
	      this.setState({
	        popupVisible: popupVisible
	      });
	    }
	  },
	  componentDidUpdate: function componentDidUpdate(_, prevState) {
	    var props = this.props;
	    var state = this.state;
	    this.renderComponent(null, function () {
	      if (prevState.popupVisible !== state.popupVisible) {
	        props.afterPopupVisibleChange(state.popupVisible);
	      }
	    });
	
	    // We must listen to `mousedown`, edge case:
	    // https://github.com/ant-design/ant-design/issues/5804
	    // https://github.com/react-component/calendar/issues/250
	    // https://github.com/react-component/trigger/issues/50
	    if (state.popupVisible) {
	      var currentDocument = void 0;
	      if (!this.clickOutsideHandler && this.isClickToHide()) {
	        currentDocument = props.getDocument();
	        this.clickOutsideHandler = (0, _addEventListener2['default'])(currentDocument, 'mousedown', this.onDocumentClick);
	      }
	      // always hide on mobile
	      // `isMobile` fix: mask clicked will cause below element events triggered
	      // https://github.com/ant-design/ant-design-mobile/issues/1909
	      // https://github.com/ant-design/ant-design-mobile/issues/1928
	      if (!this.touchOutsideHandler && isMobile) {
	        currentDocument = currentDocument || props.getDocument();
	        this.touchOutsideHandler = (0, _addEventListener2['default'])(currentDocument, 'click', this.onDocumentClick);
	      }
	      return;
	    }
	
	    this.clearOutsideHandler();
	  },
	  componentWillUnmount: function componentWillUnmount() {
	    this.clearDelayTimer();
	    this.clearOutsideHandler();
	  },
	  onMouseEnter: function onMouseEnter(e) {
	    this.fireEvents('onMouseEnter', e);
	    this.delaySetPopupVisible(true, this.props.mouseEnterDelay);
	  },
	  onMouseLeave: function onMouseLeave(e) {
	    this.fireEvents('onMouseLeave', e);
	    this.delaySetPopupVisible(false, this.props.mouseLeaveDelay);
	  },
	  onPopupMouseEnter: function onPopupMouseEnter() {
	    this.clearDelayTimer();
	  },
	  onPopupMouseLeave: function onPopupMouseLeave(e) {
	    // https://github.com/react-component/trigger/pull/13
	    // react bug?
	    if (e.relatedTarget && !e.relatedTarget.setTimeout && this._component && this._component.getPopupDomNode && (0, _contains2['default'])(this._component.getPopupDomNode(), e.relatedTarget)) {
	      return;
	    }
	    this.delaySetPopupVisible(false, this.props.mouseLeaveDelay);
	  },
	  onFocus: function onFocus(e) {
	    this.fireEvents('onFocus', e);
	    // incase focusin and focusout
	    this.clearDelayTimer();
	    if (this.isFocusToShow()) {
	      this.focusTime = Date.now();
	      this.delaySetPopupVisible(true, this.props.focusDelay);
	    }
	  },
	  onMouseDown: function onMouseDown(e) {
	    this.fireEvents('onMouseDown', e);
	    this.preClickTime = Date.now();
	  },
	  onTouchStart: function onTouchStart(e) {
	    this.fireEvents('onTouchStart', e);
	    this.preTouchTime = Date.now();
	  },
	  onBlur: function onBlur(e) {
	    this.fireEvents('onBlur', e);
	    this.clearDelayTimer();
	    if (this.isBlurToHide()) {
	      this.delaySetPopupVisible(false, this.props.blurDelay);
	    }
	  },
	  onClick: function onClick(event) {
	    this.fireEvents('onClick', event);
	    // focus will trigger click
	    if (this.focusTime) {
	      var preTime = void 0;
	      if (this.preClickTime && this.preTouchTime) {
	        preTime = Math.min(this.preClickTime, this.preTouchTime);
	      } else if (this.preClickTime) {
	        preTime = this.preClickTime;
	      } else if (this.preTouchTime) {
	        preTime = this.preTouchTime;
	      }
	      if (Math.abs(preTime - this.focusTime) < 20) {
	        return;
	      }
	      this.focusTime = 0;
	    }
	    this.preClickTime = 0;
	    this.preTouchTime = 0;
	    event.preventDefault();
	    var nextVisible = !this.state.popupVisible;
	    if (this.isClickToHide() && !nextVisible || nextVisible && this.isClickToShow()) {
	      this.setPopupVisible(!this.state.popupVisible);
	    }
	  },
	  onDocumentClick: function onDocumentClick(event) {
	    if (this.props.mask && !this.props.maskClosable) {
	      return;
	    }
	    var target = event.target;
	    var root = (0, _reactDom.findDOMNode)(this);
	    var popupNode = this.getPopupDomNode();
	    if (!(0, _contains2['default'])(root, target) && !(0, _contains2['default'])(popupNode, target)) {
	      this.close();
	    }
	  },
	  getPopupDomNode: function getPopupDomNode() {
	    // for test
	    if (this._component && this._component.getPopupDomNode) {
	      return this._component.getPopupDomNode();
	    }
	    return null;
	  },
	  getRootDomNode: function getRootDomNode() {
	    return (0, _reactDom.findDOMNode)(this);
	  },
	  getPopupClassNameFromAlign: function getPopupClassNameFromAlign(align) {
	    var className = [];
	    var props = this.props;
	    var popupPlacement = props.popupPlacement,
	        builtinPlacements = props.builtinPlacements,
	        prefixCls = props.prefixCls;
	
	    if (popupPlacement && builtinPlacements) {
	      className.push((0, _utils.getPopupClassNameFromAlign)(builtinPlacements, prefixCls, align));
	    }
	    if (props.getPopupClassNameFromAlign) {
	      className.push(props.getPopupClassNameFromAlign(align));
	    }
	    return className.join(' ');
	  },
	  getPopupAlign: function getPopupAlign() {
	    var props = this.props;
	    var popupPlacement = props.popupPlacement,
	        popupAlign = props.popupAlign,
	        builtinPlacements = props.builtinPlacements;
	
	    if (popupPlacement && builtinPlacements) {
	      return (0, _utils.getAlignFromPlacement)(builtinPlacements, popupPlacement, popupAlign);
	    }
	    return popupAlign;
	  },
	  getComponent: function getComponent() {
	    var props = this.props,
	        state = this.state;
	
	    var mouseProps = {};
	    if (this.isMouseEnterToShow()) {
	      mouseProps.onMouseEnter = this.onPopupMouseEnter;
	    }
	    if (this.isMouseLeaveToHide()) {
	      mouseProps.onMouseLeave = this.onPopupMouseLeave;
	    }
	    return _react2['default'].createElement(
	      _Popup2['default'],
	      (0, _extends3['default'])({
	        prefixCls: props.prefixCls,
	        destroyPopupOnHide: props.destroyPopupOnHide,
	        visible: state.popupVisible,
	        className: props.popupClassName,
	        action: props.action,
	        align: this.getPopupAlign(),
	        onAlign: props.onPopupAlign,
	        animation: props.popupAnimation,
	        getClassNameFromAlign: this.getPopupClassNameFromAlign
	      }, mouseProps, {
	        getRootDomNode: this.getRootDomNode,
	        style: props.popupStyle,
	        mask: props.mask,
	        zIndex: props.zIndex,
	        transitionName: props.popupTransitionName,
	        maskAnimation: props.maskAnimation,
	        maskTransitionName: props.maskTransitionName
	      }),
	      typeof props.popup === 'function' ? props.popup() : props.popup
	    );
	  },
	  setPopupVisible: function setPopupVisible(popupVisible) {
	    this.clearDelayTimer();
	    if (this.state.popupVisible !== popupVisible) {
	      if (!('popupVisible' in this.props)) {
	        this.setState({
	          popupVisible: popupVisible
	        });
	      }
	      this.props.onPopupVisibleChange(popupVisible);
	    }
	  },
	  delaySetPopupVisible: function delaySetPopupVisible(visible, delayS) {
	    var _this2 = this;
	
	    var delay = delayS * 1000;
	    this.clearDelayTimer();
	    if (delay) {
	      this.delayTimer = setTimeout(function () {
	        _this2.setPopupVisible(visible);
	        _this2.clearDelayTimer();
	      }, delay);
	    } else {
	      this.setPopupVisible(visible);
	    }
	  },
	  clearDelayTimer: function clearDelayTimer() {
	    if (this.delayTimer) {
	      clearTimeout(this.delayTimer);
	      this.delayTimer = null;
	    }
	  },
	  clearOutsideHandler: function clearOutsideHandler() {
	    if (this.clickOutsideHandler) {
	      this.clickOutsideHandler.remove();
	      this.clickOutsideHandler = null;
	    }
	
	    if (this.touchOutsideHandler) {
	      this.touchOutsideHandler.remove();
	      this.touchOutsideHandler = null;
	    }
	  },
	  createTwoChains: function createTwoChains(event) {
	    var childPros = this.props.children.props;
	    var props = this.props;
	    if (childPros[event] && props[event]) {
	      return this['fire' + event];
	    }
	    return childPros[event] || props[event];
	  },
	  isClickToShow: function isClickToShow() {
	    var _props = this.props,
	        action = _props.action,
	        showAction = _props.showAction;
	
	    return action.indexOf('click') !== -1 || showAction.indexOf('click') !== -1;
	  },
	  isClickToHide: function isClickToHide() {
	    var _props2 = this.props,
	        action = _props2.action,
	        hideAction = _props2.hideAction;
	
	    return action.indexOf('click') !== -1 || hideAction.indexOf('click') !== -1;
	  },
	  isMouseEnterToShow: function isMouseEnterToShow() {
	    var _props3 = this.props,
	        action = _props3.action,
	        showAction = _props3.showAction;
	
	    return action.indexOf('hover') !== -1 || showAction.indexOf('mouseEnter') !== -1;
	  },
	  isMouseLeaveToHide: function isMouseLeaveToHide() {
	    var _props4 = this.props,
	        action = _props4.action,
	        hideAction = _props4.hideAction;
	
	    return action.indexOf('hover') !== -1 || hideAction.indexOf('mouseLeave') !== -1;
	  },
	  isFocusToShow: function isFocusToShow() {
	    var _props5 = this.props,
	        action = _props5.action,
	        showAction = _props5.showAction;
	
	    return action.indexOf('focus') !== -1 || showAction.indexOf('focus') !== -1;
	  },
	  isBlurToHide: function isBlurToHide() {
	    var _props6 = this.props,
	        action = _props6.action,
	        hideAction = _props6.hideAction;
	
	    return action.indexOf('focus') !== -1 || hideAction.indexOf('blur') !== -1;
	  },
	  forcePopupAlign: function forcePopupAlign() {
	    if (this.state.popupVisible && this._component && this._component.alignInstance) {
	      this._component.alignInstance.forceAlign();
	    }
	  },
	  fireEvents: function fireEvents(type, e) {
	    var childCallback = this.props.children.props[type];
	    if (childCallback) {
	      childCallback(e);
	    }
	    var callback = this.props[type];
	    if (callback) {
	      callback(e);
	    }
	  },
	  close: function close() {
	    this.setPopupVisible(false);
	  },
	  render: function render() {
	    var props = this.props;
	    var children = props.children;
	    var child = _react2['default'].Children.only(children);
	    var newChildProps = {};
	    if (this.isClickToHide() || this.isClickToShow()) {
	      newChildProps.onClick = this.onClick;
	      newChildProps.onMouseDown = this.onMouseDown;
	      newChildProps.onTouchStart = this.onTouchStart;
	    } else {
	      newChildProps.onClick = this.createTwoChains('onClick');
	      newChildProps.onMouseDown = this.createTwoChains('onMouseDown');
	      newChildProps.onTouchStart = this.createTwoChains('onTouchStart');
	    }
	    if (this.isMouseEnterToShow()) {
	      newChildProps.onMouseEnter = this.onMouseEnter;
	    } else {
	      newChildProps.onMouseEnter = this.createTwoChains('onMouseEnter');
	    }
	    if (this.isMouseLeaveToHide()) {
	      newChildProps.onMouseLeave = this.onMouseLeave;
	    } else {
	      newChildProps.onMouseLeave = this.createTwoChains('onMouseLeave');
	    }
	    if (this.isFocusToShow() || this.isBlurToHide()) {
	      newChildProps.onFocus = this.onFocus;
	      newChildProps.onBlur = this.onBlur;
	    } else {
	      newChildProps.onFocus = this.createTwoChains('onFocus');
	      newChildProps.onBlur = this.createTwoChains('onBlur');
	    }
	
	    return _react2['default'].cloneElement(child, newChildProps);
	  }
	});
	
	exports['default'] = Trigger;
	module.exports = exports['default'];

/***/ }),
/* 54 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _button = __webpack_require__(330);
	
	var _button2 = _interopRequireDefault(_button);
	
	var _buttonGroup = __webpack_require__(329);
	
	var _buttonGroup2 = _interopRequireDefault(_buttonGroup);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	_button2['default'].Group = _buttonGroup2['default'];
	exports['default'] = _button2['default'];
	module.exports = exports['default'];

/***/ }),
/* 55 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _Checkbox = __webpack_require__(164);
	
	var _Checkbox2 = _interopRequireDefault(_Checkbox);
	
	var _Group = __webpack_require__(337);
	
	var _Group2 = _interopRequireDefault(_Group);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	_Checkbox2['default'].Group = _Group2['default'];
	exports['default'] = _Checkbox2['default'];
	module.exports = exports['default'];

/***/ }),
/* 56 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _rcTooltip = __webpack_require__(771);
	
	var _rcTooltip2 = _interopRequireDefault(_rcTooltip);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _placements = __webpack_require__(396);
	
	var _placements2 = _interopRequireDefault(_placements);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var splitObject = function splitObject(obj, keys) {
	    var picked = {};
	    var omited = (0, _extends3['default'])({}, obj);
	    keys.forEach(function (key) {
	        if (obj && key in obj) {
	            picked[key] = obj[key];
	            delete omited[key];
	        }
	    });
	    return { picked: picked, omited: omited };
	};
	
	var Tooltip = function (_React$Component) {
	    (0, _inherits3['default'])(Tooltip, _React$Component);
	
	    function Tooltip(props) {
	        (0, _classCallCheck3['default'])(this, Tooltip);
	
	        var _this = (0, _possibleConstructorReturn3['default'])(this, (Tooltip.__proto__ || Object.getPrototypeOf(Tooltip)).call(this, props));
	
	        _this.onVisibleChange = function (visible) {
	            var onVisibleChange = _this.props.onVisibleChange;
	
	            if (!('visible' in _this.props)) {
	                _this.setState({ visible: _this.isNoTitle() ? false : visible });
	            }
	            if (onVisibleChange && !_this.isNoTitle()) {
	                onVisibleChange(visible);
	            }
	        };
	        // 动态设置动画点
	        _this.onPopupAlign = function (domNode, align) {
	            var placements = _this.getPlacements();
	            // 当前返回的位置
	            var placement = Object.keys(placements).filter(function (key) {
	                return placements[key].points[0] === align.points[0] && placements[key].points[1] === align.points[1];
	            })[0];
	            if (!placement) {
	                return;
	            }
	            // 根据当前坐标设置动画点
	            var rect = domNode.getBoundingClientRect();
	            var transformOrigin = {
	                top: '50%',
	                left: '50%'
	            };
	            if (placement.indexOf('top') >= 0 || placement.indexOf('Bottom') >= 0) {
	                transformOrigin.top = rect.height - align.offset[1] + 'px';
	            } else if (placement.indexOf('Top') >= 0 || placement.indexOf('bottom') >= 0) {
	                transformOrigin.top = -align.offset[1] + 'px';
	            }
	            if (placement.indexOf('left') >= 0 || placement.indexOf('Right') >= 0) {
	                transformOrigin.left = rect.width - align.offset[0] + 'px';
	            } else if (placement.indexOf('right') >= 0 || placement.indexOf('Left') >= 0) {
	                transformOrigin.left = -align.offset[0] + 'px';
	            }
	            domNode.style.transformOrigin = transformOrigin.left + ' ' + transformOrigin.top;
	        };
	        _this.state = {
	            visible: !!props.visible || !!props.defaultVisible
	        };
	        return _this;
	    }
	
	    (0, _createClass3['default'])(Tooltip, [{
	        key: 'componentWillReceiveProps',
	        value: function componentWillReceiveProps(nextProps) {
	            if ('visible' in nextProps) {
	                this.setState({ visible: nextProps.visible });
	            }
	        }
	    }, {
	        key: 'getPopupDomNode',
	        value: function getPopupDomNode() {
	            return this.refs.tooltip.getPopupDomNode();
	        }
	    }, {
	        key: 'getPlacements',
	        value: function getPlacements() {
	            var _props = this.props,
	                builtinPlacements = _props.builtinPlacements,
	                arrowPointAtCenter = _props.arrowPointAtCenter,
	                autoAdjustOverflow = _props.autoAdjustOverflow;
	
	            return builtinPlacements || (0, _placements2['default'])({
	                arrowPointAtCenter: arrowPointAtCenter,
	                verticalArrowShift: 8,
	                autoAdjustOverflow: autoAdjustOverflow
	            });
	        }
	    }, {
	        key: 'isHoverTrigger',
	        value: function isHoverTrigger() {
	            var trigger = this.props.trigger;
	
	            if (!trigger || trigger === 'hover') {
	                return true;
	            }
	            if (Array.isArray(trigger)) {
	                return trigger.indexOf('hover') >= 0;
	            }
	            return false;
	        }
	        // Fix Tooltip won't hide at disabled button
	        // mouse events don't trigger at disabled button in Chrome
	        // https://github.com/react-component/tooltip/issues/18
	
	    }, {
	        key: 'getDisabledCompatibleChildren',
	        value: function getDisabledCompatibleChildren(element) {
	            if ((element.type.__ANT_BUTTON || element.type === 'button') && element.props.disabled && this.isHoverTrigger()) {
	                // Pick some layout related style properties up to span
	                // Prevent layout bugs like https://github.com/ant-design/ant-design/issues/5254
	                var _splitObject = splitObject(element.props.style, ['position', 'left', 'right', 'top', 'bottom', 'float', 'display', 'zIndex']),
	                    picked = _splitObject.picked,
	                    omited = _splitObject.omited;
	
	                var spanStyle = (0, _extends3['default'])({ display: 'inline-block' }, picked, { cursor: 'not-allowed' });
	                var buttonStyle = (0, _extends3['default'])({}, omited, { pointerEvents: 'none' });
	                var child = (0, _react.cloneElement)(element, {
	                    style: buttonStyle,
	                    className: null
	                });
	                return _react2['default'].createElement(
	                    'span',
	                    { style: spanStyle, className: element.props.className },
	                    child
	                );
	            }
	            return element;
	        }
	    }, {
	        key: 'isNoTitle',
	        value: function isNoTitle() {
	            var _props2 = this.props,
	                title = _props2.title,
	                overlay = _props2.overlay;
	
	            return !title && !overlay; // overlay for old version compatibility
	        }
	    }, {
	        key: 'render',
	        value: function render() {
	            var props = this.props,
	                state = this.state;
	            var prefixCls = props.prefixCls,
	                title = props.title,
	                overlay = props.overlay,
	                openClassName = props.openClassName,
	                getPopupContainer = props.getPopupContainer,
	                getTooltipContainer = props.getTooltipContainer;
	
	            var children = props.children;
	            var visible = state.visible;
	            // Hide tooltip when there is no title
	            if (!('visible' in props) && this.isNoTitle()) {
	                visible = false;
	            }
	            var child = this.getDisabledCompatibleChildren(_react2['default'].isValidElement(children) ? children : _react2['default'].createElement(
	                'span',
	                null,
	                children
	            ));
	            var childProps = child.props;
	            var childCls = (0, _classnames2['default'])(childProps.className, (0, _defineProperty3['default'])({}, openClassName || prefixCls + '-open', true));
	            return _react2['default'].createElement(
	                _rcTooltip2['default'],
	                (0, _extends3['default'])({}, this.props, { getTooltipContainer: getPopupContainer || getTooltipContainer, ref: 'tooltip', builtinPlacements: this.getPlacements(), overlay: overlay || title || '', visible: visible, onVisibleChange: this.onVisibleChange, onPopupAlign: this.onPopupAlign }),
	                visible ? (0, _react.cloneElement)(child, { className: childCls }) : child
	            );
	        }
	    }]);
	    return Tooltip;
	}(_react2['default'].Component);
	
	exports['default'] = Tooltip;
	
	Tooltip.defaultProps = {
	    prefixCls: 'ant-tooltip',
	    placement: 'top',
	    transitionName: 'zoom-big-fast',
	    mouseEnterDelay: 0.1,
	    mouseLeaveDelay: 0.1,
	    arrowPointAtCenter: false,
	    autoAdjustOverflow: true
	};
	module.exports = exports['default'];

/***/ }),
/* 57 */
/***/ (function(module, exports) {

	module.exports = function (exec) {
	  try {
	    return !!exec();
	  } catch (e) {
	    return true;
	  }
	};


/***/ }),
/* 58 */
/***/ (function(module, exports, __webpack_require__) {

	var dP = __webpack_require__(40);
	var createDesc = __webpack_require__(69);
	module.exports = __webpack_require__(47) ? function (object, key, value) {
	  return dP.f(object, key, createDesc(1, value));
	} : function (object, key, value) {
	  object[key] = value;
	  return object;
	};


/***/ }),
/* 59 */
/***/ (function(module, exports) {

	module.exports = function (it) {
	  return typeof it === 'object' ? it !== null : typeof it === 'function';
	};


/***/ }),
/* 60 */
/***/ (function(module, exports) {

	module.exports = {};


/***/ }),
/* 61 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: 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 && obj !== Symbol.prototype ? "symbol" : typeof obj; };
	
	var _propertyUtils = __webpack_require__(475);
	
	var RE_NUM = /[\-+]?(?:\d*\.|)\d+(?:[eE][\-+]?\d+|)/.source;
	
	var getComputedStyleX = void 0;
	
	// https://stackoverflow.com/a/3485654/3040605
	function forceRelayout(elem) {
	  var originalStyle = elem.style.display;
	  elem.style.display = 'none';
	  elem.offsetHeight; // eslint-disable-line
	  elem.style.display = originalStyle;
	}
	
	function css(el, name, v) {
	  var value = v;
	  if ((typeof name === 'undefined' ? 'undefined' : _typeof(name)) === 'object') {
	    for (var i in name) {
	      if (name.hasOwnProperty(i)) {
	        css(el, i, name[i]);
	      }
	    }
	    return undefined;
	  }
	  if (typeof value !== 'undefined') {
	    if (typeof value === 'number') {
	      value = value + 'px';
	    }
	    el.style[name] = value;
	    return undefined;
	  }
	  return getComputedStyleX(el, name);
	}
	
	function getClientPosition(elem) {
	  var box = void 0;
	  var x = void 0;
	  var y = void 0;
	  var doc = elem.ownerDocument;
	  var body = doc.body;
	  var docElem = doc && doc.documentElement;
	  // 根据 GBS 最新数据，A-Grade Browsers 都已支持 getBoundingClientRect 方法，不用再考虑传统的实现方式
	  box = elem.getBoundingClientRect();
	
	  // 注：jQuery 还考虑减去 docElem.clientLeft/clientTop
	  // 但测试发现，这样反而会导致当 html 和 body 有边距/边框样式时，获取的值不正确
	  // 此外，ie6 会忽略 html 的 margin 值，幸运地是没有谁会去设置 html 的 margin
	
	  x = box.left;
	  y = box.top;
	
	  // In IE, most of the time, 2 extra pixels are added to the top and left
	  // due to the implicit 2-pixel inset border.  In IE6/7 quirks mode and
	  // IE6 standards mode, this border can be overridden by setting the
	  // document element's border to zero -- thus, we cannot rely on the
	  // offset always being 2 pixels.
	
	  // In quirks mode, the offset can be determined by querying the body's
	  // clientLeft/clientTop, but in standards mode, it is found by querying
	  // the document element's clientLeft/clientTop.  Since we already called
	  // getClientBoundingRect we have already forced a reflow, so it is not
	  // too expensive just to query them all.
	
	  // ie 下应该减去窗口的边框吧，毕竟默认 absolute 都是相对窗口定位的
	  // 窗口边框标准是设 documentElement ,quirks 时设置 body
	  // 最好禁止在 body 和 html 上边框 ，但 ie < 9 html 默认有 2px ，减去
	  // 但是非 ie 不可能设置窗口边框，body html 也不是窗口 ,ie 可以通过 html,body 设置
	  // 标准 ie 下 docElem.clientTop 就是 border-top
	  // ie7 html 即窗口边框改变不了。永远为 2
	  // 但标准 firefox/chrome/ie9 下 docElem.clientTop 是窗口边框，即使设了 border-top 也为 0
	
	  x -= docElem.clientLeft || body.clientLeft || 0;
	  y -= docElem.clientTop || body.clientTop || 0;
	
	  return {
	    left: x,
	    top: y
	  };
	}
	
	function getScroll(w, top) {
	  var ret = w['page' + (top ? 'Y' : 'X') + 'Offset'];
	  var method = 'scroll' + (top ? 'Top' : 'Left');
	  if (typeof ret !== 'number') {
	    var d = w.document;
	    // ie6,7,8 standard mode
	    ret = d.documentElement[method];
	    if (typeof ret !== 'number') {
	      // quirks mode
	      ret = d.body[method];
	    }
	  }
	  return ret;
	}
	
	function getScrollLeft(w) {
	  return getScroll(w);
	}
	
	function getScrollTop(w) {
	  return getScroll(w, true);
	}
	
	function getOffset(el) {
	  var pos = getClientPosition(el);
	  var doc = el.ownerDocument;
	  var w = doc.defaultView || doc.parentWindow;
	  pos.left += getScrollLeft(w);
	  pos.top += getScrollTop(w);
	  return pos;
	}
	
	/**
	 * A crude way of determining if an object is a window
	 * @member util
	 */
	function isWindow(obj) {
	  // must use == for ie8
	  /* eslint eqeqeq:0 */
	  return obj !== null && obj !== undefined && obj == obj.window;
	}
	
	function getDocument(node) {
	  if (isWindow(node)) {
	    return node.document;
	  }
	  if (node.nodeType === 9) {
	    return node;
	  }
	  return node.ownerDocument;
	}
	
	function _getComputedStyle(elem, name, cs) {
	  var computedStyle = cs;
	  var val = '';
	  var d = getDocument(elem);
	  computedStyle = computedStyle || d.defaultView.getComputedStyle(elem, null);
	
	  // https://github.com/kissyteam/kissy/issues/61
	  if (computedStyle) {
	    val = computedStyle.getPropertyValue(name) || computedStyle[name];
	  }
	
	  return val;
	}
	
	var _RE_NUM_NO_PX = new RegExp('^(' + RE_NUM + ')(?!px)[a-z%]+$', 'i');
	var RE_POS = /^(top|right|bottom|left)$/;
	var CURRENT_STYLE = 'currentStyle';
	var RUNTIME_STYLE = 'runtimeStyle';
	var LEFT = 'left';
	var PX = 'px';
	
	function _getComputedStyleIE(elem, name) {
	  // currentStyle maybe null
	  // http://msdn.microsoft.com/en-us/library/ms535231.aspx
	  var ret = elem[CURRENT_STYLE] && elem[CURRENT_STYLE][name];
	
	  // 当 width/height 设置为百分比时，通过 pixelLeft 方式转换的 width/height 值
	  // 一开始就处理了! CUSTOM_STYLE.height,CUSTOM_STYLE.width ,cssHook 解决@2011-08-19
	  // 在 ie 下不对，需要直接用 offset 方式
	  // borderWidth 等值也有问题，但考虑到 borderWidth 设为百分比的概率很小，这里就不考虑了
	
	  // From the awesome hack by Dean Edwards
	  // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
	  // If we're not dealing with a regular pixel number
	  // but a number that has a weird ending, we need to convert it to pixels
	  // exclude left right for relativity
	  if (_RE_NUM_NO_PX.test(ret) && !RE_POS.test(name)) {
	    // Remember the original values
	    var style = elem.style;
	    var left = style[LEFT];
	    var rsLeft = elem[RUNTIME_STYLE][LEFT];
	
	    // prevent flashing of content
	    elem[RUNTIME_STYLE][LEFT] = elem[CURRENT_STYLE][LEFT];
	
	    // Put in the new values to get a computed value out
	    style[LEFT] = name === 'fontSize' ? '1em' : ret || 0;
	    ret = style.pixelLeft + PX;
	
	    // Revert the changed values
	    style[LEFT] = left;
	
	    elem[RUNTIME_STYLE][LEFT] = rsLeft;
	  }
	  return ret === '' ? 'auto' : ret;
	}
	
	if (typeof window !== 'undefined') {
	  getComputedStyleX = window.getComputedStyle ? _getComputedStyle : _getComputedStyleIE;
	}
	
	function getOffsetDirection(dir, option) {
	  if (dir === 'left') {
	    return option.useCssRight ? 'right' : dir;
	  }
	  return option.useCssBottom ? 'bottom' : dir;
	}
	
	function oppositeOffsetDirection(dir) {
	  if (dir === 'left') {
	    return 'right';
	  } else if (dir === 'right') {
	    return 'left';
	  } else if (dir === 'top') {
	    return 'bottom';
	  } else if (dir === 'bottom') {
	    return 'top';
	  }
	}
	
	// 设置 elem 相对 elem.ownerDocument 的坐标
	function setLeftTop(elem, offset, option) {
	  // set position first, in-case top/left are set even on static elem
	  if (css(elem, 'position') === 'static') {
	    elem.style.position = 'relative';
	  }
	  var presetH = -999;
	  var presetV = -999;
	  var horizontalProperty = getOffsetDirection('left', option);
	  var verticalProperty = getOffsetDirection('top', option);
	  var oppositeHorizontalProperty = oppositeOffsetDirection(horizontalProperty);
	  var oppositeVerticalProperty = oppositeOffsetDirection(verticalProperty);
	
	  if (horizontalProperty !== 'left') {
	    presetH = 999;
	  }
	
	  if (verticalProperty !== 'top') {
	    presetV = 999;
	  }
	  var originalTransition = '';
	  var originalOffset = getOffset(elem);
	  if ('left' in offset || 'top' in offset) {
	    originalTransition = (0, _propertyUtils.getTransitionProperty)(elem) || '';
	    (0, _propertyUtils.setTransitionProperty)(elem, 'none');
	  }
	  if ('left' in offset) {
	    elem.style[oppositeHorizontalProperty] = '';
	    elem.style[horizontalProperty] = presetH + 'px';
	  }
	  if ('top' in offset) {
	    elem.style[oppositeVerticalProperty] = '';
	    elem.style[verticalProperty] = presetV + 'px';
	  }
	  // force relayout
	  forceRelayout(elem);
	  var old = getOffset(elem);
	  var originalStyle = {};
	  for (var key in offset) {
	    if (offset.hasOwnProperty(key)) {
	      var dir = getOffsetDirection(key, option);
	      var preset = key === 'left' ? presetH : presetV;
	      var off = originalOffset[key] - old[key];
	      if (dir === key) {
	        originalStyle[dir] = preset + off;
	      } else {
	        originalStyle[dir] = preset - off;
	      }
	    }
	  }
	  css(elem, originalStyle);
	  // force relayout
	  forceRelayout(elem);
	  if ('left' in offset || 'top' in offset) {
	    (0, _propertyUtils.setTransitionProperty)(elem, originalTransition);
	  }
	  var ret = {};
	  for (var _key in offset) {
	    if (offset.hasOwnProperty(_key)) {
	      var _dir = getOffsetDirection(_key, option);
	      var _off = offset[_key] - originalOffset[_key];
	      if (_key === _dir) {
	        ret[_dir] = originalStyle[_dir] + _off;
	      } else {
	        ret[_dir] = originalStyle[_dir] - _off;
	      }
	    }
	  }
	  css(elem, ret);
	}
	
	function setTransform(elem, offset) {
	  var originalOffset = getOffset(elem);
	  var originalXY = (0, _propertyUtils.getTransformXY)(elem);
	  var resultXY = { x: originalXY.x, y: originalXY.y };
	  if ('left' in offset) {
	    resultXY.x = originalXY.x + offset.left - originalOffset.left;
	  }
	  if ('top' in offset) {
	    resultXY.y = originalXY.y + offset.top - originalOffset.top;
	  }
	  (0, _propertyUtils.setTransformXY)(elem, resultXY);
	}
	
	function setOffset(elem, offset, option) {
	  if (option.useCssRight || option.useCssBottom) {
	    setLeftTop(elem, offset, option);
	  } else if (option.useCssTransform && (0, _propertyUtils.getTransformName)() in document.body.style) {
	    setTransform(elem, offset, option);
	  } else {
	    setLeftTop(elem, offset, option);
	  }
	}
	
	function each(arr, fn) {
	  for (var i = 0; i < arr.length; i++) {
	    fn(arr[i]);
	  }
	}
	
	function isBorderBoxFn(elem) {
	  return getComputedStyleX(elem, 'boxSizing') === 'border-box';
	}
	
	var BOX_MODELS = ['margin', 'border', 'padding'];
	var CONTENT_INDEX = -1;
	var PADDING_INDEX = 2;
	var BORDER_INDEX = 1;
	var MARGIN_INDEX = 0;
	
	function swap(elem, options, callback) {
	  var old = {};
	  var style = elem.style;
	  var name = void 0;
	
	  // Remember the old values, and insert the new ones
	  for (name in options) {
	    if (options.hasOwnProperty(name)) {
	      old[name] = style[name];
	      style[name] = options[name];
	    }
	  }
	
	  callback.call(elem);
	
	  // Revert the old values
	  for (name in options) {
	    if (options.hasOwnProperty(name)) {
	      style[name] = old[name];
	    }
	  }
	}
	
	function getPBMWidth(elem, props, which) {
	  var value = 0;
	  var prop = void 0;
	  var j = void 0;
	  var i = void 0;
	  for (j = 0; j < props.length; j++) {
	    prop = props[j];
	    if (prop) {
	      for (i = 0; i < which.length; i++) {
	        var cssProp = void 0;
	        if (prop === 'border') {
	          cssProp = '' + prop + which[i] + 'Width';
	        } else {
	          cssProp = prop + which[i];
	        }
	        value += parseFloat(getComputedStyleX(elem, cssProp)) || 0;
	      }
	    }
	  }
	  return value;
	}
	
	var domUtils = {};
	
	each(['Width', 'Height'], function (name) {
	  domUtils['doc' + name] = function (refWin) {
	    var d = refWin.document;
	    return Math.max(
	    // firefox chrome documentElement.scrollHeight< body.scrollHeight
	    // ie standard mode : documentElement.scrollHeight> body.scrollHeight
	    d.documentElement['scroll' + name],
	    // quirks : documentElement.scrollHeight 最大等于可视窗口多一点？
	    d.body['scroll' + name], domUtils['viewport' + name](d));
	  };
	
	  domUtils['viewport' + name] = function (win) {
	    // pc browser includes scrollbar in window.innerWidth
	    var prop = 'client' + name;
	    var doc = win.document;
	    var body = doc.body;
	    var documentElement = doc.documentElement;
	    var documentElementProp = documentElement[prop];
	    // 标准模式取 documentElement
	    // backcompat 取 body
	    return doc.compatMode === 'CSS1Compat' && documentElementProp || body && body[prop] || documentElementProp;
	  };
	});
	
	/*
	 得到元素的大小信息
	 @param elem
	 @param name
	 @param {String} [extra]  'padding' : (css width) + padding
	 'border' : (css width) + padding + border
	 'margin' : (css width) + padding + border + margin
	 */
	function getWH(elem, name, ex) {
	  var extra = ex;
	  if (isWindow(elem)) {
	    return name === 'width' ? domUtils.viewportWidth(elem) : domUtils.viewportHeight(elem);
	  } else if (elem.nodeType === 9) {
	    return name === 'width' ? domUtils.docWidth(elem) : domUtils.docHeight(elem);
	  }
	  var which = name === 'width' ? ['Left', 'Right'] : ['Top', 'Bottom'];
	  var borderBoxValue = name === 'width' ? elem.getBoundingClientRect().width : elem.getBoundingClientRect().height;
	  var computedStyle = getComputedStyleX(elem);
	  var isBorderBox = isBorderBoxFn(elem, computedStyle);
	  var cssBoxValue = 0;
	  if (borderBoxValue === null || borderBoxValue === undefined || borderBoxValue <= 0) {
	    borderBoxValue = undefined;
	    // Fall back to computed then un computed css if necessary
	    cssBoxValue = getComputedStyleX(elem, name);
	    if (cssBoxValue === null || cssBoxValue === undefined || Number(cssBoxValue) < 0) {
	      cssBoxValue = elem.style[name] || 0;
	    }
	    // Normalize '', auto, and prepare for extra
	    cssBoxValue = parseFloat(cssBoxValue) || 0;
	  }
	  if (extra === undefined) {
	    extra = isBorderBox ? BORDER_INDEX : CONTENT_INDEX;
	  }
	  var borderBoxValueOrIsBorderBox = borderBoxValue !== undefined || isBorderBox;
	  var val = borderBoxValue || cssBoxValue;
	  if (extra === CONTENT_INDEX) {
	    if (borderBoxValueOrIsBorderBox) {
	      return val - getPBMWidth(elem, ['border', 'padding'], which, computedStyle);
	    }
	    return cssBoxValue;
	  } else if (borderBoxValueOrIsBorderBox) {
	    if (extra === BORDER_INDEX) {
	      return val;
	    }
	    return val + (extra === PADDING_INDEX ? -getPBMWidth(elem, ['border'], which, computedStyle) : getPBMWidth(elem, ['margin'], which, computedStyle));
	  }
	  return cssBoxValue + getPBMWidth(elem, BOX_MODELS.slice(extra), which, computedStyle);
	}
	
	var cssShow = {
	  position: 'absolute',
	  visibility: 'hidden',
	  display: 'block'
	};
	
	// fix #119 : https://github.com/kissyteam/kissy/issues/119
	function getWHIgnoreDisplay() {
	  for (var _len = arguments.length, args = Array(_len), _key2 = 0; _key2 < _len; _key2++) {
	    args[_key2] = arguments[_key2];
	  }
	
	  var val = void 0;
	  var elem = args[0];
	  // in case elem is window
	  // elem.offsetWidth === undefined
	  if (elem.offsetWidth !== 0) {
	    val = getWH.apply(undefined, args);
	  } else {
	    swap(elem, cssShow, function () {
	      val = getWH.apply(undefined, args);
	    });
	  }
	  return val;
	}
	
	each(['width', 'height'], function (name) {
	  var first = name.charAt(0).toUpperCase() + name.slice(1);
	  domUtils['outer' + first] = function (el, includeMargin) {
	    return el && getWHIgnoreDisplay(el, name, includeMargin ? MARGIN_INDEX : BORDER_INDEX);
	  };
	  var which = name === 'width' ? ['Left', 'Right'] : ['Top', 'Bottom'];
	
	  domUtils[name] = function (elem, v) {
	    var val = v;
	    if (val !== undefined) {
	      if (elem) {
	        var computedStyle = getComputedStyleX(elem);
	        var isBorderBox = isBorderBoxFn(elem);
	        if (isBorderBox) {
	          val += getPBMWidth(elem, ['padding', 'border'], which, computedStyle);
	        }
	        return css(elem, name, val);
	      }
	      return undefined;
	    }
	    return elem && getWHIgnoreDisplay(elem, name, CONTENT_INDEX);
	  };
	});
	
	function mix(to, from) {
	  for (var i in from) {
	    if (from.hasOwnProperty(i)) {
	      to[i] = from[i];
	    }
	  }
	  return to;
	}
	
	var utils = {
	  getWindow: function getWindow(node) {
	    if (node && node.document && node.setTimeout) {
	      return node;
	    }
	    var doc = node.ownerDocument || node;
	    return doc.defaultView || doc.parentWindow;
	  },
	
	  getDocument: getDocument,
	  offset: function offset(el, value, option) {
	    if (typeof value !== 'undefined') {
	      setOffset(el, value, option || {});
	    } else {
	      return getOffset(el);
	    }
	  },
	
	  isWindow: isWindow,
	  each: each,
	  css: css,
	  clone: function clone(obj) {
	    var i = void 0;
	    var ret = {};
	    for (i in obj) {
	      if (obj.hasOwnProperty(i)) {
	        ret[i] = obj[i];
	      }
	    }
	    var overflow = obj.overflow;
	    if (overflow) {
	      for (i in obj) {
	        if (obj.hasOwnProperty(i)) {
	          ret.overflow[i] = obj.overflow[i];
	        }
	      }
	    }
	    return ret;
	  },
	
	  mix: mix,
	  getWindowScrollLeft: function getWindowScrollLeft(w) {
	    return getScrollLeft(w);
	  },
	  getWindowScrollTop: function getWindowScrollTop(w) {
	    return getScrollTop(w);
	  },
	  merge: function merge() {
	    var ret = {};
	
	    for (var _len2 = arguments.length, args = Array(_len2), _key3 = 0; _key3 < _len2; _key3++) {
	      args[_key3] = arguments[_key3];
	    }
	
	    for (var i = 0; i < args.length; i++) {
	      utils.mix(ret, args[i]);
	    }
	    return ret;
	  },
	
	  viewportWidth: 0,
	  viewportHeight: 0
	};
	
	mix(utils, domUtils);
	
	exports['default'] = utils;
	module.exports = exports['default'];

/***/ }),
/* 62 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule SelectionState
	 * @format
	 * 
	 */
	
	'use strict';
	
	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 Immutable = __webpack_require__(11);
	
	var Record = Immutable.Record;
	
	
	var defaultRecord = {
	  anchorKey: '',
	  anchorOffset: 0,
	  focusKey: '',
	  focusOffset: 0,
	  isBackward: false,
	  hasFocus: false
	};
	
	var SelectionStateRecord = Record(defaultRecord);
	
	var SelectionState = function (_SelectionStateRecord) {
	  _inherits(SelectionState, _SelectionStateRecord);
	
	  function SelectionState() {
	    _classCallCheck(this, SelectionState);
	
	    return _possibleConstructorReturn(this, _SelectionStateRecord.apply(this, arguments));
	  }
	
	  SelectionState.prototype.serialize = function serialize() {
	    return 'Anchor: ' + this.getAnchorKey() + ':' + this.getAnchorOffset() + ', ' + 'Focus: ' + this.getFocusKey() + ':' + this.getFocusOffset() + ', ' + 'Is Backward: ' + String(this.getIsBackward()) + ', ' + 'Has Focus: ' + String(this.getHasFocus());
	  };
	
	  SelectionState.prototype.getAnchorKey = function getAnchorKey() {
	    return this.get('anchorKey');
	  };
	
	  SelectionState.prototype.getAnchorOffset = function getAnchorOffset() {
	    return this.get('anchorOffset');
	  };
	
	  SelectionState.prototype.getFocusKey = function getFocusKey() {
	    return this.get('focusKey');
	  };
	
	  SelectionState.prototype.getFocusOffset = function getFocusOffset() {
	    return this.get('focusOffset');
	  };
	
	  SelectionState.prototype.getIsBackward = function getIsBackward() {
	    return this.get('isBackward');
	  };
	
	  SelectionState.prototype.getHasFocus = function getHasFocus() {
	    return this.get('hasFocus');
	  };
	
	  /**
	   * Return whether the specified range overlaps with an edge of the
	   * SelectionState.
	   */
	
	
	  SelectionState.prototype.hasEdgeWithin = function hasEdgeWithin(blockKey, start, end) {
	    var anchorKey = this.getAnchorKey();
	    var focusKey = this.getFocusKey();
	
	    if (anchorKey === focusKey && anchorKey === blockKey) {
	      var selectionStart = this.getStartOffset();
	      var selectionEnd = this.getEndOffset();
	      return start <= selectionEnd && selectionStart <= end;
	    }
	
	    if (blockKey !== anchorKey && blockKey !== focusKey) {
	      return false;
	    }
	
	    var offsetToCheck = blockKey === anchorKey ? this.getAnchorOffset() : this.getFocusOffset();
	
	    return start <= offsetToCheck && end >= offsetToCheck;
	  };
	
	  SelectionState.prototype.isCollapsed = function isCollapsed() {
	    return this.getAnchorKey() === this.getFocusKey() && this.getAnchorOffset() === this.getFocusOffset();
	  };
	
	  SelectionState.prototype.getStartKey = function getStartKey() {
	    return this.getIsBackward() ? this.getFocusKey() : this.getAnchorKey();
	  };
	
	  SelectionState.prototype.getStartOffset = function getStartOffset() {
	    return this.getIsBackward() ? this.getFocusOffset() : this.getAnchorOffset();
	  };
	
	  SelectionState.prototype.getEndKey = function getEndKey() {
	    return this.getIsBackward() ? this.getAnchorKey() : this.getFocusKey();
	  };
	
	  SelectionState.prototype.getEndOffset = function getEndOffset() {
	    return this.getIsBackward() ? this.getAnchorOffset() : this.getFocusOffset();
	  };
	
	  SelectionState.createEmpty = function createEmpty(key) {
	    return new SelectionState({
	      anchorKey: key,
	      anchorOffset: 0,
	      focusKey: key,
	      focusOffset: 0,
	      isBackward: false,
	      hasFocus: false
	    });
	  };
	
	  return SelectionState;
	}(SelectionStateRecord);
	
	module.exports = SelectionState;

/***/ }),
/* 63 */
/***/ (function(module, exports) {

	'use strict';
	
	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 */
	
	/**
	 * This function is used to mark string literals representing CSS class names
	 * so that they can be transformed statically. This allows for modularization
	 * and minification of CSS class names.
	 *
	 * In static_upstream, this function is actually implemented, but it should
	 * eventually be replaced with something more descriptive, and the transform
	 * that is used in the main stack should be ported for use elsewhere.
	 *
	 * @param string|object className to modularize, or an object of key/values.
	 *                      In the object case, the values are conditions that
	 *                      determine if the className keys should be included.
	 * @param [string ...]  Variable list of classNames in the string case.
	 * @return string       Renderable space-separated CSS className.
	 */
	function cx(classNames) {
	  if (typeof classNames == 'object') {
	    return Object.keys(classNames).filter(function (className) {
	      return classNames[className];
	    }).map(replace).join(' ');
	  }
	  return Array.prototype.map.call(arguments, replace).join(' ');
	}
	
	function replace(str) {
	  return str.replace(/\//g, '-');
	}
	
	module.exports = cx;

/***/ }),
/* 64 */
/***/ (function(module, exports, __webpack_require__) {

	var Symbol = __webpack_require__(92),
	    getRawTag = __webpack_require__(607),
	    objectToString = __webpack_require__(636);
	
	/** `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;


/***/ }),
/* 65 */
/***/ (function(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;


/***/ }),
/* 66 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	exports.toArray = toArray;
	exports.getActiveIndex = getActiveIndex;
	exports.getActiveKey = getActiveKey;
	exports.setTransform = setTransform;
	exports.isTransformSupported = isTransformSupported;
	exports.setTransition = setTransition;
	exports.getTransformPropValue = getTransformPropValue;
	exports.isVertical = isVertical;
	exports.getTransformByIndex = getTransformByIndex;
	exports.getMarginStyle = getMarginStyle;
	exports.getStyle = getStyle;
	exports.setPxStyle = setPxStyle;
	exports.getDataAttr = getDataAttr;
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function toArray(children) {
	  // allow [c,[a,b]]
	  var c = [];
	  _react2['default'].Children.forEach(children, function (child) {
	    if (child) {
	      c.push(child);
	    }
	  });
	  return c;
	}
	
	function getActiveIndex(children, activeKey) {
	  var c = toArray(children);
	  for (var i = 0; i < c.length; i++) {
	    if (c[i].key === activeKey) {
	      return i;
	    }
	  }
	  return -1;
	}
	
	function getActiveKey(children, index) {
	  var c = toArray(children);
	  return c[index].key;
	}
	
	function setTransform(style, v) {
	  style.transform = v;
	  style.webkitTransform = v;
	  style.mozTransform = v;
	}
	
	function isTransformSupported(style) {
	  return 'transform' in style || 'webkitTransform' in style || 'MozTransform' in style;
	}
	
	function setTransition(style, v) {
	  style.transition = v;
	  style.webkitTransition = v;
	  style.MozTransition = v;
	}
	function getTransformPropValue(v) {
	  return {
	    transform: v,
	    WebkitTransform: v,
	    MozTransform: v
	  };
	}
	
	function isVertical(tabBarPosition) {
	  return tabBarPosition === 'left' || tabBarPosition === 'right';
	}
	
	function getTransformByIndex(index, tabBarPosition) {
	  var translate = isVertical(tabBarPosition) ? 'translateY' : 'translateX';
	  return translate + '(' + -index * 100 + '%) translateZ(0)';
	}
	
	function getMarginStyle(index, tabBarPosition) {
	  var marginDirection = isVertical(tabBarPosition) ? 'marginTop' : 'marginLeft';
	  return (0, _defineProperty3['default'])({}, marginDirection, -index * 100 + '%');
	}
	
	function getStyle(el, property) {
	  return +getComputedStyle(el).getPropertyValue(property).replace('px', '');
	}
	
	function setPxStyle(el, value, vertical) {
	  value = vertical ? '0px, ' + value + 'px, 0px' : value + 'px, 0px, 0px';
	  setTransform(el.style, 'translate3d(' + value + ')');
	}
	
	function getDataAttr(props) {
	  return Object.keys(props).reduce(function (prev, key) {
	    if (key.substr(0, 5) === 'aria-' || key.substr(0, 5) === 'data-' || key === 'role') {
	      prev[key] = props[key];
	    }
	    return prev;
	  }, {});
	}

/***/ }),
/* 67 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	exports['default'] = function (componentName, defaultLocale) {
	    return function (Component) {
	        var ComponentWithStatics = Component;
	        return _a = function (_Component) {
	            (0, _inherits3['default'])(_a, _Component);
	
	            function _a() {
	                (0, _classCallCheck3['default'])(this, _a);
	                return (0, _possibleConstructorReturn3['default'])(this, (_a.__proto__ || Object.getPrototypeOf(_a)).apply(this, arguments));
	            }
	
	            (0, _createClass3['default'])(_a, [{
	                key: 'getLocale',
	                value: function getLocale() {
	                    var antLocale = this.context.antLocale;
	
	                    var localeFromContext = antLocale && antLocale[componentName];
	                    var localeFromProps = this.props.locale || {};
	                    return (0, _extends3['default'])({}, defaultLocale, localeFromContext || {}, localeFromProps);
	                }
	            }]);
	            return _a;
	        }(Component), _a.propTypes = ComponentWithStatics.propTypes, _a.defaultProps = ComponentWithStatics.defaultProps, _a.contextTypes = (0, _extends3['default'])({}, ComponentWithStatics.context || {}, { antLocale: _propTypes2['default'].object }), _a;
	        var _a;
	    };
	};
	
	module.exports = exports['default'];

/***/ }),
/* 68 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _rcSelect = __webpack_require__(267);
	
	var _rcSelect2 = _interopRequireDefault(_rcSelect);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _warning = __webpack_require__(24);
	
	var _warning2 = _interopRequireDefault(_warning);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var __rest = undefined && undefined.__rest || function (s, e) {
	    var t = {};
	    for (var p in s) {
	        if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
	    }if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	        if (e.indexOf(p[i]) < 0) t[p[i]] = s[p[i]];
	    }return t;
	};
	
	var SelectPropTypes = {
	    prefixCls: _propTypes2['default'].string,
	    className: _propTypes2['default'].string,
	    size: _propTypes2['default'].oneOf(['default', 'large', 'small']),
	    combobox: _propTypes2['default'].bool,
	    notFoundContent: _propTypes2['default'].any,
	    showSearch: _propTypes2['default'].bool,
	    optionLabelProp: _propTypes2['default'].string,
	    transitionName: _propTypes2['default'].string,
	    choiceTransitionName: _propTypes2['default'].string
	};
	// => It is needless to export the declaration of below two inner components.
	// export { Option, OptGroup };
	
	var Select = function (_React$Component) {
	    (0, _inherits3['default'])(Select, _React$Component);
	
	    function Select() {
	        (0, _classCallCheck3['default'])(this, Select);
	        return (0, _possibleConstructorReturn3['default'])(this, (Select.__proto__ || Object.getPrototypeOf(Select)).apply(this, arguments));
	    }
	
	    (0, _createClass3['default'])(Select, [{
	        key: 'getLocale',
	        value: function getLocale() {
	            var antLocale = this.context.antLocale;
	
	            if (antLocale && antLocale.Select) {
	                return antLocale.Select;
	            }
	            return {
	                notFoundContent: '无匹配结果'
	            };
	        }
	    }, {
	        key: 'render',
	        value: function render() {
	            var _classNames;
	
	            var _a = this.props,
	                prefixCls = _a.prefixCls,
	                _a$className = _a.className,
	                className = _a$className === undefined ? '' : _a$className,
	                size = _a.size,
	                mode = _a.mode,
	                multiple = _a.multiple,
	                tags = _a.tags,
	                combobox = _a.combobox,
	                restProps = __rest(_a, ["prefixCls", "className", "size", "mode", "multiple", "tags", "combobox"]);
	            (0, _warning2['default'])(!multiple && !tags && !combobox, '`Select[multiple|tags|combobox]` is deprecated, please use `Select[mode]` instead.');
	            var cls = (0, _classnames2['default'])((_classNames = {}, (0, _defineProperty3['default'])(_classNames, prefixCls + '-lg', size === 'large'), (0, _defineProperty3['default'])(_classNames, prefixCls + '-sm', size === 'small'), _classNames), className);
	            var locale = this.getLocale();
	            var _props = this.props,
	                _props$notFoundConten = _props.notFoundContent,
	                notFoundContent = _props$notFoundConten === undefined ? locale.notFoundContent : _props$notFoundConten,
	                optionLabelProp = _props.optionLabelProp;
	
	            var isCombobox = mode === 'combobox' || combobox;
	            if (isCombobox) {
	                notFoundContent = null;
	                // children 带 dom 结构时，无法填入输入框
	                optionLabelProp = optionLabelProp || 'value';
	            }
	            var modeConfig = {
	                multiple: mode === 'multiple' || multiple,
	                tags: mode === 'tags' || tags,
	                combobox: isCombobox
	            };
	            return _react2['default'].createElement(_rcSelect2['default'], (0, _extends3['default'])({}, restProps, modeConfig, { prefixCls: prefixCls, className: cls, optionLabelProp: optionLabelProp || 'children', notFoundContent: notFoundContent }));
	        }
	    }]);
	    return Select;
	}(_react2['default'].Component);
	
	exports['default'] = Select;
	
	Select.Option = _rcSelect.Option;
	Select.OptGroup = _rcSelect.OptGroup;
	Select.defaultProps = {
	    prefixCls: 'ant-select',
	    showSearch: false,
	    transitionName: 'slide-up',
	    choiceTransitionName: 'zoom'
	};
	Select.propTypes = SelectPropTypes;
	Select.contextTypes = {
	    antLocale: _propTypes2['default'].object
	};
	module.exports = exports['default'];

/***/ }),
/* 69 */
/***/ (function(module, exports) {

	module.exports = function (bitmap, value) {
	  return {
	    enumerable: !(bitmap & 1),
	    configurable: !(bitmap & 2),
	    writable: !(bitmap & 4),
	    value: value
	  };
	};


/***/ }),
/* 70 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule BlockMapBuilder
	 * @format
	 * 
	 */
	
	'use strict';
	
	var Immutable = __webpack_require__(11);
	
	var OrderedMap = Immutable.OrderedMap;
	
	
	var BlockMapBuilder = {
	  createFromArray: function createFromArray(blocks) {
	    return OrderedMap(blocks.map(function (block) {
	      return [block.getKey(), block];
	    }));
	  }
	};
	
	module.exports = BlockMapBuilder;

/***/ }),
/* 71 */
/***/ (function(module, exports) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule DraftOffsetKey
	 * @format
	 * 
	 */
	
	'use strict';
	
	var KEY_DELIMITER = '-';
	
	var DraftOffsetKey = {
	  encode: function encode(blockKey, decoratorKey, leafKey) {
	    return blockKey + KEY_DELIMITER + decoratorKey + KEY_DELIMITER + leafKey;
	  },
	
	  decode: function decode(offsetKey) {
	    var _offsetKey$split = offsetKey.split(KEY_DELIMITER),
	        blockKey = _offsetKey$split[0],
	        decoratorKey = _offsetKey$split[1],
	        leafKey = _offsetKey$split[2];
	
	    return {
	      blockKey: blockKey,
	      decoratorKey: parseInt(decoratorKey, 10),
	      leafKey: parseInt(leafKey, 10)
	    };
	  }
	};
	
	module.exports = DraftOffsetKey;

/***/ }),
/* 72 */
/***/ (function(module, exports) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule findRangesImmutable
	 * @format
	 * 
	 */
	
	'use strict';
	
	/**
	 * Search through an array to find contiguous stretches of elements that
	 * match a specified filter function.
	 *
	 * When ranges are found, execute a specified `found` function to supply
	 * the values to the caller.
	 */
	function findRangesImmutable(haystack, areEqualFn, filterFn, foundFn) {
	  if (!haystack.size) {
	    return;
	  }
	
	  var cursor = 0;
	
	  haystack.reduce(function (value, nextValue, nextIndex) {
	    if (!areEqualFn(value, nextValue)) {
	      if (filterFn(value)) {
	        foundFn(cursor, nextIndex);
	      }
	      cursor = nextIndex;
	    }
	    return nextValue;
	  });
	
	  filterFn(haystack.last()) && foundFn(cursor, haystack.count());
	}
	
	module.exports = findRangesImmutable;

/***/ }),
/* 73 */
/***/ (function(module, exports) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule isEventHandled
	 * @format
	 * 
	 */
	
	'use strict';
	
	/**
	 * Utility method for determining whether or not the value returned
	 * from a handler indicates that it was handled.
	 */
	function isEventHandled(value) {
	  return value === 'handled' || value === true;
	}
	
	module.exports = isEventHandled;

/***/ }),
/* 74 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule removeTextWithStrategy
	 * @format
	 * 
	 */
	
	'use strict';
	
	var DraftModifier = __webpack_require__(26);
	
	/**
	 * For a collapsed selection state, remove text based on the specified strategy.
	 * If the selection state is not collapsed, remove the entire selected range.
	 */
	function removeTextWithStrategy(editorState, strategy, direction) {
	  var selection = editorState.getSelection();
	  var content = editorState.getCurrentContent();
	  var target = selection;
	  if (selection.isCollapsed()) {
	    if (direction === 'forward') {
	      if (editorState.isSelectionAtEndOfContent()) {
	        return content;
	      }
	    } else if (editorState.isSelectionAtStartOfContent()) {
	      return content;
	    }
	
	    target = strategy(editorState);
	    if (target === selection) {
	      return content;
	    }
	  }
	  return DraftModifier.removeRange(content, target, direction);
	}
	
	module.exports = removeTextWithStrategy;

/***/ }),
/* 75 */
/***/ (function(module, exports) {

	"use strict";
	
	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 * 
	 */
	
	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;

/***/ }),
/* 76 */
/***/ (function(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;


/***/ }),
/* 77 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.Divider = exports.ItemGroup = exports.MenuItemGroup = exports.MenuItem = exports.Item = exports.SubMenu = undefined;
	
	var _Menu = __webpack_require__(713);
	
	var _Menu2 = _interopRequireDefault(_Menu);
	
	var _SubMenu = __webpack_require__(716);
	
	var _SubMenu2 = _interopRequireDefault(_SubMenu);
	
	var _MenuItem = __webpack_require__(714);
	
	var _MenuItem2 = _interopRequireDefault(_MenuItem);
	
	var _MenuItemGroup = __webpack_require__(715);
	
	var _MenuItemGroup2 = _interopRequireDefault(_MenuItemGroup);
	
	var _Divider = __webpack_require__(712);
	
	var _Divider2 = _interopRequireDefault(_Divider);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
	
	exports.SubMenu = _SubMenu2["default"];
	exports.Item = _MenuItem2["default"];
	exports.MenuItem = _MenuItem2["default"];
	exports.MenuItemGroup = _MenuItemGroup2["default"];
	exports.ItemGroup = _MenuItemGroup2["default"];
	exports.Divider = _Divider2["default"];
	exports["default"] = _Menu2["default"];

/***/ }),
/* 78 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	/**
	 * Copyright 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule ReactComponentWithPureRenderMixin
	 */
	
	var shallowEqual = __webpack_require__(790);
	
	function shallowCompare(instance, nextProps, nextState) {
	  return !shallowEqual(instance.props, nextProps) || !shallowEqual(instance.state, nextState);
	}
	
	/**
	 * If your React component's render function is "pure", e.g. it will render the
	 * same result given the same props and state, provide this mixin for a
	 * considerable performance boost.
	 *
	 * Most React components have pure render functions.
	 *
	 * Example:
	 *
	 *   var ReactComponentWithPureRenderMixin =
	 *     require('ReactComponentWithPureRenderMixin');
	 *   React.createClass({
	 *     mixins: [ReactComponentWithPureRenderMixin],
	 *
	 *     render: function() {
	 *       return <div className={this.props.className}>foo</div>;
	 *     }
	 *   });
	 *
	 * Note: This only checks shallow equality for props and state. If these contain
	 * complex data structures this mixin may have false-negatives for deeper
	 * differences. Only mixin to components which have simple props and state, or
	 * use `forceUpdate()` when you know deep data structures have changed.
	 *
	 * See https://facebook.github.io/react/docs/pure-render-mixin.html
	 */
	var ReactComponentWithPureRenderMixin = {
	  shouldComponentUpdate: function shouldComponentUpdate(nextProps, nextState) {
	    return shallowCompare(this, nextProps, nextState);
	  }
	};
	
	module.exports = ReactComponentWithPureRenderMixin;

/***/ }),
/* 79 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	exports.getComponentLocale = getComponentLocale;
	exports.getLocaleCode = getLocaleCode;
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function getComponentLocale(props, context, componentName, getDefaultLocale) {
	    var locale = {};
	    if (context && context.antLocale && context.antLocale[componentName]) {
	        locale = context.antLocale[componentName];
	    } else {
	        var defaultLocale = getDefaultLocale();
	        // TODO: make default lang of antd be English
	        // https://github.com/ant-design/ant-design/issues/6334
	        locale = defaultLocale['default'] || defaultLocale;
	    }
	    var result = (0, _extends3['default'])({}, locale, props.locale);
	    result.lang = (0, _extends3['default'])({}, locale.lang, props.locale.lang);
	    return result;
	}
	function getLocaleCode(context) {
	    var localeCode = context.antLocale && context.antLocale.locale;
	    // Had use LocaleProvide but didn't set locale
	    if (context.antLocale && context.antLocale.exist && !localeCode) {
	        return 'zh-cn';
	    }
	    return localeCode;
	}

/***/ }),
/* 80 */
/***/ (function(module, exports) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	exports['default'] = getRequestAnimationFrame;
	exports.cancelRequestAnimationFrame = cancelRequestAnimationFrame;
	var availablePrefixs = ['moz', 'ms', 'webkit'];
	function requestAnimationFramePolyfill() {
	    var lastTime = 0;
	    return function (callback) {
	        var currTime = new Date().getTime();
	        var timeToCall = Math.max(0, 16 - (currTime - lastTime));
	        var id = window.setTimeout(function () {
	            callback(currTime + timeToCall);
	        }, timeToCall);
	        lastTime = currTime + timeToCall;
	        return id;
	    };
	}
	function getRequestAnimationFrame() {
	    if (typeof window === 'undefined') {
	        return function () {};
	    }
	    if (window.requestAnimationFrame) {
	        // https://github.com/vuejs/vue/issues/4465
	        return window.requestAnimationFrame.bind(window);
	    }
	    var prefix = availablePrefixs.filter(function (key) {
	        return key + 'RequestAnimationFrame' in window;
	    })[0];
	    return prefix ? window[prefix + 'RequestAnimationFrame'] : requestAnimationFramePolyfill();
	}
	function cancelRequestAnimationFrame(id) {
	    if (typeof window === 'undefined') {
	        return null;
	    }
	    if (window.cancelAnimationFrame) {
	        return window.cancelAnimationFrame(id);
	    }
	    var prefix = availablePrefixs.filter(function (key) {
	        return key + 'CancelAnimationFrame' in window || key + 'CancelRequestAnimationFrame' in window;
	    })[0];
	    return prefix ? (window[prefix + 'CancelAnimationFrame'] || window[prefix + 'CancelRequestAnimationFrame']).call(this, id) : clearTimeout(id);
	}

/***/ }),
/* 81 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _Input = __webpack_require__(172);
	
	var _Input2 = _interopRequireDefault(_Input);
	
	var _Group = __webpack_require__(352);
	
	var _Group2 = _interopRequireDefault(_Group);
	
	var _Search = __webpack_require__(353);
	
	var _Search2 = _interopRequireDefault(_Search);
	
	var _TextArea = __webpack_require__(173);
	
	var _TextArea2 = _interopRequireDefault(_TextArea);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	_Input2['default'].Group = _Group2['default'];
	_Input2['default'].Search = _Search2['default'];
	_Input2['default'].TextArea = _TextArea2['default'];
	exports['default'] = _Input2['default'];
	module.exports = exports['default'];

/***/ }),
/* 82 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.Group = exports.Button = undefined;
	
	var _radio = __webpack_require__(104);
	
	var _radio2 = _interopRequireDefault(_radio);
	
	var _group = __webpack_require__(371);
	
	var _group2 = _interopRequireDefault(_group);
	
	var _radioButton = __webpack_require__(372);
	
	var _radioButton2 = _interopRequireDefault(_radioButton);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	_radio2['default'].Button = _radioButton2['default'];
	_radio2['default'].Group = _group2['default'];
	exports.Button = _radioButton2['default'];
	exports.Group = _group2['default'];
	exports['default'] = _radio2['default'];

/***/ }),
/* 83 */
/***/ (function(module, exports, __webpack_require__) {

	// 19.1.2.14 / 15.2.3.14 Object.keys(O)
	var $keys = __webpack_require__(195);
	var enumBugKeys = __webpack_require__(109);
	
	module.exports = Object.keys || function keys(O) {
	  return $keys(O, enumBugKeys);
	};


/***/ }),
/* 84 */
/***/ (function(module, exports) {

	exports.f = {}.propertyIsEnumerable;


/***/ }),
/* 85 */
/***/ (function(module, exports, __webpack_require__) {

	// 7.1.13 ToObject(argument)
	var defined = __webpack_require__(108);
	module.exports = function (it) {
	  return Object(defined(it));
	};


/***/ }),
/* 86 */
/***/ (function(module, exports) {

	var id = 0;
	var px = Math.random();
	module.exports = function (key) {
	  return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));
	};


/***/ }),
/* 87 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	var $at = __webpack_require__(450)(true);
	
	// 21.1.3.27 String.prototype[@@iterator]()
	__webpack_require__(192)(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;
	  var index = this._i;
	  var point;
	  if (index >= O.length) return { value: undefined, done: true };
	  point = $at(O, index);
	  this._i += point.length;
	  return { value: point, done: false };
	});


/***/ }),
/* 88 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	module.exports = __webpack_require__(478);

/***/ }),
/* 89 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	var _assign = __webpack_require__(18);
	
	var _extends = _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; };
	
	/**
	 * 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.
	 *
	 * @providesModule DraftEntity
	 * @format
	 * 
	 */
	
	var DraftEntityInstance = __webpack_require__(204);
	var Immutable = __webpack_require__(11);
	
	var invariant = __webpack_require__(12);
	
	var Map = Immutable.Map;
	
	
	var instances = Map();
	var instanceKey = 0;
	
	/**
	 * Temporary utility for generating the warnings
	 */
	function logWarning(oldMethodCall, newMethodCall) {
	  console.warn('WARNING: ' + oldMethodCall + ' will be deprecated soon!\nPlease use "' + newMethodCall + '" instead.');
	}
	
	/**
	 * A "document entity" is an object containing metadata associated with a
	 * piece of text in a ContentBlock.
	 *
	 * For example, a `link` entity might include a `uri` property. When a
	 * ContentBlock is rendered in the browser, text that refers to that link
	 * entity may be rendered as an anchor, with the `uri` as the href value.
	 *
	 * In a ContentBlock, every position in the text may correspond to zero
	 * or one entities. This correspondence is tracked using a key string,
	 * generated via DraftEntity.create() and used to obtain entity metadata
	 * via DraftEntity.get().
	 */
	var DraftEntity = {
	  /**
	   * WARNING: This method will be deprecated soon!
	   * Please use 'contentState.getLastCreatedEntityKey' instead.
	   * ---
	   * Get the random key string from whatever entity was last created.
	   * We need this to support the new API, as part of transitioning to put Entity
	   * storage in contentState.
	   */
	  getLastCreatedEntityKey: function getLastCreatedEntityKey() {
	    logWarning('DraftEntity.getLastCreatedEntityKey', 'contentState.getLastCreatedEntityKey');
	    return DraftEntity.__getLastCreatedEntityKey();
	  },
	
	  /**
	   * WARNING: This method will be deprecated soon!
	   * Please use 'contentState.createEntity' instead.
	   * ---
	   * Create a DraftEntityInstance and store it for later retrieval.
	   *
	   * A random key string will be generated and returned. This key may
	   * be used to track the entity's usage in a ContentBlock, and for
	   * retrieving data about the entity at render time.
	   */
	  create: function create(type, mutability, data) {
	    logWarning('DraftEntity.create', 'contentState.createEntity');
	    return DraftEntity.__create(type, mutability, data);
	  },
	
	  /**
	   * WARNING: This method will be deprecated soon!
	   * Please use 'contentState.addEntity' instead.
	   * ---
	   * Add an existing DraftEntityInstance to the DraftEntity map. This is
	   * useful when restoring instances from the server.
	   */
	  add: function add(instance) {
	    logWarning('DraftEntity.add', 'contentState.addEntity');
	    return DraftEntity.__add(instance);
	  },
	
	  /**
	   * WARNING: This method will be deprecated soon!
	   * Please use 'contentState.getEntity' instead.
	   * ---
	   * Retrieve the entity corresponding to the supplied key string.
	   */
	  get: function get(key) {
	    logWarning('DraftEntity.get', 'contentState.getEntity');
	    return DraftEntity.__get(key);
	  },
	
	  /**
	   * WARNING: This method will be deprecated soon!
	   * Please use 'contentState.mergeEntityData' instead.
	   * ---
	   * Entity instances are immutable. If you need to update the data for an
	   * instance, this method will merge your data updates and return a new
	   * instance.
	   */
	  mergeData: function mergeData(key, toMerge) {
	    logWarning('DraftEntity.mergeData', 'contentState.mergeEntityData');
	    return DraftEntity.__mergeData(key, toMerge);
	  },
	
	  /**
	   * WARNING: This method will be deprecated soon!
	   * Please use 'contentState.replaceEntityData' instead.
	   * ---
	   * Completely replace the data for a given instance.
	   */
	  replaceData: function replaceData(key, newData) {
	    logWarning('DraftEntity.replaceData', 'contentState.replaceEntityData');
	    return DraftEntity.__replaceData(key, newData);
	  },
	
	  // ***********************************WARNING******************************
	  // --- the above public API will be deprecated in the next version of Draft!
	  // The methods below this line are private - don't call them directly.
	
	  /**
	   * Get the random key string from whatever entity was last created.
	   * We need this to support the new API, as part of transitioning to put Entity
	   * storage in contentState.
	   */
	  __getLastCreatedEntityKey: function __getLastCreatedEntityKey() {
	    return '' + instanceKey;
	  },
	
	  /**
	   * Create a DraftEntityInstance and store it for later retrieval.
	   *
	   * A random key string will be generated and returned. This key may
	   * be used to track the entity's usage in a ContentBlock, and for
	   * retrieving data about the entity at render time.
	   */
	  __create: function __create(type, mutability, data) {
	    return DraftEntity.__add(new DraftEntityInstance({ type: type, mutability: mutability, data: data || {} }));
	  },
	
	  /**
	   * Add an existing DraftEntityInstance to the DraftEntity map. This is
	   * useful when restoring instances from the server.
	   */
	  __add: function __add(instance) {
	    var key = '' + ++instanceKey;
	    instances = instances.set(key, instance);
	    return key;
	  },
	
	  /**
	   * Retrieve the entity corresponding to the supplied key string.
	   */
	  __get: function __get(key) {
	    var instance = instances.get(key);
	    !!!instance ?  true ? invariant(false, 'Unknown DraftEntity key: %s.', key) : invariant(false) : void 0;
	    return instance;
	  },
	
	  /**
	   * Entity instances are immutable. If you need to update the data for an
	   * instance, this method will merge your data updates and return a new
	   * instance.
	   */
	  __mergeData: function __mergeData(key, toMerge) {
	    var instance = DraftEntity.__get(key);
	    var newData = _extends({}, instance.getData(), toMerge);
	    var newInstance = instance.set('data', newData);
	    instances = instances.set(key, newInstance);
	    return newInstance;
	  },
	
	  /**
	   * Completely replace the data for a given instance.
	   */
	  __replaceData: function __replaceData(key, newData) {
	    var instance = DraftEntity.__get(key);
	    var newInstance = instance.set('data', newData);
	    instances = instances.set(key, newInstance);
	    return newInstance;
	  }
	};
	
	module.exports = DraftEntity;

/***/ }),
/* 90 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule getContentStateFragment
	 * @format
	 * 
	 */
	
	'use strict';
	
	var randomizeBlockMapKeys = __webpack_require__(221);
	var removeEntitiesAtEdges = __webpack_require__(222);
	
	var getContentStateFragment = function getContentStateFragment(contentState, selectionState) {
	  var startKey = selectionState.getStartKey();
	  var startOffset = selectionState.getStartOffset();
	  var endKey = selectionState.getEndKey();
	  var endOffset = selectionState.getEndOffset();
	
	  // Edge entities should be stripped to ensure that we don't preserve
	  // invalid partial entities when the fragment is reused. We do, however,
	  // preserve entities that are entirely within the selection range.
	  var contentWithoutEdgeEntities = removeEntitiesAtEdges(contentState, selectionState);
	
	  var blockMap = contentWithoutEdgeEntities.getBlockMap();
	  var blockKeys = blockMap.keySeq();
	  var startIndex = blockKeys.indexOf(startKey);
	  var endIndex = blockKeys.indexOf(endKey) + 1;
	
	  return randomizeBlockMapKeys(blockMap.slice(startIndex, endIndex).map(function (block, blockKey) {
	    var text = block.getText();
	    var chars = block.getCharacterList();
	
	    if (startKey === endKey) {
	      return block.merge({
	        text: text.slice(startOffset, endOffset),
	        characterList: chars.slice(startOffset, endOffset)
	      });
	    }
	
	    if (blockKey === startKey) {
	      return block.merge({
	        text: text.slice(startOffset),
	        characterList: chars.slice(startOffset)
	      });
	    }
	
	    if (blockKey === endKey) {
	      return block.merge({
	        text: text.slice(0, endOffset),
	        characterList: chars.slice(0, endOffset)
	      });
	    }
	
	    return block;
	  }));
	};
	
	module.exports = getContentStateFragment;

/***/ }),
/* 91 */
/***/ (function(module, exports) {

	/* WEBPACK VAR INJECTION */(function(global) {/**
	 * lodash (Custom Build) <https://lodash.com/>
	 * Build: `lodash modularize exports="npm" -o ./`
	 * Copyright jQuery Foundation and other contributors <https://jquery.org/>
	 * Released under MIT license <https://lodash.com/license>
	 * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
	 * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
	 */
	
	/** Used as the `TypeError` message for "Functions" methods. */
	var FUNC_ERROR_TEXT = 'Expected a function';
	
	/** Used as references for various `Number` constants. */
	var NAN = 0 / 0;
	
	/** `Object#toString` result references. */
	var symbolTag = '[object Symbol]';
	
	/** 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;
	
	/** Detect free variable `global` from Node.js. */
	var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;
	
	/** 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')();
	
	/** 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 objectToString = objectProto.toString;
	
	/* Built-in method references for those with the same name as other `lodash` methods. */
	var nativeMax = Math.max,
	    nativeMin = Math.min;
	
	/**
	 * Gets the timestamp of the number of milliseconds that have elapsed since
	 * the Unix epoch (1 January 1970 00:00:00 UTC).
	 *
	 * @static
	 * @memberOf _
	 * @since 2.4.0
	 * @category Date
	 * @returns {number} Returns the timestamp.
	 * @example
	 *
	 * _.defer(function(stamp) {
	 *   console.log(_.now() - stamp);
	 * }, _.now());
	 * // => Logs the number of milliseconds it took for the deferred invocation.
	 */
	var now = function() {
	  return root.Date.now();
	};
	
	/**
	 * Creates a debounced function that delays invoking `func` until after `wait`
	 * milliseconds have elapsed since the last time the debounced function was
	 * invoked. The debounced function comes with a `cancel` method to cancel
	 * delayed `func` invocations and a `flush` method to immediately invoke them.
	 * Provide `options` to indicate whether `func` should be invoked on the
	 * leading and/or trailing edge of the `wait` timeout. The `func` is invoked
	 * with the last arguments provided to the debounced function. Subsequent
	 * calls to the debounced function return the result of the last `func`
	 * invocation.
	 *
	 * **Note:** If `leading` and `trailing` options are `true`, `func` is
	 * invoked on the trailing edge of the timeout only if the debounced function
	 * is invoked more than once during the `wait` timeout.
	 *
	 * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
	 * until to the next tick, similar to `setTimeout` with a timeout of `0`.
	 *
	 * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
	 * for details over the differences between `_.debounce` and `_.throttle`.
	 *
	 * @static
	 * @memberOf _
	 * @since 0.1.0
	 * @category Function
	 * @param {Function} func The function to debounce.
	 * @param {number} [wait=0] The number of milliseconds to delay.
	 * @param {Object} [options={}] The options object.
	 * @param {boolean} [options.leading=false]
	 *  Specify invoking on the leading edge of the timeout.
	 * @param {number} [options.maxWait]
	 *  The maximum time `func` is allowed to be delayed before it's invoked.
	 * @param {boolean} [options.trailing=true]
	 *  Specify invoking on the trailing edge of the timeout.
	 * @returns {Function} Returns the new debounced function.
	 * @example
	 *
	 * // Avoid costly calculations while the window size is in flux.
	 * jQuery(window).on('resize', _.debounce(calculateLayout, 150));
	 *
	 * // Invoke `sendMail` when clicked, debouncing subsequent calls.
	 * jQuery(element).on('click', _.debounce(sendMail, 300, {
	 *   'leading': true,
	 *   'trailing': false
	 * }));
	 *
	 * // Ensure `batchLog` is invoked once after 1 second of debounced calls.
	 * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });
	 * var source = new EventSource('/stream');
	 * jQuery(source).on('message', debounced);
	 *
	 * // Cancel the trailing debounced invocation.
	 * jQuery(window).on('popstate', debounced.cancel);
	 */
	function debounce(func, wait, options) {
	  var lastArgs,
	      lastThis,
	      maxWait,
	      result,
	      timerId,
	      lastCallTime,
	      lastInvokeTime = 0,
	      leading = false,
	      maxing = false,
	      trailing = true;
	
	  if (typeof func != 'function') {
	    throw new TypeError(FUNC_ERROR_TEXT);
	  }
	  wait = toNumber(wait) || 0;
	  if (isObject(options)) {
	    leading = !!options.leading;
	    maxing = 'maxWait' in options;
	    maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;
	    trailing = 'trailing' in options ? !!options.trailing : trailing;
	  }
	
	  function invokeFunc(time) {
	    var args = lastArgs,
	        thisArg = lastThis;
	
	    lastArgs = lastThis = undefined;
	    lastInvokeTime = time;
	    result = func.apply(thisArg, args);
	    return result;
	  }
	
	  function leadingEdge(time) {
	    // Reset any `maxWait` timer.
	    lastInvokeTime = time;
	    // Start the timer for the trailing edge.
	    timerId = setTimeout(timerExpired, wait);
	    // Invoke the leading edge.
	    return leading ? invokeFunc(time) : result;
	  }
	
	  function remainingWait(time) {
	    var timeSinceLastCall = time - lastCallTime,
	        timeSinceLastInvoke = time - lastInvokeTime,
	        result = wait - timeSinceLastCall;
	
	    return maxing ? nativeMin(result, maxWait - timeSinceLastInvoke) : result;
	  }
	
	  function shouldInvoke(time) {
	    var timeSinceLastCall = time - lastCallTime,
	        timeSinceLastInvoke = time - lastInvokeTime;
	
	    // Either this is the first call, activity has stopped and we're at the
	    // trailing edge, the system time has gone backwards and we're treating
	    // it as the trailing edge, or we've hit the `maxWait` limit.
	    return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||
	      (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));
	  }
	
	  function timerExpired() {
	    var time = now();
	    if (shouldInvoke(time)) {
	      return trailingEdge(time);
	    }
	    // Restart the timer.
	    timerId = setTimeout(timerExpired, remainingWait(time));
	  }
	
	  function trailingEdge(time) {
	    timerId = undefined;
	
	    // Only invoke if we have `lastArgs` which means `func` has been
	    // debounced at least once.
	    if (trailing && lastArgs) {
	      return invokeFunc(time);
	    }
	    lastArgs = lastThis = undefined;
	    return result;
	  }
	
	  function cancel() {
	    if (timerId !== undefined) {
	      clearTimeout(timerId);
	    }
	    lastInvokeTime = 0;
	    lastArgs = lastCallTime = lastThis = timerId = undefined;
	  }
	
	  function flush() {
	    return timerId === undefined ? result : trailingEdge(now());
	  }
	
	  function debounced() {
	    var time = now(),
	        isInvoking = shouldInvoke(time);
	
	    lastArgs = arguments;
	    lastThis = this;
	    lastCallTime = time;
	
	    if (isInvoking) {
	      if (timerId === undefined) {
	        return leadingEdge(lastCallTime);
	      }
	      if (maxing) {
	        // Handle invocations in a tight loop.
	        timerId = setTimeout(timerExpired, wait);
	        return invokeFunc(lastCallTime);
	      }
	    }
	    if (timerId === undefined) {
	      timerId = setTimeout(timerExpired, wait);
	    }
	    return result;
	  }
	  debounced.cancel = cancel;
	  debounced.flush = flush;
	  return debounced;
	}
	
	/**
	 * 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 && (type == 'object' || type == 'function');
	}
	
	/**
	 * 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 && typeof value == 'object';
	}
	
	/**
	 * 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) && objectToString.call(value) == symbolTag);
	}
	
	/**
	 * 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 = debounce;
	
	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))

/***/ }),
/* 92 */
/***/ (function(module, exports, __webpack_require__) {

	var root = __webpack_require__(43);
	
	/** Built-in value references. */
	var Symbol = root.Symbol;
	
	module.exports = Symbol;


/***/ }),
/* 93 */
/***/ (function(module, exports, __webpack_require__) {

	var eq = __webpack_require__(233);
	
	/**
	 * 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;


/***/ }),
/* 94 */
/***/ (function(module, exports, __webpack_require__) {

	var isKeyable = __webpack_require__(618);
	
	/**
	 * 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;


/***/ }),
/* 95 */
/***/ (function(module, exports, __webpack_require__) {

	var getNative = __webpack_require__(52);
	
	/* Built-in method references that are verified to be native. */
	var nativeCreate = getNative(Object, 'create');
	
	module.exports = nativeCreate;


/***/ }),
/* 96 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _en_US = __webpack_require__(156);
	
	var _en_US2 = _interopRequireDefault(_en_US);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function noop() {}
	
	exports['default'] = {
	  propTypes: {
	    className: _propTypes2['default'].string,
	    locale: _propTypes2['default'].object,
	    style: _propTypes2['default'].object,
	    visible: _propTypes2['default'].bool,
	    onSelect: _propTypes2['default'].func,
	    prefixCls: _propTypes2['default'].string,
	    onChange: _propTypes2['default'].func,
	    onOk: _propTypes2['default'].func
	  },
	
	  getDefaultProps: function getDefaultProps() {
	    return {
	      locale: _en_US2['default'],
	      style: {},
	      visible: true,
	      prefixCls: 'rc-calendar',
	      className: '',
	      onSelect: noop,
	      onChange: noop,
	      onClear: noop,
	      renderFooter: function renderFooter() {
	        return null;
	      },
	      renderSidebar: function renderSidebar() {
	        return null;
	      }
	    };
	  },
	  shouldComponentUpdate: function shouldComponentUpdate(nextProps) {
	    return this.props.visible || nextProps.visible;
	  },
	  getFormat: function getFormat() {
	    var format = this.props.format;
	    var _props = this.props,
	        locale = _props.locale,
	        timePicker = _props.timePicker;
	
	    if (!format) {
	      if (timePicker) {
	        format = locale.dateTimeFormat;
	      } else {
	        format = locale.dateFormat;
	      }
	    }
	    return format;
	  },
	  focus: function focus() {
	    if (this.rootInstance) {
	      this.rootInstance.focus();
	    }
	  },
	  saveRoot: function saveRoot(root) {
	    this.rootInstance = root;
	  }
	};
	module.exports = exports['default'];

/***/ }),
/* 97 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.noop = noop;
	exports.getKeyFromChildrenIndex = getKeyFromChildrenIndex;
	exports.loopMenuItem = loopMenuItem;
	exports.loopMenuItemRecusively = loopMenuItemRecusively;
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
	
	function noop() {}
	
	function getKeyFromChildrenIndex(child, menuEventKey, index) {
	  var prefix = menuEventKey || '';
	  return child.key || prefix + 'item_' + index;
	}
	
	function loopMenuItem(children, cb) {
	  var index = -1;
	  _react2["default"].Children.forEach(children, function (c) {
	    index++;
	    if (c && c.type && c.type.isMenuItemGroup) {
	      _react2["default"].Children.forEach(c.props.children, function (c2) {
	        index++;
	        cb(c2, index);
	      });
	    } else {
	      cb(c, index);
	    }
	  });
	}
	
	function loopMenuItemRecusively(children, keys, ret) {
	  if (!children || ret.find) {
	    return;
	  }
	  _react2["default"].Children.forEach(children, function (c) {
	    if (ret.find) {
	      return;
	    }
	    if (c) {
	      var construt = c.type;
	      if (!construt || !(construt.isSubMenu || construt.isMenuItem || construt.isMenuItemGroup)) {
	        return;
	      }
	      if (keys.indexOf(c.key) !== -1) {
	        ret.find = true;
	      } else if (c.props.children) {
	        loopMenuItemRecusively(c.props.children, keys, ret);
	      }
	    }
	  });
	}

/***/ }),
/* 98 */
/***/ (function(module, exports) {

	module.exports = function(module) {
		if(!module.webpackPolyfill) {
			module.deprecate = function() {};
			module.paths = [];
			// module.parent = undefined by default
			module.children = [];
			module.webpackPolyfill = 1;
		}
		return module;
	}


/***/ }),
/* 99 */
/***/ (function(module, exports) {

	function arrayTreeFilter(data, filterFn, options) {
	  options = options || {};
	  options.childrenKeyName = options.childrenKeyName || 'children';
	  var children = data || [];
	  var result = [];
	  var level = 0;
	  var foundItem;
	  do {
	    var foundItem = children.filter(function(item) {
	      return filterFn(item, level);
	    })[0];
	    if (!foundItem) {
	      break;
	    }
	    result.push(foundItem);
	    children = foundItem[options.childrenKeyName] || [];
	    level += 1;
	  } while(children.length > 0);
	  return result;
	}
	
	module.exports = arrayTreeFilter;


/***/ }),
/* 100 */
/***/ (function(module, exports) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	exports['default'] = getScroll;
	function getScroll(target, top) {
	    if (typeof window === 'undefined') {
	        return 0;
	    }
	    var prop = top ? 'pageYOffset' : 'pageXOffset';
	    var method = top ? 'scrollTop' : 'scrollLeft';
	    var isWindow = target === window;
	    var ret = isWindow ? target[prop] : target[method];
	    // ie6,7,8 standard mode
	    if (isWindow && typeof ret !== 'number') {
	        ret = window.document.documentElement[method];
	    }
	    return ret;
	}
	module.exports = exports['default'];

/***/ }),
/* 101 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _cssAnimation = __webpack_require__(122);
	
	var _cssAnimation2 = _interopRequireDefault(_cssAnimation);
	
	var _getRequestAnimationFrame = __webpack_require__(80);
	
	var _getRequestAnimationFrame2 = _interopRequireDefault(_getRequestAnimationFrame);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var reqAnimFrame = (0, _getRequestAnimationFrame2['default'])();
	function animate(node, show, done) {
	    var height = void 0;
	    var requestAnimationFrameId = void 0;
	    return (0, _cssAnimation2['default'])(node, 'ant-motion-collapse', {
	        start: function start() {
	            if (!show) {
	                node.style.height = node.offsetHeight + 'px';
	                node.style.opacity = 1;
	            } else {
	                height = node.offsetHeight;
	                node.style.height = 0;
	                node.style.opacity = 0;
	            }
	        },
	        active: function active() {
	            if (requestAnimationFrameId) {
	                (0, _getRequestAnimationFrame.cancelRequestAnimationFrame)(requestAnimationFrameId);
	            }
	            requestAnimationFrameId = reqAnimFrame(function () {
	                node.style.height = (show ? height : 0) + 'px';
	                node.style.opacity = show ? 1 : 0;
	            });
	        },
	        end: function end() {
	            if (requestAnimationFrameId) {
	                (0, _getRequestAnimationFrame.cancelRequestAnimationFrame)(requestAnimationFrameId);
	            }
	            node.style.height = '';
	            node.style.opacity = '';
	            done();
	        }
	    });
	}
	var animation = {
	    enter: function enter(node, done) {
	        return animate(node, true, done);
	    },
	    leave: function leave(node, done) {
	        return animate(node, false, done);
	    },
	    appear: function appear(node, done) {
	        return animate(node, true, done);
	    }
	};
	exports['default'] = animation;
	module.exports = exports['default'];

/***/ }),
/* 102 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _dropdown = __webpack_require__(167);
	
	var _dropdown2 = _interopRequireDefault(_dropdown);
	
	var _dropdownButton = __webpack_require__(346);
	
	var _dropdownButton2 = _interopRequireDefault(_dropdownButton);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	_dropdown2['default'].Button = _dropdownButton2['default'];
	exports['default'] = _dropdown2['default'];
	module.exports = exports['default'];

/***/ }),
/* 103 */
[1078, 995],
/* 104 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _rcCheckbox = __webpack_require__(254);
	
	var _rcCheckbox2 = _interopRequireDefault(_rcCheckbox);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _shallowequal = __webpack_require__(45);
	
	var _shallowequal2 = _interopRequireDefault(_shallowequal);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var __rest = undefined && undefined.__rest || function (s, e) {
	    var t = {};
	    for (var p in s) {
	        if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
	    }if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	        if (e.indexOf(p[i]) < 0) t[p[i]] = s[p[i]];
	    }return t;
	};
	
	var Radio = function (_React$Component) {
	    (0, _inherits3['default'])(Radio, _React$Component);
	
	    function Radio() {
	        (0, _classCallCheck3['default'])(this, Radio);
	        return (0, _possibleConstructorReturn3['default'])(this, (Radio.__proto__ || Object.getPrototypeOf(Radio)).apply(this, arguments));
	    }
	
	    (0, _createClass3['default'])(Radio, [{
	        key: 'shouldComponentUpdate',
	        value: function shouldComponentUpdate(nextProps, nextState, nextContext) {
	            return !(0, _shallowequal2['default'])(this.props, nextProps) || !(0, _shallowequal2['default'])(this.state, nextState) || !(0, _shallowequal2['default'])(this.context.radioGroup, nextContext.radioGroup);
	        }
	    }, {
	        key: 'render',
	        value: function render() {
	            var _classNames;
	
	            var props = this.props,
	                context = this.context;
	
	            var prefixCls = props.prefixCls,
	                className = props.className,
	                children = props.children,
	                style = props.style,
	                restProps = __rest(props, ["prefixCls", "className", "children", "style"]);
	
	            var radioGroup = context.radioGroup;
	
	            var radioProps = (0, _extends3['default'])({}, restProps);
	            if (radioGroup) {
	                radioProps.name = radioGroup.name;
	                radioProps.onChange = radioGroup.onChange;
	                radioProps.checked = props.value === radioGroup.value;
	                radioProps.disabled = props.disabled || radioGroup.disabled;
	            }
	            var wrapperClassString = (0, _classnames2['default'])(className, (_classNames = {}, (0, _defineProperty3['default'])(_classNames, prefixCls + '-wrapper', true), (0, _defineProperty3['default'])(_classNames, prefixCls + '-wrapper-checked', radioProps.checked), (0, _defineProperty3['default'])(_classNames, prefixCls + '-wrapper-disabled', radioProps.disabled), _classNames));
	            return _react2['default'].createElement(
	                'label',
	                { className: wrapperClassString, style: style, onMouseEnter: props.onMouseEnter, onMouseLeave: props.onMouseLeave },
	                _react2['default'].createElement(_rcCheckbox2['default'], (0, _extends3['default'])({}, radioProps, { prefixCls: prefixCls })),
	                children !== undefined ? _react2['default'].createElement(
	                    'span',
	                    null,
	                    children
	                ) : null
	            );
	        }
	    }]);
	    return Radio;
	}(_react2['default'].Component);
	
	exports['default'] = Radio;
	
	Radio.defaultProps = {
	    prefixCls: 'ant-radio',
	    type: 'radio'
	};
	Radio.contextTypes = {
	    radioGroup: _propTypes2['default'].any
	};
	module.exports = exports['default'];

/***/ }),
/* 105 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Module dependencies.
	 */
	
	try {
	  var index = __webpack_require__(187);
	} catch (err) {
	  var index = __webpack_require__(187);
	}
	
	/**
	 * Whitespace regexp.
	 */
	
	var re = /\s+/;
	
	/**
	 * toString reference.
	 */
	
	var toString = Object.prototype.toString;
	
	/**
	 * Wrap `el` in a `ClassList`.
	 *
	 * @param {Element} el
	 * @return {ClassList}
	 * @api public
	 */
	
	module.exports = function(el){
	  return new ClassList(el);
	};
	
	/**
	 * Initialize a new ClassList for `el`.
	 *
	 * @param {Element} el
	 * @api private
	 */
	
	function ClassList(el) {
	  if (!el || !el.nodeType) {
	    throw new Error('A DOM element reference is required');
	  }
	  this.el = el;
	  this.list = el.classList;
	}
	
	/**
	 * Add class `name` if not already present.
	 *
	 * @param {String} name
	 * @return {ClassList}
	 * @api public
	 */
	
	ClassList.prototype.add = function(name){
	  // classList
	  if (this.list) {
	    this.list.add(name);
	    return this;
	  }
	
	  // fallback
	  var arr = this.array();
	  var i = index(arr, name);
	  if (!~i) arr.push(name);
	  this.el.className = arr.join(' ');
	  return this;
	};
	
	/**
	 * Remove class `name` when present, or
	 * pass a regular expression to remove
	 * any which match.
	 *
	 * @param {String|RegExp} name
	 * @return {ClassList}
	 * @api public
	 */
	
	ClassList.prototype.remove = function(name){
	  if ('[object RegExp]' == toString.call(name)) {
	    return this.removeMatching(name);
	  }
	
	  // classList
	  if (this.list) {
	    this.list.remove(name);
	    return this;
	  }
	
	  // fallback
	  var arr = this.array();
	  var i = index(arr, name);
	  if (~i) arr.splice(i, 1);
	  this.el.className = arr.join(' ');
	  return this;
	};
	
	/**
	 * Remove all classes matching `re`.
	 *
	 * @param {RegExp} re
	 * @return {ClassList}
	 * @api private
	 */
	
	ClassList.prototype.removeMatching = function(re){
	  var arr = this.array();
	  for (var i = 0; i < arr.length; i++) {
	    if (re.test(arr[i])) {
	      this.remove(arr[i]);
	    }
	  }
	  return this;
	};
	
	/**
	 * Toggle class `name`, can force state via `force`.
	 *
	 * For browsers that support classList, but do not support `force` yet,
	 * the mistake will be detected and corrected.
	 *
	 * @param {String} name
	 * @param {Boolean} force
	 * @return {ClassList}
	 * @api public
	 */
	
	ClassList.prototype.toggle = function(name, force){
	  // classList
	  if (this.list) {
	    if ("undefined" !== typeof force) {
	      if (force !== this.list.toggle(name, force)) {
	        this.list.toggle(name); // toggle again to correct
	      }
	    } else {
	      this.list.toggle(name);
	    }
	    return this;
	  }
	
	  // fallback
	  if ("undefined" !== typeof force) {
	    if (!force) {
	      this.remove(name);
	    } else {
	      this.add(name);
	    }
	  } else {
	    if (this.has(name)) {
	      this.remove(name);
	    } else {
	      this.add(name);
	    }
	  }
	
	  return this;
	};
	
	/**
	 * Return an array of classes.
	 *
	 * @return {Array}
	 * @api public
	 */
	
	ClassList.prototype.array = function(){
	  var className = this.el.getAttribute('class') || '';
	  var str = className.replace(/^\s+|\s+$/g, '');
	  var arr = str.split(re);
	  if ('' === arr[0]) arr.shift();
	  return arr;
	};
	
	/**
	 * Check if class `name` is present.
	 *
	 * @param {String} name
	 * @return {ClassList}
	 * @api public
	 */
	
	ClassList.prototype.has =
	ClassList.prototype.contains = function(name){
	  return this.list
	    ? this.list.contains(name)
	    : !! ~index(this.array(), name);
	};


/***/ }),
/* 106 */
/***/ (function(module, exports) {

	var toString = {}.toString;
	
	module.exports = function (it) {
	  return toString.call(it).slice(8, -1);
	};


/***/ }),
/* 107 */
/***/ (function(module, exports, __webpack_require__) {

	// optional / simple context binding
	var aFunction = __webpack_require__(433);
	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);
	  };
	};


/***/ }),
/* 108 */
/***/ (function(module, exports) {

	// 7.2.1 RequireObjectCoercible(argument)
	module.exports = function (it) {
	  if (it == undefined) throw TypeError("Can't call method on  " + it);
	  return it;
	};


/***/ }),
/* 109 */
/***/ (function(module, exports) {

	// IE 8- don't enum bug keys
	module.exports = (
	  'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf'
	).split(',');


/***/ }),
/* 110 */
/***/ (function(module, exports) {

	module.exports = true;


/***/ }),
/* 111 */
/***/ (function(module, exports, __webpack_require__) {

	// 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])
	var anObject = __webpack_require__(46);
	var dPs = __webpack_require__(447);
	var enumBugKeys = __webpack_require__(109);
	var IE_PROTO = __webpack_require__(115)('IE_PROTO');
	var Empty = function () { /* empty */ };
	var 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 = __webpack_require__(189)('iframe');
	  var i = enumBugKeys.length;
	  var lt = '<';
	  var gt = '>';
	  var iframeDocument;
	  iframe.style.display = 'none';
	  __webpack_require__(438).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);
	};


/***/ }),
/* 112 */
/***/ (function(module, exports, __webpack_require__) {

	var pIE = __webpack_require__(84);
	var createDesc = __webpack_require__(69);
	var toIObject = __webpack_require__(49);
	var toPrimitive = __webpack_require__(118);
	var has = __webpack_require__(48);
	var IE8_DOM_DEFINE = __webpack_require__(190);
	var gOPD = Object.getOwnPropertyDescriptor;
	
	exports.f = __webpack_require__(47) ? 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]);
	};


/***/ }),
/* 113 */
/***/ (function(module, exports) {

	exports.f = Object.getOwnPropertySymbols;


/***/ }),
/* 114 */
/***/ (function(module, exports, __webpack_require__) {

	var def = __webpack_require__(40).f;
	var has = __webpack_require__(48);
	var TAG = __webpack_require__(32)('toStringTag');
	
	module.exports = function (it, tag, stat) {
	  if (it && !has(it = stat ? it : it.prototype, TAG)) def(it, TAG, { configurable: true, value: tag });
	};


/***/ }),
/* 115 */
/***/ (function(module, exports, __webpack_require__) {

	var shared = __webpack_require__(116)('keys');
	var uid = __webpack_require__(86);
	module.exports = function (key) {
	  return shared[key] || (shared[key] = uid(key));
	};


/***/ }),
/* 116 */
/***/ (function(module, exports, __webpack_require__) {

	var global = __webpack_require__(39);
	var SHARED = '__core-js_shared__';
	var store = global[SHARED] || (global[SHARED] = {});
	module.exports = function (key) {
	  return store[key] || (store[key] = {});
	};


/***/ }),
/* 117 */
/***/ (function(module, exports) {

	// 7.1.4 ToInteger
	var ceil = Math.ceil;
	var floor = Math.floor;
	module.exports = function (it) {
	  return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);
	};


/***/ }),
/* 118 */
/***/ (function(module, exports, __webpack_require__) {

	// 7.1.1 ToPrimitive(input [, PreferredType])
	var isObject = __webpack_require__(59);
	// 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");
	};


/***/ }),
/* 119 */
/***/ (function(module, exports, __webpack_require__) {

	var global = __webpack_require__(39);
	var core = __webpack_require__(25);
	var LIBRARY = __webpack_require__(110);
	var wksExt = __webpack_require__(120);
	var defineProperty = __webpack_require__(40).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) });
	};


/***/ }),
/* 120 */
/***/ (function(module, exports, __webpack_require__) {

	exports.f = __webpack_require__(32);


/***/ }),
/* 121 */
/***/ (function(module, exports, __webpack_require__) {

	__webpack_require__(455);
	var global = __webpack_require__(39);
	var hide = __webpack_require__(58);
	var Iterators = __webpack_require__(60);
	var TO_STRING_TAG = __webpack_require__(32)('toStringTag');
	
	var DOMIterables = ('CSSRuleList,CSSStyleDeclaration,CSSValueList,ClientRectList,DOMRectList,DOMStringList,' +
	  'DOMTokenList,DataTransferItemList,FileList,HTMLAllCollection,HTMLCollection,HTMLFormElement,HTMLSelectElement,' +
	  'MediaList,MimeTypeArray,NamedNodeMap,NodeList,PaintRequestList,Plugin,PluginArray,SVGLengthList,SVGNumberList,' +
	  'SVGPathSegList,SVGPointList,SVGStringList,SVGTransformList,SourceBufferList,StyleSheetList,TextTrackCueList,' +
	  'TextTrackList,TouchList').split(',');
	
	for (var i = 0; i < DOMIterables.length; i++) {
	  var NAME = DOMIterables[i];
	  var Collection = global[NAME];
	  var proto = Collection && Collection.prototype;
	  if (proto && !proto[TO_STRING_TAG]) hide(proto, TO_STRING_TAG, NAME);
	  Iterators[NAME] = Iterators.Array;
	}


/***/ }),
/* 122 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.isCssAnimationSupported = undefined;
	
	var _typeof2 = __webpack_require__(21);
	
	var _typeof3 = _interopRequireDefault(_typeof2);
	
	var _Event = __webpack_require__(467);
	
	var _Event2 = _interopRequireDefault(_Event);
	
	var _componentClasses = __webpack_require__(105);
	
	var _componentClasses2 = _interopRequireDefault(_componentClasses);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var isCssAnimationSupported = _Event2['default'].endEvents.length !== 0;
	var capitalPrefixes = ['Webkit', 'Moz', 'O',
	// ms is special .... !
	'ms'];
	var prefixes = ['-webkit-', '-moz-', '-o-', 'ms-', ''];
	
	function getStyleProperty(node, name) {
	  // old ff need null, https://developer.mozilla.org/en-US/docs/Web/API/Window/getComputedStyle
	  var style = window.getComputedStyle(node, null);
	  var ret = '';
	  for (var i = 0; i < prefixes.length; i++) {
	    ret = style.getPropertyValue(prefixes[i] + name);
	    if (ret) {
	      break;
	    }
	  }
	  return ret;
	}
	
	function fixBrowserByTimeout(node) {
	  if (isCssAnimationSupported) {
	    var transitionDelay = parseFloat(getStyleProperty(node, 'transition-delay')) || 0;
	    var transitionDuration = parseFloat(getStyleProperty(node, 'transition-duration')) || 0;
	    var animationDelay = parseFloat(getStyleProperty(node, 'animation-delay')) || 0;
	    var animationDuration = parseFloat(getStyleProperty(node, 'animation-duration')) || 0;
	    var time = Math.max(transitionDuration + transitionDelay, animationDuration + animationDelay);
	    // sometimes, browser bug
	    node.rcEndAnimTimeout = setTimeout(function () {
	      node.rcEndAnimTimeout = null;
	      if (node.rcEndListener) {
	        node.rcEndListener();
	      }
	    }, time * 1000 + 200);
	  }
	}
	
	function clearBrowserBugTimeout(node) {
	  if (node.rcEndAnimTimeout) {
	    clearTimeout(node.rcEndAnimTimeout);
	    node.rcEndAnimTimeout = null;
	  }
	}
	
	var cssAnimation = function cssAnimation(node, transitionName, endCallback) {
	  var nameIsObj = (typeof transitionName === 'undefined' ? 'undefined' : (0, _typeof3['default'])(transitionName)) === 'object';
	  var className = nameIsObj ? transitionName.name : transitionName;
	  var activeClassName = nameIsObj ? transitionName.active : transitionName + '-active';
	  var end = endCallback;
	  var start = void 0;
	  var active = void 0;
	  var nodeClasses = (0, _componentClasses2['default'])(node);
	
	  if (endCallback && Object.prototype.toString.call(endCallback) === '[object Object]') {
	    end = endCallback.end;
	    start = endCallback.start;
	    active = endCallback.active;
	  }
	
	  if (node.rcEndListener) {
	    node.rcEndListener();
	  }
	
	  node.rcEndListener = function (e) {
	    if (e && e.target !== node) {
	      return;
	    }
	
	    if (node.rcAnimTimeout) {
	      clearTimeout(node.rcAnimTimeout);
	      node.rcAnimTimeout = null;
	    }
	
	    clearBrowserBugTimeout(node);
	
	    nodeClasses.remove(className);
	    nodeClasses.remove(activeClassName);
	
	    _Event2['default'].removeEndEventListener(node, node.rcEndListener);
	    node.rcEndListener = null;
	
	    // Usually this optional end is used for informing an owner of
	    // a leave animation and telling it to remove the child.
	    if (end) {
	      end();
	    }
	  };
	
	  _Event2['default'].addEndEventListener(node, node.rcEndListener);
	
	  if (start) {
	    start();
	  }
	  nodeClasses.add(className);
	
	  node.rcAnimTimeout = setTimeout(function () {
	    node.rcAnimTimeout = null;
	    nodeClasses.add(activeClassName);
	    if (active) {
	      setTimeout(active, 0);
	    }
	    fixBrowserByTimeout(node);
	    // 30ms for firefox
	  }, 30);
	
	  return {
	    stop: function stop() {
	      if (node.rcEndListener) {
	        node.rcEndListener();
	      }
	    }
	  };
	};
	
	cssAnimation.style = function (node, style, callback) {
	  if (node.rcEndListener) {
	    node.rcEndListener();
	  }
	
	  node.rcEndListener = function (e) {
	    if (e && e.target !== node) {
	      return;
	    }
	
	    if (node.rcAnimTimeout) {
	      clearTimeout(node.rcAnimTimeout);
	      node.rcAnimTimeout = null;
	    }
	
	    clearBrowserBugTimeout(node);
	
	    _Event2['default'].removeEndEventListener(node, node.rcEndListener);
	    node.rcEndListener = null;
	
	    // Usually this optional callback is used for informing an owner of
	    // a leave animation and telling it to remove the child.
	    if (callback) {
	      callback();
	    }
	  };
	
	  _Event2['default'].addEndEventListener(node, node.rcEndListener);
	
	  node.rcAnimTimeout = setTimeout(function () {
	    for (var s in style) {
	      if (style.hasOwnProperty(s)) {
	        node.style[s] = style[s];
	      }
	    }
	    node.rcAnimTimeout = null;
	    fixBrowserByTimeout(node);
	  }, 0);
	};
	
	cssAnimation.setTransition = function (node, p, value) {
	  var property = p;
	  var v = value;
	  if (value === undefined) {
	    v = property;
	    property = '';
	  }
	  property = property || '';
	  capitalPrefixes.forEach(function (prefix) {
	    node.style[prefix + 'Transition' + property] = v;
	  });
	};
	
	cssAnimation.isCssAnimationSupported = isCssAnimationSupported;
	
	exports.isCssAnimationSupported = isCssAnimationSupported;
	exports['default'] = cssAnimation;

/***/ }),
/* 123 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule ContentState
	 * @format
	 * 
	 */
	
	'use strict';
	
	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 BlockMapBuilder = __webpack_require__(70);
	var CharacterMetadata = __webpack_require__(27);
	var ContentBlock = __webpack_require__(50);
	var ContentBlockNode = __webpack_require__(30);
	var DraftEntity = __webpack_require__(89);
	var DraftFeatureFlags = __webpack_require__(42);
	var Immutable = __webpack_require__(11);
	var SelectionState = __webpack_require__(62);
	
	var generateRandomKey = __webpack_require__(37);
	var sanitizeDraftText = __webpack_require__(129);
	
	var List = Immutable.List,
	    Record = Immutable.Record,
	    Repeat = Immutable.Repeat;
	
	
	var experimentalTreeDataSupport = DraftFeatureFlags.draft_tree_data_support;
	
	var defaultRecord = {
	  entityMap: null,
	  blockMap: null,
	  selectionBefore: null,
	  selectionAfter: null
	};
	
	var ContentBlockNodeRecord = experimentalTreeDataSupport ? ContentBlockNode : ContentBlock;
	
	var ContentStateRecord = Record(defaultRecord);
	
	var ContentState = function (_ContentStateRecord) {
	  _inherits(ContentState, _ContentStateRecord);
	
	  function ContentState() {
	    _classCallCheck(this, ContentState);
	
	    return _possibleConstructorReturn(this, _ContentStateRecord.apply(this, arguments));
	  }
	
	  ContentState.prototype.getEntityMap = function getEntityMap() {
	    // TODO: update this when we fully remove DraftEntity
	    return DraftEntity;
	  };
	
	  ContentState.prototype.getBlockMap = function getBlockMap() {
	    return this.get('blockMap');
	  };
	
	  ContentState.prototype.getSelectionBefore = function getSelectionBefore() {
	    return this.get('selectionBefore');
	  };
	
	  ContentState.prototype.getSelectionAfter = function getSelectionAfter() {
	    return this.get('selectionAfter');
	  };
	
	  ContentState.prototype.getBlockForKey = function getBlockForKey(key) {
	    var block = this.getBlockMap().get(key);
	    return block;
	  };
	
	  ContentState.prototype.getKeyBefore = function getKeyBefore(key) {
	    return this.getBlockMap().reverse().keySeq().skipUntil(function (v) {
	      return v === key;
	    }).skip(1).first();
	  };
	
	  ContentState.prototype.getKeyAfter = function getKeyAfter(key) {
	    return this.getBlockMap().keySeq().skipUntil(function (v) {
	      return v === key;
	    }).skip(1).first();
	  };
	
	  ContentState.prototype.getBlockAfter = function getBlockAfter(key) {
	    return this.getBlockMap().skipUntil(function (_, k) {
	      return k === key;
	    }).skip(1).first();
	  };
	
	  ContentState.prototype.getBlockBefore = function getBlockBefore(key) {
	    return this.getBlockMap().reverse().skipUntil(function (_, k) {
	      return k === key;
	    }).skip(1).first();
	  };
	
	  ContentState.prototype.getBlocksAsArray = function getBlocksAsArray() {
	    return this.getBlockMap().toArray();
	  };
	
	  ContentState.prototype.getFirstBlock = function getFirstBlock() {
	    return this.getBlockMap().first();
	  };
	
	  ContentState.prototype.getLastBlock = function getLastBlock() {
	    return this.getBlockMap().last();
	  };
	
	  ContentState.prototype.getPlainText = function getPlainText(delimiter) {
	    return this.getBlockMap().map(function (block) {
	      return block ? block.getText() : '';
	    }).join(delimiter || '\n');
	  };
	
	  ContentState.prototype.getLastCreatedEntityKey = function getLastCreatedEntityKey() {
	    // TODO: update this when we fully remove DraftEntity
	    return DraftEntity.__getLastCreatedEntityKey();
	  };
	
	  ContentState.prototype.hasText = function hasText() {
	    var blockMap = this.getBlockMap();
	    return blockMap.size > 1 || blockMap.first().getLength() > 0;
	  };
	
	  ContentState.prototype.createEntity = function createEntity(type, mutability, data) {
	    // TODO: update this when we fully remove DraftEntity
	    DraftEntity.__create(type, mutability, data);
	    return this;
	  };
	
	  ContentState.prototype.mergeEntityData = function mergeEntityData(key, toMerge) {
	    // TODO: update this when we fully remove DraftEntity
	    DraftEntity.__mergeData(key, toMerge);
	    return this;
	  };
	
	  ContentState.prototype.replaceEntityData = function replaceEntityData(key, newData) {
	    // TODO: update this when we fully remove DraftEntity
	    DraftEntity.__replaceData(key, newData);
	    return this;
	  };
	
	  ContentState.prototype.addEntity = function addEntity(instance) {
	    // TODO: update this when we fully remove DraftEntity
	    DraftEntity.__add(instance);
	    return this;
	  };
	
	  ContentState.prototype.getEntity = function getEntity(key) {
	    // TODO: update this when we fully remove DraftEntity
	    return DraftEntity.__get(key);
	  };
	
	  ContentState.createFromBlockArray = function createFromBlockArray(
	  // TODO: update flow type when we completely deprecate the old entity API
	  blocks, entityMap) {
	    // TODO: remove this when we completely deprecate the old entity API
	    var theBlocks = Array.isArray(blocks) ? blocks : blocks.contentBlocks;
	    var blockMap = BlockMapBuilder.createFromArray(theBlocks);
	    var selectionState = blockMap.isEmpty() ? new SelectionState() : SelectionState.createEmpty(blockMap.first().getKey());
	    return new ContentState({
	      blockMap: blockMap,
	      entityMap: entityMap || DraftEntity,
	      selectionBefore: selectionState,
	      selectionAfter: selectionState
	    });
	  };
	
	  ContentState.createFromText = function createFromText(text) {
	    var delimiter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : /\r\n?|\n/g;
	
	    var strings = text.split(delimiter);
	    var blocks = strings.map(function (block) {
	      block = sanitizeDraftText(block);
	      return new ContentBlockNodeRecord({
	        key: generateRandomKey(),
	        text: block,
	        type: 'unstyled',
	        characterList: List(Repeat(CharacterMetadata.EMPTY, block.length))
	      });
	    });
	    return ContentState.createFromBlockArray(blocks);
	  };
	
	  return ContentState;
	}(ContentStateRecord);
	
	module.exports = ContentState;

/***/ }),
/* 124 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule DefaultDraftBlockRenderMap
	 * @format
	 * 
	 */
	
	'use strict';
	
	var _require = __webpack_require__(11),
	    Map = _require.Map;
	
	var React = __webpack_require__(1);
	
	var cx = __webpack_require__(63);
	
	var UL_WRAP = React.createElement('ul', { className: cx('public/DraftStyleDefault/ul') });
	var OL_WRAP = React.createElement('ol', { className: cx('public/DraftStyleDefault/ol') });
	var PRE_WRAP = React.createElement('pre', { className: cx('public/DraftStyleDefault/pre') });
	
	var DefaultDraftBlockRenderMap = Map({
	  'header-one': {
	    element: 'h1'
	  },
	  'header-two': {
	    element: 'h2'
	  },
	  'header-three': {
	    element: 'h3'
	  },
	  'header-four': {
	    element: 'h4'
	  },
	  'header-five': {
	    element: 'h5'
	  },
	  'header-six': {
	    element: 'h6'
	  },
	  'unordered-list-item': {
	    element: 'li',
	    wrapper: UL_WRAP
	  },
	  'ordered-list-item': {
	    element: 'li',
	    wrapper: OL_WRAP
	  },
	  blockquote: {
	    element: 'blockquote'
	  },
	  atomic: {
	    element: 'figure'
	  },
	  'code-block': {
	    element: 'pre',
	    wrapper: PRE_WRAP
	  },
	  unstyled: {
	    element: 'div',
	    aliasedElements: ['p']
	  }
	});
	
	module.exports = DefaultDraftBlockRenderMap;

/***/ }),
/* 125 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule KeyBindingUtil
	 * @format
	 * 
	 */
	
	'use strict';
	
	var UserAgent = __webpack_require__(36);
	
	var isOSX = UserAgent.isPlatform('Mac OS X');
	
	var KeyBindingUtil = {
	  /**
	   * Check whether the ctrlKey modifier is *not* being used in conjunction with
	   * the altKey modifier. If they are combined, the result is an `altGraph`
	   * key modifier, which should not be handled by this set of key bindings.
	   */
	  isCtrlKeyCommand: function isCtrlKeyCommand(e) {
	    return !!e.ctrlKey && !e.altKey;
	  },
	
	  isOptionKeyCommand: function isOptionKeyCommand(e) {
	    return isOSX && e.altKey;
	  },
	
	  hasCommandModifier: function hasCommandModifier(e) {
	    return isOSX ? !!e.metaKey && !e.altKey : KeyBindingUtil.isCtrlKeyCommand(e);
	  }
	};
	
	module.exports = KeyBindingUtil;

/***/ }),
/* 126 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule findAncestorOffsetKey
	 * @format
	 * 
	 */
	
	'use strict';
	
	var getSelectionOffsetKeyForNode = __webpack_require__(215);
	
	/**
	 * Get the key from the node's nearest offset-aware ancestor.
	 */
	function findAncestorOffsetKey(node) {
	  var searchNode = node;
	  while (searchNode && searchNode !== document.documentElement) {
	    var key = getSelectionOffsetKeyForNode(searchNode);
	    if (key != null) {
	      return key;
	    }
	    searchNode = searchNode.parentNode;
	  }
	  return null;
	}
	
	module.exports = findAncestorOffsetKey;

/***/ }),
/* 127 */
/***/ (function(module, exports) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule getEntityKeyForSelection
	 * @format
	 * 
	 */
	
	'use strict';
	
	/**
	 * Return the entity key that should be used when inserting text for the
	 * specified target selection, only if the entity is `MUTABLE`. `IMMUTABLE`
	 * and `SEGMENTED` entities should not be used for insertion behavior.
	 */
	function getEntityKeyForSelection(contentState, targetSelection) {
	  var entityKey;
	
	  if (targetSelection.isCollapsed()) {
	    var key = targetSelection.getAnchorKey();
	    var offset = targetSelection.getAnchorOffset();
	    if (offset > 0) {
	      entityKey = contentState.getBlockForKey(key).getEntityAt(offset - 1);
	      if (entityKey !== contentState.getBlockForKey(key).getEntityAt(offset)) {
	        return null;
	      }
	      return filterKey(contentState.getEntityMap(), entityKey);
	    }
	    return null;
	  }
	
	  var startKey = targetSelection.getStartKey();
	  var startOffset = targetSelection.getStartOffset();
	  var startBlock = contentState.getBlockForKey(startKey);
	
	  entityKey = startOffset === startBlock.getLength() ? null : startBlock.getEntityAt(startOffset);
	
	  return filterKey(contentState.getEntityMap(), entityKey);
	}
	
	/**
	 * Determine whether an entity key corresponds to a `MUTABLE` entity. If so,
	 * return it. If not, return null.
	 */
	function filterKey(entityMap, entityKey) {
	  if (entityKey) {
	    var entity = entityMap.__get(entityKey);
	    return entity.getMutability() === 'MUTABLE' ? entityKey : null;
	  }
	  return null;
	}
	
	module.exports = getEntityKeyForSelection;

/***/ }),
/* 128 */
/***/ (function(module, exports) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule moveSelectionBackward
	 * @format
	 * 
	 */
	
	'use strict';
	
	/**
	 * Given a collapsed selection, move the focus `maxDistance` backward within
	 * the selected block. If the selection will go beyond the start of the block,
	 * move focus to the end of the previous block, but no further.
	 *
	 * This function is not Unicode-aware, so surrogate pairs will be treated
	 * as having length 2.
	 */
	function moveSelectionBackward(editorState, maxDistance) {
	  var selection = editorState.getSelection();
	  var content = editorState.getCurrentContent();
	  var key = selection.getStartKey();
	  var offset = selection.getStartOffset();
	
	  var focusKey = key;
	  var focusOffset = 0;
	
	  if (maxDistance > offset) {
	    var keyBefore = content.getKeyBefore(key);
	    if (keyBefore == null) {
	      focusKey = key;
	    } else {
	      focusKey = keyBefore;
	      var blockBefore = content.getBlockForKey(keyBefore);
	      focusOffset = blockBefore.getText().length;
	    }
	  } else {
	    focusOffset = offset - maxDistance;
	  }
	
	  return selection.merge({
	    focusKey: focusKey,
	    focusOffset: focusOffset,
	    isBackward: true
	  });
	}
	
	module.exports = moveSelectionBackward;

/***/ }),
/* 129 */
/***/ (function(module, exports) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule sanitizeDraftText
	 * @format
	 * 
	 */
	
	'use strict';
	
	var REGEX_BLOCK_DELIMITER = new RegExp('\r', 'g');
	
	function sanitizeDraftText(input) {
	  return input.replace(REGEX_BLOCK_DELIMITER, '');
	}
	
	module.exports = sanitizeDraftText;

/***/ }),
/* 130 */
/***/ (function(module, exports) {

	"use strict";
	
	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 */
	
	module.exports = {
	  BACKSPACE: 8,
	  TAB: 9,
	  RETURN: 13,
	  ALT: 18,
	  ESC: 27,
	  SPACE: 32,
	  PAGE_UP: 33,
	  PAGE_DOWN: 34,
	  END: 35,
	  HOME: 36,
	  LEFT: 37,
	  UP: 38,
	  RIGHT: 39,
	  DOWN: 40,
	  DELETE: 46,
	  COMMA: 188,
	  PERIOD: 190,
	  A: 65,
	  Z: 90,
	  ZERO: 48,
	  NUMPAD_0: 96,
	  NUMPAD_9: 105
	};

/***/ }),
/* 131 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 * @typechecks
	 */
	
	var getStyleProperty = __webpack_require__(563);
	
	/**
	 * @param {DOMNode} element [description]
	 * @param {string} name Overflow style property name.
	 * @return {boolean} True if the supplied ndoe is scrollable.
	 */
	function _isNodeScrollable(element, name) {
	  var overflow = Style.get(element, name);
	  return overflow === 'auto' || overflow === 'scroll';
	}
	
	/**
	 * Utilities for querying and mutating style properties.
	 */
	var Style = {
	  /**
	   * Gets the style property for the supplied node. This will return either the
	   * computed style, if available, or the declared style.
	   *
	   * @param {DOMNode} node
	   * @param {string} name Style property name.
	   * @return {?string} Style property value.
	   */
	  get: getStyleProperty,
	
	  /**
	   * Determines the nearest ancestor of a node that is scrollable.
	   *
	   * NOTE: This can be expensive if used repeatedly or on a node nested deeply.
	   *
	   * @param {?DOMNode} node Node from which to start searching.
	   * @return {?DOMWindow|DOMElement} Scroll parent of the supplied node.
	   */
	  getScrollParent: function getScrollParent(node) {
	    if (!node) {
	      return null;
	    }
	    var ownerDocument = node.ownerDocument;
	    while (node && node !== ownerDocument.body) {
	      if (_isNodeScrollable(node, 'overflow') || _isNodeScrollable(node, 'overflowY') || _isNodeScrollable(node, 'overflowX')) {
	        return node;
	      }
	      node = node.parentNode;
	    }
	    return ownerDocument.defaultView || ownerDocument.parentWindow;
	  }
	
	};
	
	module.exports = Style;

/***/ }),
/* 132 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 * @typechecks
	 * 
	 */
	
	/**
	 * Constants to represent text directionality
	 *
	 * Also defines a *global* direciton, to be used in bidi algorithms as a
	 * default fallback direciton, when no better direction is found or provided.
	 *
	 * NOTE: Use `setGlobalDir()`, or update `initGlobalDir()`, to set the initial
	 *       global direction value based on the application.
	 *
	 * Part of the implementation of Unicode Bidirectional Algorithm (UBA)
	 * Unicode Standard Annex #9 (UAX9)
	 * http://www.unicode.org/reports/tr9/
	 */
	
	'use strict';
	
	var invariant = __webpack_require__(12);
	
	var NEUTRAL = 'NEUTRAL'; // No strong direction
	var LTR = 'LTR'; // Left-to-Right direction
	var RTL = 'RTL'; // Right-to-Left direction
	
	var globalDir = null;
	
	// == Helpers ==
	
	/**
	 * Check if a directionality value is a Strong one
	 */
	function isStrong(dir) {
	  return dir === LTR || dir === RTL;
	}
	
	/**
	 * Get string value to be used for `dir` HTML attribute or `direction` CSS
	 * property.
	 */
	function getHTMLDir(dir) {
	  !isStrong(dir) ?  true ? invariant(false, '`dir` must be a strong direction to be converted to HTML Direction') : invariant(false) : void 0;
	  return dir === LTR ? 'ltr' : 'rtl';
	}
	
	/**
	 * Get string value to be used for `dir` HTML attribute or `direction` CSS
	 * property, but returns null if `dir` has same value as `otherDir`.
	 * `null`.
	 */
	function getHTMLDirIfDifferent(dir, otherDir) {
	  !isStrong(dir) ?  true ? invariant(false, '`dir` must be a strong direction to be converted to HTML Direction') : invariant(false) : void 0;
	  !isStrong(otherDir) ?  true ? invariant(false, '`otherDir` must be a strong direction to be converted to HTML Direction') : invariant(false) : void 0;
	  return dir === otherDir ? null : getHTMLDir(dir);
	}
	
	// == Global Direction ==
	
	/**
	 * Set the global direction.
	 */
	function setGlobalDir(dir) {
	  globalDir = dir;
	}
	
	/**
	 * Initialize the global direction
	 */
	function initGlobalDir() {
	  setGlobalDir(LTR);
	}
	
	/**
	 * Get the global direction
	 */
	function getGlobalDir() {
	  if (!globalDir) {
	    this.initGlobalDir();
	  }
	  !globalDir ?  true ? invariant(false, 'Global direction not set.') : invariant(false) : void 0;
	  return globalDir;
	}
	
	var UnicodeBidiDirection = {
	  // Values
	  NEUTRAL: NEUTRAL,
	  LTR: LTR,
	  RTL: RTL,
	  // Helpers
	  isStrong: isStrong,
	  getHTMLDir: getHTMLDir,
	  getHTMLDirIfDifferent: getHTMLDirIfDifferent,
	  // Global Direction
	  setGlobalDir: setGlobalDir,
	  initGlobalDir: initGlobalDir,
	  getGlobalDir: getGlobalDir
	};
	
	module.exports = UnicodeBidiDirection;

/***/ }),
/* 133 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 * 
	 */
	
	var isTextNode = __webpack_require__(568);
	
	/*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;

/***/ }),
/* 134 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 * @typechecks
	 */
	
	'use strict';
	
	var getDocumentScrollElement = __webpack_require__(560);
	var getUnboundedScrollPosition = __webpack_require__(564);
	
	/**
	 * Gets the scroll position of the supplied element or window.
	 *
	 * The return values are bounded. This means that if the scroll position is
	 * negative or exceeds the element boundaries (which is possible using inertial
	 * scrolling), you will get zero or the maximum scroll position, respectively.
	 *
	 * If you need the unbound scroll position, use `getUnboundedScrollPosition`.
	 *
	 * @param {DOMWindow|DOMElement} scrollable
	 * @return {object} Map with `x` and `y` keys.
	 */
	function getScrollPosition(scrollable) {
	  var documentScrollElement = getDocumentScrollElement(scrollable.ownerDocument || scrollable.document);
	  if (scrollable.Window && scrollable instanceof scrollable.Window) {
	    scrollable = documentScrollElement;
	  }
	  var scrollPosition = getUnboundedScrollPosition(scrollable);
	
	  var viewport = scrollable === documentScrollElement ? scrollable.ownerDocument.documentElement : scrollable;
	
	  var xMax = scrollable.scrollWidth - viewport.clientWidth;
	  var yMax = scrollable.scrollHeight - viewport.clientHeight;
	
	  scrollPosition.x = Math.max(0, Math.min(scrollPosition.x, xMax));
	  scrollPosition.y = Math.max(0, Math.min(scrollPosition.y, yMax));
	
	  return scrollPosition;
	}
	
	module.exports = getScrollPosition;

/***/ }),
/* 135 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2014-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 */
	
	'use strict';
	
	var emptyFunction = __webpack_require__(75);
	
	/**
	 * 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 (true) {
	  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;

/***/ }),
/* 136 */
/***/ (function(module, exports, __webpack_require__) {

	var isArray = __webpack_require__(65),
	    isKey = __webpack_require__(617),
	    stringToPath = __webpack_require__(640),
	    toString = __webpack_require__(649);
	
	/**
	 * 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;


/***/ }),
/* 137 */
/***/ (function(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) {
	  var type = typeof value;
	  length = length == null ? MAX_SAFE_INTEGER : length;
	
	  return !!length &&
	    (type == 'number' ||
	      (type != 'symbol' && reIsUint.test(value))) &&
	        (value > -1 && value % 1 == 0 && value < length);
	}
	
	module.exports = isIndex;


/***/ }),
/* 138 */
/***/ (function(module, exports, __webpack_require__) {

	var isSymbol = __webpack_require__(142);
	
	/** 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;


/***/ }),
/* 139 */
/***/ (function(module, exports, __webpack_require__) {

	var baseHas = __webpack_require__(594),
	    hasPath = __webpack_require__(610);
	
	/**
	 * Checks if `path` is a direct property of `object`.
	 *
	 * @static
	 * @since 0.1.0
	 * @memberOf _
	 * @category Object
	 * @param {Object} object The object to query.
	 * @param {Array|string} path The path to check.
	 * @returns {boolean} Returns `true` if `path` exists, else `false`.
	 * @example
	 *
	 * var object = { 'a': { 'b': 2 } };
	 * var other = _.create({ 'a': _.create({ 'b': 2 }) });
	 *
	 * _.has(object, 'a');
	 * // => true
	 *
	 * _.has(object, 'a.b');
	 * // => true
	 *
	 * _.has(object, ['a', 'b']);
	 * // => true
	 *
	 * _.has(other, 'a');
	 * // => false
	 */
	function has(object, path) {
	  return object != null && hasPath(object, path, baseHas);
	}
	
	module.exports = has;


/***/ }),
/* 140 */
/***/ (function(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;


/***/ }),
/* 141 */
/***/ (function(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;


/***/ }),
/* 142 */
/***/ (function(module, exports, __webpack_require__) {

	var baseGetTag = __webpack_require__(64),
	    isObjectLike = __webpack_require__(76);
	
	/** `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;


/***/ }),
/* 143 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _DateTHead = __webpack_require__(665);
	
	var _DateTHead2 = _interopRequireDefault(_DateTHead);
	
	var _DateTBody = __webpack_require__(664);
	
	var _DateTBody2 = _interopRequireDefault(_DateTBody);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var DateTable = function (_React$Component) {
	  (0, _inherits3['default'])(DateTable, _React$Component);
	
	  function DateTable() {
	    (0, _classCallCheck3['default'])(this, DateTable);
	    return (0, _possibleConstructorReturn3['default'])(this, (DateTable.__proto__ || Object.getPrototypeOf(DateTable)).apply(this, arguments));
	  }
	
	  (0, _createClass3['default'])(DateTable, [{
	    key: 'render',
	    value: function render() {
	      var props = this.props;
	      var prefixCls = props.prefixCls;
	      return _react2['default'].createElement(
	        'table',
	        { className: prefixCls + '-table', cellSpacing: '0', role: 'grid' },
	        _react2['default'].createElement(_DateTHead2['default'], props),
	        _react2['default'].createElement(_DateTBody2['default'], props)
	      );
	    }
	  }]);
	  return DateTable;
	}(_react2['default'].Component);
	
	exports['default'] = DateTable;
	module.exports = exports['default'];

/***/ }),
/* 144 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _moment = __webpack_require__(13);
	
	var _moment2 = _interopRequireDefault(_moment);
	
	var _index = __webpack_require__(44);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function noop() {}
	
	function getNow() {
	  return (0, _moment2['default'])();
	}
	
	function getNowByCurrentStateValue(value) {
	  var ret = void 0;
	  if (value) {
	    ret = (0, _index.getTodayTime)(value);
	  } else {
	    ret = getNow();
	  }
	  return ret;
	}
	
	var CalendarMixin = {
	  propTypes: {
	    value: _propTypes2['default'].object,
	    defaultValue: _propTypes2['default'].object,
	    onKeyDown: _propTypes2['default'].func
	  },
	
	  getDefaultProps: function getDefaultProps() {
	    return {
	      onKeyDown: noop
	    };
	  },
	  getInitialState: function getInitialState() {
	    var props = this.props;
	    var value = props.value || props.defaultValue || getNow();
	    return {
	      value: value,
	      selectedValue: props.selectedValue || props.defaultSelectedValue
	    };
	  },
	  componentWillReceiveProps: function componentWillReceiveProps(nextProps) {
	    var value = nextProps.value;
	    var selectedValue = nextProps.selectedValue;
	
	    if ('value' in nextProps) {
	      value = value || nextProps.defaultValue || getNowByCurrentStateValue(this.state.value);
	      this.setState({
	        value: value
	      });
	    }
	    if ('selectedValue' in nextProps) {
	      this.setState({
	        selectedValue: selectedValue
	      });
	    }
	  },
	  onSelect: function onSelect(value, cause) {
	    if (value) {
	      this.setValue(value);
	    }
	    this.setSelectedValue(value, cause);
	  },
	  renderRoot: function renderRoot(newProps) {
	    var _className;
	
	    var props = this.props;
	    var prefixCls = props.prefixCls;
	
	    var className = (_className = {}, (0, _defineProperty3['default'])(_className, prefixCls, 1), (0, _defineProperty3['default'])(_className, prefixCls + '-hidden', !props.visible), (0, _defineProperty3['default'])(_className, props.className, !!props.className), (0, _defineProperty3['default'])(_className, newProps.className, !!newProps.className), _className);
	
	    return _react2['default'].createElement(
	      'div',
	      {
	        ref: this.saveRoot,
	        className: '' + (0, _classnames2['default'])(className),
	        style: this.props.style,
	        tabIndex: '0',
	        onKeyDown: this.onKeyDown
	      },
	      newProps.children
	    );
	  },
	  setSelectedValue: function setSelectedValue(selectedValue, cause) {
	    // if (this.isAllowedDate(selectedValue)) {
	    if (!('selectedValue' in this.props)) {
	      this.setState({
	        selectedValue: selectedValue
	      });
	    }
	    this.props.onSelect(selectedValue, cause);
	    // }
	  },
	  setValue: function setValue(value) {
	    var originalValue = this.state.value;
	    if (!('value' in this.props)) {
	      this.setState({
	        value: value
	      });
	    }
	    if (originalValue && value && !originalValue.isSame(value) || !originalValue && value || originalValue && !value) {
	      this.props.onChange(value);
	    }
	  },
	  isAllowedDate: function isAllowedDate(value) {
	    var disabledDate = this.props.disabledDate;
	    var disabledTime = this.props.disabledTime;
	    return (0, _index.isAllowedDate)(value, disabledDate, disabledTime);
	  }
	};
	
	exports['default'] = CalendarMixin;
	module.exports = exports['default'];

/***/ }),
/* 145 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports["default"] = exportContent;
	
	var _draftJs = __webpack_require__(41);
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function encodeContent(text) {
	  return text.split('&').join('&amp;').split('<').join('&lt;').split('>').join('&gt;').split('\xA0').join('&nbsp;').split('\n').join('<br > \n');
	}
	
	var MentionGenerator = function () {
	  function MentionGenerator(contentState, options) {
	    _classCallCheck(this, MentionGenerator);
	
	    this.contentState = contentState;
	    this.options = options;
	  }
	
	  MentionGenerator.prototype.generate = function generate() {
	    var contentRaw = (0, _draftJs.convertToRaw)(this.contentState);
	    return this.processContent(contentRaw);
	  };
	
	  MentionGenerator.prototype.processContent = function processContent(contentRaw) {
	    var blocks = contentRaw.blocks;
	    var encode = this.options.encode;
	
	    return blocks.map(function (block) {
	      return encode ? encodeContent(block.text) : block.text;
	    }).join(encode ? '<br />\n' : '\n');
	  };
	
	  return MentionGenerator;
	}();
	
	function exportContent(contentState) {
	  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
	
	  return new MentionGenerator(contentState, options).generate();
	}
	module.exports = exports['default'];

/***/ }),
/* 146 */
/***/ (function(module, exports) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports["default"] = getSearchWord;
	function getWord(text, position) {
	  var str = String(text);
	  /* eslint no-bitwise:0 */
	  var pos = Number(position) >>> 0;
	
	  // Search for the word's beginning and end.
	  var left = str.slice(0, pos + 1).search(/\S+$/);
	  var right = str.slice(pos).search(/\s/);
	
	  if (right < 0) {
	    return {
	      word: str.slice(left),
	      begin: left,
	      end: str.length
	    };
	  }
	
	  // Return the word, using the located bounds to extract it from the string.
	  return {
	    word: str.slice(left, right + pos),
	    begin: left,
	    end: right + pos
	  };
	}
	
	function getSearchWord(editorState, selection) {
	  var anchorKey = selection.getAnchorKey();
	  var anchorOffset = selection.getAnchorOffset() - 1;
	  var currentContent = editorState.getCurrentContent();
	  var currentBlock = currentContent.getBlockForKey(anchorKey);
	  if (currentBlock) {
	    var blockText = currentBlock.getText();
	    return getWord(blockText, anchorOffset);
	  }
	  return '';
	}
	module.exports = exports['default'];

/***/ }),
/* 147 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	exports.argumentContainer = argumentContainer;
	exports.getValueFromEvent = getValueFromEvent;
	exports.getErrorStrs = getErrorStrs;
	exports.isEmptyObject = isEmptyObject;
	exports.flattenArray = flattenArray;
	exports.mirror = mirror;
	exports.hasRules = hasRules;
	exports.startsWith = startsWith;
	exports.getParams = getParams;
	exports.getNameIfNested = getNameIfNested;
	exports.flatFieldNames = flatFieldNames;
	exports.clearVirtualField = clearVirtualField;
	exports.getVirtualPaths = getVirtualPaths;
	exports.normalizeValidateRules = normalizeValidateRules;
	
	var _hoistNonReactStatics = __webpack_require__(573);
	
	var _hoistNonReactStatics2 = _interopRequireDefault(_hoistNonReactStatics);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function getDisplayName(WrappedComponent) {
	  return WrappedComponent.displayName || WrappedComponent.name || 'WrappedComponent';
	}
	
	function argumentContainer(Container, WrappedComponent) {
	  /* eslint no-param-reassign:0 */
	  Container.displayName = 'Form(' + getDisplayName(WrappedComponent) + ')';
	  Container.WrappedComponent = WrappedComponent;
	  return (0, _hoistNonReactStatics2['default'])(Container, WrappedComponent);
	}
	
	function getValueFromEvent(e) {
	  // support custom element
	  if (!e || !e.target) {
	    return e;
	  }
	  var target = e.target;
	
	  return target.type === 'checkbox' ? target.checked : target.value;
	}
	
	function getErrorStrs(errors) {
	  if (errors) {
	    return errors.map(function (e) {
	      if (e && e.message) {
	        return e.message;
	      }
	      return e;
	    });
	  }
	  return errors;
	}
	
	function isEmptyObject(obj) {
	  return Object.keys(obj).length === 0;
	}
	
	function flattenArray(arr) {
	  return Array.prototype.concat.apply([], arr);
	}
	
	function mirror(obj) {
	  return obj;
	}
	
	function hasRules(validate) {
	  if (validate) {
	    return validate.some(function (item) {
	      return !!item.rules && item.rules.length;
	    });
	  }
	  return false;
	}
	
	function startsWith(str, prefix) {
	  return str.lastIndexOf(prefix, 0) === 0;
	}
	
	function getParams(ns, opt, cb) {
	  var names = ns;
	  var callback = cb;
	  var options = opt;
	  if (cb === undefined) {
	    if (typeof names === 'function') {
	      callback = names;
	      options = {};
	      names = undefined;
	    } else if (Array.isArray(ns)) {
	      if (typeof options === 'function') {
	        callback = options;
	        options = {};
	      } else {
	        options = options || {};
	      }
	    } else {
	      callback = options;
	      options = names || {};
	      names = undefined;
	    }
	  }
	  return {
	    names: names,
	    callback: callback,
	    options: options
	  };
	}
	
	var NAME_KEY_SEP = '.';
	var NAME_INDEX_OPEN_SEP = '[';
	
	function getNameIfNested(str) {
	  var keyIndex = str.indexOf(NAME_KEY_SEP);
	  var arrayIndex = str.indexOf(NAME_INDEX_OPEN_SEP);
	
	  var index = void 0;
	
	  if (keyIndex === -1 && arrayIndex === -1) {
	    return {
	      name: str
	    };
	  } else if (keyIndex === -1) {
	    index = arrayIndex;
	  } else if (arrayIndex === -1) {
	    index = keyIndex;
	  } else {
	    index = Math.min(keyIndex, arrayIndex);
	  }
	
	  return {
	    name: str.slice(0, index),
	    isNested: true
	  };
	}
	
	function flatFieldNames(names) {
	  var ret = {};
	  names.forEach(function (n) {
	    ret[getNameIfNested(n).name] = 1;
	  });
	  return Object.keys(ret);
	}
	
	function clearVirtualField(name, fields, fieldsMeta) {
	  if (fieldsMeta[name] && fieldsMeta[name].virtual) {
	    /* eslint no-loop-func:0 */
	    Object.keys(fields).forEach(function (ok) {
	      if (getNameIfNested(ok).name === name) {
	        delete fields[ok];
	      }
	    });
	  }
	}
	
	function getVirtualPaths(fieldsMeta) {
	  var virtualPaths = {};
	  Object.keys(fieldsMeta).forEach(function (name) {
	    var leadingName = fieldsMeta[name].leadingName;
	    if (leadingName && fieldsMeta[leadingName].virtual) {
	      if (leadingName in virtualPaths) {
	        virtualPaths[leadingName].push(name);
	      } else {
	        virtualPaths[leadingName] = [name];
	      }
	    }
	  });
	  return virtualPaths;
	}
	
	function normalizeValidateRules(validate, rules, validateTrigger) {
	  var validateRules = validate.map(function (item) {
	    var newItem = (0, _extends3['default'])({}, item, {
	      trigger: item.trigger || []
	    });
	    if (typeof newItem.trigger === 'string') {
	      newItem.trigger = [newItem.trigger];
	    }
	    return newItem;
	  });
	  if (rules) {
	    validateRules.push({
	      trigger: validateTrigger ? [].concat(validateTrigger) : [],
	      rules: rules
	    });
	  }
	  return validateRules;
	}

/***/ }),
/* 148 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.UNSELECTABLE_ATTRIBUTE = exports.UNSELECTABLE_STYLE = undefined;
	exports.getValuePropValue = getValuePropValue;
	exports.getPropValue = getPropValue;
	exports.isCombobox = isCombobox;
	exports.isMultipleOrTags = isMultipleOrTags;
	exports.isMultipleOrTagsOrCombobox = isMultipleOrTagsOrCombobox;
	exports.isSingleMode = isSingleMode;
	exports.toArray = toArray;
	exports.preventDefaultEvent = preventDefaultEvent;
	exports.findIndexInValueByKey = findIndexInValueByKey;
	exports.findIndexInValueByLabel = findIndexInValueByLabel;
	exports.getSelectKeys = getSelectKeys;
	exports.findFirstMenuItem = findFirstMenuItem;
	exports.includesSeparators = includesSeparators;
	exports.splitBySeparators = splitBySeparators;
	exports.defaultFilterFn = defaultFilterFn;
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function getValuePropValue(child) {
	  var props = child.props;
	  if ('value' in props) {
	    return props.value;
	  }
	  if (child.key) {
	    return child.key;
	  }
	  if (child.type && child.type.isSelectOptGroup && props.label) {
	    return props.label;
	  }
	  throw new Error('Need at least a key or a value or a label (only for OptGroup) for ' + child);
	}
	
	function getPropValue(child, prop) {
	  if (prop === 'value') {
	    return getValuePropValue(child);
	  }
	  return child.props[prop];
	}
	
	function isCombobox(props) {
	  return props.combobox;
	}
	
	function isMultipleOrTags(props) {
	  return props.multiple || props.tags;
	}
	
	function isMultipleOrTagsOrCombobox(props) {
	  return isMultipleOrTags(props) || isCombobox(props);
	}
	
	function isSingleMode(props) {
	  return !isMultipleOrTagsOrCombobox(props);
	}
	
	function toArray(value) {
	  var ret = value;
	  if (value === undefined) {
	    ret = [];
	  } else if (!Array.isArray(value)) {
	    ret = [value];
	  }
	  return ret;
	}
	
	function preventDefaultEvent(e) {
	  e.preventDefault();
	}
	
	function findIndexInValueByKey(value, key) {
	  var index = -1;
	  for (var i = 0; i < value.length; i++) {
	    if (value[i].key === key) {
	      index = i;
	      break;
	    }
	  }
	  return index;
	}
	
	function findIndexInValueByLabel(value, label) {
	  var index = -1;
	  for (var i = 0; i < value.length; i++) {
	    if (toArray(value[i].label).join('') === label) {
	      index = i;
	      break;
	    }
	  }
	  return index;
	}
	
	function getSelectKeys(menuItems, value) {
	  if (value === null || value === undefined) {
	    return [];
	  }
	  var selectedKeys = [];
	  _react2['default'].Children.forEach(menuItems, function (item) {
	    if (item.type.isMenuItemGroup) {
	      selectedKeys = selectedKeys.concat(getSelectKeys(item.props.children, value));
	    } else {
	      var itemValue = getValuePropValue(item);
	      var itemKey = item.key;
	      if (findIndexInValueByKey(value, itemValue) !== -1 && itemKey) {
	        selectedKeys.push(itemKey);
	      }
	    }
	  });
	  return selectedKeys;
	}
	
	var UNSELECTABLE_STYLE = exports.UNSELECTABLE_STYLE = {
	  userSelect: 'none',
	  WebkitUserSelect: 'none'
	};
	
	var UNSELECTABLE_ATTRIBUTE = exports.UNSELECTABLE_ATTRIBUTE = {
	  unselectable: 'unselectable'
	};
	
	function findFirstMenuItem(children) {
	  for (var i = 0; i < children.length; i++) {
	    var child = children[i];
	    if (child.type.isMenuItemGroup) {
	      var found = findFirstMenuItem(child.props.children);
	      if (found) {
	        return found;
	      }
	    } else if (!child.props.disabled) {
	      return child;
	    }
	  }
	  return null;
	}
	
	function includesSeparators(string, separators) {
	  for (var i = 0; i < separators.length; ++i) {
	    if (string.lastIndexOf(separators[i]) > 0) {
	      return true;
	    }
	  }
	  return false;
	}
	
	function splitBySeparators(string, separators) {
	  var reg = new RegExp('[' + separators.join() + ']');
	  return string.split(reg).filter(function (token) {
	    return token;
	  });
	}
	
	function defaultFilterFn(input, child) {
	  return String(getPropValue(child, this.props.optionFilterProp)).indexOf(input) > -1;
	}

/***/ }),
/* 149 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _toConsumableArray2 = __webpack_require__(31);
	
	var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);
	
	exports.isEventFromHandle = isEventFromHandle;
	exports.isValueOutOfRange = isValueOutOfRange;
	exports.isNotTouchEvent = isNotTouchEvent;
	exports.getClosestPoint = getClosestPoint;
	exports.getPrecision = getPrecision;
	exports.getMousePosition = getMousePosition;
	exports.getTouchPosition = getTouchPosition;
	exports.getHandleCenterPosition = getHandleCenterPosition;
	exports.ensureValueInRange = ensureValueInRange;
	exports.ensureValuePrecision = ensureValuePrecision;
	exports.pauseEvent = pauseEvent;
	exports.getKeyboardValueMutator = getKeyboardValueMutator;
	
	var _reactDom = __webpack_require__(10);
	
	var _KeyCode = __webpack_require__(29);
	
	var _KeyCode2 = _interopRequireDefault(_KeyCode);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function isEventFromHandle(e, handles) {
	  return Object.keys(handles).some(function (key) {
	    return e.target === (0, _reactDom.findDOMNode)(handles[key]);
	  });
	}
	
	function isValueOutOfRange(value, _ref) {
	  var min = _ref.min,
	      max = _ref.max;
	
	  return value < min || value > max;
	}
	
	function isNotTouchEvent(e) {
	  return e.touches.length > 1 || e.type.toLowerCase() === 'touchend' && e.touches.length > 0;
	}
	
	function getClosestPoint(val, _ref2) {
	  var marks = _ref2.marks,
	      step = _ref2.step,
	      min = _ref2.min;
	
	  var points = Object.keys(marks).map(parseFloat);
	  if (step !== null) {
	    var closestStep = Math.round((val - min) / step) * step + min;
	    points.push(closestStep);
	  }
	  var diffs = points.map(function (point) {
	    return Math.abs(val - point);
	  });
	  return points[diffs.indexOf(Math.min.apply(Math, (0, _toConsumableArray3['default'])(diffs)))];
	}
	
	function getPrecision(step) {
	  var stepString = step.toString();
	  var precision = 0;
	  if (stepString.indexOf('.') >= 0) {
	    precision = stepString.length - stepString.indexOf('.') - 1;
	  }
	  return precision;
	}
	
	function getMousePosition(vertical, e) {
	  return vertical ? e.clientY : e.pageX;
	}
	
	function getTouchPosition(vertical, e) {
	  return vertical ? e.touches[0].clientY : e.touches[0].pageX;
	}
	
	function getHandleCenterPosition(vertical, handle) {
	  var coords = handle.getBoundingClientRect();
	  return vertical ? coords.top + coords.height * 0.5 : coords.left + coords.width * 0.5;
	}
	
	function ensureValueInRange(val, _ref3) {
	  var max = _ref3.max,
	      min = _ref3.min;
	
	  if (val <= min) {
	    return min;
	  }
	  if (val >= max) {
	    return max;
	  }
	  return val;
	}
	
	function ensureValuePrecision(val, props) {
	  var step = props.step;
	
	  var closestPoint = getClosestPoint(val, props);
	  return step === null ? closestPoint : parseFloat(closestPoint.toFixed(getPrecision(step)));
	}
	
	function pauseEvent(e) {
	  e.stopPropagation();
	  e.preventDefault();
	}
	
	function getKeyboardValueMutator(e) {
	  switch (e.keyCode) {
	    case _KeyCode2['default'].UP:
	    case _KeyCode2['default'].RIGHT:
	      return function (value, props) {
	        return value + props.step;
	      };
	
	    case _KeyCode2['default'].DOWN:
	    case _KeyCode2['default'].LEFT:
	      return function (value, props) {
	        return value - props.step;
	      };
	
	    case _KeyCode2['default'].END:
	      return function (value, props) {
	        return props.max;
	      };
	    case _KeyCode2['default'].HOME:
	      return function (value, props) {
	        return props.min;
	      };
	    case _KeyCode2['default'].PAGE_UP:
	      return function (value, props) {
	        return value + props.step * 2;
	      };
	    case _KeyCode2['default'].PAGE_DOWN:
	      return function (value, props) {
	        return value - props.step * 2;
	      };
	
	    default:
	      return undefined;
	  }
	}

/***/ }),
/* 150 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	var fetchKeys = __webpack_require__(228);
	
	module.exports = function shallowEqual(objA, objB, compare, compareContext) {
	
	    var ret = compare ? compare.call(compareContext, objA, objB) : void 0;
	
	    if (ret !== void 0) {
	        return !!ret;
	    }
	
	    if (objA === objB) {
	        return true;
	    }
	
	    if (typeof objA !== 'object' || objA === null || typeof objB !== 'object' || objB === null) {
	        return false;
	    }
	
	    var keysA = fetchKeys(objA);
	    var keysB = fetchKeys(objB);
	
	    var len = keysA.length;
	    if (len !== keysB.length) {
	        return false;
	    }
	
	    compareContext = compareContext || null;
	
	    // Test for A's keys different from B.
	    var bHasOwnProperty = Object.prototype.hasOwnProperty.bind(objB);
	    for (var i = 0; i < len; i++) {
	        var key = keysA[i];
	        if (!bHasOwnProperty(key)) {
	            return false;
	        }
	        var valueA = objA[key];
	        var valueB = objB[key];
	
	        var _ret = compare ? compare.call(compareContext, valueA, valueB, key) : void 0;
	        if (_ret === false || _ret === void 0 && valueA !== valueB) {
	            return false;
	        }
	    }
	
	    return true;
	};

/***/ }),
/* 151 */
/***/ (function(module, exports) {

	'use strict';
	
	exports.__esModule = true;
	var SHOW_ALL = exports.SHOW_ALL = 'SHOW_ALL';
	var SHOW_PARENT = exports.SHOW_PARENT = 'SHOW_PARENT';
	var SHOW_CHILD = exports.SHOW_CHILD = 'SHOW_CHILD';

/***/ }),
/* 152 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports['default'] = toArray;
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function toArray(children) {
	  var ret = [];
	  _react2['default'].Children.forEach(children, function (c) {
	    ret.push(c);
	  });
	  return ret;
	}
	module.exports = exports['default'];

/***/ }),
/* 153 */
/***/ (function(module, exports) {

	"use strict";
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports["default"] = createChainedFunction;
	/**
	 * Safe chained function
	 *
	 * Will only create a new function if needed,
	 * otherwise will pass back existing functions or null.
	 *
	 * @returns {function|null}
	 */
	function createChainedFunction() {
	  var args = [].slice.call(arguments, 0);
	  if (args.length === 1) {
	    return args[0];
	  }
	
	  return function chainedFunction() {
	    for (var i = 0; i < args.length; i++) {
	      if (args[i] && args[i].apply) {
	        args[i].apply(this, arguments);
	      }
	    }
	  };
	}
	module.exports = exports['default'];

/***/ }),
/* 154 */
/***/ (function(module, exports, __webpack_require__) {

	'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; };
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _reactDom = __webpack_require__(10);
	
	var _reactDom2 = _interopRequireDefault(_reactDom);
	
	var _trackHelper = __webpack_require__(286);
	
	var _objectAssign = __webpack_require__(18);
	
	var _objectAssign2 = _interopRequireDefault(_objectAssign);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
	
	var helpers = {
	  initialize: function initialize(props) {
	    var slickList = _reactDom2.default.findDOMNode(this.list);
	
	    var slideCount = _react2.default.Children.count(props.children);
	    var listWidth = this.getWidth(slickList);
	    var trackWidth = this.getWidth(_reactDom2.default.findDOMNode(this.track));
	    var slideWidth;
	
	    if (!props.vertical) {
	      var centerPaddingAdj = props.centerMode && parseInt(props.centerPadding) * 2;
	      slideWidth = (this.getWidth(_reactDom2.default.findDOMNode(this)) - centerPaddingAdj) / props.slidesToShow;
	    } else {
	      slideWidth = this.getWidth(_reactDom2.default.findDOMNode(this));
	    }
	
	    var slideHeight = this.getHeight(slickList.querySelector('[data-index="0"]'));
	    var listHeight = slideHeight * props.slidesToShow;
	
	    var currentSlide = props.rtl ? slideCount - 1 - props.initialSlide : props.initialSlide;
	
	    this.setState({
	      slideCount: slideCount,
	      slideWidth: slideWidth,
	      listWidth: listWidth,
	      trackWidth: trackWidth,
	      currentSlide: currentSlide,
	      slideHeight: slideHeight,
	      listHeight: listHeight
	    }, function () {
	
	      var targetLeft = (0, _trackHelper.getTrackLeft)((0, _objectAssign2.default)({
	        slideIndex: this.state.currentSlide,
	        trackRef: this.track
	      }, props, this.state));
	      // getCSS function needs previously set state
	      var trackStyle = (0, _trackHelper.getTrackCSS)((0, _objectAssign2.default)({ left: targetLeft }, props, this.state));
	
	      this.setState({ trackStyle: trackStyle });
	
	      this.autoPlay(); // once we're set up, trigger the initial autoplay.
	    });
	  },
	  update: function update(props) {
	    var slickList = _reactDom2.default.findDOMNode(this.list);
	    // This method has mostly same code as initialize method.
	    // Refactor it
	    var slideCount = _react2.default.Children.count(props.children);
	    var listWidth = this.getWidth(slickList);
	    var trackWidth = this.getWidth(_reactDom2.default.findDOMNode(this.track));
	    var slideWidth;
	
	    if (!props.vertical) {
	      var centerPaddingAdj = props.centerMode && parseInt(props.centerPadding) * 2;
	      slideWidth = (this.getWidth(_reactDom2.default.findDOMNode(this)) - centerPaddingAdj) / props.slidesToShow;
	    } else {
	      slideWidth = this.getWidth(_reactDom2.default.findDOMNode(this));
	    }
	
	    var slideHeight = this.getHeight(slickList.querySelector('[data-index="0"]'));
	    var listHeight = slideHeight * props.slidesToShow;
	
	    // pause slider if autoplay is set to false
	    if (!props.autoplay) {
	      this.pause();
	    } else {
	      this.autoPlay();
	    }
	
	    this.setState({
	      slideCount: slideCount,
	      slideWidth: slideWidth,
	      listWidth: listWidth,
	      trackWidth: trackWidth,
	      slideHeight: slideHeight,
	      listHeight: listHeight
	    }, function () {
	
	      var targetLeft = (0, _trackHelper.getTrackLeft)((0, _objectAssign2.default)({
	        slideIndex: this.state.currentSlide,
	        trackRef: this.track
	      }, props, this.state));
	      // getCSS function needs previously set state
	      var trackStyle = (0, _trackHelper.getTrackCSS)((0, _objectAssign2.default)({ left: targetLeft }, props, this.state));
	
	      this.setState({ trackStyle: trackStyle });
	    });
	  },
	  getWidth: function getWidth(elem) {
	    return elem && (elem.getBoundingClientRect().width || elem.offsetWidth) || 0;
	  },
	  getHeight: function getHeight(elem) {
	    return elem && (elem.getBoundingClientRect().height || elem.offsetHeight) || 0;
	  },
	
	  adaptHeight: function adaptHeight() {
	    if (this.props.adaptiveHeight) {
	      var selector = '[data-index="' + this.state.currentSlide + '"]';
	      if (this.list) {
	        var slickList = _reactDom2.default.findDOMNode(this.list);
	        slickList.style.height = slickList.querySelector(selector).offsetHeight + 'px';
	      }
	    }
	  },
	  canGoNext: function canGoNext(opts) {
	    var canGo = true;
	    if (!opts.infinite) {
	      if (opts.centerMode) {
	        // check if current slide is last slide
	        if (opts.currentSlide >= opts.slideCount - 1) {
	          canGo = false;
	        }
	      } else {
	        // check if all slides are shown in slider
	        if (opts.slideCount <= opts.slidesToShow || opts.currentSlide >= opts.slideCount - opts.slidesToShow) {
	          canGo = false;
	        }
	      }
	    }
	    return canGo;
	  },
	  slideHandler: function slideHandler(index) {
	    var _this = this;
	
	    // Functionality of animateSlide and postSlide is merged into this function
	    // console.log('slideHandler', index);
	    var targetSlide, currentSlide;
	    var targetLeft, currentLeft;
	    var callback;
	
	    if (this.props.waitForAnimate && this.state.animating) {
	      return;
	    }
	
	    if (this.props.fade) {
	      currentSlide = this.state.currentSlide;
	
	      // Don't change slide if it's not infite and current slide is the first or last slide.
	      if (this.props.infinite === false && (index < 0 || index >= this.state.slideCount)) {
	        return;
	      }
	
	      //  Shifting targetSlide back into the range
	      if (index < 0) {
	        targetSlide = index + this.state.slideCount;
	      } else if (index >= this.state.slideCount) {
	        targetSlide = index - this.state.slideCount;
	      } else {
	        targetSlide = index;
	      }
	
	      if (this.props.lazyLoad && this.state.lazyLoadedList.indexOf(targetSlide) < 0) {
	        this.setState({
	          lazyLoadedList: this.state.lazyLoadedList.concat(targetSlide)
	        });
	      }
	
	      callback = function callback() {
	        _this.setState({
	          animating: false
	        });
	        if (_this.props.afterChange) {
	          _this.props.afterChange(targetSlide);
	        }
	        delete _this.animationEndCallback;
	      };
	
	      this.setState({
	        animating: true,
	        currentSlide: targetSlide
	      }, function () {
	        this.animationEndCallback = setTimeout(callback, this.props.speed);
	      });
	
	      if (this.props.beforeChange) {
	        this.props.beforeChange(this.state.currentSlide, targetSlide);
	      }
	
	      this.autoPlay();
	      return;
	    }
	
	    targetSlide = index;
	    if (targetSlide < 0) {
	      if (this.props.infinite === false) {
	        currentSlide = 0;
	      } else if (this.state.slideCount % this.props.slidesToScroll !== 0) {
	        currentSlide = this.state.slideCount - this.state.slideCount % this.props.slidesToScroll;
	      } else {
	        currentSlide = this.state.slideCount + targetSlide;
	      }
	    } else if (targetSlide >= this.state.slideCount) {
	      if (this.props.infinite === false) {
	        currentSlide = this.state.slideCount - this.props.slidesToShow;
	      } else if (this.state.slideCount % this.props.slidesToScroll !== 0) {
	        currentSlide = 0;
	      } else {
	        currentSlide = targetSlide - this.state.slideCount;
	      }
	    } else {
	      currentSlide = targetSlide;
	    }
	
	    targetLeft = (0, _trackHelper.getTrackLeft)((0, _objectAssign2.default)({
	      slideIndex: targetSlide,
	      trackRef: this.track
	    }, this.props, this.state));
	
	    currentLeft = (0, _trackHelper.getTrackLeft)((0, _objectAssign2.default)({
	      slideIndex: currentSlide,
	      trackRef: this.track
	    }, this.props, this.state));
	
	    if (this.props.infinite === false) {
	      targetLeft = currentLeft;
	    }
	
	    if (this.props.beforeChange) {
	      this.props.beforeChange(this.state.currentSlide, currentSlide);
	    }
	
	    if (this.props.lazyLoad) {
	      var loaded = true;
	      var slidesToLoad = [];
	      for (var i = targetSlide; i < targetSlide + this.props.slidesToShow; i++) {
	        loaded = loaded && this.state.lazyLoadedList.indexOf(i) >= 0;
	        if (!loaded) {
	          slidesToLoad.push(i);
	        }
	      }
	      if (!loaded) {
	        this.setState({
	          lazyLoadedList: this.state.lazyLoadedList.concat(slidesToLoad)
	        });
	      }
	    }
	
	    // Slide Transition happens here.
	    // animated transition happens to target Slide and
	    // non - animated transition happens to current Slide
	    // If CSS transitions are false, directly go the current slide.
	
	    if (this.props.useCSS === false) {
	
	      this.setState({
	        currentSlide: currentSlide,
	        trackStyle: (0, _trackHelper.getTrackCSS)((0, _objectAssign2.default)({ left: currentLeft }, this.props, this.state))
	      }, function () {
	        if (this.props.afterChange) {
	          this.props.afterChange(currentSlide);
	        }
	      });
	    } else {
	
	      var nextStateChanges = {
	        animating: false,
	        currentSlide: currentSlide,
	        trackStyle: (0, _trackHelper.getTrackCSS)((0, _objectAssign2.default)({ left: currentLeft }, this.props, this.state)),
	        swipeLeft: null
	      };
	
	      callback = function callback() {
	        _this.setState(nextStateChanges);
	        if (_this.props.afterChange) {
	          _this.props.afterChange(currentSlide);
	        }
	        delete _this.animationEndCallback;
	      };
	
	      this.setState({
	        animating: true,
	        currentSlide: currentSlide,
	        trackStyle: (0, _trackHelper.getTrackAnimateCSS)((0, _objectAssign2.default)({ left: targetLeft }, this.props, this.state))
	      }, function () {
	        this.animationEndCallback = setTimeout(callback, this.props.speed);
	      });
	    }
	
	    this.autoPlay();
	  },
	  swipeDirection: function swipeDirection(touchObject) {
	    var xDist, yDist, r, swipeAngle;
	
	    xDist = touchObject.startX - touchObject.curX;
	    yDist = touchObject.startY - touchObject.curY;
	    r = Math.atan2(yDist, xDist);
	
	    swipeAngle = Math.round(r * 180 / Math.PI);
	    if (swipeAngle < 0) {
	      swipeAngle = 360 - Math.abs(swipeAngle);
	    }
	    if (swipeAngle <= 45 && swipeAngle >= 0 || swipeAngle <= 360 && swipeAngle >= 315) {
	      return this.props.rtl === false ? 'left' : 'right';
	    }
	    if (swipeAngle >= 135 && swipeAngle <= 225) {
	      return this.props.rtl === false ? 'right' : 'left';
	    }
	    if (this.props.verticalSwiping === true) {
	      if (swipeAngle >= 35 && swipeAngle <= 135) {
	        return 'down';
	      } else {
	        return 'up';
	      }
	    }
	
	    return 'vertical';
	  },
	  play: function play() {
	    var nextIndex;
	
	    if (!this.state.mounted) {
	      return false;
	    }
	
	    if (this.props.rtl) {
	      nextIndex = this.state.currentSlide - this.props.slidesToScroll;
	    } else {
	      if (this.canGoNext(_extends({}, this.props, this.state))) {
	        nextIndex = this.state.currentSlide + this.props.slidesToScroll;
	      } else {
	        return false;
	      }
	    }
	
	    this.slideHandler(nextIndex);
	  },
	  autoPlay: function autoPlay() {
	    if (this.state.autoPlayTimer) {
	      clearTimeout(this.state.autoPlayTimer);
	    }
	    if (this.props.autoplay) {
	      this.setState({
	        autoPlayTimer: setTimeout(this.play, this.props.autoplaySpeed)
	      });
	    }
	  },
	  pause: function pause() {
	    if (this.state.autoPlayTimer) {
	      clearTimeout(this.state.autoPlayTimer);
	      this.setState({
	        autoPlayTimer: null
	      });
	    }
	  }
	};
	
	exports.default = helpers;

/***/ }),
/* 155 */
/***/ (function(module, exports, __webpack_require__) {

	/* WEBPACK VAR INJECTION */(function(global, process) {(function (global, undefined) {
	    "use strict";
	
	    if (global.setImmediate) {
	        return;
	    }
	
	    var nextHandle = 1; // Spec says greater than zero
	    var tasksByHandle = {};
	    var currentlyRunningATask = false;
	    var doc = global.document;
	    var registerImmediate;
	
	    function setImmediate(callback) {
	      // Callback can either be a function or a string
	      if (typeof callback !== "function") {
	        callback = new Function("" + callback);
	      }
	      // Copy function arguments
	      var args = new Array(arguments.length - 1);
	      for (var i = 0; i < args.length; i++) {
	          args[i] = arguments[i + 1];
	      }
	      // Store and register the task
	      var task = { callback: callback, args: args };
	      tasksByHandle[nextHandle] = task;
	      registerImmediate(nextHandle);
	      return nextHandle++;
	    }
	
	    function clearImmediate(handle) {
	        delete tasksByHandle[handle];
	    }
	
	    function run(task) {
	        var callback = task.callback;
	        var args = task.args;
	        switch (args.length) {
	        case 0:
	            callback();
	            break;
	        case 1:
	            callback(args[0]);
	            break;
	        case 2:
	            callback(args[0], args[1]);
	            break;
	        case 3:
	            callback(args[0], args[1], args[2]);
	            break;
	        default:
	            callback.apply(undefined, args);
	            break;
	        }
	    }
	
	    function runIfPresent(handle) {
	        // From the spec: "Wait until any invocations of this algorithm started before this one have completed."
	        // So if we're currently running a task, we'll need to delay this invocation.
	        if (currentlyRunningATask) {
	            // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a
	            // "too much recursion" error.
	            setTimeout(runIfPresent, 0, handle);
	        } else {
	            var task = tasksByHandle[handle];
	            if (task) {
	                currentlyRunningATask = true;
	                try {
	                    run(task);
	                } finally {
	                    clearImmediate(handle);
	                    currentlyRunningATask = false;
	                }
	            }
	        }
	    }
	
	    function installNextTickImplementation() {
	        registerImmediate = function(handle) {
	            process.nextTick(function () { runIfPresent(handle); });
	        };
	    }
	
	    function canUsePostMessage() {
	        // The test against `importScripts` prevents this implementation from being installed inside a web worker,
	        // where `global.postMessage` means something completely different and can't be used for this purpose.
	        if (global.postMessage && !global.importScripts) {
	            var postMessageIsAsynchronous = true;
	            var oldOnMessage = global.onmessage;
	            global.onmessage = function() {
	                postMessageIsAsynchronous = false;
	            };
	            global.postMessage("", "*");
	            global.onmessage = oldOnMessage;
	            return postMessageIsAsynchronous;
	        }
	    }
	
	    function installPostMessageImplementation() {
	        // Installs an event handler on `global` for the `message` event: see
	        // * https://developer.mozilla.org/en/DOM/window.postMessage
	        // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages
	
	        var messagePrefix = "setImmediate$" + Math.random() + "$";
	        var onGlobalMessage = function(event) {
	            if (event.source === global &&
	                typeof event.data === "string" &&
	                event.data.indexOf(messagePrefix) === 0) {
	                runIfPresent(+event.data.slice(messagePrefix.length));
	            }
	        };
	
	        if (global.addEventListener) {
	            global.addEventListener("message", onGlobalMessage, false);
	        } else {
	            global.attachEvent("onmessage", onGlobalMessage);
	        }
	
	        registerImmediate = function(handle) {
	            global.postMessage(messagePrefix + handle, "*");
	        };
	    }
	
	    function installMessageChannelImplementation() {
	        var channel = new MessageChannel();
	        channel.port1.onmessage = function(event) {
	            var handle = event.data;
	            runIfPresent(handle);
	        };
	
	        registerImmediate = function(handle) {
	            channel.port2.postMessage(handle);
	        };
	    }
	
	    function installReadyStateChangeImplementation() {
	        var html = doc.documentElement;
	        registerImmediate = function(handle) {
	            // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted
	            // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.
	            var script = doc.createElement("script");
	            script.onreadystatechange = function () {
	                runIfPresent(handle);
	                script.onreadystatechange = null;
	                html.removeChild(script);
	                script = null;
	            };
	            html.appendChild(script);
	        };
	    }
	
	    function installSetTimeoutImplementation() {
	        registerImmediate = function(handle) {
	            setTimeout(runIfPresent, 0, handle);
	        };
	    }
	
	    // If supported, we should attach to the prototype of global, since that is where setTimeout et al. live.
	    var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global);
	    attachTo = attachTo && attachTo.setTimeout ? attachTo : global;
	
	    // Don't get fooled by e.g. browserify environments.
	    if ({}.toString.call(global.process) === "[object process]") {
	        // For Node.js before 0.9
	        installNextTickImplementation();
	
	    } else if (canUsePostMessage()) {
	        // For non-IE10 modern browsers
	        installPostMessageImplementation();
	
	    } else if (global.MessageChannel) {
	        // For web workers, where supported
	        installMessageChannelImplementation();
	
	    } else if (doc && "onreadystatechange" in doc.createElement("script")) {
	        // For IE 6–8
	        installReadyStateChangeImplementation();
	
	    } else {
	        // For older browsers
	        installSetTimeoutImplementation();
	    }
	
	    attachTo.setImmediate = setImmediate;
	    attachTo.clearImmediate = clearImmediate;
	}(typeof self === "undefined" ? typeof global === "undefined" ? this : global : self));
	
	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()), __webpack_require__(652)))

/***/ }),
/* 156 */
/***/ (function(module, exports) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports['default'] = {
	  today: 'Today',
	  now: 'Now',
	  backToToday: 'Back to today',
	  ok: 'Ok',
	  clear: 'Clear',
	  month: 'Month',
	  year: 'Year',
	  timeSelect: 'Select time',
	  dateSelect: 'Select date',
	  monthSelect: 'Choose a month',
	  yearSelect: 'Choose a year',
	  decadeSelect: 'Choose a decade',
	  yearFormat: 'YYYY',
	  dateFormat: 'M/D/YYYY',
	  dayFormat: 'D',
	  dateTimeFormat: 'M/D/YYYY HH:mm:ss',
	  monthBeforeYear: true,
	  previousMonth: 'Previous month (PageUp)',
	  nextMonth: 'Next month (PageDown)',
	  previousYear: 'Last year (Control + left)',
	  nextYear: 'Next year (Control + right)',
	  previousDecade: 'Last decade',
	  nextDecade: 'Next decade',
	  previousCentury: 'Last century',
	  nextCentury: 'Next century'
	};
	module.exports = exports['default'];

/***/ }),
/* 157 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _util = __webpack_require__(19);
	
	var util = _interopRequireWildcard(_util);
	
	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; } }
	
	/**
	 *  Rule for validating required fields.
	 *
	 *  @param rule The validation rule.
	 *  @param value The value of the field on the source object.
	 *  @param source The source object being validated.
	 *  @param errors An array of errors that this rule may add
	 *  validation errors to.
	 *  @param options The validation options.
	 *  @param options.messages The validation messages.
	 */
	function required(rule, value, source, errors, options, type) {
	  if (rule.required && (!source.hasOwnProperty(rule.field) || util.isEmptyValue(value, type || rule.type))) {
	    errors.push(util.format(options.messages.required, rule.fullField));
	  }
	}
	
	exports['default'] = required;
	module.exports = exports['default'];

/***/ }),
/* 158 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _toConsumableArray2 = __webpack_require__(31);
	
	var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);
	
	exports['default'] = throttleByAnimationFrame;
	exports.throttleByAnimationFrameDecorator = throttleByAnimationFrameDecorator;
	
	var _getRequestAnimationFrame = __webpack_require__(80);
	
	var _getRequestAnimationFrame2 = _interopRequireDefault(_getRequestAnimationFrame);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var reqAnimFrame = (0, _getRequestAnimationFrame2['default'])();
	function throttleByAnimationFrame(fn) {
	    var requestId = void 0;
	    var later = function later(args) {
	        return function () {
	            requestId = null;
	            fn.apply(undefined, (0, _toConsumableArray3['default'])(args));
	        };
	    };
	    var throttled = function throttled() {
	        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
	            args[_key] = arguments[_key];
	        }
	
	        if (requestId == null) {
	            requestId = reqAnimFrame(later(args));
	        }
	    };
	    throttled.cancel = function () {
	        return (0, _getRequestAnimationFrame.cancelRequestAnimationFrame)(requestId);
	    };
	    return throttled;
	}
	function throttleByAnimationFrameDecorator() {
	    return function (target, key, descriptor) {
	        var fn = descriptor.value;
	        var definingProperty = false;
	        return {
	            configurable: true,
	            get: function get() {
	                if (definingProperty || this === target.prototype || this.hasOwnProperty(key)) {
	                    return fn;
	                }
	                var boundFn = throttleByAnimationFrame(fn.bind(this));
	                definingProperty = true;
	                Object.defineProperty(this, key, {
	                    value: boundFn,
	                    configurable: true,
	                    writable: true
	                });
	                definingProperty = false;
	                return boundFn;
	            }
	        };
	    };
	}

/***/ }),
/* 159 */
/***/ (function(module, exports, __webpack_require__) {

	"use strict";
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _typeof2 = __webpack_require__(21);
	
	var _typeof3 = _interopRequireDefault(_typeof2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _reactDom = __webpack_require__(10);
	
	var _reactDom2 = _interopRequireDefault(_reactDom);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _addEventListener = __webpack_require__(34);
	
	var _addEventListener2 = _interopRequireDefault(_addEventListener);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _shallowequal = __webpack_require__(45);
	
	var _shallowequal2 = _interopRequireDefault(_shallowequal);
	
	var _omit = __webpack_require__(28);
	
	var _omit2 = _interopRequireDefault(_omit);
	
	var _getScroll = __webpack_require__(100);
	
	var _getScroll2 = _interopRequireDefault(_getScroll);
	
	var _throttleByAnimationFrame = __webpack_require__(158);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
	
	var __decorate = undefined && undefined.__decorate || function (decorators, target, key, desc) {
	    var c = arguments.length,
	        r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc,
	        d;
	    if ((typeof Reflect === "undefined" ? "undefined" : (0, _typeof3["default"])(Reflect)) === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);else for (var i = decorators.length - 1; i >= 0; i--) {
	        if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    }return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	
	function getTargetRect(target) {
	    return target !== window ? target.getBoundingClientRect() : { top: 0, left: 0, bottom: 0 };
	}
	function getOffset(element, target) {
	    var elemRect = element.getBoundingClientRect();
	    var targetRect = getTargetRect(target);
	    var scrollTop = (0, _getScroll2["default"])(target, true);
	    var scrollLeft = (0, _getScroll2["default"])(target, false);
	    var docElem = window.document.body;
	    var clientTop = docElem.clientTop || 0;
	    var clientLeft = docElem.clientLeft || 0;
	    return {
	        top: elemRect.top - targetRect.top + scrollTop - clientTop,
	        left: elemRect.left - targetRect.left + scrollLeft - clientLeft,
	        width: elemRect.width,
	        height: elemRect.height
	    };
	}
	function noop() {}
	function getDefaultTarget() {
	    return typeof window !== 'undefined' ? window : null;
	}
	
	var Affix = function (_React$Component) {
	    (0, _inherits3["default"])(Affix, _React$Component);
	
	    function Affix(props) {
	        (0, _classCallCheck3["default"])(this, Affix);
	
	        var _this = (0, _possibleConstructorReturn3["default"])(this, (Affix.__proto__ || Object.getPrototypeOf(Affix)).call(this, props));
	
	        _this.events = ['resize', 'scroll', 'touchstart', 'touchmove', 'touchend', 'pageshow', 'load'];
	        _this.eventHandlers = {};
	        _this.state = {
	            affixStyle: null,
	            placeholderStyle: null
	        };
	        return _this;
	    }
	
	    (0, _createClass3["default"])(Affix, [{
	        key: "setAffixStyle",
	        value: function setAffixStyle(e, affixStyle) {
	            var _this2 = this;
	
	            var _props = this.props,
	                _props$onChange = _props.onChange,
	                onChange = _props$onChange === undefined ? noop : _props$onChange,
	                _props$target = _props.target,
	                target = _props$target === undefined ? getDefaultTarget : _props$target;
	
	            var originalAffixStyle = this.state.affixStyle;
	            var isWindow = target() === window;
	            if (e.type === 'scroll' && originalAffixStyle && affixStyle && isWindow) {
	                return;
	            }
	            if ((0, _shallowequal2["default"])(affixStyle, originalAffixStyle)) {
	                return;
	            }
	            this.setState({ affixStyle: affixStyle }, function () {
	                var affixed = !!_this2.state.affixStyle;
	                if (affixStyle && !originalAffixStyle || !affixStyle && originalAffixStyle) {
	                    onChange(affixed);
	                }
	            });
	        }
	    }, {
	        key: "setPlaceholderStyle",
	        value: function setPlaceholderStyle(placeholderStyle) {
	            var originalPlaceholderStyle = this.state.placeholderStyle;
	            if ((0, _shallowequal2["default"])(placeholderStyle, originalPlaceholderStyle)) {
	                return;
	            }
	            this.setState({ placeholderStyle: placeholderStyle });
	        }
	    }, {
	        key: "updatePosition",
	        value: function updatePosition(e) {
	            var _props2 = this.props,
	                offsetTop = _props2.offsetTop,
	                offsetBottom = _props2.offsetBottom,
	                offset = _props2.offset,
	                _props2$target = _props2.target,
	                target = _props2$target === undefined ? getDefaultTarget : _props2$target;
	
	            var targetNode = target();
	            // Backwards support
	            offsetTop = offsetTop || offset;
	            var scrollTop = (0, _getScroll2["default"])(targetNode, true);
	            var affixNode = _reactDom2["default"].findDOMNode(this);
	            var elemOffset = getOffset(affixNode, targetNode);
	            var elemSize = {
	                width: this.refs.fixedNode.offsetWidth,
	                height: this.refs.fixedNode.offsetHeight
	            };
	            var offsetMode = {
	                top: false,
	                bottom: false
	            };
	            // Default to `offsetTop=0`.
	            if (typeof offsetTop !== 'number' && typeof offsetBottom !== 'number') {
	                offsetMode.top = true;
	                offsetTop = 0;
	            } else {
	                offsetMode.top = typeof offsetTop === 'number';
	                offsetMode.bottom = typeof offsetBottom === 'number';
	            }
	            var targetRect = getTargetRect(targetNode);
	            var targetInnerHeight = targetNode.innerHeight || targetNode.clientHeight;
	            if (scrollTop > elemOffset.top - offsetTop && offsetMode.top) {
	                // Fixed Top
	                var width = elemOffset.width;
	                this.setAffixStyle(e, {
	                    position: 'fixed',
	                    top: targetRect.top + offsetTop,
	                    left: targetRect.left + elemOffset.left,
	                    width: width
	                });
	                this.setPlaceholderStyle({
	                    width: width,
	                    height: elemSize.height
	                });
	            } else if (scrollTop < elemOffset.top + elemSize.height + offsetBottom - targetInnerHeight && offsetMode.bottom) {
	                // Fixed Bottom
	                var targetBottomOffet = targetNode === window ? 0 : window.innerHeight - targetRect.bottom;
	                var _width = elemOffset.width;
	                this.setAffixStyle(e, {
	                    position: 'fixed',
	                    bottom: targetBottomOffet + offsetBottom,
	                    left: targetRect.left + elemOffset.left,
	                    width: _width
	                });
	                this.setPlaceholderStyle({
	                    width: _width,
	                    height: elemOffset.height
	                });
	            } else {
	                var affixStyle = this.state.affixStyle;
	
	                if (e.type === 'resize' && affixStyle && affixStyle.position === 'fixed' && affixNode.offsetWidth) {
	                    this.setAffixStyle(e, (0, _extends3["default"])({}, affixStyle, { width: affixNode.offsetWidth }));
	                } else {
	                    this.setAffixStyle(e, null);
	                }
	                this.setPlaceholderStyle(null);
	            }
	        }
	    }, {
	        key: "componentDidMount",
	        value: function componentDidMount() {
	            var _this3 = this;
	
	            var target = this.props.target || getDefaultTarget;
	            // Wait for parent component ref has its value
	            this.timeout = setTimeout(function () {
	                _this3.setTargetEventListeners(target);
	            });
	        }
	    }, {
	        key: "componentWillReceiveProps",
	        value: function componentWillReceiveProps(nextProps) {
	            if (this.props.target !== nextProps.target) {
	                this.clearEventListeners();
	                this.setTargetEventListeners(nextProps.target);
	                // Mock Event object.
	                this.updatePosition({});
	            }
	        }
	    }, {
	        key: "componentWillUnmount",
	        value: function componentWillUnmount() {
	            this.clearEventListeners();
	            clearTimeout(this.timeout);
	            this.updatePosition.cancel();
	        }
	    }, {
	        key: "setTargetEventListeners",
	        value: function setTargetEventListeners(getTarget) {
	            var _this4 = this;
	
	            var target = getTarget();
	            if (!target) {
	                return;
	            }
	            this.clearEventListeners();
	            this.events.forEach(function (eventName) {
	                _this4.eventHandlers[eventName] = (0, _addEventListener2["default"])(target, eventName, _this4.updatePosition);
	            });
	        }
	    }, {
	        key: "clearEventListeners",
	        value: function clearEventListeners() {
	            var _this5 = this;
	
	            this.events.forEach(function (eventName) {
	                var handler = _this5.eventHandlers[eventName];
	                if (handler && handler.remove) {
	                    handler.remove();
	                }
	            });
	        }
	    }, {
	        key: "render",
	        value: function render() {
	            var className = (0, _classnames2["default"])((0, _defineProperty3["default"])({}, this.props.prefixCls || 'ant-affix', this.state.affixStyle));
	            var props = (0, _omit2["default"])(this.props, ['prefixCls', 'offsetTop', 'offsetBottom', 'target', 'onChange']);
	            var placeholderStyle = (0, _extends3["default"])({}, this.state.placeholderStyle, this.props.style);
	            return _react2["default"].createElement(
	                "div",
	                (0, _extends3["default"])({}, props, { style: placeholderStyle }),
	                _react2["default"].createElement(
	                    "div",
	                    { className: className, ref: "fixedNode", style: this.state.affixStyle },
	                    this.props.children
	                )
	            );
	        }
	    }]);
	    return Affix;
	}(_react2["default"].Component);
	
	exports["default"] = Affix;
	
	Affix.propTypes = {
	    offsetTop: _propTypes2["default"].number,
	    offsetBottom: _propTypes2["default"].number,
	    target: _propTypes2["default"].func
	};
	__decorate([(0, _throttleByAnimationFrame.throttleByAnimationFrameDecorator)()], Affix.prototype, "updatePosition", null);
	module.exports = exports["default"];

/***/ }),
/* 160 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var __rest = undefined && undefined.__rest || function (s, e) {
	    var t = {};
	    for (var p in s) {
	        if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
	    }if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	        if (e.indexOf(p[i]) < 0) t[p[i]] = s[p[i]];
	    }return t;
	};
	
	var BreadcrumbItem = function (_React$Component) {
	    (0, _inherits3['default'])(BreadcrumbItem, _React$Component);
	
	    function BreadcrumbItem() {
	        (0, _classCallCheck3['default'])(this, BreadcrumbItem);
	        return (0, _possibleConstructorReturn3['default'])(this, (BreadcrumbItem.__proto__ || Object.getPrototypeOf(BreadcrumbItem)).apply(this, arguments));
	    }
	
	    (0, _createClass3['default'])(BreadcrumbItem, [{
	        key: 'render',
	        value: function render() {
	            var _a = this.props,
	                prefixCls = _a.prefixCls,
	                separator = _a.separator,
	                children = _a.children,
	                restProps = __rest(_a, ["prefixCls", "separator", "children"]);
	            var link = void 0;
	            if ('href' in this.props) {
	                link = _react2['default'].createElement(
	                    'a',
	                    (0, _extends3['default'])({ className: prefixCls + '-link' }, restProps),
	                    children
	                );
	            } else {
	                link = _react2['default'].createElement(
	                    'span',
	                    (0, _extends3['default'])({ className: prefixCls + '-link' }, restProps),
	                    children
	                );
	            }
	            if (children) {
	                return _react2['default'].createElement(
	                    'span',
	                    null,
	                    link,
	                    _react2['default'].createElement(
	                        'span',
	                        { className: prefixCls + '-separator' },
	                        separator
	                    )
	                );
	            }
	            return null;
	        }
	    }]);
	    return BreadcrumbItem;
	}(_react2['default'].Component);
	
	exports['default'] = BreadcrumbItem;
	
	BreadcrumbItem.__ANT_BREADCRUMB_ITEM = true;
	BreadcrumbItem.defaultProps = {
	    prefixCls: 'ant-breadcrumb',
	    separator: '/'
	};
	BreadcrumbItem.propTypes = {
	    prefixCls: _propTypes2['default'].string,
	    separator: _propTypes2['default'].oneOfType([_propTypes2['default'].string, _propTypes2['default'].element]),
	    href: _propTypes2['default'].string
	};
	module.exports = exports['default'];

/***/ }),
/* 161 */
[1078, 984],
/* 162 */
/***/ (function(module, exports) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	var PREFIX_CLS = exports.PREFIX_CLS = 'ant-fullcalendar';

/***/ }),
/* 163 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _zh_CN = __webpack_require__(166);
	
	var _zh_CN2 = _interopRequireDefault(_zh_CN);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	exports['default'] = _zh_CN2['default'];
	module.exports = exports['default'];

/***/ }),
/* 164 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _rcCheckbox = __webpack_require__(254);
	
	var _rcCheckbox2 = _interopRequireDefault(_rcCheckbox);
	
	var _shallowequal = __webpack_require__(45);
	
	var _shallowequal2 = _interopRequireDefault(_shallowequal);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var __rest = undefined && undefined.__rest || function (s, e) {
	    var t = {};
	    for (var p in s) {
	        if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
	    }if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	        if (e.indexOf(p[i]) < 0) t[p[i]] = s[p[i]];
	    }return t;
	};
	
	var Checkbox = function (_React$Component) {
	    (0, _inherits3['default'])(Checkbox, _React$Component);
	
	    function Checkbox() {
	        (0, _classCallCheck3['default'])(this, Checkbox);
	        return (0, _possibleConstructorReturn3['default'])(this, (Checkbox.__proto__ || Object.getPrototypeOf(Checkbox)).apply(this, arguments));
	    }
	
	    (0, _createClass3['default'])(Checkbox, [{
	        key: 'shouldComponentUpdate',
	        value: function shouldComponentUpdate(nextProps, nextState, nextContext) {
	            return !(0, _shallowequal2['default'])(this.props, nextProps) || !(0, _shallowequal2['default'])(this.state, nextState) || !(0, _shallowequal2['default'])(this.context.checkboxGroup, nextContext.checkboxGroup);
	        }
	    }, {
	        key: 'render',
	        value: function render() {
	            var props = this.props,
	                context = this.context;
	
	            var prefixCls = props.prefixCls,
	                className = props.className,
	                children = props.children,
	                indeterminate = props.indeterminate,
	                style = props.style,
	                onMouseEnter = props.onMouseEnter,
	                onMouseLeave = props.onMouseLeave,
	                restProps = __rest(props, ["prefixCls", "className", "children", "indeterminate", "style", "onMouseEnter", "onMouseLeave"]);
	
	            var checkboxGroup = context.checkboxGroup;
	
	            var checkboxProps = (0, _extends3['default'])({}, restProps);
	            if (checkboxGroup) {
	                checkboxProps.onChange = function () {
	                    return checkboxGroup.toggleOption({ label: children, value: props.value });
	                };
	                checkboxProps.checked = checkboxGroup.value.indexOf(props.value) !== -1;
	                checkboxProps.disabled = props.disabled || checkboxGroup.disabled;
	            }
	            var classString = (0, _classnames2['default'])(className, (0, _defineProperty3['default'])({}, prefixCls + '-wrapper', true));
	            var checkboxClass = (0, _classnames2['default'])((0, _defineProperty3['default'])({}, prefixCls + '-indeterminate', indeterminate));
	            return _react2['default'].createElement(
	                'label',
	                { className: classString, style: style, onMouseEnter: onMouseEnter, onMouseLeave: onMouseLeave },
	                _react2['default'].createElement(_rcCheckbox2['default'], (0, _extends3['default'])({}, checkboxProps, { prefixCls: prefixCls, className: checkboxClass })),
	                children !== undefined ? _react2['default'].createElement(
	                    'span',
	                    null,
	                    children
	                ) : null
	            );
	        }
	    }]);
	    return Checkbox;
	}(_react2['default'].Component);
	
	exports['default'] = Checkbox;
	
	Checkbox.defaultProps = {
	    prefixCls: 'ant-checkbox',
	    indeterminate: false
	};
	Checkbox.contextTypes = {
	    checkboxGroup: _propTypes2['default'].any
	};
	module.exports = exports['default'];

/***/ }),
/* 165 */
[1078, 989],
/* 166 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _zh_CN = __webpack_require__(250);
	
	var _zh_CN2 = _interopRequireDefault(_zh_CN);
	
	var _zh_CN3 = __webpack_require__(182);
	
	var _zh_CN4 = _interopRequireDefault(_zh_CN3);
	
	var _moment = __webpack_require__(13);
	
	var _moment2 = _interopRequireDefault(_moment);
	
	__webpack_require__(651);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	// 备注：以下代码无法完全按最初设计运行，但为了保证兼容性，需要保留，直至 antd 默认语言改为英文
	//  1. 如果用户不给时间类组件传入 value defaultValue，则运行符合预期
	//  2. 如果用户传入 value defaultValue，因为这段代码没有在用户代码之前运行，所以用户调用 moment 时，默认语言依然为英文
	// To set the default locale of moment to zh-cn globally.
	_moment2['default'].locale('zh-cn');
	// Merge into a locale object
	var locale = {
	    lang: (0, _extends3['default'])({ placeholder: '请选择日期', rangePlaceholder: ['开始日期', '结束日期'] }, _zh_CN2['default']),
	    timePickerLocale: (0, _extends3['default'])({}, _zh_CN4['default'])
	};
	// should add whitespace between char in Button
	locale.lang.ok = '确 定';
	// All settings at:
	// https://github.com/ant-design/ant-design/blob/master/components/date-picker/locale/example.json
	exports['default'] = locale;
	module.exports = exports['default'];

/***/ }),
/* 167 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _rcDropdown = __webpack_require__(683);
	
	var _rcDropdown2 = _interopRequireDefault(_rcDropdown);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _warning = __webpack_require__(24);
	
	var _warning2 = _interopRequireDefault(_warning);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var Dropdown = function (_React$Component) {
	    (0, _inherits3['default'])(Dropdown, _React$Component);
	
	    function Dropdown() {
	        (0, _classCallCheck3['default'])(this, Dropdown);
	        return (0, _possibleConstructorReturn3['default'])(this, (Dropdown.__proto__ || Object.getPrototypeOf(Dropdown)).apply(this, arguments));
	    }
	
	    (0, _createClass3['default'])(Dropdown, [{
	        key: 'getTransitionName',
	        value: function getTransitionName() {
	            var _props$placement = this.props.placement,
	                placement = _props$placement === undefined ? '' : _props$placement;
	
	            if (placement.indexOf('top') >= 0) {
	                return 'slide-down';
	            }
	            return 'slide-up';
	        }
	    }, {
	        key: 'componentDidMount',
	        value: function componentDidMount() {
	            var overlay = this.props.overlay;
	
	            var overlayProps = overlay.props;
	            (0, _warning2['default'])(!overlayProps.mode || overlayProps.mode === 'vertical', 'mode="' + overlayProps.mode + '" is not supported for Dropdown\'s Menu.');
	        }
	    }, {
	        key: 'render',
	        value: function render() {
	            var _props = this.props,
	                children = _props.children,
	                prefixCls = _props.prefixCls,
	                overlay = _props.overlay,
	                trigger = _props.trigger,
	                disabled = _props.disabled;
	
	            var dropdownTrigger = (0, _react.cloneElement)(children, {
	                className: (0, _classnames2['default'])(children.props.className, prefixCls + '-trigger'),
	                disabled: disabled
	            });
	            // menu cannot be selectable in dropdown defaultly
	            var overlayProps = overlay && overlay.props;
	            var selectable = overlayProps && 'selectable' in overlayProps ? overlayProps.selectable : false;
	            var fixedModeOverlay = (0, _react.cloneElement)(overlay, {
	                mode: 'vertical',
	                selectable: selectable
	            });
	            return _react2['default'].createElement(
	                _rcDropdown2['default'],
	                (0, _extends3['default'])({}, this.props, { transitionName: this.getTransitionName(), trigger: disabled ? [] : trigger, overlay: fixedModeOverlay }),
	                dropdownTrigger
	            );
	        }
	    }]);
	    return Dropdown;
	}(_react2['default'].Component);
	
	exports['default'] = Dropdown;
	
	Dropdown.defaultProps = {
	    prefixCls: 'ant-dropdown',
	    mouseEnterDelay: 0.15,
	    mouseLeaveDelay: 0.1,
	    placement: 'bottomLeft'
	};
	module.exports = exports['default'];

/***/ }),
/* 168 */
/***/ (function(module, exports) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	var FIELD_META_PROP = exports.FIELD_META_PROP = 'data-__meta';

/***/ }),
/* 169 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _extends3 = __webpack_require__(2);
	
	var _extends4 = _interopRequireDefault(_extends3);
	
	var _typeof2 = __webpack_require__(21);
	
	var _typeof3 = _interopRequireDefault(_typeof2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var __rest = undefined && undefined.__rest || function (s, e) {
	    var t = {};
	    for (var p in s) {
	        if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
	    }if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	        if (e.indexOf(p[i]) < 0) t[p[i]] = s[p[i]];
	    }return t;
	};
	
	var stringOrNumber = _propTypes2['default'].oneOfType([_propTypes2['default'].string, _propTypes2['default'].number]);
	var objectOrNumber = _propTypes2['default'].oneOfType([_propTypes2['default'].object, _propTypes2['default'].number]);
	
	var Col = function (_React$Component) {
	    (0, _inherits3['default'])(Col, _React$Component);
	
	    function Col() {
	        (0, _classCallCheck3['default'])(this, Col);
	        return (0, _possibleConstructorReturn3['default'])(this, (Col.__proto__ || Object.getPrototypeOf(Col)).apply(this, arguments));
	    }
	
	    (0, _createClass3['default'])(Col, [{
	        key: 'render',
	        value: function render() {
	            var _classNames;
	
	            var props = this.props;
	
	            var span = props.span,
	                order = props.order,
	                offset = props.offset,
	                push = props.push,
	                pull = props.pull,
	                className = props.className,
	                children = props.children,
	                _props$prefixCls = props.prefixCls,
	                prefixCls = _props$prefixCls === undefined ? 'ant-col' : _props$prefixCls,
	                others = __rest(props, ["span", "order", "offset", "push", "pull", "className", "children", "prefixCls"]);
	
	            var sizeClassObj = {};
	            ['xs', 'sm', 'md', 'lg', 'xl'].forEach(function (size) {
	                var _extends2;
	
	                var sizeProps = {};
	                if (typeof props[size] === 'number') {
	                    sizeProps.span = props[size];
	                } else if ((0, _typeof3['default'])(props[size]) === 'object') {
	                    sizeProps = props[size] || {};
	                }
	                delete others[size];
	                sizeClassObj = (0, _extends4['default'])({}, sizeClassObj, (_extends2 = {}, (0, _defineProperty3['default'])(_extends2, prefixCls + '-' + size + '-' + sizeProps.span, sizeProps.span !== undefined), (0, _defineProperty3['default'])(_extends2, prefixCls + '-' + size + '-order-' + sizeProps.order, sizeProps.order || sizeProps.order === 0), (0, _defineProperty3['default'])(_extends2, prefixCls + '-' + size + '-offset-' + sizeProps.offset, sizeProps.offset || sizeProps.offset === 0), (0, _defineProperty3['default'])(_extends2, prefixCls + '-' + size + '-push-' + sizeProps.push, sizeProps.push || sizeProps.push === 0), (0, _defineProperty3['default'])(_extends2, prefixCls + '-' + size + '-pull-' + sizeProps.pull, sizeProps.pull || sizeProps.pull === 0), _extends2));
	            });
	            var classes = (0, _classnames2['default'])((_classNames = {}, (0, _defineProperty3['default'])(_classNames, prefixCls + '-' + span, span !== undefined), (0, _defineProperty3['default'])(_classNames, prefixCls + '-order-' + order, order), (0, _defineProperty3['default'])(_classNames, prefixCls + '-offset-' + offset, offset), (0, _defineProperty3['default'])(_classNames, prefixCls + '-push-' + push, push), (0, _defineProperty3['default'])(_classNames, prefixCls + '-pull-' + pull, pull), _classNames), className, sizeClassObj);
	            return _react2['default'].createElement(
	                'div',
	                (0, _extends4['default'])({}, others, { className: classes }),
	                children
	            );
	        }
	    }]);
	    return Col;
	}(_react2['default'].Component);
	
	exports['default'] = Col;
	
	Col.propTypes = {
	    span: stringOrNumber,
	    order: stringOrNumber,
	    offset: stringOrNumber,
	    push: stringOrNumber,
	    pull: stringOrNumber,
	    className: _propTypes2['default'].string,
	    children: _propTypes2['default'].node,
	    xs: objectOrNumber,
	    sm: objectOrNumber,
	    md: objectOrNumber,
	    lg: objectOrNumber,
	    xl: objectOrNumber
	};
	module.exports = exports['default'];

/***/ }),
/* 170 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.Col = exports.Row = undefined;
	
	var _row = __webpack_require__(171);
	
	var _row2 = _interopRequireDefault(_row);
	
	var _col = __webpack_require__(169);
	
	var _col2 = _interopRequireDefault(_col);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	exports.Row = _row2['default'];
	exports.Col = _col2['default'];

/***/ }),
/* 171 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var __rest = undefined && undefined.__rest || function (s, e) {
	    var t = {};
	    for (var p in s) {
	        if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
	    }if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	        if (e.indexOf(p[i]) < 0) t[p[i]] = s[p[i]];
	    }return t;
	};
	
	var Row = function (_React$Component) {
	    (0, _inherits3['default'])(Row, _React$Component);
	
	    function Row() {
	        (0, _classCallCheck3['default'])(this, Row);
	        return (0, _possibleConstructorReturn3['default'])(this, (Row.__proto__ || Object.getPrototypeOf(Row)).apply(this, arguments));
	    }
	
	    (0, _createClass3['default'])(Row, [{
	        key: 'render',
	        value: function render() {
	            var _classNames;
	
	            var _a = this.props,
	                type = _a.type,
	                justify = _a.justify,
	                align = _a.align,
	                className = _a.className,
	                gutter = _a.gutter,
	                style = _a.style,
	                children = _a.children,
	                _a$prefixCls = _a.prefixCls,
	                prefixCls = _a$prefixCls === undefined ? 'ant-row' : _a$prefixCls,
	                others = __rest(_a, ["type", "justify", "align", "className", "gutter", "style", "children", "prefixCls"]);
	            var classes = (0, _classnames2['default'])((_classNames = {}, (0, _defineProperty3['default'])(_classNames, prefixCls, !type), (0, _defineProperty3['default'])(_classNames, prefixCls + '-' + type, type), (0, _defineProperty3['default'])(_classNames, prefixCls + '-' + type + '-' + justify, type && justify), (0, _defineProperty3['default'])(_classNames, prefixCls + '-' + type + '-' + align, type && align), _classNames), className);
	            var rowStyle = gutter > 0 ? (0, _extends3['default'])({ marginLeft: gutter / -2, marginRight: gutter / -2 }, style) : style;
	            var cols = _react.Children.map(children, function (col) {
	                if (!col) {
	                    return null;
	                }
	                if (col.props && gutter > 0) {
	                    return (0, _react.cloneElement)(col, {
	                        style: (0, _extends3['default'])({ paddingLeft: gutter / 2, paddingRight: gutter / 2 }, col.props.style)
	                    });
	                }
	                return col;
	            });
	            return _react2['default'].createElement(
	                'div',
	                (0, _extends3['default'])({}, others, { className: classes, style: rowStyle }),
	                cols
	            );
	        }
	    }]);
	    return Row;
	}(_react2['default'].Component);
	
	exports['default'] = Row;
	
	Row.defaultProps = {
	    gutter: 0
	};
	Row.propTypes = {
	    type: _propTypes2['default'].string,
	    align: _propTypes2['default'].string,
	    justify: _propTypes2['default'].string,
	    className: _propTypes2['default'].string,
	    children: _propTypes2['default'].node,
	    gutter: _propTypes2['default'].number,
	    prefixCls: _propTypes2['default'].string
	};
	module.exports = exports['default'];

/***/ }),
/* 172 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _omit = __webpack_require__(28);
	
	var _omit2 = _interopRequireDefault(_omit);
	
	var _TextArea = __webpack_require__(173);
	
	var _TextArea2 = _interopRequireDefault(_TextArea);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function fixControlledValue(value) {
	    if (typeof value === 'undefined' || value === null) {
	        return '';
	    }
	    return value;
	}
	
	var Input = function (_Component) {
	    (0, _inherits3['default'])(Input, _Component);
	
	    function Input() {
	        (0, _classCallCheck3['default'])(this, Input);
	
	        var _this = (0, _possibleConstructorReturn3['default'])(this, (Input.__proto__ || Object.getPrototypeOf(Input)).apply(this, arguments));
	
	        _this.handleKeyDown = function (e) {
	            var _this$props = _this.props,
	                onPressEnter = _this$props.onPressEnter,
	                onKeyDown = _this$props.onKeyDown;
	
	            if (e.keyCode === 13 && onPressEnter) {
	                onPressEnter(e);
	            }
	            if (onKeyDown) {
	                onKeyDown(e);
	            }
	        };
	        return _this;
	    }
	
	    (0, _createClass3['default'])(Input, [{
	        key: 'focus',
	        value: function focus() {
	            this.refs.input.focus();
	        }
	    }, {
	        key: 'blur',
	        value: function blur() {
	            this.refs.input.blur();
	        }
	    }, {
	        key: 'getInputClassName',
	        value: function getInputClassName() {
	            var _classNames;
	
	            var _props = this.props,
	                prefixCls = _props.prefixCls,
	                size = _props.size,
	                disabled = _props.disabled;
	
	            return (0, _classnames2['default'])(prefixCls, (_classNames = {}, (0, _defineProperty3['default'])(_classNames, prefixCls + '-sm', size === 'small'), (0, _defineProperty3['default'])(_classNames, prefixCls + '-lg', size === 'large'), (0, _defineProperty3['default'])(_classNames, prefixCls + '-disabled', disabled), _classNames));
	        }
	    }, {
	        key: 'renderLabeledInput',
	        value: function renderLabeledInput(children) {
	            var _classNames3;
	
	            var props = this.props;
	            // Not wrap when there is not addons
	            if (!props.addonBefore && !props.addonAfter) {
	                return children;
	            }
	            var wrapperClassName = props.prefixCls + '-group';
	            var addonClassName = wrapperClassName + '-addon';
	            var addonBefore = props.addonBefore ? _react2['default'].createElement(
	                'span',
	                { className: addonClassName },
	                props.addonBefore
	            ) : null;
	            var addonAfter = props.addonAfter ? _react2['default'].createElement(
	                'span',
	                { className: addonClassName },
	                props.addonAfter
	            ) : null;
	            var className = (0, _classnames2['default'])(props.prefixCls + '-wrapper', (0, _defineProperty3['default'])({}, wrapperClassName, addonBefore || addonAfter));
	            var groupClassName = (0, _classnames2['default'])(props.prefixCls + '-group-wrapper', (_classNames3 = {}, (0, _defineProperty3['default'])(_classNames3, props.prefixCls + '-group-wrapper-sm', props.size === 'small'), (0, _defineProperty3['default'])(_classNames3, props.prefixCls + '-group-wrapper-lg', props.size === 'large'), _classNames3));
	            // Need another wrapper for changing display:table to display:inline-block
	            // and put style prop in wrapper
	            if (addonBefore || addonAfter) {
	                return _react2['default'].createElement(
	                    'span',
	                    { className: groupClassName, style: props.style },
	                    _react2['default'].createElement(
	                        'span',
	                        { className: className },
	                        addonBefore,
	                        (0, _react.cloneElement)(children, { style: null }),
	                        addonAfter
	                    )
	                );
	            }
	            return _react2['default'].createElement(
	                'span',
	                { className: className },
	                addonBefore,
	                children,
	                addonAfter
	            );
	        }
	    }, {
	        key: 'renderLabeledIcon',
	        value: function renderLabeledIcon(children) {
	            var props = this.props;
	
	            if (!('prefix' in props || 'suffix' in props)) {
	                return children;
	            }
	            var prefix = props.prefix ? _react2['default'].createElement(
	                'span',
	                { className: props.prefixCls + '-prefix' },
	                props.prefix
	            ) : null;
	            var suffix = props.suffix ? _react2['default'].createElement(
	                'span',
	                { className: props.prefixCls + '-suffix' },
	                props.suffix
	            ) : null;
	            return _react2['default'].createElement(
	                'span',
	                { className: (0, _classnames2['default'])(props.className, props.prefixCls + '-affix-wrapper'), style: props.style },
	                prefix,
	                (0, _react.cloneElement)(children, { style: null, className: this.getInputClassName() }),
	                suffix
	            );
	        }
	    }, {
	        key: 'renderInput',
	        value: function renderInput() {
	            var _props2 = this.props,
	                value = _props2.value,
	                className = _props2.className;
	            // Fix https://fb.me/react-unknown-prop
	
	            var otherProps = (0, _omit2['default'])(this.props, ['prefixCls', 'onPressEnter', 'addonBefore', 'addonAfter', 'prefix', 'suffix']);
	            if ('value' in this.props) {
	                otherProps.value = fixControlledValue(value);
	                // Input elements must be either controlled or uncontrolled,
	                // specify either the value prop, or the defaultValue prop, but not both.
	                delete otherProps.defaultValue;
	            }
	            return this.renderLabeledIcon(_react2['default'].createElement('input', (0, _extends3['default'])({}, otherProps, { className: (0, _classnames2['default'])(this.getInputClassName(), className), onKeyDown: this.handleKeyDown, ref: 'input' })));
	        }
	    }, {
	        key: 'render',
	        value: function render() {
	            if (this.props.type === 'textarea') {
	                return _react2['default'].createElement(_TextArea2['default'], (0, _extends3['default'])({}, this.props, { ref: 'input' }));
	            }
	            return this.renderLabeledInput(this.renderInput());
	        }
	    }]);
	    return Input;
	}(_react.Component);
	
	exports['default'] = Input;
	
	Input.defaultProps = {
	    prefixCls: 'ant-input',
	    type: 'text',
	    disabled: false
	};
	Input.propTypes = {
	    type: _propTypes2['default'].string,
	    id: _propTypes2['default'].oneOfType([_propTypes2['default'].string, _propTypes2['default'].number]),
	    size: _propTypes2['default'].oneOf(['small', 'default', 'large']),
	    maxLength: _propTypes2['default'].string,
	    disabled: _propTypes2['default'].bool,
	    value: _propTypes2['default'].any,
	    defaultValue: _propTypes2['default'].any,
	    className: _propTypes2['default'].string,
	    addonBefore: _propTypes2['default'].node,
	    addonAfter: _propTypes2['default'].node,
	    prefixCls: _propTypes2['default'].string,
	    autosize: _propTypes2['default'].oneOfType([_propTypes2['default'].bool, _propTypes2['default'].object]),
	    onPressEnter: _propTypes2['default'].func,
	    onKeyDown: _propTypes2['default'].func,
	    onFocus: _propTypes2['default'].func,
	    onBlur: _propTypes2['default'].func,
	    prefix: _propTypes2['default'].node,
	    suffix: _propTypes2['default'].node
	};
	module.exports = exports['default'];

/***/ }),
/* 173 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _omit = __webpack_require__(28);
	
	var _omit2 = _interopRequireDefault(_omit);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _calculateNodeHeight = __webpack_require__(354);
	
	var _calculateNodeHeight2 = _interopRequireDefault(_calculateNodeHeight);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function onNextFrame(cb) {
	    if (window.requestAnimationFrame) {
	        return window.requestAnimationFrame(cb);
	    }
	    return window.setTimeout(cb, 1);
	}
	function clearNextFrameAction(nextFrameId) {
	    if (window.cancelAnimationFrame) {
	        window.cancelAnimationFrame(nextFrameId);
	    } else {
	        window.clearTimeout(nextFrameId);
	    }
	}
	
	var TextArea = function (_React$Component) {
	    (0, _inherits3['default'])(TextArea, _React$Component);
	
	    function TextArea() {
	        (0, _classCallCheck3['default'])(this, TextArea);
	
	        var _this = (0, _possibleConstructorReturn3['default'])(this, (TextArea.__proto__ || Object.getPrototypeOf(TextArea)).apply(this, arguments));
	
	        _this.state = {
	            textareaStyles: null
	        };
	        _this.resizeTextarea = function () {
	            var autosize = _this.props.autosize;
	
	            if (!autosize || !_this.textAreaRef) {
	                return;
	            }
	            var minRows = autosize ? autosize.minRows : null;
	            var maxRows = autosize ? autosize.maxRows : null;
	            var textareaStyles = (0, _calculateNodeHeight2['default'])(_this.textAreaRef, false, minRows, maxRows);
	            _this.setState({ textareaStyles: textareaStyles });
	        };
	        _this.handleTextareaChange = function (e) {
	            if (!('value' in _this.props)) {
	                _this.resizeTextarea();
	            }
	            var onChange = _this.props.onChange;
	
	            if (onChange) {
	                onChange(e);
	            }
	        };
	        _this.handleKeyDown = function (e) {
	            var _this$props = _this.props,
	                onPressEnter = _this$props.onPressEnter,
	                onKeyDown = _this$props.onKeyDown;
	
	            if (e.keyCode === 13 && onPressEnter) {
	                onPressEnter(e);
	            }
	            if (onKeyDown) {
	                onKeyDown(e);
	            }
	        };
	        _this.saveTextAreaRef = function (textArea) {
	            _this.textAreaRef = textArea;
	        };
	        return _this;
	    }
	
	    (0, _createClass3['default'])(TextArea, [{
	        key: 'componentDidMount',
	        value: function componentDidMount() {
	            this.resizeTextarea();
	        }
	    }, {
	        key: 'componentWillReceiveProps',
	        value: function componentWillReceiveProps(nextProps) {
	            // Re-render with the new content then recalculate the height as required.
	            if (this.props.value !== nextProps.value) {
	                if (this.nextFrameActionId) {
	                    clearNextFrameAction(this.nextFrameActionId);
	                }
	                this.nextFrameActionId = onNextFrame(this.resizeTextarea);
	            }
	        }
	    }, {
	        key: 'focus',
	        value: function focus() {
	            this.textAreaRef.focus();
	        }
	    }, {
	        key: 'blur',
	        value: function blur() {
	            this.textAreaRef.blur();
	        }
	    }, {
	        key: 'getTextAreaClassName',
	        value: function getTextAreaClassName() {
	            var _props = this.props,
	                prefixCls = _props.prefixCls,
	                className = _props.className,
	                disabled = _props.disabled;
	
	            return (0, _classnames2['default'])(prefixCls, className, (0, _defineProperty3['default'])({}, prefixCls + '-disabled', disabled));
	        }
	    }, {
	        key: 'render',
	        value: function render() {
	            var props = this.props;
	            var otherProps = (0, _omit2['default'])(props, ['prefixCls', 'onPressEnter', 'autosize']);
	            var style = (0, _extends3['default'])({}, props.style, this.state.textareaStyles);
	            // Fix https://github.com/ant-design/ant-design/issues/6776
	            // Make sure it could be reset when using form.getFieldDecorator
	            if ('value' in otherProps) {
	                otherProps.value = otherProps.value || '';
	            }
	            return _react2['default'].createElement('textarea', (0, _extends3['default'])({}, otherProps, { className: this.getTextAreaClassName(), style: style, onKeyDown: this.handleKeyDown, onChange: this.handleTextareaChange, ref: this.saveTextAreaRef }));
	        }
	    }]);
	    return TextArea;
	}(_react2['default'].Component);
	
	exports['default'] = TextArea;
	
	TextArea.defaultProps = {
	    prefixCls: 'ant-input'
	};
	module.exports = exports['default'];

/***/ }),
/* 174 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _rcMenu = __webpack_require__(77);
	
	var _rcMenu2 = _interopRequireDefault(_rcMenu);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _openAnimation = __webpack_require__(101);
	
	var _openAnimation2 = _interopRequireDefault(_openAnimation);
	
	var _warning = __webpack_require__(24);
	
	var _warning2 = _interopRequireDefault(_warning);
	
	var _MenuItem = __webpack_require__(360);
	
	var _MenuItem2 = _interopRequireDefault(_MenuItem);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var Menu = function (_React$Component) {
	    (0, _inherits3['default'])(Menu, _React$Component);
	
	    function Menu(props) {
	        (0, _classCallCheck3['default'])(this, Menu);
	
	        var _this = (0, _possibleConstructorReturn3['default'])(this, (Menu.__proto__ || Object.getPrototypeOf(Menu)).call(this, props));
	
	        _this.inlineOpenKeys = [];
	        _this.handleClick = function (e) {
	            _this.handleOpenChange([]);
	            var onClick = _this.props.onClick;
	
	            if (onClick) {
	                onClick(e);
	            }
	        };
	        _this.handleOpenChange = function (openKeys) {
	            _this.setOpenKeys(openKeys);
	            var onOpenChange = _this.props.onOpenChange;
	
	            if (onOpenChange) {
	                onOpenChange(openKeys);
	            }
	        };
	        (0, _warning2['default'])(!('onOpen' in props || 'onClose' in props), '`onOpen` and `onClose` are removed, please use `onOpenChange` instead, ' + 'see: https://u.ant.design/menu-on-open-change.');
	        (0, _warning2['default'])(!('inlineCollapsed' in props && props.mode !== 'inline'), '`inlineCollapsed` should only be used when Menu\'s `mode` is inline.');
	        var openKeys = void 0;
	        if ('defaultOpenKeys' in props) {
	            openKeys = props.defaultOpenKeys;
	        } else if ('openKeys' in props) {
	            openKeys = props.openKeys;
	        }
	        _this.state = {
	            openKeys: openKeys || []
	        };
	        return _this;
	    }
	
	    (0, _createClass3['default'])(Menu, [{
	        key: 'getChildContext',
	        value: function getChildContext() {
	            return {
	                inlineCollapsed: this.getInlineCollapsed()
	            };
	        }
	    }, {
	        key: 'componentWillReceiveProps',
	        value: function componentWillReceiveProps(nextProps, nextContext) {
	            if (this.props.mode === 'inline' && nextProps.mode !== 'inline') {
	                this.switchModeFromInline = true;
	            }
	            if ('openKeys' in nextProps) {
	                this.setState({ openKeys: nextProps.openKeys });
	                return;
	            }
	            if (nextProps.inlineCollapsed && !this.props.inlineCollapsed || nextContext.siderCollapsed && !this.context.siderCollapsed) {
	                this.switchModeFromInline = !!this.state.openKeys.length;
	                this.inlineOpenKeys = this.state.openKeys;
	                this.setState({ openKeys: [] });
	            }
	            if (!nextProps.inlineCollapsed && this.props.inlineCollapsed || !nextContext.siderCollapsed && this.context.siderCollapsed) {
	                this.setState({ openKeys: this.inlineOpenKeys });
	                this.inlineOpenKeys = [];
	            }
	        }
	    }, {
	        key: 'setOpenKeys',
	        value: function setOpenKeys(openKeys) {
	            if (!('openKeys' in this.props)) {
	                this.setState({ openKeys: openKeys });
	            }
	        }
	    }, {
	        key: 'getRealMenuMode',
	        value: function getRealMenuMode() {
	            var inlineCollapsed = this.getInlineCollapsed();
	            if (this.switchModeFromInline && inlineCollapsed && this.leaveAnimationExecutedWhenInlineCollapsed) {
	                this.leaveAnimationExecutedWhenInlineCollapsed = false;
	                return 'inline';
	            }
	            var mode = this.props.mode;
	
	            return inlineCollapsed ? 'vertical' : mode;
	        }
	    }, {
	        key: 'getInlineCollapsed',
	        value: function getInlineCollapsed() {
	            var inlineCollapsed = this.props.inlineCollapsed;
	
	            if (this.context.siderCollapsed !== undefined) {
	                return this.context.siderCollapsed;
	            }
	            return inlineCollapsed;
	        }
	    }, {
	        key: 'getMenuOpenAnimation',
	        value: function getMenuOpenAnimation(menuMode) {
	            var _this2 = this;
	
	            var _props = this.props,
	                openAnimation = _props.openAnimation,
	                openTransitionName = _props.openTransitionName;
	
	            var menuOpenAnimation = openAnimation || openTransitionName;
	            if (openAnimation === undefined && openTransitionName === undefined) {
	                switch (menuMode) {
	                    case 'horizontal':
	                        menuOpenAnimation = 'slide-up';
	                        break;
	                    case 'vertical':
	                        // When mode switch from inline
	                        // submenu should hide without animation
	                        if (this.switchModeFromInline) {
	                            menuOpenAnimation = '';
	                            this.switchModeFromInline = false;
	                        } else {
	                            menuOpenAnimation = 'zoom-big';
	                        }
	                        break;
	                    case 'inline':
	                        menuOpenAnimation = (0, _extends3['default'])({}, _openAnimation2['default'], { leave: function leave(node, done) {
	                                return _openAnimation2['default'].leave(node, function () {
	                                    // Make sure inline menu leave animation finished before mode is switched
	                                    _this2.switchModeFromInline = false;
	                                    // Fix https://github.com/ant-design/ant-design/issues/8475
	                                    _this2.leaveAnimationExecutedWhenInlineCollapsed = true;
	                                    _this2.setState({});
	                                    done();
	                                });
	                            } });
	                        break;
	                    default:
	                }
	            }
	            return menuOpenAnimation;
	        }
	    }, {
	        key: 'render',
	        value: function render() {
	            var _props2 = this.props,
	                prefixCls = _props2.prefixCls,
	                className = _props2.className,
	                theme = _props2.theme;
	
	            var menuMode = this.getRealMenuMode();
	            var menuOpenAnimation = this.getMenuOpenAnimation(menuMode);
	            var menuClassName = (0, _classnames2['default'])(className, prefixCls + '-' + theme, (0, _defineProperty3['default'])({}, prefixCls + '-inline-collapsed', this.getInlineCollapsed()));
	            var menuProps = {
	                openKeys: this.state.openKeys,
	                onOpenChange: this.handleOpenChange,
	                className: menuClassName,
	                mode: menuMode
	            };
	            if (menuMode !== 'inline') {
	                // closing vertical popup submenu after click it
	                menuProps.onClick = this.handleClick;
	                menuProps.openTransitionName = menuOpenAnimation;
	            } else {
	                menuProps.openAnimation = menuOpenAnimation;
	            }
	            return _react2['default'].createElement(_rcMenu2['default'], (0, _extends3['default'])({}, this.props, menuProps));
	        }
	    }]);
	    return Menu;
	}(_react2['default'].Component);
	
	exports['default'] = Menu;
	
	Menu.Divider = _rcMenu.Divider;
	Menu.Item = _MenuItem2['default'];
	Menu.SubMenu = _rcMenu.SubMenu;
	Menu.ItemGroup = _rcMenu.ItemGroup;
	Menu.defaultProps = {
	    prefixCls: 'ant-menu',
	    className: '',
	    theme: 'light'
	};
	Menu.childContextTypes = {
	    inlineCollapsed: _propTypes2['default'].bool
	};
	Menu.contextTypes = {
	    siderCollapsed: _propTypes2['default'].bool
	};
	module.exports = exports['default'];

/***/ }),
/* 175 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _rcDialog = __webpack_require__(680);
	
	var _rcDialog2 = _interopRequireDefault(_rcDialog);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _addEventListener = __webpack_require__(34);
	
	var _addEventListener2 = _interopRequireDefault(_addEventListener);
	
	var _button = __webpack_require__(54);
	
	var _button2 = _interopRequireDefault(_button);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var mousePosition = void 0;
	var mousePositionEventBinded = void 0;
	
	var Modal = function (_React$Component) {
	    (0, _inherits3['default'])(Modal, _React$Component);
	
	    function Modal() {
	        (0, _classCallCheck3['default'])(this, Modal);
	
	        var _this = (0, _possibleConstructorReturn3['default'])(this, (Modal.__proto__ || Object.getPrototypeOf(Modal)).apply(this, arguments));
	
	        _this.handleCancel = function (e) {
	            var onCancel = _this.props.onCancel;
	            if (onCancel) {
	                onCancel(e);
	            }
	        };
	        _this.handleOk = function (e) {
	            var onOk = _this.props.onOk;
	            if (onOk) {
	                onOk(e);
	            }
	        };
	        return _this;
	    }
	
	    (0, _createClass3['default'])(Modal, [{
	        key: 'componentDidMount',
	        value: function componentDidMount() {
	            if (mousePositionEventBinded) {
	                return;
	            }
	            // 只有点击事件支持从鼠标位置动画展开
	            (0, _addEventListener2['default'])(document.documentElement, 'click', function (e) {
	                mousePosition = {
	                    x: e.pageX,
	                    y: e.pageY
	                };
	                // 100ms 内发生过点击事件，则从点击位置动画展示
	                // 否则直接 zoom 展示
	                // 这样可以兼容非点击方式展开
	                setTimeout(function () {
	                    return mousePosition = null;
	                }, 100);
	            });
	            mousePositionEventBinded = true;
	        }
	    }, {
	        key: 'render',
	        value: function render() {
	            var _props = this.props,
	                okText = _props.okText,
	                okType = _props.okType,
	                cancelText = _props.cancelText,
	                confirmLoading = _props.confirmLoading,
	                footer = _props.footer,
	                visible = _props.visible;
	
	            if (this.context.antLocale && this.context.antLocale.Modal) {
	                okText = okText || this.context.antLocale.Modal.okText;
	                cancelText = cancelText || this.context.antLocale.Modal.cancelText;
	            }
	            var defaultFooter = [_react2['default'].createElement(
	                _button2['default'],
	                { key: 'cancel', size: 'large', onClick: this.handleCancel },
	                cancelText || '取消'
	            ), _react2['default'].createElement(
	                _button2['default'],
	                { key: 'confirm', type: okType, size: 'large', loading: confirmLoading, onClick: this.handleOk },
	                okText || '确定'
	            )];
	            return _react2['default'].createElement(_rcDialog2['default'], (0, _extends3['default'])({}, this.props, { footer: footer === undefined ? defaultFooter : footer, visible: visible, mousePosition: mousePosition, onClose: this.handleCancel }));
	        }
	    }]);
	    return Modal;
	}(_react2['default'].Component);
	
	exports['default'] = Modal;
	
	Modal.defaultProps = {
	    prefixCls: 'ant-modal',
	    width: 520,
	    transitionName: 'zoom',
	    maskTransitionName: 'fade',
	    confirmLoading: false,
	    visible: false,
	    okType: 'primary'
	};
	Modal.propTypes = {
	    prefixCls: _propTypes2['default'].string,
	    onOk: _propTypes2['default'].func,
	    onCancel: _propTypes2['default'].func,
	    okText: _propTypes2['default'].node,
	    cancelText: _propTypes2['default'].node,
	    width: _propTypes2['default'].oneOfType([_propTypes2['default'].number, _propTypes2['default'].string]),
	    confirmLoading: _propTypes2['default'].bool,
	    visible: _propTypes2['default'].bool,
	    align: _propTypes2['default'].object,
	    footer: _propTypes2['default'].node,
	    title: _propTypes2['default'].node,
	    closable: _propTypes2['default'].bool
	};
	Modal.contextTypes = {
	    antLocale: _propTypes2['default'].object
	};
	module.exports = exports['default'];

/***/ }),
/* 176 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	exports.changeConfirmLocale = changeConfirmLocale;
	exports.getConfirmLocale = getConfirmLocale;
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var defaultLocale = {
	    okText: '确定',
	    cancelText: '取消',
	    justOkText: '知道了'
	};
	var runtimeLocale = (0, _extends3['default'])({}, defaultLocale);
	function changeConfirmLocale(newLocale) {
	    if (newLocale) {
	        runtimeLocale = (0, _extends3['default'])({}, runtimeLocale, newLocale);
	    } else {
	        runtimeLocale = (0, _extends3['default'])({}, defaultLocale);
	    }
	}
	function getConfirmLocale() {
	    return runtimeLocale;
	}

/***/ }),
/* 177 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.PaginationProps = undefined;
	
	var _Pagination = __webpack_require__(367);
	
	Object.defineProperty(exports, 'PaginationProps', {
	  enumerable: true,
	  get: function get() {
	    return _Pagination.PaginationProps;
	  }
	});
	
	var _Pagination2 = _interopRequireDefault(_Pagination);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	exports['default'] = _Pagination2['default'];

/***/ }),
/* 178 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _progress = __webpack_require__(370);
	
	var _progress2 = _interopRequireDefault(_progress);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	exports['default'] = _progress2['default'];
	module.exports = exports['default'];

/***/ }),
/* 179 */
[1079, 1008],
/* 180 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _rcAnimate = __webpack_require__(22);
	
	var _rcAnimate2 = _interopRequireDefault(_rcAnimate);
	
	var _isCssAnimationSupported = __webpack_require__(314);
	
	var _isCssAnimationSupported2 = _interopRequireDefault(_isCssAnimationSupported);
	
	var _omit = __webpack_require__(28);
	
	var _omit2 = _interopRequireDefault(_omit);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var __rest = undefined && undefined.__rest || function (s, e) {
	    var t = {};
	    for (var p in s) {
	        if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
	    }if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	        if (e.indexOf(p[i]) < 0) t[p[i]] = s[p[i]];
	    }return t;
	};
	
	var Spin = function (_React$Component) {
	    (0, _inherits3['default'])(Spin, _React$Component);
	
	    function Spin(props) {
	        (0, _classCallCheck3['default'])(this, Spin);
	
	        var _this = (0, _possibleConstructorReturn3['default'])(this, (Spin.__proto__ || Object.getPrototypeOf(Spin)).call(this, props));
	
	        var spinning = props.spinning;
	        _this.state = {
	            spinning: spinning
	        };
	        return _this;
	    }
	
	    (0, _createClass3['default'])(Spin, [{
	        key: 'isNestedPattern',
	        value: function isNestedPattern() {
	            return !!(this.props && this.props.children);
	        }
	    }, {
	        key: 'componentDidMount',
	        value: function componentDidMount() {
	            if (!(0, _isCssAnimationSupported2['default'])()) {
	                // Show text in IE8/9
	                this.setState({
	                    notCssAnimationSupported: true
	                });
	            }
	        }
	    }, {
	        key: 'componentWillUnmount',
	        value: function componentWillUnmount() {
	            if (this.debounceTimeout) {
	                clearTimeout(this.debounceTimeout);
	            }
	            if (this.delayTimeout) {
	                clearTimeout(this.delayTimeout);
	            }
	        }
	    }, {
	        key: 'componentWillReceiveProps',
	        value: function componentWillReceiveProps(nextProps) {
	            var _this2 = this;
	
	            var currentSpinning = this.props.spinning;
	            var spinning = nextProps.spinning;
	            var delay = this.props.delay;
	
	            if (this.debounceTimeout) {
	                clearTimeout(this.debounceTimeout);
	            }
	            if (currentSpinning && !spinning) {
	                this.debounceTimeout = setTimeout(function () {
	                    return _this2.setState({ spinning: spinning });
	                }, 200);
	                if (this.delayTimeout) {
	                    clearTimeout(this.delayTimeout);
	                }
	            } else {
	                if (spinning && delay && !isNaN(Number(delay))) {
	                    if (this.delayTimeout) {
	                        clearTimeout(this.delayTimeout);
	                    }
	                    this.delayTimeout = setTimeout(function () {
	                        return _this2.setState({ spinning: spinning });
	                    }, delay);
	                } else {
	                    this.setState({ spinning: spinning });
	                }
	            }
	        }
	    }, {
	        key: 'render',
	        value: function render() {
	            var _classNames;
	
	            var _a = this.props,
	                className = _a.className,
	                size = _a.size,
	                prefixCls = _a.prefixCls,
	                tip = _a.tip,
	                wrapperClassName = _a.wrapperClassName,
	                restProps = __rest(_a, ["className", "size", "prefixCls", "tip", "wrapperClassName"]);var _state = this.state,
	                spinning = _state.spinning,
	                notCssAnimationSupported = _state.notCssAnimationSupported;
	
	            var spinClassName = (0, _classnames2['default'])(prefixCls, (_classNames = {}, (0, _defineProperty3['default'])(_classNames, prefixCls + '-sm', size === 'small'), (0, _defineProperty3['default'])(_classNames, prefixCls + '-lg', size === 'large'), (0, _defineProperty3['default'])(_classNames, prefixCls + '-spinning', spinning), (0, _defineProperty3['default'])(_classNames, prefixCls + '-show-text', !!tip || notCssAnimationSupported), _classNames), className);
	            // fix https://fb.me/react-unknown-prop
	            var divProps = (0, _omit2['default'])(restProps, ['spinning', 'delay']);
	            var spinElement = _react2['default'].createElement(
	                'div',
	                (0, _extends3['default'])({}, divProps, { className: spinClassName }),
	                _react2['default'].createElement(
	                    'span',
	                    { className: prefixCls + '-dot' },
	                    _react2['default'].createElement('i', null),
	                    _react2['default'].createElement('i', null),
	                    _react2['default'].createElement('i', null),
	                    _react2['default'].createElement('i', null)
	                ),
	                tip ? _react2['default'].createElement(
	                    'div',
	                    { className: prefixCls + '-text' },
	                    tip
	                ) : null
	            );
	            if (this.isNestedPattern()) {
	                var _classNames2;
	
	                var animateClassName = prefixCls + '-nested-loading';
	                if (wrapperClassName) {
	                    animateClassName += ' ' + wrapperClassName;
	                }
	                var containerClassName = (0, _classnames2['default'])((_classNames2 = {}, (0, _defineProperty3['default'])(_classNames2, prefixCls + '-container', true), (0, _defineProperty3['default'])(_classNames2, prefixCls + '-blur', spinning), _classNames2));
	                return _react2['default'].createElement(
	                    _rcAnimate2['default'],
	                    (0, _extends3['default'])({}, divProps, { component: 'div', className: animateClassName, style: null, transitionName: 'fade' }),
	                    spinning && _react2['default'].createElement(
	                        'div',
	                        { key: 'loading' },
	                        spinElement
	                    ),
	                    _react2['default'].createElement(
	                        'div',
	                        { className: containerClassName, key: 'container' },
	                        this.props.children
	                    )
	                );
	            }
	            return spinElement;
	        }
	    }]);
	    return Spin;
	}(_react2['default'].Component);
	
	exports['default'] = Spin;
	
	Spin.defaultProps = {
	    prefixCls: 'ant-spin',
	    spinning: true,
	    size: 'default',
	    wrapperClassName: ''
	};
	Spin.propTypes = {
	    prefixCls: _propTypes2['default'].string,
	    className: _propTypes2['default'].string,
	    spinning: _propTypes2['default'].bool,
	    size: _propTypes2['default'].oneOf(['small', 'default', 'large']),
	    wrapperClassName: _propTypes2['default'].string
	};
	module.exports = exports['default'];

/***/ }),
/* 181 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	exports.generateShowHourMinuteSecond = generateShowHourMinuteSecond;
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _moment = __webpack_require__(13);
	
	var _moment2 = _interopRequireDefault(_moment);
	
	var _TimePicker = __webpack_require__(768);
	
	var _TimePicker2 = _interopRequireDefault(_TimePicker);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _injectLocale = __webpack_require__(67);
	
	var _injectLocale2 = _interopRequireDefault(_injectLocale);
	
	var _zh_CN = __webpack_require__(182);
	
	var _zh_CN2 = _interopRequireDefault(_zh_CN);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function generateShowHourMinuteSecond(format) {
	    // Ref: http://momentjs.com/docs/#/parsing/string-format/
	    return {
	        showHour: format.indexOf('H') > -1 || format.indexOf('h') > -1 || format.indexOf('k') > -1,
	        showMinute: format.indexOf('m') > -1,
	        showSecond: format.indexOf('s') > -1
	    };
	}
	
	var TimePicker = function (_React$Component) {
	    (0, _inherits3['default'])(TimePicker, _React$Component);
	
	    function TimePicker(props) {
	        (0, _classCallCheck3['default'])(this, TimePicker);
	
	        var _this = (0, _possibleConstructorReturn3['default'])(this, (TimePicker.__proto__ || Object.getPrototypeOf(TimePicker)).call(this, props));
	
	        _this.handleChange = function (value) {
	            if (!('value' in _this.props)) {
	                _this.setState({ value: value });
	            }
	            var _this$props = _this.props,
	                onChange = _this$props.onChange,
	                _this$props$format = _this$props.format,
	                format = _this$props$format === undefined ? 'HH:mm:ss' : _this$props$format;
	
	            if (onChange) {
	                onChange(value, value && value.format(format) || '');
	            }
	        };
	        _this.handleOpenClose = function (_ref) {
	            var open = _ref.open;
	            var onOpenChange = _this.props.onOpenChange;
	
	            if (onOpenChange) {
	                onOpenChange(open);
	            }
	        };
	        _this.saveTimePicker = function (timePickerRef) {
	            _this.timePickerRef = timePickerRef;
	        };
	        var value = props.value || props.defaultValue;
	        if (value && !_moment2['default'].isMoment(value)) {
	            throw new Error('The value/defaultValue of TimePicker must be a moment object after `antd@2.0`, ' + 'see: https://u.ant.design/time-picker-value');
	        }
	        _this.state = {
	            value: value
	        };
	        return _this;
	    }
	
	    (0, _createClass3['default'])(TimePicker, [{
	        key: 'componentWillReceiveProps',
	        value: function componentWillReceiveProps(nextProps) {
	            if ('value' in nextProps) {
	                this.setState({ value: nextProps.value });
	            }
	        }
	    }, {
	        key: 'focus',
	        value: function focus() {
	            this.timePickerRef.focus();
	        }
	    }, {
	        key: 'getDefaultFormat',
	        value: function getDefaultFormat() {
	            var _props = this.props,
	                format = _props.format,
	                use12Hours = _props.use12Hours;
	
	            if (format) {
	                return format;
	            } else if (use12Hours) {
	                return 'h:mm:ss a';
	            }
	            return 'HH:mm:ss';
	        }
	    }, {
	        key: 'render',
	        value: function render() {
	            var props = (0, _extends3['default'])({}, this.props);
	            delete props.defaultValue;
	            var format = this.getDefaultFormat();
	            var className = (0, _classnames2['default'])(props.className, (0, _defineProperty3['default'])({}, props.prefixCls + '-' + props.size, !!props.size));
	            var addon = function addon(panel) {
	                return props.addon ? _react2['default'].createElement(
	                    'div',
	                    { className: props.prefixCls + '-panel-addon' },
	                    props.addon(panel)
	                ) : null;
	            };
	            return _react2['default'].createElement(_TimePicker2['default'], (0, _extends3['default'])({}, generateShowHourMinuteSecond(format), props, { ref: this.saveTimePicker, format: format, className: className, value: this.state.value, placeholder: props.placeholder === undefined ? this.getLocale().placeholder : props.placeholder, onChange: this.handleChange, onOpen: this.handleOpenClose, onClose: this.handleOpenClose, addon: addon }));
	        }
	    }]);
	    return TimePicker;
	}(_react2['default'].Component);
	
	TimePicker.defaultProps = {
	    prefixCls: 'ant-time-picker',
	    align: {
	        offset: [0, -2]
	    },
	    disabled: false,
	    disabledHours: undefined,
	    disabledMinutes: undefined,
	    disabledSeconds: undefined,
	    hideDisabledOptions: false,
	    placement: 'bottomLeft',
	    transitionName: 'slide-up'
	};
	var injectTimePickerLocale = (0, _injectLocale2['default'])('TimePicker', _zh_CN2['default']);
	exports['default'] = injectTimePickerLocale(TimePicker);

/***/ }),
/* 182 */
/***/ (function(module, exports) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	var locale = {
	    placeholder: '请选择时间'
	};
	exports['default'] = locale;
	module.exports = exports['default'];

/***/ }),
/* 183 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _icon = __webpack_require__(16);
	
	var _icon2 = _interopRequireDefault(_icon);
	
	var _input = __webpack_require__(81);
	
	var _input2 = _interopRequireDefault(_input);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var Search = function (_React$Component) {
	    (0, _inherits3['default'])(Search, _React$Component);
	
	    function Search() {
	        (0, _classCallCheck3['default'])(this, Search);
	
	        var _this = (0, _possibleConstructorReturn3['default'])(this, (Search.__proto__ || Object.getPrototypeOf(Search)).apply(this, arguments));
	
	        _this.handleChange = function (e) {
	            var onChange = _this.props.onChange;
	            if (onChange) {
	                onChange(e);
	            }
	        };
	        _this.handleClear = function (e) {
	            e.preventDefault();
	            var handleClear = _this.props.handleClear;
	            if (handleClear) {
	                handleClear(e);
	            }
	        };
	        return _this;
	    }
	
	    (0, _createClass3['default'])(Search, [{
	        key: 'render',
	        value: function render() {
	            var _props = this.props,
	                placeholder = _props.placeholder,
	                value = _props.value,
	                prefixCls = _props.prefixCls;
	
	            var icon = value && value.length > 0 ? _react2['default'].createElement(
	                'a',
	                { href: '#', className: prefixCls + '-action', onClick: this.handleClear },
	                _react2['default'].createElement(_icon2['default'], { type: 'cross-circle' })
	            ) : _react2['default'].createElement(
	                'span',
	                { className: prefixCls + '-action' },
	                _react2['default'].createElement(_icon2['default'], { type: 'search' })
	            );
	            return _react2['default'].createElement(
	                'div',
	                null,
	                _react2['default'].createElement(_input2['default'], { placeholder: placeholder, className: prefixCls, value: value, ref: 'input', onChange: this.handleChange }),
	                icon
	            );
	        }
	    }]);
	    return Search;
	}(_react2['default'].Component);
	
	exports['default'] = Search;
	
	Search.defaultProps = {
	    placeholder: ''
	};
	module.exports = exports['default'];

/***/ }),
/* 184 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	exports.UploadProps = undefined;
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _rcUpload = __webpack_require__(786);
	
	var _rcUpload2 = _interopRequireDefault(_rcUpload);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _lodash = __webpack_require__(581);
	
	var _lodash2 = _interopRequireDefault(_lodash);
	
	var _UploadList = __webpack_require__(405);
	
	var _UploadList2 = _interopRequireDefault(_UploadList);
	
	var _interface = __webpack_require__(407);
	
	var _utils = __webpack_require__(408);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var defaultLocale = {
	    uploading: '文件上传中',
	    removeFile: '删除文件',
	    uploadError: '上传错误',
	    previewFile: '预览文件'
	};
	exports.UploadProps = _interface.UploadProps;
	
	var Upload = function (_React$Component) {
	    (0, _inherits3['default'])(Upload, _React$Component);
	
	    function Upload(props) {
	        (0, _classCallCheck3['default'])(this, Upload);
	
	        var _this = (0, _possibleConstructorReturn3['default'])(this, (Upload.__proto__ || Object.getPrototypeOf(Upload)).call(this, props));
	
	        _this.onStart = function (file) {
	            var targetItem = void 0;
	            var nextFileList = _this.state.fileList.concat();
	            if (file.length > 0) {
	                targetItem = file.map(function (f) {
	                    var fileObject = (0, _utils.fileToObject)(f);
	                    fileObject.status = 'uploading';
	                    return fileObject;
	                });
	                nextFileList = nextFileList.concat(targetItem);
	            } else {
	                targetItem = (0, _utils.fileToObject)(file);
	                targetItem.status = 'uploading';
	                nextFileList.push(targetItem);
	            }
	            _this.onChange({
	                file: targetItem,
	                fileList: nextFileList
	            });
	            // fix ie progress
	            if (!window.FormData) {
	                _this.autoUpdateProgress(0, targetItem);
	            }
	        };
	        _this.onSuccess = function (response, file) {
	            _this.clearProgressTimer();
	            try {
	                if (typeof response === 'string') {
	                    response = JSON.parse(response);
	                }
	            } catch (e) {}
	            var fileList = _this.state.fileList;
	            var targetItem = (0, _utils.getFileItem)(file, fileList);
	            // removed
	            if (!targetItem) {
	                return;
	            }
	            targetItem.status = 'done';
	            targetItem.response = response;
	            _this.onChange({
	                file: (0, _extends3['default'])({}, targetItem),
	                fileList: fileList
	            });
	        };
	        _this.onProgress = function (e, file) {
	            var fileList = _this.state.fileList;
	            var targetItem = (0, _utils.getFileItem)(file, fileList);
	            // removed
	            if (!targetItem) {
	                return;
	            }
	            targetItem.percent = e.percent;
	            _this.onChange({
	                event: e,
	                file: (0, _extends3['default'])({}, targetItem),
	                fileList: _this.state.fileList
	            });
	        };
	        _this.onError = function (error, response, file) {
	            _this.clearProgressTimer();
	            var fileList = _this.state.fileList;
	            var targetItem = (0, _utils.getFileItem)(file, fileList);
	            // removed
	            if (!targetItem) {
	                return;
	            }
	            targetItem.error = error;
	            targetItem.response = response;
	            targetItem.status = 'error';
	            _this.onChange({
	                file: (0, _extends3['default'])({}, targetItem),
	                fileList: fileList
	            });
	        };
	        _this.handleManualRemove = function (file) {
	            _this.refs.upload.abort(file);
	            file.status = 'removed'; // eslint-disable-line
	            _this.handleRemove(file);
	        };
	        _this.onChange = function (info) {
	            if (!('fileList' in _this.props)) {
	                _this.setState({ fileList: info.fileList });
	            }
	            var onChange = _this.props.onChange;
	
	            if (onChange) {
	                onChange(info);
	            }
	        };
	        _this.onFileDrop = function (e) {
	            _this.setState({
	                dragState: e.type
	            });
	        };
	        _this.beforeUpload = function (file, fileList) {
	            if (!_this.props.beforeUpload) {
	                return true;
	            }
	            var result = _this.props.beforeUpload(file, fileList);
	            if (result === false) {
	                _this.onChange({
	                    file: file,
	                    fileList: (0, _lodash2['default'])(fileList.concat(_this.state.fileList), function (item) {
	                        return item.uid;
	                    })
	                });
	                return false;
	            } else if (result && result.then) {
	                return result;
	            }
	            return true;
	        };
	        _this.state = {
	            fileList: props.fileList || props.defaultFileList || [],
	            dragState: 'drop'
	        };
	        return _this;
	    }
	
	    (0, _createClass3['default'])(Upload, [{
	        key: 'componentWillUnmount',
	        value: function componentWillUnmount() {
	            this.clearProgressTimer();
	        }
	    }, {
	        key: 'getLocale',
	        value: function getLocale() {
	            var locale = {};
	            if (this.context.antLocale && this.context.antLocale.Upload) {
	                locale = this.context.antLocale.Upload;
	            }
	            return (0, _extends3['default'])({}, defaultLocale, locale, this.props.locale);
	        }
	    }, {
	        key: 'autoUpdateProgress',
	        value: function autoUpdateProgress(_, file) {
	            var _this2 = this;
	
	            var getPercent = (0, _utils.genPercentAdd)();
	            var curPercent = 0;
	            this.clearProgressTimer();
	            this.progressTimer = setInterval(function () {
	                curPercent = getPercent(curPercent);
	                _this2.onProgress({
	                    percent: curPercent
	                }, file);
	            }, 200);
	        }
	    }, {
	        key: 'handleRemove',
	        value: function handleRemove(file) {
	            var _this3 = this;
	
	            var onRemove = this.props.onRemove;
	
	            Promise.resolve(typeof onRemove === 'function' ? onRemove(file) : onRemove).then(function (ret) {
	                // Prevent removing file
	                if (ret === false) {
	                    return;
	                }
	                var removedFileList = (0, _utils.removeFileItem)(file, _this3.state.fileList);
	                if (removedFileList) {
	                    _this3.onChange({
	                        file: file,
	                        fileList: removedFileList
	                    });
	                }
	            });
	        }
	    }, {
	        key: 'componentWillReceiveProps',
	        value: function componentWillReceiveProps(nextProps) {
	            if ('fileList' in nextProps) {
	                this.setState({
	                    fileList: nextProps.fileList || []
	                });
	            }
	        }
	    }, {
	        key: 'clearProgressTimer',
	        value: function clearProgressTimer() {
	            clearInterval(this.progressTimer);
	        }
	    }, {
	        key: 'render',
	        value: function render() {
	            var _classNames2;
	
	            var _props = this.props,
	                _props$prefixCls = _props.prefixCls,
	                prefixCls = _props$prefixCls === undefined ? '' : _props$prefixCls,
	                showUploadList = _props.showUploadList,
	                listType = _props.listType,
	                onPreview = _props.onPreview,
	                type = _props.type,
	                disabled = _props.disabled,
	                children = _props.children,
	                className = _props.className;
	
	            var rcUploadProps = (0, _extends3['default'])({ onStart: this.onStart, onError: this.onError, onProgress: this.onProgress, onSuccess: this.onSuccess }, this.props, { beforeUpload: this.beforeUpload });
	            delete rcUploadProps.className;
	            var showRemoveIcon = showUploadList.showRemoveIcon,
	                showPreviewIcon = showUploadList.showPreviewIcon;
	
	            var uploadList = showUploadList ? _react2['default'].createElement(_UploadList2['default'], { listType: listType, items: this.state.fileList, onPreview: onPreview, onRemove: this.handleManualRemove, showRemoveIcon: showRemoveIcon, showPreviewIcon: showPreviewIcon, locale: this.getLocale() }) : null;
	            if (type === 'drag') {
	                var _classNames;
	
	                var dragCls = (0, _classnames2['default'])(prefixCls, (_classNames = {}, (0, _defineProperty3['default'])(_classNames, prefixCls + '-drag', true), (0, _defineProperty3['default'])(_classNames, prefixCls + '-drag-uploading', this.state.fileList.some(function (file) {
	                    return file.status === 'uploading';
	                })), (0, _defineProperty3['default'])(_classNames, prefixCls + '-drag-hover', this.state.dragState === 'dragover'), (0, _defineProperty3['default'])(_classNames, prefixCls + '-disabled', disabled), _classNames));
	                return _react2['default'].createElement(
	                    'span',
	                    { className: className },
	                    _react2['default'].createElement(
	                        'div',
	                        { className: dragCls, onDrop: this.onFileDrop, onDragOver: this.onFileDrop, onDragLeave: this.onFileDrop },
	                        _react2['default'].createElement(
	                            _rcUpload2['default'],
	                            (0, _extends3['default'])({}, rcUploadProps, { ref: 'upload', className: prefixCls + '-btn' }),
	                            _react2['default'].createElement(
	                                'div',
	                                { className: prefixCls + '-drag-container' },
	                                children
	                            )
	                        )
	                    ),
	                    uploadList
	                );
	            }
	            var uploadButtonCls = (0, _classnames2['default'])(prefixCls, (_classNames2 = {}, (0, _defineProperty3['default'])(_classNames2, prefixCls + '-select', true), (0, _defineProperty3['default'])(_classNames2, prefixCls + '-select-' + listType, true), (0, _defineProperty3['default'])(_classNames2, prefixCls + '-disabled', disabled), _classNames2));
	            var uploadButton = _react2['default'].createElement(
	                'div',
	                { className: uploadButtonCls, style: { display: children ? '' : 'none' } },
	                _react2['default'].createElement(_rcUpload2['default'], (0, _extends3['default'])({}, rcUploadProps, { ref: 'upload' }))
	            );
	            if (listType === 'picture-card') {
	                return _react2['default'].createElement(
	                    'span',
	                    { className: className },
	                    uploadList,
	                    uploadButton
	                );
	            }
	            return _react2['default'].createElement(
	                'span',
	                { className: className },
	                uploadButton,
	                uploadList
	            );
	        }
	    }]);
	    return Upload;
	}(_react2['default'].Component);
	
	exports['default'] = Upload;
	
	Upload.defaultProps = {
	    prefixCls: 'ant-upload',
	    type: 'select',
	    multiple: false,
	    action: '',
	    data: {},
	    accept: '',
	    beforeUpload: _utils.T,
	    showUploadList: true,
	    listType: 'text',
	    className: '',
	    disabled: false,
	    supportServerRender: true
	};
	Upload.contextTypes = {
	    antLocale: _propTypes2['default'].object
	};

/***/ }),
/* 185 */
/***/ (function(module, exports, __webpack_require__) {

	module.exports = { "default": __webpack_require__(427), __esModule: true };

/***/ }),
/* 186 */
/***/ (function(module, exports, __webpack_require__) {

	"use strict";
	
	exports.__esModule = true;
	
	var _isIterable2 = __webpack_require__(412);
	
	var _isIterable3 = _interopRequireDefault(_isIterable2);
	
	var _getIterator2 = __webpack_require__(411);
	
	var _getIterator3 = _interopRequireDefault(_getIterator2);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
	
	exports.default = function () {
	  function sliceIterator(arr, i) {
	    var _arr = [];
	    var _n = true;
	    var _d = false;
	    var _e = undefined;
	
	    try {
	      for (var _i = (0, _getIterator3.default)(arr), _s; !(_n = (_s = _i.next()).done); _n = true) {
	        _arr.push(_s.value);
	
	        if (i && _arr.length === i) break;
	      }
	    } catch (err) {
	      _d = true;
	      _e = err;
	    } finally {
	      try {
	        if (!_n && _i["return"]) _i["return"]();
	      } finally {
	        if (_d) throw _e;
	      }
	    }
	
	    return _arr;
	  }
	
	  return function (arr, i) {
	    if (Array.isArray(arr)) {
	      return arr;
	    } else if ((0, _isIterable3.default)(Object(arr))) {
	      return sliceIterator(arr, i);
	    } else {
	      throw new TypeError("Invalid attempt to destructure non-iterable instance");
	    }
	  };
	}();

/***/ }),
/* 187 */
/***/ (function(module, exports) {

	module.exports = function(arr, obj){
	  if (arr.indexOf) return arr.indexOf(obj);
	  for (var i = 0; i < arr.length; ++i) {
	    if (arr[i] === obj) return i;
	  }
	  return -1;
	};

/***/ }),
/* 188 */
/***/ (function(module, exports, __webpack_require__) {

	// getting tag from 19.1.3.6 Object.prototype.toString()
	var cof = __webpack_require__(106);
	var TAG = __webpack_require__(32)('toStringTag');
	// ES3 wrong here
	var 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;
	};


/***/ }),
/* 189 */
/***/ (function(module, exports, __webpack_require__) {

	var isObject = __webpack_require__(59);
	var document = __webpack_require__(39).document;
	// typeof document.createElement is 'object' in old IE
	var is = isObject(document) && isObject(document.createElement);
	module.exports = function (it) {
	  return is ? document.createElement(it) : {};
	};


/***/ }),
/* 190 */
/***/ (function(module, exports, __webpack_require__) {

	module.exports = !__webpack_require__(47) && !__webpack_require__(57)(function () {
	  return Object.defineProperty(__webpack_require__(189)('div'), 'a', { get: function () { return 7; } }).a != 7;
	});


/***/ }),
/* 191 */
/***/ (function(module, exports, __webpack_require__) {

	// fallback for non-array-like ES3 and non-enumerable old V8 strings
	var cof = __webpack_require__(106);
	// eslint-disable-next-line no-prototype-builtins
	module.exports = Object('z').propertyIsEnumerable(0) ? Object : function (it) {
	  return cof(it) == 'String' ? it.split('') : Object(it);
	};


/***/ }),
/* 192 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	var LIBRARY = __webpack_require__(110);
	var $export = __webpack_require__(38);
	var redefine = __webpack_require__(197);
	var hide = __webpack_require__(58);
	var Iterators = __webpack_require__(60);
	var $iterCreate = __webpack_require__(442);
	var setToStringTag = __webpack_require__(114);
	var getPrototypeOf = __webpack_require__(194);
	var ITERATOR = __webpack_require__(32)('iterator');
	var BUGGY = !([].keys && 'next' in [].keys()); // Safari has buggy iterators w/o `next`
	var FF_ITERATOR = '@@iterator';
	var KEYS = 'keys';
	var 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';
	  var DEF_VALUES = DEFAULT == VALUES;
	  var VALUES_BUG = false;
	  var proto = Base.prototype;
	  var $native = proto[ITERATOR] || proto[FF_ITERATOR] || DEFAULT && proto[DEFAULT];
	  var $default = $native || getMethod(DEFAULT);
	  var $entries = DEFAULT ? !DEF_VALUES ? $default : getMethod('entries') : undefined;
	  var $anyNative = NAME == 'Array' ? proto.entries || $native : $native;
	  var methods, key, IteratorPrototype;
	  // Fix native
	  if ($anyNative) {
	    IteratorPrototype = getPrototypeOf($anyNative.call(new Base()));
	    if (IteratorPrototype !== Object.prototype && IteratorPrototype.next) {
	      // Set @@toStringTag to native iterators
	      setToStringTag(IteratorPrototype, TAG, true);
	      // fix for some old engines
	      if (!LIBRARY && typeof IteratorPrototype[ITERATOR] != 'function') 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;
	};


/***/ }),
/* 193 */
/***/ (function(module, exports, __webpack_require__) {

	// 19.1.2.7 / 15.2.3.4 Object.getOwnPropertyNames(O)
	var $keys = __webpack_require__(195);
	var hiddenKeys = __webpack_require__(109).concat('length', 'prototype');
	
	exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
	  return $keys(O, hiddenKeys);
	};


/***/ }),
/* 194 */
/***/ (function(module, exports, __webpack_require__) {

	// 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O)
	var has = __webpack_require__(48);
	var toObject = __webpack_require__(85);
	var IE_PROTO = __webpack_require__(115)('IE_PROTO');
	var 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;
	};


/***/ }),
/* 195 */
/***/ (function(module, exports, __webpack_require__) {

	var has = __webpack_require__(48);
	var toIObject = __webpack_require__(49);
	var arrayIndexOf = __webpack_require__(435)(false);
	var IE_PROTO = __webpack_require__(115)('IE_PROTO');
	
	module.exports = function (object, names) {
	  var O = toIObject(object);
	  var i = 0;
	  var result = [];
	  var 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;
	};


/***/ }),
/* 196 */
/***/ (function(module, exports, __webpack_require__) {

	// most Object methods by ES6 should accept primitives
	var $export = __webpack_require__(38);
	var core = __webpack_require__(25);
	var fails = __webpack_require__(57);
	module.exports = function (KEY, exec) {
	  var fn = (core.Object || {})[KEY] || Object[KEY];
	  var exp = {};
	  exp[KEY] = exec(fn);
	  $export($export.S + $export.F * fails(function () { fn(1); }), 'Object', exp);
	};


/***/ }),
/* 197 */
/***/ (function(module, exports, __webpack_require__) {

	module.exports = __webpack_require__(58);


/***/ }),
/* 198 */
/***/ (function(module, exports, __webpack_require__) {

	// 7.1.15 ToLength
	var toInteger = __webpack_require__(117);
	var min = Math.min;
	module.exports = function (it) {
	  return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991
	};


/***/ }),
/* 199 */
/***/ (function(module, exports, __webpack_require__) {

	var classof = __webpack_require__(188);
	var ITERATOR = __webpack_require__(32)('iterator');
	var Iterators = __webpack_require__(60);
	module.exports = __webpack_require__(25).getIteratorMethod = function (it) {
	  if (it != undefined) return it[ITERATOR]
	    || it['@@iterator']
	    || Iterators[classof(it)];
	};


/***/ }),
/* 200 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _utils = __webpack_require__(61);
	
	var _utils2 = _interopRequireDefault(_utils);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	/**
	 * 得到会导致元素显示不全的祖先元素
	 */
	
	function getOffsetParent(element) {
	  if (_utils2['default'].isWindow(element) || element.nodeType === 9) {
	    return null;
	  }
	  // ie 这个也不是完全可行
	  /*
	   <div style="width: 50px;height: 100px;overflow: hidden">
	   <div style="width: 50px;height: 100px;position: relative;" id="d6">
	   元素 6 高 100px 宽 50px<br/>
	   </div>
	   </div>
	   */
	  // element.offsetParent does the right thing in ie7 and below. Return parent with layout!
	  //  In other browsers it only includes elements with position absolute, relative or
	  // fixed, not elements with overflow set to auto or scroll.
	  //        if (UA.ie && ieMode < 8) {
	  //            return element.offsetParent;
	  //        }
	  // 统一的 offsetParent 方法
	  var doc = _utils2['default'].getDocument(element);
	  var body = doc.body;
	  var parent = void 0;
	  var positionStyle = _utils2['default'].css(element, 'position');
	  var skipStatic = positionStyle === 'fixed' || positionStyle === 'absolute';
	
	  if (!skipStatic) {
	    return element.nodeName.toLowerCase() === 'html' ? null : element.parentNode;
	  }
	
	  for (parent = element.parentNode; parent && parent !== body; parent = parent.parentNode) {
	    positionStyle = _utils2['default'].css(parent, 'position');
	    if (positionStyle !== 'static') {
	      return parent;
	    }
	  }
	  return null;
	}
	
	exports['default'] = getOffsetParent;
	module.exports = exports['default'];

/***/ }),
/* 201 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule BlockTree
	 * @format
	 * 
	 */
	
	'use strict';
	
	var Immutable = __webpack_require__(11);
	
	var emptyFunction = __webpack_require__(75);
	var findRangesImmutable = __webpack_require__(72);
	
	var List = Immutable.List,
	    Repeat = Immutable.Repeat,
	    Record = Immutable.Record;
	
	
	var returnTrue = emptyFunction.thatReturnsTrue;
	
	var FINGERPRINT_DELIMITER = '-';
	
	var defaultLeafRange = {
	  start: null,
	  end: null
	};
	
	var LeafRange = Record(defaultLeafRange);
	
	var defaultDecoratorRange = {
	  start: null,
	  end: null,
	  decoratorKey: null,
	  leaves: null
	};
	
	var DecoratorRange = Record(defaultDecoratorRange);
	
	var BlockTree = {
	  /**
	   * Generate a block tree for a given ContentBlock/decorator pair.
	   */
	  generate: function generate(contentState, block, decorator) {
	    var textLength = block.getLength();
	    if (!textLength) {
	      return List.of(new DecoratorRange({
	        start: 0,
	        end: 0,
	        decoratorKey: null,
	        leaves: List.of(new LeafRange({ start: 0, end: 0 }))
	      }));
	    }
	
	    var leafSets = [];
	    var decorations = decorator ? decorator.getDecorations(block, contentState) : List(Repeat(null, textLength));
	
	    var chars = block.getCharacterList();
	
	    findRangesImmutable(decorations, areEqual, returnTrue, function (start, end) {
	      leafSets.push(new DecoratorRange({
	        start: start,
	        end: end,
	        decoratorKey: decorations.get(start),
	        leaves: generateLeaves(chars.slice(start, end).toList(), start)
	      }));
	    });
	
	    return List(leafSets);
	  },
	
	  /**
	   * Create a string representation of the given tree map. This allows us
	   * to rapidly determine whether a tree has undergone a significant
	   * structural change.
	   */
	  getFingerprint: function getFingerprint(tree) {
	    return tree.map(function (leafSet) {
	      var decoratorKey = leafSet.get('decoratorKey');
	      var fingerprintString = decoratorKey !== null ? decoratorKey + '.' + (leafSet.get('end') - leafSet.get('start')) : '';
	      return '' + fingerprintString + '.' + leafSet.get('leaves').size;
	    }).join(FINGERPRINT_DELIMITER);
	  }
	};
	
	/**
	 * Generate LeafRange records for a given character list.
	 */
	function generateLeaves(characters, offset) {
	  var leaves = [];
	  var inlineStyles = characters.map(function (c) {
	    return c.getStyle();
	  }).toList();
	  findRangesImmutable(inlineStyles, areEqual, returnTrue, function (start, end) {
	    leaves.push(new LeafRange({
	      start: start + offset,
	      end: end + offset
	    }));
	  });
	  return List(leaves);
	}
	
	function areEqual(a, b) {
	  return a === b;
	}
	
	module.exports = BlockTree;

/***/ }),
/* 202 */
/***/ (function(module, exports) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule DefaultDraftInlineStyle
	 * @format
	 * 
	 */
	
	'use strict';
	
	module.exports = {
	  BOLD: {
	    fontWeight: 'bold'
	  },
	
	  CODE: {
	    fontFamily: 'monospace',
	    wordWrap: 'break-word'
	  },
	
	  ITALIC: {
	    fontStyle: 'italic'
	  },
	
	  STRIKETHROUGH: {
	    textDecoration: 'line-through'
	  },
	
	  UNDERLINE: {
	    textDecoration: 'underline'
	  }
	};

/***/ }),
/* 203 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule DraftEditorBlock.react
	 * @format
	 * 
	 */
	
	'use strict';
	
	var _assign = __webpack_require__(18);
	
	var _extends = _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; };
	
	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 DraftEditorLeaf = __webpack_require__(489);
	var DraftOffsetKey = __webpack_require__(71);
	var React = __webpack_require__(1);
	var ReactDOM = __webpack_require__(10);
	var Scroll = __webpack_require__(225);
	var Style = __webpack_require__(131);
	var UnicodeBidi = __webpack_require__(226);
	var UnicodeBidiDirection = __webpack_require__(132);
	
	var cx = __webpack_require__(63);
	var getElementPosition = __webpack_require__(561);
	var getScrollPosition = __webpack_require__(134);
	var getViewportDimensions = __webpack_require__(565);
	var invariant = __webpack_require__(12);
	var nullthrows = __webpack_require__(33);
	
	var SCROLL_BUFFER = 10;
	
	/**
	 * Return whether a block overlaps with either edge of the `SelectionState`.
	 */
	var isBlockOnSelectionEdge = function isBlockOnSelectionEdge(selection, key) {
	  return selection.getAnchorKey() === key || selection.getFocusKey() === key;
	};
	
	/**
	 * The default block renderer for a `DraftEditor` component.
	 *
	 * A `DraftEditorBlock` is able to render a given `ContentBlock` to its
	 * appropriate decorator and inline style components.
	 */
	
	var DraftEditorBlock = function (_React$Component) {
	  _inherits(DraftEditorBlock, _React$Component);
	
	  function DraftEditorBlock() {
	    _classCallCheck(this, DraftEditorBlock);
	
	    return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	  }
	
	  DraftEditorBlock.prototype.shouldComponentUpdate = function shouldComponentUpdate(nextProps) {
	    return this.props.block !== nextProps.block || this.props.tree !== nextProps.tree || this.props.direction !== nextProps.direction || isBlockOnSelectionEdge(nextProps.selection, nextProps.block.getKey()) && nextProps.forceSelection;
	  };
	
	  /**
	   * When a block is mounted and overlaps the selection state, we need to make
	   * sure that the cursor is visible to match native behavior. This may not
	   * be the case if the user has pressed `RETURN` or pasted some content, since
	   * programatically creating these new blocks and setting the DOM selection
	   * will miss out on the browser natively scrolling to that position.
	   *
	   * To replicate native behavior, if the block overlaps the selection state
	   * on mount, force the scroll position. Check the scroll state of the scroll
	   * parent, and adjust it to align the entire block to the bottom of the
	   * scroll parent.
	   */
	
	
	  DraftEditorBlock.prototype.componentDidMount = function componentDidMount() {
	    var selection = this.props.selection;
	    var endKey = selection.getEndKey();
	    if (!selection.getHasFocus() || endKey !== this.props.block.getKey()) {
	      return;
	    }
	
	    var blockNode = ReactDOM.findDOMNode(this);
	    var scrollParent = Style.getScrollParent(blockNode);
	    var scrollPosition = getScrollPosition(scrollParent);
	    var scrollDelta = void 0;
	
	    if (scrollParent === window) {
	      var nodePosition = getElementPosition(blockNode);
	      var nodeBottom = nodePosition.y + nodePosition.height;
	      var viewportHeight = getViewportDimensions().height;
	      scrollDelta = nodeBottom - viewportHeight;
	      if (scrollDelta > 0) {
	        window.scrollTo(scrollPosition.x, scrollPosition.y + scrollDelta + SCROLL_BUFFER);
	      }
	    } else {
	      !(blockNode instanceof HTMLElement) ?  true ? invariant(false, 'blockNode is not an HTMLElement') : invariant(false) : void 0;
	      var blockBottom = blockNode.offsetHeight + blockNode.offsetTop;
	      var scrollBottom = scrollParent.offsetHeight + scrollPosition.y;
	      scrollDelta = blockBottom - scrollBottom;
	      if (scrollDelta > 0) {
	        Scroll.setTop(scrollParent, Scroll.getTop(scrollParent) + scrollDelta + SCROLL_BUFFER);
	      }
	    }
	  };
	
	  DraftEditorBlock.prototype._renderChildren = function _renderChildren() {
	    var _this2 = this;
	
	    var block = this.props.block;
	    var blockKey = block.getKey();
	    var text = block.getText();
	    var lastLeafSet = this.props.tree.size - 1;
	    var hasSelection = isBlockOnSelectionEdge(this.props.selection, blockKey);
	
	    return this.props.tree.map(function (leafSet, ii) {
	      var leavesForLeafSet = leafSet.get('leaves');
	      var lastLeaf = leavesForLeafSet.size - 1;
	      var leaves = leavesForLeafSet.map(function (leaf, jj) {
	        var offsetKey = DraftOffsetKey.encode(blockKey, ii, jj);
	        var start = leaf.get('start');
	        var end = leaf.get('end');
	        return React.createElement(DraftEditorLeaf, {
	          key: offsetKey,
	          offsetKey: offsetKey,
	          block: block,
	          start: start,
	          selection: hasSelection ? _this2.props.selection : null,
	          forceSelection: _this2.props.forceSelection,
	          text: text.slice(start, end),
	          styleSet: block.getInlineStyleAt(start),
	          customStyleMap: _this2.props.customStyleMap,
	          customStyleFn: _this2.props.customStyleFn,
	          isLast: ii === lastLeafSet && jj === lastLeaf
	        });
	      }).toArray();
	
	      var decoratorKey = leafSet.get('decoratorKey');
	      if (decoratorKey == null) {
	        return leaves;
	      }
	
	      if (!_this2.props.decorator) {
	        return leaves;
	      }
	
	      var decorator = nullthrows(_this2.props.decorator);
	
	      var DecoratorComponent = decorator.getComponentForKey(decoratorKey);
	      if (!DecoratorComponent) {
	        return leaves;
	      }
	
	      var decoratorProps = decorator.getPropsForKey(decoratorKey);
	      var decoratorOffsetKey = DraftOffsetKey.encode(blockKey, ii, 0);
	      var decoratedText = text.slice(leavesForLeafSet.first().get('start'), leavesForLeafSet.last().get('end'));
	
	      // Resetting dir to the same value on a child node makes Chrome/Firefox
	      // confused on cursor movement. See http://jsfiddle.net/d157kLck/3/
	      var dir = UnicodeBidiDirection.getHTMLDirIfDifferent(UnicodeBidi.getDirection(decoratedText), _this2.props.direction);
	
	      return React.createElement(
	        DecoratorComponent,
	        _extends({}, decoratorProps, {
	          contentState: _this2.props.contentState,
	          decoratedText: decoratedText,
	          dir: dir,
	          key: decoratorOffsetKey,
	          entityKey: block.getEntityAt(leafSet.get('start')),
	          offsetKey: decoratorOffsetKey }),
	        leaves
	      );
	    }).toArray();
	  };
	
	  DraftEditorBlock.prototype.render = function render() {
	    var _props = this.props,
	        direction = _props.direction,
	        offsetKey = _props.offsetKey;
	
	    var className = cx({
	      'public/DraftStyleDefault/block': true,
	      'public/DraftStyleDefault/ltr': direction === 'LTR',
	      'public/DraftStyleDefault/rtl': direction === 'RTL'
	    });
	
	    return React.createElement(
	      'div',
	      { 'data-offset-key': offsetKey, className: className },
	      this._renderChildren()
	    );
	  };
	
	  return DraftEditorBlock;
	}(React.Component);
	
	module.exports = DraftEditorBlock;

/***/ }),
/* 204 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule DraftEntityInstance
	 * @legacyServerCallableInstance
	 * @format
	 * 
	 */
	
	'use strict';
	
	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 Immutable = __webpack_require__(11);
	
	var Record = Immutable.Record;
	
	
	var DraftEntityInstanceRecord = Record({
	  type: 'TOKEN',
	  mutability: 'IMMUTABLE',
	  data: Object
	});
	
	/**
	 * An instance of a document entity, consisting of a `type` and relevant
	 * `data`, metadata about the entity.
	 *
	 * For instance, a "link" entity might provide a URI, and a "mention"
	 * entity might provide the mentioned user's ID. These pieces of data
	 * may be used when rendering the entity as part of a ContentBlock DOM
	 * representation. For a link, the data would be used as an href for
	 * the rendered anchor. For a mention, the ID could be used to retrieve
	 * a hovercard.
	 */
	
	var DraftEntityInstance = function (_DraftEntityInstanceR) {
	  _inherits(DraftEntityInstance, _DraftEntityInstanceR);
	
	  function DraftEntityInstance() {
	    _classCallCheck(this, DraftEntityInstance);
	
	    return _possibleConstructorReturn(this, _DraftEntityInstanceR.apply(this, arguments));
	  }
	
	  DraftEntityInstance.prototype.getType = function getType() {
	    return this.get('type');
	  };
	
	  DraftEntityInstance.prototype.getMutability = function getMutability() {
	    return this.get('mutability');
	  };
	
	  DraftEntityInstance.prototype.getData = function getData() {
	    return this.get('data');
	  };
	
	  return DraftEntityInstance;
	}(DraftEntityInstanceRecord);
	
	module.exports = DraftEntityInstance;

/***/ }),
/* 205 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule DraftRemovableWord
	 * @format
	 * 
	 */
	
	'use strict';
	
	var TokenizeUtil = __webpack_require__(552);
	
	var punctuation = TokenizeUtil.getPunctuation();
	
	// The apostrophe and curly single quotes behave in a curious way: when
	// surrounded on both sides by word characters, they behave as word chars; when
	// either neighbor is punctuation or an end of the string, they behave as
	// punctuation.
	var CHAMELEON_CHARS = '[\'\u2018\u2019]';
	
	// Remove the underscore, which should count as part of the removable word. The
	// "chameleon chars" also count as punctuation in this regex.
	var WHITESPACE_AND_PUNCTUATION = '\\s|(?![_])' + punctuation;
	
	var DELETE_STRING = '^' + '(?:' + WHITESPACE_AND_PUNCTUATION + ')*' + '(?:' + CHAMELEON_CHARS + '|(?!' + WHITESPACE_AND_PUNCTUATION + ').)*' + '(?:(?!' + WHITESPACE_AND_PUNCTUATION + ').)';
	var DELETE_REGEX = new RegExp(DELETE_STRING);
	
	var BACKSPACE_STRING = '(?:(?!' + WHITESPACE_AND_PUNCTUATION + ').)' + '(?:' + CHAMELEON_CHARS + '|(?!' + WHITESPACE_AND_PUNCTUATION + ').)*' + '(?:' + WHITESPACE_AND_PUNCTUATION + ')*' + '$';
	var BACKSPACE_REGEX = new RegExp(BACKSPACE_STRING);
	
	function getRemovableWord(text, isBackward) {
	  var matches = isBackward ? BACKSPACE_REGEX.exec(text) : DELETE_REGEX.exec(text);
	  return matches ? matches[0] : text;
	}
	
	var DraftRemovableWord = {
	  getBackward: function getBackward(text) {
	    return getRemovableWord(text, true);
	  },
	
	  getForward: function getForward(text) {
	    return getRemovableWord(text, false);
	  }
	};
	
	module.exports = DraftRemovableWord;

/***/ }),
/* 206 */
/***/ (function(module, exports) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule DraftStringKey
	 * @format
	 * 
	 */
	
	'use strict';
	
	var DraftStringKey = {
	  stringify: function stringify(key) {
	    return '_' + String(key);
	  },
	
	  unstringify: function unstringify(key) {
	    return key.slice(1);
	  }
	};
	
	module.exports = DraftStringKey;

/***/ }),
/* 207 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule RichTextEditorUtil
	 * @format
	 * 
	 */
	
	'use strict';
	
	var DraftModifier = __webpack_require__(26);
	var EditorState = __webpack_require__(15);
	var SelectionState = __webpack_require__(62);
	
	var adjustBlockDepthForContentState = __webpack_require__(499);
	var nullthrows = __webpack_require__(33);
	
	var RichTextEditorUtil = {
	  currentBlockContainsLink: function currentBlockContainsLink(editorState) {
	    var selection = editorState.getSelection();
	    var contentState = editorState.getCurrentContent();
	    var entityMap = contentState.getEntityMap();
	    return contentState.getBlockForKey(selection.getAnchorKey()).getCharacterList().slice(selection.getStartOffset(), selection.getEndOffset()).some(function (v) {
	      var entity = v.getEntity();
	      return !!entity && entityMap.__get(entity).getType() === 'LINK';
	    });
	  },
	
	  getCurrentBlockType: function getCurrentBlockType(editorState) {
	    var selection = editorState.getSelection();
	    return editorState.getCurrentContent().getBlockForKey(selection.getStartKey()).getType();
	  },
	
	  getDataObjectForLinkURL: function getDataObjectForLinkURL(uri) {
	    return { url: uri.toString() };
	  },
	
	  handleKeyCommand: function handleKeyCommand(editorState, command) {
	    switch (command) {
	      case 'bold':
	        return RichTextEditorUtil.toggleInlineStyle(editorState, 'BOLD');
	      case 'italic':
	        return RichTextEditorUtil.toggleInlineStyle(editorState, 'ITALIC');
	      case 'underline':
	        return RichTextEditorUtil.toggleInlineStyle(editorState, 'UNDERLINE');
	      case 'code':
	        return RichTextEditorUtil.toggleCode(editorState);
	      case 'backspace':
	      case 'backspace-word':
	      case 'backspace-to-start-of-line':
	        return RichTextEditorUtil.onBackspace(editorState);
	      case 'delete':
	      case 'delete-word':
	      case 'delete-to-end-of-block':
	        return RichTextEditorUtil.onDelete(editorState);
	      default:
	        // they may have custom editor commands; ignore those
	        return null;
	    }
	  },
	
	  insertSoftNewline: function insertSoftNewline(editorState) {
	    var contentState = DraftModifier.insertText(editorState.getCurrentContent(), editorState.getSelection(), '\n', editorState.getCurrentInlineStyle(), null);
	
	    var newEditorState = EditorState.push(editorState, contentState, 'insert-characters');
	
	    return EditorState.forceSelection(newEditorState, contentState.getSelectionAfter());
	  },
	
	  /**
	   * For collapsed selections at the start of styled blocks, backspace should
	   * just remove the existing style.
	   */
	  onBackspace: function onBackspace(editorState) {
	    var selection = editorState.getSelection();
	    if (!selection.isCollapsed() || selection.getAnchorOffset() || selection.getFocusOffset()) {
	      return null;
	    }
	
	    // First, try to remove a preceding atomic block.
	    var content = editorState.getCurrentContent();
	    var startKey = selection.getStartKey();
	    var blockBefore = content.getBlockBefore(startKey);
	
	    if (blockBefore && blockBefore.getType() === 'atomic') {
	      var blockMap = content.getBlockMap()['delete'](blockBefore.getKey());
	      var withoutAtomicBlock = content.merge({
	        blockMap: blockMap,
	        selectionAfter: selection
	      });
	      if (withoutAtomicBlock !== content) {
	        return EditorState.push(editorState, withoutAtomicBlock, 'remove-range');
	      }
	    }
	
	    // If that doesn't succeed, try to remove the current block style.
	    var withoutBlockStyle = RichTextEditorUtil.tryToRemoveBlockStyle(editorState);
	
	    if (withoutBlockStyle) {
	      return EditorState.push(editorState, withoutBlockStyle, 'change-block-type');
	    }
	
	    return null;
	  },
	
	  onDelete: function onDelete(editorState) {
	    var selection = editorState.getSelection();
	    if (!selection.isCollapsed()) {
	      return null;
	    }
	
	    var content = editorState.getCurrentContent();
	    var startKey = selection.getStartKey();
	    var block = content.getBlockForKey(startKey);
	    var length = block.getLength();
	
	    // The cursor is somewhere within the text. Behave normally.
	    if (selection.getStartOffset() < length) {
	      return null;
	    }
	
	    var blockAfter = content.getBlockAfter(startKey);
	
	    if (!blockAfter || blockAfter.getType() !== 'atomic') {
	      return null;
	    }
	
	    var atomicBlockTarget = selection.merge({
	      focusKey: blockAfter.getKey(),
	      focusOffset: blockAfter.getLength()
	    });
	
	    var withoutAtomicBlock = DraftModifier.removeRange(content, atomicBlockTarget, 'forward');
	
	    if (withoutAtomicBlock !== content) {
	      return EditorState.push(editorState, withoutAtomicBlock, 'remove-range');
	    }
	
	    return null;
	  },
	
	  onTab: function onTab(event, editorState, maxDepth) {
	    var selection = editorState.getSelection();
	    var key = selection.getAnchorKey();
	    if (key !== selection.getFocusKey()) {
	      return editorState;
	    }
	
	    var content = editorState.getCurrentContent();
	    var block = content.getBlockForKey(key);
	    var type = block.getType();
	    if (type !== 'unordered-list-item' && type !== 'ordered-list-item') {
	      return editorState;
	    }
	
	    event.preventDefault();
	
	    // Only allow indenting one level beyond the block above, and only if
	    // the block above is a list item as well.
	    var blockAbove = content.getBlockBefore(key);
	    if (!blockAbove) {
	      return editorState;
	    }
	
	    var typeAbove = blockAbove.getType();
	    if (typeAbove !== 'unordered-list-item' && typeAbove !== 'ordered-list-item') {
	      return editorState;
	    }
	
	    var depth = block.getDepth();
	    if (!event.shiftKey && depth === maxDepth) {
	      return editorState;
	    }
	
	    maxDepth = Math.min(blockAbove.getDepth() + 1, maxDepth);
	
	    var withAdjustment = adjustBlockDepthForContentState(content, selection, event.shiftKey ? -1 : 1, maxDepth);
	
	    return EditorState.push(editorState, withAdjustment, 'adjust-depth');
	  },
	
	  toggleBlockType: function toggleBlockType(editorState, blockType) {
	    var selection = editorState.getSelection();
	    var startKey = selection.getStartKey();
	    var endKey = selection.getEndKey();
	    var content = editorState.getCurrentContent();
	    var target = selection;
	
	    // Triple-click can lead to a selection that includes offset 0 of the
	    // following block. The `SelectionState` for this case is accurate, but
	    // we should avoid toggling block type for the trailing block because it
	    // is a confusing interaction.
	    if (startKey !== endKey && selection.getEndOffset() === 0) {
	      var blockBefore = nullthrows(content.getBlockBefore(endKey));
	      endKey = blockBefore.getKey();
	      target = target.merge({
	        anchorKey: startKey,
	        anchorOffset: selection.getStartOffset(),
	        focusKey: endKey,
	        focusOffset: blockBefore.getLength(),
	        isBackward: false
	      });
	    }
	
	    var hasAtomicBlock = content.getBlockMap().skipWhile(function (_, k) {
	      return k !== startKey;
	    }).reverse().skipWhile(function (_, k) {
	      return k !== endKey;
	    }).some(function (v) {
	      return v.getType() === 'atomic';
	    });
	
	    if (hasAtomicBlock) {
	      return editorState;
	    }
	
	    var typeToSet = content.getBlockForKey(startKey).getType() === blockType ? 'unstyled' : blockType;
	
	    return EditorState.push(editorState, DraftModifier.setBlockType(content, target, typeToSet), 'change-block-type');
	  },
	
	  toggleCode: function toggleCode(editorState) {
	    var selection = editorState.getSelection();
	    var anchorKey = selection.getAnchorKey();
	    var focusKey = selection.getFocusKey();
	
	    if (selection.isCollapsed() || anchorKey !== focusKey) {
	      return RichTextEditorUtil.toggleBlockType(editorState, 'code-block');
	    }
	
	    return RichTextEditorUtil.toggleInlineStyle(editorState, 'CODE');
	  },
	
	  /**
	   * Toggle the specified inline style for the selection. If the
	   * user's selection is collapsed, apply or remove the style for the
	   * internal state. If it is not collapsed, apply the change directly
	   * to the document state.
	   */
	  toggleInlineStyle: function toggleInlineStyle(editorState, inlineStyle) {
	    var selection = editorState.getSelection();
	    var currentStyle = editorState.getCurrentInlineStyle();
	
	    // If the selection is collapsed, toggle the specified style on or off and
	    // set the result as the new inline style override. This will then be
	    // used as the inline style for the next character to be inserted.
	    if (selection.isCollapsed()) {
	      return EditorState.setInlineStyleOverride(editorState, currentStyle.has(inlineStyle) ? currentStyle.remove(inlineStyle) : currentStyle.add(inlineStyle));
	    }
	
	    // If characters are selected, immediately apply or remove the
	    // inline style on the document state itself.
	    var content = editorState.getCurrentContent();
	    var newContent;
	
	    // If the style is already present for the selection range, remove it.
	    // Otherwise, apply it.
	    if (currentStyle.has(inlineStyle)) {
	      newContent = DraftModifier.removeInlineStyle(content, selection, inlineStyle);
	    } else {
	      newContent = DraftModifier.applyInlineStyle(content, selection, inlineStyle);
	    }
	
	    return EditorState.push(editorState, newContent, 'change-inline-style');
	  },
	
	  toggleLink: function toggleLink(editorState, targetSelection, entityKey) {
	    var withoutLink = DraftModifier.applyEntity(editorState.getCurrentContent(), targetSelection, entityKey);
	
	    return EditorState.push(editorState, withoutLink, 'apply-entity');
	  },
	
	  /**
	   * When a collapsed cursor is at the start of the first styled block, or
	   * an empty styled block, changes block to 'unstyled'. Returns null if
	   * block or selection does not meet that criteria.
	   */
	  tryToRemoveBlockStyle: function tryToRemoveBlockStyle(editorState) {
	    var selection = editorState.getSelection();
	    var offset = selection.getAnchorOffset();
	    if (selection.isCollapsed() && offset === 0) {
	      var key = selection.getAnchorKey();
	      var content = editorState.getCurrentContent();
	      var block = content.getBlockForKey(key);
	
	      var firstBlock = content.getFirstBlock();
	      if (block.getLength() > 0 && block !== firstBlock) {
	        return null;
	      }
	
	      var type = block.getType();
	      var blockBefore = content.getBlockBefore(key);
	      if (type === 'code-block' && blockBefore && blockBefore.getType() === 'code-block' && blockBefore.getLength() !== 0) {
	        return null;
	      }
	
	      if (type !== 'unstyled') {
	        return DraftModifier.setBlockType(content, selection, 'unstyled');
	      }
	    }
	    return null;
	  }
	};
	
	module.exports = RichTextEditorUtil;

/***/ }),
/* 208 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule convertFromHTMLToContentBlocks
	 * @format
	 * 
	 */
	
	'use strict';
	
	var _extends = _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 _knownListItemDepthCl,
	    _assign = __webpack_require__(18);
	
	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; }
	
	var CharacterMetadata = __webpack_require__(27);
	var ContentBlock = __webpack_require__(50);
	var ContentBlockNode = __webpack_require__(30);
	var DefaultDraftBlockRenderMap = __webpack_require__(124);
	var DraftEntity = __webpack_require__(89);
	var DraftFeatureFlags = __webpack_require__(42);
	var Immutable = __webpack_require__(11);
	
	var _require = __webpack_require__(11),
	    Set = _require.Set;
	
	var URI = __webpack_require__(553);
	
	var cx = __webpack_require__(63);
	var generateRandomKey = __webpack_require__(37);
	var getSafeBodyFromHTML = __webpack_require__(214);
	var invariant = __webpack_require__(12);
	var sanitizeDraftText = __webpack_require__(129);
	
	var experimentalTreeDataSupport = DraftFeatureFlags.draft_tree_data_support;
	
	var List = Immutable.List,
	    OrderedSet = Immutable.OrderedSet;
	
	
	var NBSP = '&nbsp;';
	var SPACE = ' ';
	
	// Arbitrary max indent
	var MAX_DEPTH = 4;
	
	// used for replacing characters in HTML
	var REGEX_CR = new RegExp('\r', 'g');
	var REGEX_LF = new RegExp('\n', 'g');
	var REGEX_NBSP = new RegExp(NBSP, 'g');
	var REGEX_CARRIAGE = new RegExp('&#13;?', 'g');
	var REGEX_ZWS = new RegExp('&#8203;?', 'g');
	
	// https://developer.mozilla.org/en-US/docs/Web/CSS/font-weight
	var boldValues = ['bold', 'bolder', '500', '600', '700', '800', '900'];
	var notBoldValues = ['light', 'lighter', '100', '200', '300', '400'];
	
	// Block tag flow is different because LIs do not have
	// a deterministic style ;_;
	var inlineTags = {
	  b: 'BOLD',
	  code: 'CODE',
	  del: 'STRIKETHROUGH',
	  em: 'ITALIC',
	  i: 'ITALIC',
	  s: 'STRIKETHROUGH',
	  strike: 'STRIKETHROUGH',
	  strong: 'BOLD',
	  u: 'UNDERLINE'
	};
	
	var knownListItemDepthClasses = (_knownListItemDepthCl = {}, _defineProperty(_knownListItemDepthCl, cx('public/DraftStyleDefault/depth0'), 0), _defineProperty(_knownListItemDepthCl, cx('public/DraftStyleDefault/depth1'), 1), _defineProperty(_knownListItemDepthCl, cx('public/DraftStyleDefault/depth2'), 2), _defineProperty(_knownListItemDepthCl, cx('public/DraftStyleDefault/depth3'), 3), _defineProperty(_knownListItemDepthCl, cx('public/DraftStyleDefault/depth4'), 4), _knownListItemDepthCl);
	
	var anchorAttr = ['className', 'href', 'rel', 'target', 'title'];
	
	var imgAttr = ['alt', 'className', 'height', 'src', 'width'];
	
	var lastBlock = void 0;
	
	var EMPTY_CHUNK = {
	  text: '',
	  inlines: [],
	  entities: [],
	  blocks: []
	};
	
	var EMPTY_BLOCK = {
	  children: List(),
	  depth: 0,
	  key: '',
	  type: ''
	};
	
	var getListBlockType = function getListBlockType(tag, lastList) {
	  if (tag === 'li') {
	    return lastList === 'ol' ? 'ordered-list-item' : 'unordered-list-item';
	  }
	  return null;
	};
	
	var getBlockMapSupportedTags = function getBlockMapSupportedTags(blockRenderMap) {
	  var unstyledElement = blockRenderMap.get('unstyled').element;
	  var tags = Set([]);
	
	  blockRenderMap.forEach(function (draftBlock) {
	    if (draftBlock.aliasedElements) {
	      draftBlock.aliasedElements.forEach(function (tag) {
	        tags = tags.add(tag);
	      });
	    }
	
	    tags = tags.add(draftBlock.element);
	  });
	
	  return tags.filter(function (tag) {
	    return tag && tag !== unstyledElement;
	  }).toArray().sort();
	};
	
	// custom element conversions
	var getMultiMatchedType = function getMultiMatchedType(tag, lastList, multiMatchExtractor) {
	  for (var ii = 0; ii < multiMatchExtractor.length; ii++) {
	    var matchType = multiMatchExtractor[ii](tag, lastList);
	    if (matchType) {
	      return matchType;
	    }
	  }
	  return null;
	};
	
	var getBlockTypeForTag = function getBlockTypeForTag(tag, lastList, blockRenderMap) {
	  var matchedTypes = blockRenderMap.filter(function (draftBlock) {
	    return draftBlock.element === tag || draftBlock.wrapper === tag || draftBlock.aliasedElements && draftBlock.aliasedElements.some(function (alias) {
	      return alias === tag;
	    });
	  }).keySeq().toSet().toArray().sort();
	
	  // if we dont have any matched type, return unstyled
	  // if we have one matched type return it
	  // if we have multi matched types use the multi-match function to gather type
	  switch (matchedTypes.length) {
	    case 0:
	      return 'unstyled';
	    case 1:
	      return matchedTypes[0];
	    default:
	      return getMultiMatchedType(tag, lastList, [getListBlockType]) || 'unstyled';
	  }
	};
	
	var processInlineTag = function processInlineTag(tag, node, currentStyle) {
	  var styleToCheck = inlineTags[tag];
	  if (styleToCheck) {
	    currentStyle = currentStyle.add(styleToCheck).toOrderedSet();
	  } else if (node instanceof HTMLElement) {
	    var htmlElement = node;
	    currentStyle = currentStyle.withMutations(function (style) {
	      var fontWeight = htmlElement.style.fontWeight;
	      var fontStyle = htmlElement.style.fontStyle;
	      var textDecoration = htmlElement.style.textDecoration;
	
	      if (boldValues.indexOf(fontWeight) >= 0) {
	        style.add('BOLD');
	      } else if (notBoldValues.indexOf(fontWeight) >= 0) {
	        style.remove('BOLD');
	      }
	
	      if (fontStyle === 'italic') {
	        style.add('ITALIC');
	      } else if (fontStyle === 'normal') {
	        style.remove('ITALIC');
	      }
	
	      if (textDecoration === 'underline') {
	        style.add('UNDERLINE');
	      }
	      if (textDecoration === 'line-through') {
	        style.add('STRIKETHROUGH');
	      }
	      if (textDecoration === 'none') {
	        style.remove('UNDERLINE');
	        style.remove('STRIKETHROUGH');
	      }
	    }).toOrderedSet();
	  }
	  return currentStyle;
	};
	
	var joinChunks = function joinChunks(A, B, experimentalHasNestedBlocks) {
	  // Sometimes two blocks will touch in the DOM and we need to strip the
	  // extra delimiter to preserve niceness.
	  var lastInA = A.text.slice(-1);
	  var firstInB = B.text.slice(0, 1);
	
	  if (lastInA === '\r' && firstInB === '\r' && !experimentalHasNestedBlocks) {
	    A.text = A.text.slice(0, -1);
	    A.inlines.pop();
	    A.entities.pop();
	    A.blocks.pop();
	  }
	
	  // Kill whitespace after blocks
	  if (lastInA === '\r') {
	    if (B.text === SPACE || B.text === '\n') {
	      return A;
	    } else if (firstInB === SPACE || firstInB === '\n') {
	      B.text = B.text.slice(1);
	      B.inlines.shift();
	      B.entities.shift();
	    }
	  }
	
	  return {
	    text: A.text + B.text,
	    inlines: A.inlines.concat(B.inlines),
	    entities: A.entities.concat(B.entities),
	    blocks: A.blocks.concat(B.blocks)
	  };
	};
	
	/**
	 * Check to see if we have anything like <p> <blockquote> <h1>... to create
	 * block tags from. If we do, we can use those and ignore <div> tags. If we
	 * don't, we can treat <div> tags as meaningful (unstyled) blocks.
	 */
	var containsSemanticBlockMarkup = function containsSemanticBlockMarkup(html, blockTags) {
	  return blockTags.some(function (tag) {
	    return html.indexOf('<' + tag) !== -1;
	  });
	};
	
	var hasValidLinkText = function hasValidLinkText(link) {
	  !(link instanceof HTMLAnchorElement) ?  true ? invariant(false, 'Link must be an HTMLAnchorElement.') : invariant(false) : void 0;
	  var protocol = link.protocol;
	  return protocol === 'http:' || protocol === 'https:' || protocol === 'mailto:';
	};
	
	var getWhitespaceChunk = function getWhitespaceChunk(inEntity) {
	  var entities = new Array(1);
	  if (inEntity) {
	    entities[0] = inEntity;
	  }
	  return _extends({}, EMPTY_CHUNK, {
	    text: SPACE,
	    inlines: [OrderedSet()],
	    entities: entities
	  });
	};
	
	var getSoftNewlineChunk = function getSoftNewlineChunk() {
	  return _extends({}, EMPTY_CHUNK, {
	    text: '\n',
	    inlines: [OrderedSet()],
	    entities: new Array(1)
	  });
	};
	
	var getChunkedBlock = function getChunkedBlock() {
	  var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
	
	  return _extends({}, EMPTY_BLOCK, props);
	};
	
	var getBlockDividerChunk = function getBlockDividerChunk(block, depth) {
	  var parentKey = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
	
	  return {
	    text: '\r',
	    inlines: [OrderedSet()],
	    entities: new Array(1),
	    blocks: [getChunkedBlock({
	      parent: parentKey,
	      key: generateRandomKey(),
	      type: block,
	      depth: Math.max(0, Math.min(MAX_DEPTH, depth))
	    })]
	  };
	};
	
	/**
	 *  If we're pasting from one DraftEditor to another we can check to see if
	 *  existing list item depth classes are being used and preserve this style
	 */
	var getListItemDepth = function getListItemDepth(node) {
	  var depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
	
	  Object.keys(knownListItemDepthClasses).some(function (depthClass) {
	    if (node.classList.contains(depthClass)) {
	      depth = knownListItemDepthClasses[depthClass];
	    }
	  });
	  return depth;
	};
	
	var genFragment = function genFragment(entityMap, node, inlineStyle, lastList, inBlock, blockTags, depth, blockRenderMap, inEntity, parentKey) {
	  var lastLastBlock = lastBlock;
	  var nodeName = node.nodeName.toLowerCase();
	  var newEntityMap = entityMap;
	  var nextBlockType = 'unstyled';
	  var newBlock = false;
	  var inBlockType = inBlock && getBlockTypeForTag(inBlock, lastList, blockRenderMap);
	  var chunk = _extends({}, EMPTY_CHUNK);
	  var newChunk = null;
	  var blockKey = void 0;
	
	  // Base Case
	  if (nodeName === '#text') {
	    var _text = node.textContent;
	    var nodeTextContent = _text.trim();
	
	    // We should not create blocks for leading spaces that are
	    // existing around ol/ul and their children list items
	    if (lastList && nodeTextContent === '' && node.parentElement) {
	      var parentNodeName = node.parentElement.nodeName.toLowerCase();
	      if (parentNodeName === 'ol' || parentNodeName === 'ul') {
	        return { chunk: _extends({}, EMPTY_CHUNK), entityMap: entityMap };
	      }
	    }
	
	    if (nodeTextContent === '' && inBlock !== 'pre') {
	      return { chunk: getWhitespaceChunk(inEntity), entityMap: entityMap };
	    }
	    if (inBlock !== 'pre') {
	      // Can't use empty string because MSWord
	      _text = _text.replace(REGEX_LF, SPACE);
	    }
	
	    // save the last block so we can use it later
	    lastBlock = nodeName;
	
	    return {
	      chunk: {
	        text: _text,
	        inlines: Array(_text.length).fill(inlineStyle),
	        entities: Array(_text.length).fill(inEntity),
	        blocks: []
	      },
	      entityMap: entityMap
	    };
	  }
	
	  // save the last block so we can use it later
	  lastBlock = nodeName;
	
	  // BR tags
	  if (nodeName === 'br') {
	    if (lastLastBlock === 'br' && (!inBlock || inBlockType === 'unstyled')) {
	      return {
	        chunk: getBlockDividerChunk('unstyled', depth, parentKey),
	        entityMap: entityMap
	      };
	    }
	    return { chunk: getSoftNewlineChunk(), entityMap: entityMap };
	  }
	
	  // IMG tags
	  if (nodeName === 'img' && node instanceof HTMLImageElement && node.attributes.getNamedItem('src') && node.attributes.getNamedItem('src').value) {
	    var image = node;
	    var entityConfig = {};
	
	    imgAttr.forEach(function (attr) {
	      var imageAttribute = image.getAttribute(attr);
	      if (imageAttribute) {
	        entityConfig[attr] = imageAttribute;
	      }
	    });
	    // Forcing this node to have children because otherwise no entity will be
	    // created for this node.
	    // The child text node cannot just have a space or return as content -
	    // we strip those out.
	    // See https://github.com/facebook/draft-js/issues/231 for some context.
	    node.textContent = '\uD83D\uDCF7';
	
	    // TODO: update this when we remove DraftEntity entirely
	    inEntity = DraftEntity.__create('IMAGE', 'MUTABLE', entityConfig || {});
	  }
	
	  // Inline tags
	  inlineStyle = processInlineTag(nodeName, node, inlineStyle);
	
	  // Handle lists
	  if (nodeName === 'ul' || nodeName === 'ol') {
	    if (lastList) {
	      depth += 1;
	    }
	    lastList = nodeName;
	  }
	
	  if (!experimentalTreeDataSupport && nodeName === 'li' && node instanceof HTMLElement) {
	    depth = getListItemDepth(node, depth);
	  }
	
	  var blockType = getBlockTypeForTag(nodeName, lastList, blockRenderMap);
	  var inListBlock = lastList && inBlock === 'li' && nodeName === 'li';
	  var inBlockOrHasNestedBlocks = (!inBlock || experimentalTreeDataSupport) && blockTags.indexOf(nodeName) !== -1;
	
	  // Block Tags
	  if (inListBlock || inBlockOrHasNestedBlocks) {
	    chunk = getBlockDividerChunk(blockType, depth, parentKey);
	    blockKey = chunk.blocks[0].key;
	    inBlock = nodeName;
	    newBlock = !experimentalTreeDataSupport;
	  }
	
	  // this is required so that we can handle 'ul' and 'ol'
	  if (inListBlock) {
	    nextBlockType = lastList === 'ul' ? 'unordered-list-item' : 'ordered-list-item';
	  }
	
	  // Recurse through children
	  var child = node.firstChild;
	  if (child != null) {
	    nodeName = child.nodeName.toLowerCase();
	  }
	
	  var entityId = null;
	
	  while (child) {
	    if (child instanceof HTMLAnchorElement && child.href && hasValidLinkText(child)) {
	      (function () {
	        var anchor = child;
	        var entityConfig = {};
	
	        anchorAttr.forEach(function (attr) {
	          var anchorAttribute = anchor.getAttribute(attr);
	          if (anchorAttribute) {
	            entityConfig[attr] = anchorAttribute;
	          }
	        });
	
	        entityConfig.url = new URI(anchor.href).toString();
	        // TODO: update this when we remove DraftEntity completely
	        entityId = DraftEntity.__create('LINK', 'MUTABLE', entityConfig || {});
	      })();
	    } else {
	      entityId = undefined;
	    }
	
	    var _genFragment = genFragment(newEntityMap, child, inlineStyle, lastList, inBlock, blockTags, depth, blockRenderMap, entityId || inEntity, experimentalTreeDataSupport ? blockKey : null),
	        generatedChunk = _genFragment.chunk,
	        maybeUpdatedEntityMap = _genFragment.entityMap;
	
	    newChunk = generatedChunk;
	    newEntityMap = maybeUpdatedEntityMap;
	
	    chunk = joinChunks(chunk, newChunk, experimentalTreeDataSupport);
	    var sibling = child.nextSibling;
	
	    // Put in a newline to break up blocks inside blocks
	    if (!parentKey && sibling && blockTags.indexOf(nodeName) >= 0 && inBlock) {
	      chunk = joinChunks(chunk, getSoftNewlineChunk());
	    }
	    if (sibling) {
	      nodeName = sibling.nodeName.toLowerCase();
	    }
	    child = sibling;
	  }
	
	  if (newBlock) {
	    chunk = joinChunks(chunk, getBlockDividerChunk(nextBlockType, depth, parentKey));
	  }
	
	  return { chunk: chunk, entityMap: newEntityMap };
	};
	
	var getChunkForHTML = function getChunkForHTML(html, DOMBuilder, blockRenderMap, entityMap) {
	  html = html.trim().replace(REGEX_CR, '').replace(REGEX_NBSP, SPACE).replace(REGEX_CARRIAGE, '').replace(REGEX_ZWS, '');
	
	  var supportedBlockTags = getBlockMapSupportedTags(blockRenderMap);
	
	  var safeBody = DOMBuilder(html);
	  if (!safeBody) {
	    return null;
	  }
	  lastBlock = null;
	
	  // Sometimes we aren't dealing with content that contains nice semantic
	  // tags. In this case, use divs to separate everything out into paragraphs
	  // and hope for the best.
	  var workingBlocks = containsSemanticBlockMarkup(html, supportedBlockTags) ? supportedBlockTags : ['div'];
	
	  // Start with -1 block depth to offset the fact that we are passing in a fake
	  // UL block to start with.
	  var fragment = genFragment(entityMap, safeBody, OrderedSet(), 'ul', null, workingBlocks, -1, blockRenderMap);
	
	  var chunk = fragment.chunk;
	  var newEntityMap = fragment.entityMap;
	
	  // join with previous block to prevent weirdness on paste
	  if (chunk.text.indexOf('\r') === 0) {
	    chunk = {
	      text: chunk.text.slice(1),
	      inlines: chunk.inlines.slice(1),
	      entities: chunk.entities.slice(1),
	      blocks: chunk.blocks
	    };
	  }
	
	  // Kill block delimiter at the end
	  if (chunk.text.slice(-1) === '\r') {
	    chunk.text = chunk.text.slice(0, -1);
	    chunk.inlines = chunk.inlines.slice(0, -1);
	    chunk.entities = chunk.entities.slice(0, -1);
	    chunk.blocks.pop();
	  }
	
	  // If we saw no block tags, put an unstyled one in
	  if (chunk.blocks.length === 0) {
	    chunk.blocks.push(_extends({}, EMPTY_CHUNK, {
	      type: 'unstyled',
	      depth: 0
	    }));
	  }
	
	  // Sometimes we start with text that isn't in a block, which is then
	  // followed by blocks. Need to fix up the blocks to add in
	  // an unstyled block for this content
	  if (chunk.text.split('\r').length === chunk.blocks.length + 1) {
	    chunk.blocks.unshift({ type: 'unstyled', depth: 0 });
	  }
	
	  return { chunk: chunk, entityMap: newEntityMap };
	};
	
	var convertChunkToContentBlocks = function convertChunkToContentBlocks(chunk) {
	  if (!chunk || !chunk.text || !Array.isArray(chunk.blocks)) {
	    return null;
	  }
	
	  var initialState = {
	    cacheRef: {},
	    contentBlocks: []
	  };
	
	  var start = 0;
	
	  var rawBlocks = chunk.blocks,
	      rawInlines = chunk.inlines,
	      rawEntities = chunk.entities;
	
	
	  var BlockNodeRecord = experimentalTreeDataSupport ? ContentBlockNode : ContentBlock;
	
	  return chunk.text.split('\r').reduce(function (acc, textBlock, index) {
	    // Make absolutely certain that our text is acceptable.
	    textBlock = sanitizeDraftText(textBlock);
	
	    var block = rawBlocks[index];
	    var end = start + textBlock.length;
	    var inlines = rawInlines.slice(start, end);
	    var entities = rawEntities.slice(start, end);
	    var characterList = List(inlines.map(function (style, index) {
	      var data = { style: style, entity: null };
	      if (entities[index]) {
	        data.entity = entities[index];
	      }
	      return CharacterMetadata.create(data);
	    }));
	    start = end + 1;
	
	    var depth = block.depth,
	        type = block.type,
	        parent = block.parent;
	
	
	    var key = block.key || generateRandomKey();
	    var parentTextNodeKey = null; // will be used to store container text nodes
	
	    // childrens add themselves to their parents since we are iterating in order
	    if (parent) {
	      var parentIndex = acc.cacheRef[parent];
	      var parentRecord = acc.contentBlocks[parentIndex];
	
	      // if parent has text we need to split it into a separate unstyled element
	      if (parentRecord.getChildKeys().isEmpty() && parentRecord.getText()) {
	        var parentCharacterList = parentRecord.getCharacterList();
	        var parentText = parentRecord.getText();
	        parentTextNodeKey = generateRandomKey();
	
	        var textNode = new ContentBlockNode({
	          key: parentTextNodeKey,
	          text: parentText,
	          characterList: parentCharacterList,
	          parent: parent,
	          nextSibling: key
	        });
	
	        acc.contentBlocks.push(textNode);
	
	        parentRecord = parentRecord.withMutations(function (block) {
	          block.set('characterList', List()).set('text', '').set('children', parentRecord.children.push(textNode.getKey()));
	        });
	      }
	
	      acc.contentBlocks[parentIndex] = parentRecord.set('children', parentRecord.children.push(key));
	    }
	
	    var blockNode = new BlockNodeRecord({
	      key: key,
	      parent: parent,
	      type: type,
	      depth: depth,
	      text: textBlock,
	      characterList: characterList,
	      prevSibling: parentTextNodeKey || (index === 0 || rawBlocks[index - 1].parent !== parent ? null : rawBlocks[index - 1].key),
	      nextSibling: index === rawBlocks.length - 1 || rawBlocks[index + 1].parent !== parent ? null : rawBlocks[index + 1].key
	    });
	
	    // insert node
	    acc.contentBlocks.push(blockNode);
	
	    // cache ref for building links
	    acc.cacheRef[blockNode.key] = index;
	
	    return acc;
	  }, initialState).contentBlocks;
	};
	
	var convertFromHTMLtoContentBlocks = function convertFromHTMLtoContentBlocks(html) {
	  var DOMBuilder = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : getSafeBodyFromHTML;
	  var blockRenderMap = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : DefaultDraftBlockRenderMap;
	
	  // Be ABSOLUTELY SURE that the dom builder you pass here won't execute
	  // arbitrary code in whatever environment you're running this in. For an
	  // example of how we try to do this in-browser, see getSafeBodyFromHTML.
	
	  // TODO: replace DraftEntity with an OrderedMap here
	  var chunkData = getChunkForHTML(html, DOMBuilder, blockRenderMap, DraftEntity);
	
	  if (chunkData == null) {
	    return null;
	  }
	
	  var chunk = chunkData.chunk,
	      entityMap = chunkData.entityMap;
	
	  var contentBlocks = convertChunkToContentBlocks(chunk);
	
	  return {
	    contentBlocks: contentBlocks,
	    entityMap: entityMap
	  };
	};
	
	module.exports = convertFromHTMLtoContentBlocks;

/***/ }),
/* 209 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule getDefaultKeyBinding
	 * @format
	 * 
	 */
	
	'use strict';
	
	var KeyBindingUtil = __webpack_require__(125);
	var Keys = __webpack_require__(130);
	var UserAgent = __webpack_require__(36);
	
	var isOSX = UserAgent.isPlatform('Mac OS X');
	var isWindows = UserAgent.isPlatform('Windows');
	
	// Firefox on OSX had a bug resulting in navigation instead of cursor movement.
	// This bug was fixed in Firefox 29. Feature detection is virtually impossible
	// so we just check the version number. See #342765.
	var shouldFixFirefoxMovement = isOSX && UserAgent.isBrowser('Firefox < 29');
	
	var hasCommandModifier = KeyBindingUtil.hasCommandModifier,
	    isCtrlKeyCommand = KeyBindingUtil.isCtrlKeyCommand;
	
	
	function shouldRemoveWord(e) {
	  return isOSX && e.altKey || isCtrlKeyCommand(e);
	}
	
	/**
	 * Get the appropriate undo/redo command for a Z key command.
	 */
	function getZCommand(e) {
	  if (!hasCommandModifier(e)) {
	    return null;
	  }
	  return e.shiftKey ? 'redo' : 'undo';
	}
	
	function getDeleteCommand(e) {
	  // Allow default "cut" behavior for Windows on Shift + Delete.
	  if (isWindows && e.shiftKey) {
	    return null;
	  }
	  return shouldRemoveWord(e) ? 'delete-word' : 'delete';
	}
	
	function getBackspaceCommand(e) {
	  if (hasCommandModifier(e) && isOSX) {
	    return 'backspace-to-start-of-line';
	  }
	  return shouldRemoveWord(e) ? 'backspace-word' : 'backspace';
	}
	
	/**
	 * Retrieve a bound key command for the given event.
	 */
	function getDefaultKeyBinding(e) {
	  switch (e.keyCode) {
	    case 66:
	      // B
	      return hasCommandModifier(e) ? 'bold' : null;
	    case 68:
	      // D
	      return isCtrlKeyCommand(e) ? 'delete' : null;
	    case 72:
	      // H
	      return isCtrlKeyCommand(e) ? 'backspace' : null;
	    case 73:
	      // I
	      return hasCommandModifier(e) ? 'italic' : null;
	    case 74:
	      // J
	      return hasCommandModifier(e) ? 'code' : null;
	    case 75:
	      // K
	      return !isWindows && isCtrlKeyCommand(e) ? 'secondary-cut' : null;
	    case 77:
	      // M
	      return isCtrlKeyCommand(e) ? 'split-block' : null;
	    case 79:
	      // O
	      return isCtrlKeyCommand(e) ? 'split-block' : null;
	    case 84:
	      // T
	      return isOSX && isCtrlKeyCommand(e) ? 'transpose-characters' : null;
	    case 85:
	      // U
	      return hasCommandModifier(e) ? 'underline' : null;
	    case 87:
	      // W
	      return isOSX && isCtrlKeyCommand(e) ? 'backspace-word' : null;
	    case 89:
	      // Y
	      if (isCtrlKeyCommand(e)) {
	        return isWindows ? 'redo' : 'secondary-paste';
	      }
	      return null;
	    case 90:
	      // Z
	      return getZCommand(e) || null;
	    case Keys.RETURN:
	      return 'split-block';
	    case Keys.DELETE:
	      return getDeleteCommand(e);
	    case Keys.BACKSPACE:
	      return getBackspaceCommand(e);
	    // LEFT/RIGHT handlers serve as a workaround for a Firefox bug.
	    case Keys.LEFT:
	      return shouldFixFirefoxMovement && hasCommandModifier(e) ? 'move-selection-to-start-of-block' : null;
	    case Keys.RIGHT:
	      return shouldFixFirefoxMovement && hasCommandModifier(e) ? 'move-selection-to-end-of-block' : null;
	    default:
	      return null;
	  }
	}
	
	module.exports = getDefaultKeyBinding;

/***/ }),
/* 210 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule getDraftEditorSelectionWithNodes
	 * @format
	 * 
	 */
	
	'use strict';
	
	var findAncestorOffsetKey = __webpack_require__(126);
	var getSelectionOffsetKeyForNode = __webpack_require__(215);
	var getUpdatedSelectionState = __webpack_require__(217);
	var invariant = __webpack_require__(12);
	var nullthrows = __webpack_require__(33);
	
	/**
	 * Convert the current selection range to an anchor/focus pair of offset keys
	 * and values that can be interpreted by components.
	 */
	function getDraftEditorSelectionWithNodes(editorState, root, anchorNode, anchorOffset, focusNode, focusOffset) {
	  var anchorIsTextNode = anchorNode.nodeType === Node.TEXT_NODE;
	  var focusIsTextNode = focusNode.nodeType === Node.TEXT_NODE;
	
	  // If the selection range lies only on text nodes, the task is simple.
	  // Find the nearest offset-aware elements and use the
	  // offset values supplied by the selection range.
	  if (anchorIsTextNode && focusIsTextNode) {
	    return {
	      selectionState: getUpdatedSelectionState(editorState, nullthrows(findAncestorOffsetKey(anchorNode)), anchorOffset, nullthrows(findAncestorOffsetKey(focusNode)), focusOffset),
	      needsRecovery: false
	    };
	  }
	
	  var anchorPoint = null;
	  var focusPoint = null;
	  var needsRecovery = true;
	
	  // An element is selected. Convert this selection range into leaf offset
	  // keys and offset values for consumption at the component level. This
	  // is common in Firefox, where select-all and triple click behavior leads
	  // to entire elements being selected.
	  //
	  // Note that we use the `needsRecovery` parameter in the callback here. This
	  // is because when certain elements are selected, the behavior for subsequent
	  // cursor movement (e.g. via arrow keys) is uncertain and may not match
	  // expectations at the component level. For example, if an entire <div> is
	  // selected and the user presses the right arrow, Firefox keeps the selection
	  // on the <div>. If we allow subsequent keypresses to insert characters
	  // natively, they will be inserted into a browser-created text node to the
	  // right of that <div>. This is obviously undesirable.
	  //
	  // With the `needsRecovery` flag, we inform the caller that it is responsible
	  // for manually setting the selection state on the rendered document to
	  // ensure proper selection state maintenance.
	
	  if (anchorIsTextNode) {
	    anchorPoint = {
	      key: nullthrows(findAncestorOffsetKey(anchorNode)),
	      offset: anchorOffset
	    };
	    focusPoint = getPointForNonTextNode(root, focusNode, focusOffset);
	  } else if (focusIsTextNode) {
	    focusPoint = {
	      key: nullthrows(findAncestorOffsetKey(focusNode)),
	      offset: focusOffset
	    };
	    anchorPoint = getPointForNonTextNode(root, anchorNode, anchorOffset);
	  } else {
	    anchorPoint = getPointForNonTextNode(root, anchorNode, anchorOffset);
	    focusPoint = getPointForNonTextNode(root, focusNode, focusOffset);
	
	    // If the selection is collapsed on an empty block, don't force recovery.
	    // This way, on arrow key selection changes, the browser can move the
	    // cursor from a non-zero offset on one block, through empty blocks,
	    // to a matching non-zero offset on other text blocks.
	    if (anchorNode === focusNode && anchorOffset === focusOffset) {
	      needsRecovery = !!anchorNode.firstChild && anchorNode.firstChild.nodeName !== 'BR';
	    }
	  }
	
	  return {
	    selectionState: getUpdatedSelectionState(editorState, anchorPoint.key, anchorPoint.offset, focusPoint.key, focusPoint.offset),
	    needsRecovery: needsRecovery
	  };
	}
	
	/**
	 * Identify the first leaf descendant for the given node.
	 */
	function getFirstLeaf(node) {
	  while (node.firstChild && (
	  // data-blocks has no offset
	  node.firstChild instanceof Element && node.firstChild.getAttribute('data-blocks') === 'true' || getSelectionOffsetKeyForNode(node.firstChild))) {
	    node = node.firstChild;
	  }
	  return node;
	}
	
	/**
	 * Identify the last leaf descendant for the given node.
	 */
	function getLastLeaf(node) {
	  while (node.lastChild && (
	  // data-blocks has no offset
	  node.lastChild instanceof Element && node.lastChild.getAttribute('data-blocks') === 'true' || getSelectionOffsetKeyForNode(node.lastChild))) {
	    node = node.lastChild;
	  }
	  return node;
	}
	
	function getPointForNonTextNode(editorRoot, startNode, childOffset) {
	  var node = startNode;
	  var offsetKey = findAncestorOffsetKey(node);
	
	  !(offsetKey != null || editorRoot && (editorRoot === node || editorRoot.firstChild === node)) ?  true ? invariant(false, 'Unknown node in selection range.') : invariant(false) : void 0;
	
	  // If the editorRoot is the selection, step downward into the content
	  // wrapper.
	  if (editorRoot === node) {
	    node = node.firstChild;
	    !(node instanceof Element && node.getAttribute('data-contents') === 'true') ?  true ? invariant(false, 'Invalid DraftEditorContents structure.') : invariant(false) : void 0;
	    if (childOffset > 0) {
	      childOffset = node.childNodes.length;
	    }
	  }
	
	  // If the child offset is zero and we have an offset key, we're done.
	  // If there's no offset key because the entire editor is selected,
	  // find the leftmost ("first") leaf in the tree and use that as the offset
	  // key.
	  if (childOffset === 0) {
	    var key = null;
	    if (offsetKey != null) {
	      key = offsetKey;
	    } else {
	      var firstLeaf = getFirstLeaf(node);
	      key = nullthrows(getSelectionOffsetKeyForNode(firstLeaf));
	    }
	    return { key: key, offset: 0 };
	  }
	
	  var nodeBeforeCursor = node.childNodes[childOffset - 1];
	  var leafKey = null;
	  var textLength = null;
	
	  if (!getSelectionOffsetKeyForNode(nodeBeforeCursor)) {
	    // Our target node may be a leaf or a text node, in which case we're
	    // already where we want to be and can just use the child's length as
	    // our offset.
	    leafKey = nullthrows(offsetKey);
	    textLength = getTextContentLength(nodeBeforeCursor);
	  } else {
	    // Otherwise, we'll look at the child to the left of the cursor and find
	    // the last leaf node in its subtree.
	    var lastLeaf = getLastLeaf(nodeBeforeCursor);
	    leafKey = nullthrows(getSelectionOffsetKeyForNode(lastLeaf));
	    textLength = getTextContentLength(lastLeaf);
	  }
	
	  return {
	    key: leafKey,
	    offset: textLength
	  };
	}
	
	/**
	 * Return the length of a node's textContent, regarding single newline
	 * characters as zero-length. This allows us to avoid problems with identifying
	 * the correct selection offset for empty blocks in IE, in which we
	 * render newlines instead of break tags.
	 */
	function getTextContentLength(node) {
	  var textContent = node.textContent;
	  return textContent === '\n' ? 0 : textContent.length;
	}
	
	module.exports = getDraftEditorSelectionWithNodes;

/***/ }),
/* 211 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule getFragmentFromSelection
	 * @format
	 * 
	 */
	
	'use strict';
	
	var getContentStateFragment = __webpack_require__(90);
	
	function getFragmentFromSelection(editorState) {
	  var selectionState = editorState.getSelection();
	
	  if (selectionState.isCollapsed()) {
	    return null;
	  }
	
	  return getContentStateFragment(editorState.getCurrentContent(), selectionState);
	}
	
	module.exports = getFragmentFromSelection;

/***/ }),
/* 212 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule getNextDelimiterBlockKey
	 * @format
	 * 
	 *
	 * This is unstable and not part of the public API and should not be used by
	 * production systems. This file may be update/removed without notice.
	 */
	
	var ContentBlockNode = __webpack_require__(30);
	
	var getNextDelimiterBlockKey = function getNextDelimiterBlockKey(block, blockMap) {
	  var isExperimentalTreeBlock = block instanceof ContentBlockNode;
	
	  if (!isExperimentalTreeBlock) {
	    return null;
	  }
	
	  var nextSiblingKey = block.getNextSiblingKey();
	
	  if (nextSiblingKey) {
	    return nextSiblingKey;
	  }
	
	  var parent = block.getParentKey();
	
	  if (!parent) {
	    return null;
	  }
	
	  var nextNonDescendantBlock = blockMap.get(parent);
	  while (nextNonDescendantBlock && !nextNonDescendantBlock.getNextSiblingKey()) {
	    var parentKey = nextNonDescendantBlock.getParentKey();
	    nextNonDescendantBlock = parentKey ? blockMap.get(parentKey) : null;
	  }
	
	  if (!nextNonDescendantBlock) {
	    return null;
	  }
	
	  return nextNonDescendantBlock.getNextSiblingKey();
	};
	
	module.exports = getNextDelimiterBlockKey;

/***/ }),
/* 213 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule getRangeClientRects
	 * @format
	 * 
	 */
	
	'use strict';
	
	var UserAgent = __webpack_require__(36);
	
	var invariant = __webpack_require__(12);
	
	var isChrome = UserAgent.isBrowser('Chrome');
	
	// In Chrome, the client rects will include the entire bounds of all nodes that
	// begin (have a start tag) within the selection, even if the selection does
	// not overlap the entire node. To resolve this, we split the range at each
	// start tag and join the client rects together.
	// https://code.google.com/p/chromium/issues/detail?id=324437
	/* eslint-disable consistent-return */
	function getRangeClientRectsChrome(range) {
	  var tempRange = range.cloneRange();
	  var clientRects = [];
	
	  for (var ancestor = range.endContainer; ancestor != null; ancestor = ancestor.parentNode) {
	    // If we've climbed up to the common ancestor, we can now use the
	    // original start point and stop climbing the tree.
	    var atCommonAncestor = ancestor === range.commonAncestorContainer;
	    if (atCommonAncestor) {
	      tempRange.setStart(range.startContainer, range.startOffset);
	    } else {
	      tempRange.setStart(tempRange.endContainer, 0);
	    }
	    var rects = Array.from(tempRange.getClientRects());
	    clientRects.push(rects);
	    if (atCommonAncestor) {
	      var _ref;
	
	      clientRects.reverse();
	      return (_ref = []).concat.apply(_ref, clientRects);
	    }
	    tempRange.setEndBefore(ancestor);
	  }
	
	   true ?  true ? invariant(false, 'Found an unexpected detached subtree when getting range client rects.') : invariant(false) : void 0;
	}
	/* eslint-enable consistent-return */
	
	/**
	 * Like range.getClientRects() but normalizes for browser bugs.
	 */
	var getRangeClientRects = isChrome ? getRangeClientRectsChrome : function (range) {
	  return Array.from(range.getClientRects());
	};
	
	module.exports = getRangeClientRects;

/***/ }),
/* 214 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule getSafeBodyFromHTML
	 * @format
	 * 
	 */
	
	'use strict';
	
	var UserAgent = __webpack_require__(36);
	
	var invariant = __webpack_require__(12);
	
	var isOldIE = UserAgent.isBrowser('IE <= 9');
	
	// Provides a dom node that will not execute scripts
	// https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation.createHTMLDocument
	// https://developer.mozilla.org/en-US/Add-ons/Code_snippets/HTML_to_DOM
	
	function getSafeBodyFromHTML(html) {
	  var doc;
	  var root = null;
	  // Provides a safe context
	  if (!isOldIE && document.implementation && document.implementation.createHTMLDocument) {
	    doc = document.implementation.createHTMLDocument('foo');
	    !doc.documentElement ?  true ? invariant(false, 'Missing doc.documentElement') : invariant(false) : void 0;
	    doc.documentElement.innerHTML = html;
	    root = doc.getElementsByTagName('body')[0];
	  }
	  return root;
	}
	
	module.exports = getSafeBodyFromHTML;

/***/ }),
/* 215 */
/***/ (function(module, exports) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule getSelectionOffsetKeyForNode
	 * @format
	 * 
	 */
	
	'use strict';
	
	/**
	 * Get offset key from a node or it's child nodes. Return the first offset key
	 * found on the DOM tree of given node.
	 */
	
	function getSelectionOffsetKeyForNode(node) {
	  if (node instanceof Element) {
	    var offsetKey = node.getAttribute('data-offset-key');
	    if (offsetKey) {
	      return offsetKey;
	    }
	    for (var ii = 0; ii < node.childNodes.length; ii++) {
	      var childOffsetKey = getSelectionOffsetKeyForNode(node.childNodes[ii]);
	      if (childOffsetKey) {
	        return childOffsetKey;
	      }
	    }
	  }
	  return null;
	}
	
	module.exports = getSelectionOffsetKeyForNode;

/***/ }),
/* 216 */
/***/ (function(module, exports, __webpack_require__) {

	/* WEBPACK VAR INJECTION */(function(global) {/**
	 * 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.
	 *
	 * @providesModule getTextContentFromFiles
	 * @format
	 * 
	 */
	
	'use strict';
	
	var invariant = __webpack_require__(12);
	
	var TEXT_CLIPPING_REGEX = /\.textClipping$/;
	
	var TEXT_TYPES = {
	  'text/plain': true,
	  'text/html': true,
	  'text/rtf': true
	};
	
	// Somewhat arbitrary upper bound on text size. Let's not lock up the browser.
	var TEXT_SIZE_UPPER_BOUND = 5000;
	
	/**
	 * Extract the text content from a file list.
	 */
	function getTextContentFromFiles(files, callback) {
	  var readCount = 0;
	  var results = [];
	  files.forEach(function ( /*blob*/file) {
	    readFile(file, function ( /*string*/text) {
	      readCount++;
	      text && results.push(text.slice(0, TEXT_SIZE_UPPER_BOUND));
	      if (readCount == files.length) {
	        callback(results.join('\r'));
	      }
	    });
	  });
	}
	
	/**
	 * todo isaac: Do work to turn html/rtf into a content fragment.
	 */
	function readFile(file, callback) {
	  if (!global.FileReader || file.type && !(file.type in TEXT_TYPES)) {
	    callback('');
	    return;
	  }
	
	  if (file.type === '') {
	    var contents = '';
	    // Special-case text clippings, which have an empty type but include
	    // `.textClipping` in the file name. `readAsText` results in an empty
	    // string for text clippings, so we force the file name to serve
	    // as the text value for the file.
	    if (TEXT_CLIPPING_REGEX.test(file.name)) {
	      contents = file.name.replace(TEXT_CLIPPING_REGEX, '');
	    }
	    callback(contents);
	    return;
	  }
	
	  var reader = new FileReader();
	  reader.onload = function () {
	    var result = reader.result;
	    !(typeof result === 'string') ?  true ? invariant(false, 'We should be calling "FileReader.readAsText" which returns a string') : invariant(false) : void 0;
	    callback(result);
	  };
	  reader.onerror = function () {
	    callback('');
	  };
	  reader.readAsText(file);
	}
	
	module.exports = getTextContentFromFiles;
	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))

/***/ }),
/* 217 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule getUpdatedSelectionState
	 * @format
	 * 
	 */
	
	'use strict';
	
	var DraftOffsetKey = __webpack_require__(71);
	
	var nullthrows = __webpack_require__(33);
	
	function getUpdatedSelectionState(editorState, anchorKey, anchorOffset, focusKey, focusOffset) {
	  var selection = nullthrows(editorState.getSelection());
	  if (true) {
	    if (!anchorKey || !focusKey) {
	      /*eslint-disable no-console */
	      console.warn('Invalid selection state.', arguments, editorState.toJS());
	      /*eslint-enable no-console */
	      return selection;
	    }
	  }
	
	  var anchorPath = DraftOffsetKey.decode(anchorKey);
	  var anchorBlockKey = anchorPath.blockKey;
	  var anchorLeaf = editorState.getBlockTree(anchorBlockKey).getIn([anchorPath.decoratorKey, 'leaves', anchorPath.leafKey]);
	
	  var focusPath = DraftOffsetKey.decode(focusKey);
	  var focusBlockKey = focusPath.blockKey;
	  var focusLeaf = editorState.getBlockTree(focusBlockKey).getIn([focusPath.decoratorKey, 'leaves', focusPath.leafKey]);
	
	  var anchorLeafStart = anchorLeaf.get('start');
	  var focusLeafStart = focusLeaf.get('start');
	
	  var anchorBlockOffset = anchorLeaf ? anchorLeafStart + anchorOffset : null;
	  var focusBlockOffset = focusLeaf ? focusLeafStart + focusOffset : null;
	
	  var areEqual = selection.getAnchorKey() === anchorBlockKey && selection.getAnchorOffset() === anchorBlockOffset && selection.getFocusKey() === focusBlockKey && selection.getFocusOffset() === focusBlockOffset;
	
	  if (areEqual) {
	    return selection;
	  }
	
	  var isBackward = false;
	  if (anchorBlockKey === focusBlockKey) {
	    var anchorLeafEnd = anchorLeaf.get('end');
	    var focusLeafEnd = focusLeaf.get('end');
	    if (focusLeafStart === anchorLeafStart && focusLeafEnd === anchorLeafEnd) {
	      isBackward = focusOffset < anchorOffset;
	    } else {
	      isBackward = focusLeafStart < anchorLeafStart;
	    }
	  } else {
	    var startKey = editorState.getCurrentContent().getBlockMap().keySeq().skipUntil(function (v) {
	      return v === anchorBlockKey || v === focusBlockKey;
	    }).first();
	    isBackward = startKey === focusBlockKey;
	  }
	
	  return selection.merge({
	    anchorKey: anchorBlockKey,
	    anchorOffset: anchorBlockOffset,
	    focusKey: focusBlockKey,
	    focusOffset: focusBlockOffset,
	    isBackward: isBackward
	  });
	}
	
	module.exports = getUpdatedSelectionState;

/***/ }),
/* 218 */
/***/ (function(module, exports) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule insertIntoList
	 * @format
	 * 
	 */
	
	'use strict';
	
	/**
	 * Maintain persistence for target list when appending and prepending.
	 */
	function insertIntoList(targetList, toInsert, offset) {
	  if (offset === targetList.count()) {
	    toInsert.forEach(function (c) {
	      targetList = targetList.push(c);
	    });
	  } else if (offset === 0) {
	    toInsert.reverse().forEach(function (c) {
	      targetList = targetList.unshift(c);
	    });
	  } else {
	    var head = targetList.slice(0, offset);
	    var tail = targetList.slice(offset);
	    targetList = head.concat(toInsert, tail).toList();
	  }
	  return targetList;
	}
	
	module.exports = insertIntoList;

/***/ }),
/* 219 */
/***/ (function(module, exports) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule isSelectionAtLeafStart
	 * @format
	 * 
	 */
	
	'use strict';
	
	function isSelectionAtLeafStart(editorState) {
	  var selection = editorState.getSelection();
	  var anchorKey = selection.getAnchorKey();
	  var blockTree = editorState.getBlockTree(anchorKey);
	  var offset = selection.getStartOffset();
	
	  var isAtStart = false;
	
	  blockTree.some(function (leafSet) {
	    if (offset === leafSet.get('start')) {
	      isAtStart = true;
	      return true;
	    }
	
	    if (offset < leafSet.get('end')) {
	      return leafSet.get('leaves').some(function (leaf) {
	        var leafStart = leaf.get('start');
	        if (offset === leafStart) {
	          isAtStart = true;
	          return true;
	        }
	
	        return false;
	      });
	    }
	
	    return false;
	  });
	
	  return isAtStart;
	}
	
	module.exports = isSelectionAtLeafStart;

/***/ }),
/* 220 */
/***/ (function(module, exports) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule moveSelectionForward
	 * @format
	 * 
	 */
	
	'use strict';
	
	/**
	 * Given a collapsed selection, move the focus `maxDistance` forward within
	 * the selected block. If the selection will go beyond the end of the block,
	 * move focus to the start of the next block, but no further.
	 *
	 * This function is not Unicode-aware, so surrogate pairs will be treated
	 * as having length 2.
	 */
	function moveSelectionForward(editorState, maxDistance) {
	  var selection = editorState.getSelection();
	  var key = selection.getStartKey();
	  var offset = selection.getStartOffset();
	  var content = editorState.getCurrentContent();
	
	  var focusKey = key;
	  var focusOffset;
	
	  var block = content.getBlockForKey(key);
	
	  if (maxDistance > block.getText().length - offset) {
	    focusKey = content.getKeyAfter(key);
	    focusOffset = 0;
	  } else {
	    focusOffset = offset + maxDistance;
	  }
	
	  return selection.merge({ focusKey: focusKey, focusOffset: focusOffset });
	}
	
	module.exports = moveSelectionForward;

/***/ }),
/* 221 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule randomizeBlockMapKeys
	 * @format
	 * 
	 */
	
	'use strict';
	
	var ContentBlockNode = __webpack_require__(30);
	var Immutable = __webpack_require__(11);
	
	var generateRandomKey = __webpack_require__(37);
	
	var OrderedMap = Immutable.OrderedMap;
	
	
	var randomizeContentBlockNodeKeys = function randomizeContentBlockNodeKeys(blockMap) {
	  var newKeysRef = {};
	
	  // we keep track of root blocks in order to update subsequent sibling links
	  var lastRootBlock = void 0;
	
	  return OrderedMap(blockMap.withMutations(function (blockMapState) {
	    blockMapState.forEach(function (block, index) {
	      var oldKey = block.getKey();
	      var nextKey = block.getNextSiblingKey();
	      var prevKey = block.getPrevSiblingKey();
	      var childrenKeys = block.getChildKeys();
	      var parentKey = block.getParentKey();
	
	      // new key that we will use to build linking
	      var key = generateRandomKey();
	
	      // we will add it here to re-use it later
	      newKeysRef[oldKey] = key;
	
	      if (nextKey) {
	        var nextBlock = blockMapState.get(nextKey);
	        if (nextBlock) {
	          blockMapState.setIn([nextKey, 'prevSibling'], key);
	        } else {
	          // this can happen when generating random keys for fragments
	          blockMapState.setIn([oldKey, 'nextSibling'], null);
	        }
	      }
	
	      if (prevKey) {
	        var prevBlock = blockMapState.get(prevKey);
	        if (prevBlock) {
	          blockMapState.setIn([prevKey, 'nextSibling'], key);
	        } else {
	          // this can happen when generating random keys for fragments
	          blockMapState.setIn([oldKey, 'prevSibling'], null);
	        }
	      }
	
	      if (parentKey && blockMapState.get(parentKey)) {
	        var parentBlock = blockMapState.get(parentKey);
	        var parentChildrenList = parentBlock.getChildKeys();
	        blockMapState.setIn([parentKey, 'children'], parentChildrenList.set(parentChildrenList.indexOf(block.getKey()), key));
	      } else {
	        // blocks will then be treated as root block nodes
	        blockMapState.setIn([oldKey, 'parent'], null);
	
	        if (lastRootBlock) {
	          blockMapState.setIn([lastRootBlock.getKey(), 'nextSibling'], key);
	          blockMapState.setIn([oldKey, 'prevSibling'], newKeysRef[lastRootBlock.getKey()]);
	        }
	
	        lastRootBlock = blockMapState.get(oldKey);
	      }
	
	      childrenKeys.forEach(function (childKey) {
	        var childBlock = blockMapState.get(childKey);
	        if (childBlock) {
	          blockMapState.setIn([childKey, 'parent'], key);
	        } else {
	          blockMapState.setIn([oldKey, 'children'], block.getChildKeys().filter(function (child) {
	            return child !== childKey;
	          }));
	        }
	      });
	    });
	  }).toArray().map(function (block) {
	    return [newKeysRef[block.getKey()], block.set('key', newKeysRef[block.getKey()])];
	  }));
	};
	
	var randomizeContentBlockKeys = function randomizeContentBlockKeys(blockMap) {
	  return OrderedMap(blockMap.toArray().map(function (block) {
	    var key = generateRandomKey();
	    return [key, block.set('key', key)];
	  }));
	};
	
	var randomizeBlockMapKeys = function randomizeBlockMapKeys(blockMap) {
	  var isTreeBasedBlockMap = blockMap.first() instanceof ContentBlockNode;
	
	  if (!isTreeBasedBlockMap) {
	    return randomizeContentBlockKeys(blockMap);
	  }
	
	  return randomizeContentBlockNodeKeys(blockMap);
	};
	
	module.exports = randomizeBlockMapKeys;

/***/ }),
/* 222 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule removeEntitiesAtEdges
	 * @format
	 * 
	 */
	
	'use strict';
	
	var CharacterMetadata = __webpack_require__(27);
	
	var findRangesImmutable = __webpack_require__(72);
	var invariant = __webpack_require__(12);
	
	function removeEntitiesAtEdges(contentState, selectionState) {
	  var blockMap = contentState.getBlockMap();
	  var entityMap = contentState.getEntityMap();
	
	  var updatedBlocks = {};
	
	  var startKey = selectionState.getStartKey();
	  var startOffset = selectionState.getStartOffset();
	  var startBlock = blockMap.get(startKey);
	  var updatedStart = removeForBlock(entityMap, startBlock, startOffset);
	
	  if (updatedStart !== startBlock) {
	    updatedBlocks[startKey] = updatedStart;
	  }
	
	  var endKey = selectionState.getEndKey();
	  var endOffset = selectionState.getEndOffset();
	  var endBlock = blockMap.get(endKey);
	  if (startKey === endKey) {
	    endBlock = updatedStart;
	  }
	
	  var updatedEnd = removeForBlock(entityMap, endBlock, endOffset);
	
	  if (updatedEnd !== endBlock) {
	    updatedBlocks[endKey] = updatedEnd;
	  }
	
	  if (!Object.keys(updatedBlocks).length) {
	    return contentState.set('selectionAfter', selectionState);
	  }
	
	  return contentState.merge({
	    blockMap: blockMap.merge(updatedBlocks),
	    selectionAfter: selectionState
	  });
	}
	
	function getRemovalRange(characters, key, offset) {
	  var removalRange;
	  findRangesImmutable(characters, function (a, b) {
	    return a.getEntity() === b.getEntity();
	  }, function (element) {
	    return element.getEntity() === key;
	  }, function (start, end) {
	    if (start <= offset && end >= offset) {
	      removalRange = { start: start, end: end };
	    }
	  });
	  !(typeof removalRange === 'object') ?  true ? invariant(false, 'Removal range must exist within character list.') : invariant(false) : void 0;
	  return removalRange;
	}
	
	function removeForBlock(entityMap, block, offset) {
	  var chars = block.getCharacterList();
	  var charBefore = offset > 0 ? chars.get(offset - 1) : undefined;
	  var charAfter = offset < chars.count() ? chars.get(offset) : undefined;
	  var entityBeforeCursor = charBefore ? charBefore.getEntity() : undefined;
	  var entityAfterCursor = charAfter ? charAfter.getEntity() : undefined;
	
	  if (entityAfterCursor && entityAfterCursor === entityBeforeCursor) {
	    var entity = entityMap.__get(entityAfterCursor);
	    if (entity.getMutability() !== 'MUTABLE') {
	      var _getRemovalRange = getRemovalRange(chars, entityAfterCursor, offset),
	          start = _getRemovalRange.start,
	          end = _getRemovalRange.end;
	
	      var current;
	      while (start < end) {
	        current = chars.get(start);
	        chars = chars.set(start, CharacterMetadata.applyEntity(current, null));
	        start++;
	      }
	      return block.set('characterList', chars);
	    }
	  }
	
	  return block;
	}
	
	module.exports = removeEntitiesAtEdges;

/***/ }),
/* 223 */
/***/ (function(module, exports) {

	/**
	 * Helper function for iterating over a collection
	 *
	 * @param collection
	 * @param fn
	 */
	function each(collection, fn) {
	    var i      = 0,
	        length = collection.length,
	        cont;
	
	    for(i; i < length; i++) {
	        cont = fn(collection[i], i);
	        if(cont === false) {
	            break; //allow early exit
	        }
	    }
	}
	
	/**
	 * Helper function for determining whether target object is an array
	 *
	 * @param target the object under test
	 * @return {Boolean} true if array, false otherwise
	 */
	function isArray(target) {
	    return Object.prototype.toString.apply(target) === '[object Array]';
	}
	
	/**
	 * Helper function for determining whether target object is a function
	 *
	 * @param target the object under test
	 * @return {Boolean} true if function, false otherwise
	 */
	function isFunction(target) {
	    return typeof target === 'function';
	}
	
	module.exports = {
	    isFunction : isFunction,
	    isArray : isArray,
	    each : each
	};


/***/ }),
/* 224 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 * @typechecks
	 */
	
	var PhotosMimeType = __webpack_require__(551);
	
	var createArrayFromMixed = __webpack_require__(558);
	var emptyFunction = __webpack_require__(75);
	
	var CR_LF_REGEX = new RegExp('\r\n', 'g');
	var LF_ONLY = '\n';
	
	var RICH_TEXT_TYPES = {
	  'text/rtf': 1,
	  'text/html': 1
	};
	
	/**
	 * If DataTransferItem is a file then return the Blob of data.
	 *
	 * @param {object} item
	 * @return {?blob}
	 */
	function getFileFromDataTransfer(item) {
	  if (item.kind == 'file') {
	    return item.getAsFile();
	  }
	}
	
	var DataTransfer = function () {
	  /**
	   * @param {object} data
	   */
	  function DataTransfer(data) {
	    _classCallCheck(this, DataTransfer);
	
	    this.data = data;
	
	    // Types could be DOMStringList or array
	    this.types = data.types ? createArrayFromMixed(data.types) : [];
	  }
	
	  /**
	   * Is this likely to be a rich text data transfer?
	   *
	   * @return {boolean}
	   */
	
	
	  DataTransfer.prototype.isRichText = function isRichText() {
	    // If HTML is available, treat this data as rich text. This way, we avoid
	    // using a pasted image if it is packaged with HTML -- this may occur with
	    // pastes from MS Word, for example.  However this is only rich text if
	    // there's accompanying text.
	    if (this.getHTML() && this.getText()) {
	      return true;
	    }
	
	    // When an image is copied from a preview window, you end up with two
	    // DataTransferItems one of which is a file's metadata as text.  Skip those.
	    if (this.isImage()) {
	      return false;
	    }
	
	    return this.types.some(function (type) {
	      return RICH_TEXT_TYPES[type];
	    });
	  };
	
	  /**
	   * Get raw text.
	   *
	   * @return {?string}
	   */
	
	
	  DataTransfer.prototype.getText = function getText() {
	    var text;
	    if (this.data.getData) {
	      if (!this.types.length) {
	        text = this.data.getData('Text');
	      } else if (this.types.indexOf('text/plain') != -1) {
	        text = this.data.getData('text/plain');
	      }
	    }
	    return text ? text.replace(CR_LF_REGEX, LF_ONLY) : null;
	  };
	
	  /**
	   * Get HTML paste data
	   *
	   * @return {?string}
	   */
	
	
	  DataTransfer.prototype.getHTML = function getHTML() {
	    if (this.data.getData) {
	      if (!this.types.length) {
	        return this.data.getData('Text');
	      } else if (this.types.indexOf('text/html') != -1) {
	        return this.data.getData('text/html');
	      }
	    }
	  };
	
	  /**
	   * Is this a link data transfer?
	   *
	   * @return {boolean}
	   */
	
	
	  DataTransfer.prototype.isLink = function isLink() {
	    return this.types.some(function (type) {
	      return type.indexOf('Url') != -1 || type.indexOf('text/uri-list') != -1 || type.indexOf('text/x-moz-url');
	    });
	  };
	
	  /**
	   * Get a link url.
	   *
	   * @return {?string}
	   */
	
	
	  DataTransfer.prototype.getLink = function getLink() {
	    if (this.data.getData) {
	      if (this.types.indexOf('text/x-moz-url') != -1) {
	        var url = this.data.getData('text/x-moz-url').split('\n');
	        return url[0];
	      }
	      return this.types.indexOf('text/uri-list') != -1 ? this.data.getData('text/uri-list') : this.data.getData('url');
	    }
	
	    return null;
	  };
	
	  /**
	   * Is this an image data transfer?
	   *
	   * @return {boolean}
	   */
	
	
	  DataTransfer.prototype.isImage = function isImage() {
	    var isImage = this.types.some(function (type) {
	      // Firefox will have a type of application/x-moz-file for images during
	      // dragging
	      return type.indexOf('application/x-moz-file') != -1;
	    });
	
	    if (isImage) {
	      return true;
	    }
	
	    var items = this.getFiles();
	    for (var i = 0; i < items.length; i++) {
	      var type = items[i].type;
	      if (!PhotosMimeType.isImage(type)) {
	        return false;
	      }
	    }
	
	    return true;
	  };
	
	  DataTransfer.prototype.getCount = function getCount() {
	    if (this.data.hasOwnProperty('items')) {
	      return this.data.items.length;
	    } else if (this.data.hasOwnProperty('mozItemCount')) {
	      return this.data.mozItemCount;
	    } else if (this.data.files) {
	      return this.data.files.length;
	    }
	    return null;
	  };
	
	  /**
	   * Get files.
	   *
	   * @return {array}
	   */
	
	
	  DataTransfer.prototype.getFiles = function getFiles() {
	    if (this.data.items) {
	      // createArrayFromMixed doesn't properly handle DataTransferItemLists.
	      return Array.prototype.slice.call(this.data.items).map(getFileFromDataTransfer).filter(emptyFunction.thatReturnsArgument);
	    } else if (this.data.files) {
	      return Array.prototype.slice.call(this.data.files);
	    } else {
	      return [];
	    }
	  };
	
	  /**
	   * Are there any files to fetch?
	   *
	   * @return {boolean}
	   */
	
	
	  DataTransfer.prototype.hasFiles = function hasFiles() {
	    return this.getFiles().length > 0;
	  };
	
	  return DataTransfer;
	}();
	
	module.exports = DataTransfer;

/***/ }),
/* 225 */
/***/ (function(module, exports) {

	"use strict";
	
	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 */
	
	/**
	 * @param {DOMElement} element
	 * @param {DOMDocument} doc
	 * @return {boolean}
	 */
	function _isViewportScrollElement(element, doc) {
	  return !!doc && (element === doc.documentElement || element === doc.body);
	}
	
	/**
	 * Scroll Module. This class contains 4 simple static functions
	 * to be used to access Element.scrollTop/scrollLeft properties.
	 * To solve the inconsistencies between browsers when either
	 * document.body or document.documentElement is supplied,
	 * below logic will be used to alleviate the issue:
	 *
	 * 1. If 'element' is either 'document.body' or 'document.documentElement,
	 *    get whichever element's 'scroll{Top,Left}' is larger.
	 * 2. If 'element' is either 'document.body' or 'document.documentElement',
	 *    set the 'scroll{Top,Left}' on both elements.
	 */
	
	var Scroll = {
	  /**
	   * @param {DOMElement} element
	   * @return {number}
	   */
	  getTop: function getTop(element) {
	    var doc = element.ownerDocument;
	    return _isViewportScrollElement(element, doc) ?
	    // In practice, they will either both have the same value,
	    // or one will be zero and the other will be the scroll position
	    // of the viewport. So we can use `X || Y` instead of `Math.max(X, Y)`
	    doc.body.scrollTop || doc.documentElement.scrollTop : element.scrollTop;
	  },
	
	  /**
	   * @param {DOMElement} element
	   * @param {number} newTop
	   */
	  setTop: function setTop(element, newTop) {
	    var doc = element.ownerDocument;
	    if (_isViewportScrollElement(element, doc)) {
	      doc.body.scrollTop = doc.documentElement.scrollTop = newTop;
	    } else {
	      element.scrollTop = newTop;
	    }
	  },
	
	  /**
	   * @param {DOMElement} element
	   * @return {number}
	   */
	  getLeft: function getLeft(element) {
	    var doc = element.ownerDocument;
	    return _isViewportScrollElement(element, doc) ? doc.body.scrollLeft || doc.documentElement.scrollLeft : element.scrollLeft;
	  },
	
	  /**
	   * @param {DOMElement} element
	   * @param {number} newLeft
	   */
	  setLeft: function setLeft(element, newLeft) {
	    var doc = element.ownerDocument;
	    if (_isViewportScrollElement(element, doc)) {
	      doc.body.scrollLeft = doc.documentElement.scrollLeft = newLeft;
	    } else {
	      element.scrollLeft = newLeft;
	    }
	  }
	};
	
	module.exports = Scroll;

/***/ }),
/* 226 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 * @typechecks
	 * 
	 */
	
	/**
	 * Basic (stateless) API for text direction detection
	 *
	 * Part of our implementation of Unicode Bidirectional Algorithm (UBA)
	 * Unicode Standard Annex #9 (UAX9)
	 * http://www.unicode.org/reports/tr9/
	 */
	
	'use strict';
	
	var UnicodeBidiDirection = __webpack_require__(132);
	
	var invariant = __webpack_require__(12);
	
	/**
	 * RegExp ranges of characters with a *Strong* Bidi_Class value.
	 *
	 * Data is based on DerivedBidiClass.txt in UCD version 7.0.0.
	 *
	 * NOTE: For performance reasons, we only support Unicode's
	 *       Basic Multilingual Plane (BMP) for now.
	 */
	var RANGE_BY_BIDI_TYPE = {
	
	  L: 'A-Za-z\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u01BA\u01BB' + '\u01BC-\u01BF\u01C0-\u01C3\u01C4-\u0293\u0294\u0295-\u02AF\u02B0-\u02B8' + '\u02BB-\u02C1\u02D0-\u02D1\u02E0-\u02E4\u02EE\u0370-\u0373\u0376-\u0377' + '\u037A\u037B-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1' + '\u03A3-\u03F5\u03F7-\u0481\u0482\u048A-\u052F\u0531-\u0556\u0559' + '\u055A-\u055F\u0561-\u0587\u0589\u0903\u0904-\u0939\u093B\u093D' + '\u093E-\u0940\u0949-\u094C\u094E-\u094F\u0950\u0958-\u0961\u0964-\u0965' + '\u0966-\u096F\u0970\u0971\u0972-\u0980\u0982-\u0983\u0985-\u098C' + '\u098F-\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD' + '\u09BE-\u09C0\u09C7-\u09C8\u09CB-\u09CC\u09CE\u09D7\u09DC-\u09DD' + '\u09DF-\u09E1\u09E6-\u09EF\u09F0-\u09F1\u09F4-\u09F9\u09FA\u0A03' + '\u0A05-\u0A0A\u0A0F-\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32-\u0A33' + '\u0A35-\u0A36\u0A38-\u0A39\u0A3E-\u0A40\u0A59-\u0A5C\u0A5E\u0A66-\u0A6F' + '\u0A72-\u0A74\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0' + '\u0AB2-\u0AB3\u0AB5-\u0AB9\u0ABD\u0ABE-\u0AC0\u0AC9\u0ACB-\u0ACC\u0AD0' + '\u0AE0-\u0AE1\u0AE6-\u0AEF\u0AF0\u0B02-\u0B03\u0B05-\u0B0C\u0B0F-\u0B10' + '\u0B13-\u0B28\u0B2A-\u0B30\u0B32-\u0B33\u0B35-\u0B39\u0B3D\u0B3E\u0B40' + '\u0B47-\u0B48\u0B4B-\u0B4C\u0B57\u0B5C-\u0B5D\u0B5F-\u0B61\u0B66-\u0B6F' + '\u0B70\u0B71\u0B72-\u0B77\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95' + '\u0B99-\u0B9A\u0B9C\u0B9E-\u0B9F\u0BA3-\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9' + '\u0BBE-\u0BBF\u0BC1-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCC\u0BD0\u0BD7' + '\u0BE6-\u0BEF\u0BF0-\u0BF2\u0C01-\u0C03\u0C05-\u0C0C\u0C0E-\u0C10' + '\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C41-\u0C44\u0C58-\u0C59\u0C60-\u0C61' + '\u0C66-\u0C6F\u0C7F\u0C82-\u0C83\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8' + '\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CBE\u0CBF\u0CC0-\u0CC4\u0CC6' + '\u0CC7-\u0CC8\u0CCA-\u0CCB\u0CD5-\u0CD6\u0CDE\u0CE0-\u0CE1\u0CE6-\u0CEF' + '\u0CF1-\u0CF2\u0D02-\u0D03\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D' + '\u0D3E-\u0D40\u0D46-\u0D48\u0D4A-\u0D4C\u0D4E\u0D57\u0D60-\u0D61' + '\u0D66-\u0D6F\u0D70-\u0D75\u0D79\u0D7A-\u0D7F\u0D82-\u0D83\u0D85-\u0D96' + '\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCF-\u0DD1\u0DD8-\u0DDF' + '\u0DE6-\u0DEF\u0DF2-\u0DF3\u0DF4\u0E01-\u0E30\u0E32-\u0E33\u0E40-\u0E45' + '\u0E46\u0E4F\u0E50-\u0E59\u0E5A-\u0E5B\u0E81-\u0E82\u0E84\u0E87-\u0E88' + '\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7' + '\u0EAA-\u0EAB\u0EAD-\u0EB0\u0EB2-\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6' + '\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F01-\u0F03\u0F04-\u0F12\u0F13\u0F14' + '\u0F15-\u0F17\u0F1A-\u0F1F\u0F20-\u0F29\u0F2A-\u0F33\u0F34\u0F36\u0F38' + '\u0F3E-\u0F3F\u0F40-\u0F47\u0F49-\u0F6C\u0F7F\u0F85\u0F88-\u0F8C' + '\u0FBE-\u0FC5\u0FC7-\u0FCC\u0FCE-\u0FCF\u0FD0-\u0FD4\u0FD5-\u0FD8' + '\u0FD9-\u0FDA\u1000-\u102A\u102B-\u102C\u1031\u1038\u103B-\u103C\u103F' + '\u1040-\u1049\u104A-\u104F\u1050-\u1055\u1056-\u1057\u105A-\u105D\u1061' + '\u1062-\u1064\u1065-\u1066\u1067-\u106D\u106E-\u1070\u1075-\u1081' + '\u1083-\u1084\u1087-\u108C\u108E\u108F\u1090-\u1099\u109A-\u109C' + '\u109E-\u109F\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FB\u10FC' + '\u10FD-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288' + '\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5' + '\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1360-\u1368' + '\u1369-\u137C\u1380-\u138F\u13A0-\u13F4\u1401-\u166C\u166D-\u166E' + '\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EB-\u16ED\u16EE-\u16F0' + '\u16F1-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1735-\u1736' + '\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17B6\u17BE-\u17C5' + '\u17C7-\u17C8\u17D4-\u17D6\u17D7\u17D8-\u17DA\u17DC\u17E0-\u17E9' + '\u1810-\u1819\u1820-\u1842\u1843\u1844-\u1877\u1880-\u18A8\u18AA' + '\u18B0-\u18F5\u1900-\u191E\u1923-\u1926\u1929-\u192B\u1930-\u1931' + '\u1933-\u1938\u1946-\u194F\u1950-\u196D\u1970-\u1974\u1980-\u19AB' + '\u19B0-\u19C0\u19C1-\u19C7\u19C8-\u19C9\u19D0-\u19D9\u19DA\u1A00-\u1A16' + '\u1A19-\u1A1A\u1A1E-\u1A1F\u1A20-\u1A54\u1A55\u1A57\u1A61\u1A63-\u1A64' + '\u1A6D-\u1A72\u1A80-\u1A89\u1A90-\u1A99\u1AA0-\u1AA6\u1AA7\u1AA8-\u1AAD' + '\u1B04\u1B05-\u1B33\u1B35\u1B3B\u1B3D-\u1B41\u1B43-\u1B44\u1B45-\u1B4B' + '\u1B50-\u1B59\u1B5A-\u1B60\u1B61-\u1B6A\u1B74-\u1B7C\u1B82\u1B83-\u1BA0' + '\u1BA1\u1BA6-\u1BA7\u1BAA\u1BAE-\u1BAF\u1BB0-\u1BB9\u1BBA-\u1BE5\u1BE7' + '\u1BEA-\u1BEC\u1BEE\u1BF2-\u1BF3\u1BFC-\u1BFF\u1C00-\u1C23\u1C24-\u1C2B' + '\u1C34-\u1C35\u1C3B-\u1C3F\u1C40-\u1C49\u1C4D-\u1C4F\u1C50-\u1C59' + '\u1C5A-\u1C77\u1C78-\u1C7D\u1C7E-\u1C7F\u1CC0-\u1CC7\u1CD3\u1CE1' + '\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF2-\u1CF3\u1CF5-\u1CF6\u1D00-\u1D2B' + '\u1D2C-\u1D6A\u1D6B-\u1D77\u1D78\u1D79-\u1D9A\u1D9B-\u1DBF\u1E00-\u1F15' + '\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D' + '\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC' + '\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u200E' + '\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D' + '\u2124\u2126\u2128\u212A-\u212D\u212F-\u2134\u2135-\u2138\u2139' + '\u213C-\u213F\u2145-\u2149\u214E\u214F\u2160-\u2182\u2183-\u2184' + '\u2185-\u2188\u2336-\u237A\u2395\u249C-\u24E9\u26AC\u2800-\u28FF' + '\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2C7B\u2C7C-\u2C7D\u2C7E-\u2CE4' + '\u2CEB-\u2CEE\u2CF2-\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F' + '\u2D70\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE' + '\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u3005\u3006\u3007' + '\u3021-\u3029\u302E-\u302F\u3031-\u3035\u3038-\u303A\u303B\u303C' + '\u3041-\u3096\u309D-\u309E\u309F\u30A1-\u30FA\u30FC-\u30FE\u30FF' + '\u3105-\u312D\u3131-\u318E\u3190-\u3191\u3192-\u3195\u3196-\u319F' + '\u31A0-\u31BA\u31F0-\u31FF\u3200-\u321C\u3220-\u3229\u322A-\u3247' + '\u3248-\u324F\u3260-\u327B\u327F\u3280-\u3289\u328A-\u32B0\u32C0-\u32CB' + '\u32D0-\u32FE\u3300-\u3376\u337B-\u33DD\u33E0-\u33FE\u3400-\u4DB5' + '\u4E00-\u9FCC\uA000-\uA014\uA015\uA016-\uA48C\uA4D0-\uA4F7\uA4F8-\uA4FD' + '\uA4FE-\uA4FF\uA500-\uA60B\uA60C\uA610-\uA61F\uA620-\uA629\uA62A-\uA62B' + '\uA640-\uA66D\uA66E\uA680-\uA69B\uA69C-\uA69D\uA6A0-\uA6E5\uA6E6-\uA6EF' + '\uA6F2-\uA6F7\uA722-\uA76F\uA770\uA771-\uA787\uA789-\uA78A\uA78B-\uA78E' + '\uA790-\uA7AD\uA7B0-\uA7B1\uA7F7\uA7F8-\uA7F9\uA7FA\uA7FB-\uA801' + '\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA823-\uA824\uA827\uA830-\uA835' + '\uA836-\uA837\uA840-\uA873\uA880-\uA881\uA882-\uA8B3\uA8B4-\uA8C3' + '\uA8CE-\uA8CF\uA8D0-\uA8D9\uA8F2-\uA8F7\uA8F8-\uA8FA\uA8FB\uA900-\uA909' + '\uA90A-\uA925\uA92E-\uA92F\uA930-\uA946\uA952-\uA953\uA95F\uA960-\uA97C' + '\uA983\uA984-\uA9B2\uA9B4-\uA9B5\uA9BA-\uA9BB\uA9BD-\uA9C0\uA9C1-\uA9CD' + '\uA9CF\uA9D0-\uA9D9\uA9DE-\uA9DF\uA9E0-\uA9E4\uA9E6\uA9E7-\uA9EF' + '\uA9F0-\uA9F9\uA9FA-\uA9FE\uAA00-\uAA28\uAA2F-\uAA30\uAA33-\uAA34' + '\uAA40-\uAA42\uAA44-\uAA4B\uAA4D\uAA50-\uAA59\uAA5C-\uAA5F\uAA60-\uAA6F' + '\uAA70\uAA71-\uAA76\uAA77-\uAA79\uAA7A\uAA7B\uAA7D\uAA7E-\uAAAF\uAAB1' + '\uAAB5-\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADC\uAADD\uAADE-\uAADF' + '\uAAE0-\uAAEA\uAAEB\uAAEE-\uAAEF\uAAF0-\uAAF1\uAAF2\uAAF3-\uAAF4\uAAF5' + '\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E' + '\uAB30-\uAB5A\uAB5B\uAB5C-\uAB5F\uAB64-\uAB65\uABC0-\uABE2\uABE3-\uABE4' + '\uABE6-\uABE7\uABE9-\uABEA\uABEB\uABEC\uABF0-\uABF9\uAC00-\uD7A3' + '\uD7B0-\uD7C6\uD7CB-\uD7FB\uE000-\uF8FF\uF900-\uFA6D\uFA70-\uFAD9' + '\uFB00-\uFB06\uFB13-\uFB17\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFF6F\uFF70' + '\uFF71-\uFF9D\uFF9E-\uFF9F\uFFA0-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF' + '\uFFD2-\uFFD7\uFFDA-\uFFDC',
	
	  R: '\u0590\u05BE\u05C0\u05C3\u05C6\u05C8-\u05CF\u05D0-\u05EA\u05EB-\u05EF' + '\u05F0-\u05F2\u05F3-\u05F4\u05F5-\u05FF\u07C0-\u07C9\u07CA-\u07EA' + '\u07F4-\u07F5\u07FA\u07FB-\u07FF\u0800-\u0815\u081A\u0824\u0828' + '\u082E-\u082F\u0830-\u083E\u083F\u0840-\u0858\u085C-\u085D\u085E' + '\u085F-\u089F\u200F\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB37\uFB38-\uFB3C' + '\uFB3D\uFB3E\uFB3F\uFB40-\uFB41\uFB42\uFB43-\uFB44\uFB45\uFB46-\uFB4F',
	
	  AL: '\u0608\u060B\u060D\u061B\u061C\u061D\u061E-\u061F\u0620-\u063F\u0640' + '\u0641-\u064A\u066D\u066E-\u066F\u0671-\u06D3\u06D4\u06D5\u06E5-\u06E6' + '\u06EE-\u06EF\u06FA-\u06FC\u06FD-\u06FE\u06FF\u0700-\u070D\u070E\u070F' + '\u0710\u0712-\u072F\u074B-\u074C\u074D-\u07A5\u07B1\u07B2-\u07BF' + '\u08A0-\u08B2\u08B3-\u08E3\uFB50-\uFBB1\uFBB2-\uFBC1\uFBC2-\uFBD2' + '\uFBD3-\uFD3D\uFD40-\uFD4F\uFD50-\uFD8F\uFD90-\uFD91\uFD92-\uFDC7' + '\uFDC8-\uFDCF\uFDF0-\uFDFB\uFDFC\uFDFE-\uFDFF\uFE70-\uFE74\uFE75' + '\uFE76-\uFEFC\uFEFD-\uFEFE'
	
	};
	
	var REGEX_STRONG = new RegExp('[' + RANGE_BY_BIDI_TYPE.L + RANGE_BY_BIDI_TYPE.R + RANGE_BY_BIDI_TYPE.AL + ']');
	
	var REGEX_RTL = new RegExp('[' + RANGE_BY_BIDI_TYPE.R + RANGE_BY_BIDI_TYPE.AL + ']');
	
	/**
	 * Returns the first strong character (has Bidi_Class value of L, R, or AL).
	 *
	 * @param str  A text block; e.g. paragraph, table cell, tag
	 * @return     A character with strong bidi direction, or null if not found
	 */
	function firstStrongChar(str) {
	  var match = REGEX_STRONG.exec(str);
	  return match == null ? null : match[0];
	}
	
	/**
	 * Returns the direction of a block of text, based on the direction of its
	 * first strong character (has Bidi_Class value of L, R, or AL).
	 *
	 * @param str  A text block; e.g. paragraph, table cell, tag
	 * @return     The resolved direction
	 */
	function firstStrongCharDir(str) {
	  var strongChar = firstStrongChar(str);
	  if (strongChar == null) {
	    return UnicodeBidiDirection.NEUTRAL;
	  }
	  return REGEX_RTL.exec(strongChar) ? UnicodeBidiDirection.RTL : UnicodeBidiDirection.LTR;
	}
	
	/**
	 * Returns the direction of a block of text, based on the direction of its
	 * first strong character (has Bidi_Class value of L, R, or AL), or a fallback
	 * direction, if no strong character is found.
	 *
	 * This function is supposed to be used in respect to Higher-Level Protocol
	 * rule HL1. (http://www.unicode.org/reports/tr9/#HL1)
	 *
	 * @param str       A text block; e.g. paragraph, table cell, tag
	 * @param fallback  Fallback direction, used if no strong direction detected
	 *                  for the block (default = NEUTRAL)
	 * @return          The resolved direction
	 */
	function resolveBlockDir(str, fallback) {
	  fallback = fallback || UnicodeBidiDirection.NEUTRAL;
	  if (!str.length) {
	    return fallback;
	  }
	  var blockDir = firstStrongCharDir(str);
	  return blockDir === UnicodeBidiDirection.NEUTRAL ? fallback : blockDir;
	}
	
	/**
	 * Returns the direction of a block of text, based on the direction of its
	 * first strong character (has Bidi_Class value of L, R, or AL), or a fallback
	 * direction, if no strong character is found.
	 *
	 * NOTE: This function is similar to resolveBlockDir(), but uses the global
	 * direction as the fallback, so it *always* returns a Strong direction,
	 * making it useful for integration in places that you need to make the final
	 * decision, like setting some CSS class.
	 *
	 * This function is supposed to be used in respect to Higher-Level Protocol
	 * rule HL1. (http://www.unicode.org/reports/tr9/#HL1)
	 *
	 * @param str             A text block; e.g. paragraph, table cell
	 * @param strongFallback  Fallback direction, used if no strong direction
	 *                        detected for the block (default = global direction)
	 * @return                The resolved Strong direction
	 */
	function getDirection(str, strongFallback) {
	  if (!strongFallback) {
	    strongFallback = UnicodeBidiDirection.getGlobalDir();
	  }
	  !UnicodeBidiDirection.isStrong(strongFallback) ?  true ? invariant(false, 'Fallback direction must be a strong direction') : invariant(false) : void 0;
	  return resolveBlockDir(str, strongFallback);
	}
	
	/**
	 * Returns true if getDirection(arguments...) returns LTR.
	 *
	 * @param str             A text block; e.g. paragraph, table cell
	 * @param strongFallback  Fallback direction, used if no strong direction
	 *                        detected for the block (default = global direction)
	 * @return                True if the resolved direction is LTR
	 */
	function isDirectionLTR(str, strongFallback) {
	  return getDirection(str, strongFallback) === UnicodeBidiDirection.LTR;
	}
	
	/**
	 * Returns true if getDirection(arguments...) returns RTL.
	 *
	 * @param str             A text block; e.g. paragraph, table cell
	 * @param strongFallback  Fallback direction, used if no strong direction
	 *                        detected for the block (default = global direction)
	 * @return                True if the resolved direction is RTL
	 */
	function isDirectionRTL(str, strongFallback) {
	  return getDirection(str, strongFallback) === UnicodeBidiDirection.RTL;
	}
	
	var UnicodeBidi = {
	  firstStrongChar: firstStrongChar,
	  firstStrongCharDir: firstStrongCharDir,
	  resolveBlockDir: resolveBlockDir,
	  getDirection: getDirection,
	  isDirectionLTR: isDirectionLTR,
	  isDirectionRTL: isDirectionRTL
	};
	
	module.exports = UnicodeBidi;

/***/ }),
/* 227 */
/***/ (function(module, exports) {

	'use strict';
	
	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 * @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.
	 *
	 * @param {?DOMDocument} doc Defaults to current document.
	 * @return {?DOMElement}
	 */
	function getActiveElement(doc) /*?DOMElement*/{
	  doc = doc || (typeof document !== 'undefined' ? document : undefined);
	  if (typeof doc === 'undefined') {
	    return null;
	  }
	  try {
	    return doc.activeElement || doc.body;
	  } catch (e) {
	    return doc.body;
	  }
	}
	
	module.exports = getActiveElement;

/***/ }),
/* 228 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * lodash 3.1.2 (Custom Build) <https://lodash.com/>
	 * Build: `lodash modern modularize exports="npm" -o ./`
	 * Copyright 2012-2015 The Dojo Foundation <http://dojofoundation.org/>
	 * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
	 * Copyright 2009-2015 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
	 * Available under MIT license <https://lodash.com/license>
	 */
	var getNative = __webpack_require__(576),
	    isArguments = __webpack_require__(578),
	    isArray = __webpack_require__(579);
	
	/** Used to detect unsigned integer values. */
	var reIsUint = /^\d+$/;
	
	/** Used for native method references. */
	var objectProto = Object.prototype;
	
	/** Used to check objects for own properties. */
	var hasOwnProperty = objectProto.hasOwnProperty;
	
	/* Native method references for those with the same name as other `lodash` methods. */
	var nativeKeys = getNative(Object, 'keys');
	
	/**
	 * Used as the [maximum length](http://ecma-international.org/ecma-262/6.0/#sec-number.max_safe_integer)
	 * of an array-like value.
	 */
	var MAX_SAFE_INTEGER = 9007199254740991;
	
	/**
	 * The base implementation of `_.property` without support for deep paths.
	 *
	 * @private
	 * @param {string} key The key of the property to get.
	 * @returns {Function} Returns the new function.
	 */
	function baseProperty(key) {
	  return function(object) {
	    return object == null ? undefined : object[key];
	  };
	}
	
	/**
	 * Gets the "length" property value of `object`.
	 *
	 * **Note:** This function is used to avoid a [JIT bug](https://bugs.webkit.org/show_bug.cgi?id=142792)
	 * that affects Safari on at least iOS 8.1-8.3 ARM64.
	 *
	 * @private
	 * @param {Object} object The object to query.
	 * @returns {*} Returns the "length" value.
	 */
	var getLength = baseProperty('length');
	
	/**
	 * Checks if `value` is array-like.
	 *
	 * @private
	 * @param {*} value The value to check.
	 * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
	 */
	function isArrayLike(value) {
	  return value != null && isLength(getLength(value));
	}
	
	/**
	 * 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) {
	  value = (typeof value == 'number' || reIsUint.test(value)) ? +value : -1;
	  length = length == null ? MAX_SAFE_INTEGER : length;
	  return value > -1 && value % 1 == 0 && value < length;
	}
	
	/**
	 * Checks if `value` is a valid array-like length.
	 *
	 * **Note:** This function is based on [`ToLength`](http://ecma-international.org/ecma-262/6.0/#sec-tolength).
	 *
	 * @private
	 * @param {*} value The value to check.
	 * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
	 */
	function isLength(value) {
	  return typeof value == 'number' && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
	}
	
	/**
	 * A fallback implementation of `Object.keys` which creates an array of the
	 * own enumerable property names of `object`.
	 *
	 * @private
	 * @param {Object} object The object to query.
	 * @returns {Array} Returns the array of property names.
	 */
	function shimKeys(object) {
	  var props = keysIn(object),
	      propsLength = props.length,
	      length = propsLength && object.length;
	
	  var allowIndexes = !!length && isLength(length) &&
	    (isArray(object) || isArguments(object));
	
	  var index = -1,
	      result = [];
	
	  while (++index < propsLength) {
	    var key = props[index];
	    if ((allowIndexes && isIndex(key, length)) || hasOwnProperty.call(object, key)) {
	      result.push(key);
	    }
	  }
	  return result;
	}
	
	/**
	 * Checks if `value` is the [language type](https://es5.github.io/#x8) of `Object`.
	 * (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
	 *
	 * @static
	 * @memberOf _
	 * @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(1);
	 * // => false
	 */
	function isObject(value) {
	  // Avoid a V8 JIT bug in Chrome 19-20.
	  // See https://code.google.com/p/v8/issues/detail?id=2291 for more details.
	  var type = typeof value;
	  return !!value && (type == 'object' || type == 'function');
	}
	
	/**
	 * 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/6.0/#sec-object.keys)
	 * for more details.
	 *
	 * @static
	 * @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']
	 */
	var keys = !nativeKeys ? shimKeys : function(object) {
	  var Ctor = object == null ? undefined : object.constructor;
	  if ((typeof Ctor == 'function' && Ctor.prototype === object) ||
	      (typeof object != 'function' && isArrayLike(object))) {
	    return shimKeys(object);
	  }
	  return isObject(object) ? nativeKeys(object) : [];
	};
	
	/**
	 * Creates an array of the own and inherited enumerable property names of `object`.
	 *
	 * **Note:** Non-object values are coerced to objects.
	 *
	 * @static
	 * @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;
	 *
	 * _.keysIn(new Foo);
	 * // => ['a', 'b', 'c'] (iteration order is not guaranteed)
	 */
	function keysIn(object) {
	  if (object == null) {
	    return [];
	  }
	  if (!isObject(object)) {
	    object = Object(object);
	  }
	  var length = object.length;
	  length = (length && isLength(length) &&
	    (isArray(object) || isArguments(object)) && length) || 0;
	
	  var Ctor = object.constructor,
	      index = -1,
	      isProto = typeof Ctor == 'function' && Ctor.prototype === object,
	      result = Array(length),
	      skipIndexes = length > 0;
	
	  while (++index < length) {
	    result[index] = (index + '');
	  }
	  for (var key in object) {
	    if (!(skipIndexes && isIndex(key, length)) &&
	        !(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {
	      result.push(key);
	    }
	  }
	  return result;
	}
	
	module.exports = keys;


/***/ }),
/* 229 */
/***/ (function(module, exports, __webpack_require__) {

	var getNative = __webpack_require__(52),
	    root = __webpack_require__(43);
	
	/* Built-in method references that are verified to be native. */
	var Map = getNative(root, 'Map');
	
	module.exports = Map;


/***/ }),
/* 230 */
/***/ (function(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;


/***/ }),
/* 231 */
/***/ (function(module, exports) {

	/* WEBPACK VAR INJECTION */(function(global) {/** Detect free variable `global` from Node.js. */
	var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;
	
	module.exports = freeGlobal;
	
	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))

/***/ }),
/* 232 */
/***/ (function(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;


/***/ }),
/* 233 */
/***/ (function(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;


/***/ }),
/* 234 */
/***/ (function(module, exports, __webpack_require__) {

	var baseGet = __webpack_require__(593);
	
	/**
	 * Gets the value at `path` of `object`. If the resolved value is
	 * `undefined`, the `defaultValue` is returned in its place.
	 *
	 * @static
	 * @memberOf _
	 * @since 3.7.0
	 * @category Object
	 * @param {Object} object The object to query.
	 * @param {Array|string} path The path of the property to get.
	 * @param {*} [defaultValue] The value returned for `undefined` resolved values.
	 * @returns {*} Returns the resolved value.
	 * @example
	 *
	 * var object = { 'a': [{ 'b': { 'c': 3 } }] };
	 *
	 * _.get(object, 'a[0].b.c');
	 * // => 3
	 *
	 * _.get(object, ['a', '0', 'b', 'c']);
	 * // => 3
	 *
	 * _.get(object, 'a.b.c', 'default');
	 * // => 'default'
	 */
	function get(object, path, defaultValue) {
	  var result = object == null ? undefined : baseGet(object, path);
	  return result === undefined ? defaultValue : result;
	}
	
	module.exports = get;


/***/ }),
/* 235 */
/***/ (function(module, exports, __webpack_require__) {

	var baseIsArguments = __webpack_require__(595),
	    isObjectLike = __webpack_require__(76);
	
	/** 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;


/***/ }),
/* 236 */
/***/ (function(module, exports, __webpack_require__) {

	var isFunction = __webpack_require__(237),
	    isLength = __webpack_require__(140);
	
	/**
	 * 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;


/***/ }),
/* 237 */
/***/ (function(module, exports, __webpack_require__) {

	var baseGetTag = __webpack_require__(64),
	    isObject = __webpack_require__(141);
	
	/** `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;


/***/ }),
/* 238 */
/***/ (function(module, exports, __webpack_require__) {

	var baseSet = __webpack_require__(599);
	
	/**
	 * Sets the value at `path` of `object`. If a portion of `path` doesn't exist,
	 * it's created. Arrays are created for missing index properties while objects
	 * are created for all other missing properties. Use `_.setWith` to customize
	 * `path` creation.
	 *
	 * **Note:** This method mutates `object`.
	 *
	 * @static
	 * @memberOf _
	 * @since 3.7.0
	 * @category Object
	 * @param {Object} object The object to modify.
	 * @param {Array|string} path The path of the property to set.
	 * @param {*} value The value to set.
	 * @returns {Object} Returns `object`.
	 * @example
	 *
	 * var object = { 'a': [{ 'b': { 'c': 3 } }] };
	 *
	 * _.set(object, 'a[0].b.c', 4);
	 * console.log(object.a[0].b.c);
	 * // => 4
	 *
	 * _.set(object, ['x', '0', 'y', 'z'], 5);
	 * console.log(object.x[0].y.z);
	 * // => 5
	 */
	function set(object, path, value) {
	  return object == null ? object : baseSet(object, path, value);
	}
	
	module.exports = set;


/***/ }),
/* 239 */
/***/ (function(module, exports) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 */
	
	'use strict';
	
	var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';
	
	module.exports = ReactPropTypesSecret;


/***/ }),
/* 240 */
/***/ (function(module, exports) {

	"use strict";
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	var util = {
	  isAppearSupported: function isAppearSupported(props) {
	    return props.transitionName && props.transitionAppear || props.animation.appear;
	  },
	  isEnterSupported: function isEnterSupported(props) {
	    return props.transitionName && props.transitionEnter || props.animation.enter;
	  },
	  isLeaveSupported: function isLeaveSupported(props) {
	    return props.transitionName && props.transitionLeave || props.animation.leave;
	  },
	  allowAppearCallback: function allowAppearCallback(props) {
	    return props.transitionAppear || props.animation.appear;
	  },
	  allowEnterCallback: function allowEnterCallback(props) {
	    return props.transitionEnter || props.animation.enter;
	  },
	  allowLeaveCallback: function allowLeaveCallback(props) {
	    return props.transitionLeave || props.animation.leave;
	  }
	};
	exports["default"] = util;
	module.exports = exports['default'];

/***/ }),
/* 241 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _createReactClass = __webpack_require__(14);
	
	var _createReactClass2 = _interopRequireDefault(_createReactClass);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _KeyCode = __webpack_require__(29);
	
	var _KeyCode2 = _interopRequireDefault(_KeyCode);
	
	var _MonthPanel = __webpack_require__(251);
	
	var _MonthPanel2 = _interopRequireDefault(_MonthPanel);
	
	var _CalendarMixin = __webpack_require__(144);
	
	var _CalendarMixin2 = _interopRequireDefault(_CalendarMixin);
	
	var _CommonMixin = __webpack_require__(96);
	
	var _CommonMixin2 = _interopRequireDefault(_CommonMixin);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var MonthCalendar = (0, _createReactClass2['default'])({
	  displayName: 'MonthCalendar',
	
	  propTypes: {
	    monthCellRender: _propTypes2['default'].func,
	    dateCellRender: _propTypes2['default'].func
	  },
	  mixins: [_CommonMixin2['default'], _CalendarMixin2['default']],
	
	  onKeyDown: function onKeyDown(event) {
	    var keyCode = event.keyCode;
	    var ctrlKey = event.ctrlKey || event.metaKey;
	    var stateValue = this.state.value;
	    var disabledDate = this.props.disabledDate;
	
	    var value = stateValue;
	    switch (keyCode) {
	      case _KeyCode2['default'].DOWN:
	        value = stateValue.clone();
	        value.add(3, 'months');
	        break;
	      case _KeyCode2['default'].UP:
	        value = stateValue.clone();
	        value.add(-3, 'months');
	        break;
	      case _KeyCode2['default'].LEFT:
	        value = stateValue.clone();
	        if (ctrlKey) {
	          value.add(-1, 'years');
	        } else {
	          value.add(-1, 'months');
	        }
	        break;
	      case _KeyCode2['default'].RIGHT:
	        value = stateValue.clone();
	        if (ctrlKey) {
	          value.add(1, 'years');
	        } else {
	          value.add(1, 'months');
	        }
	        break;
	      case _KeyCode2['default'].ENTER:
	        if (!disabledDate || !disabledDate(stateValue)) {
	          this.onSelect(stateValue);
	        }
	        event.preventDefault();
	        return 1;
	      default:
	        return undefined;
	    }
	    if (value !== stateValue) {
	      this.setValue(value);
	      event.preventDefault();
	      return 1;
	    }
	  },
	  render: function render() {
	    var props = this.props;
	    var children = _react2['default'].createElement(_MonthPanel2['default'], {
	      locale: props.locale,
	      disabledDate: props.disabledDate,
	      style: { position: 'relative' },
	      value: this.state.value,
	      cellRender: props.monthCellRender,
	      contentRender: props.monthCellContentRender,
	      rootPrefixCls: props.prefixCls,
	      onChange: this.setValue,
	      onSelect: this.onSelect
	    });
	    return this.renderRoot({
	      children: children
	    });
	  }
	});
	
	exports['default'] = MonthCalendar;
	module.exports = exports['default'];

/***/ }),
/* 242 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _reactDom = __webpack_require__(10);
	
	var _reactDom2 = _interopRequireDefault(_reactDom);
	
	var _createReactClass = __webpack_require__(14);
	
	var _createReactClass2 = _interopRequireDefault(_createReactClass);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _createChainedFunction = __webpack_require__(153);
	
	var _createChainedFunction2 = _interopRequireDefault(_createChainedFunction);
	
	var _KeyCode = __webpack_require__(29);
	
	var _KeyCode2 = _interopRequireDefault(_KeyCode);
	
	var _placements = __webpack_require__(668);
	
	var _placements2 = _interopRequireDefault(_placements);
	
	var _rcTrigger = __webpack_require__(53);
	
	var _rcTrigger2 = _interopRequireDefault(_rcTrigger);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function noop() {}
	
	function refFn(field, component) {
	  this[field] = component;
	}
	
	var Picker = (0, _createReactClass2['default'])({
	  displayName: 'Picker',
	
	  propTypes: {
	    animation: _propTypes2['default'].oneOfType([_propTypes2['default'].func, _propTypes2['default'].string]),
	    disabled: _propTypes2['default'].bool,
	    transitionName: _propTypes2['default'].string,
	    onChange: _propTypes2['default'].func,
	    onOpenChange: _propTypes2['default'].func,
	    children: _propTypes2['default'].func,
	    getCalendarContainer: _propTypes2['default'].func,
	    calendar: _propTypes2['default'].element,
	    style: _propTypes2['default'].object,
	    open: _propTypes2['default'].bool,
	    defaultOpen: _propTypes2['default'].bool,
	    prefixCls: _propTypes2['default'].string,
	    placement: _propTypes2['default'].any,
	    value: _propTypes2['default'].oneOfType([_propTypes2['default'].object, _propTypes2['default'].array]),
	    defaultValue: _propTypes2['default'].oneOfType([_propTypes2['default'].object, _propTypes2['default'].array]),
	    align: _propTypes2['default'].object
	  },
	
	  getDefaultProps: function getDefaultProps() {
	    return {
	      prefixCls: 'rc-calendar-picker',
	      style: {},
	      align: {},
	      placement: 'bottomLeft',
	      defaultOpen: false,
	      onChange: noop,
	      onOpenChange: noop
	    };
	  },
	  getInitialState: function getInitialState() {
	    var props = this.props;
	    var open = void 0;
	    if ('open' in props) {
	      open = props.open;
	    } else {
	      open = props.defaultOpen;
	    }
	    var value = props.value || props.defaultValue;
	    this.saveCalendarRef = refFn.bind(this, 'calendarInstance');
	    return {
	      open: open,
	      value: value
	    };
	  },
	  componentWillReceiveProps: function componentWillReceiveProps(nextProps) {
	    var value = nextProps.value,
	        open = nextProps.open;
	
	    if ('value' in nextProps) {
	      this.setState({
	        value: value
	      });
	    }
	    if (open !== undefined) {
	      this.setState({
	        open: open
	      });
	    }
	  },
	  componentDidUpdate: function componentDidUpdate(_, prevState) {
	    if (!prevState.open && this.state.open) {
	      // setTimeout is for making sure saveCalendarRef happen before focusCalendar
	      this.focusTimeout = setTimeout(this.focusCalendar, 0, this);
	    }
	  },
	  componentWillUnmount: function componentWillUnmount() {
	    clearTimeout(this.focusTimeout);
	  },
	  onCalendarKeyDown: function onCalendarKeyDown(event) {
	    if (event.keyCode === _KeyCode2['default'].ESC) {
	      event.stopPropagation();
	      this.close(this.focus);
	    }
	  },
	  onCalendarSelect: function onCalendarSelect(value) {
	    var cause = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
	
	    var props = this.props;
	    if (!('value' in props)) {
	      this.setState({
	        value: value
	      });
	    }
	    if (cause.source === 'keyboard' || !props.calendar.props.timePicker && cause.source !== 'dateInput' || cause.source === 'todayButton') {
	      this.close(this.focus);
	    }
	    props.onChange(value);
	  },
	  onKeyDown: function onKeyDown(event) {
	    if (event.keyCode === _KeyCode2['default'].DOWN && !this.state.open) {
	      this.open();
	      event.preventDefault();
	    }
	  },
	  onCalendarOk: function onCalendarOk() {
	    this.close(this.focus);
	  },
	  onCalendarClear: function onCalendarClear() {
	    this.close(this.focus);
	  },
	  onVisibleChange: function onVisibleChange(open) {
	    this.setOpen(open);
	  },
	  getCalendarElement: function getCalendarElement() {
	    var props = this.props;
	    var state = this.state;
	    var calendarProps = props.calendar.props;
	    var value = state.value;
	
	    var defaultValue = value;
	    var extraProps = {
	      ref: this.saveCalendarRef,
	      defaultValue: defaultValue || calendarProps.defaultValue,
	      selectedValue: value,
	      onKeyDown: this.onCalendarKeyDown,
	      onOk: (0, _createChainedFunction2['default'])(calendarProps.onOk, this.onCalendarOk),
	      onSelect: (0, _createChainedFunction2['default'])(calendarProps.onSelect, this.onCalendarSelect),
	      onClear: (0, _createChainedFunction2['default'])(calendarProps.onClear, this.onCalendarClear)
	    };
	
	    return _react2['default'].cloneElement(props.calendar, extraProps);
	  },
	  setOpen: function setOpen(open, callback) {
	    var onOpenChange = this.props.onOpenChange;
	
	    if (this.state.open !== open) {
	      if (!('open' in this.props)) {
	        this.setState({
	          open: open
	        }, callback);
	      }
	      onOpenChange(open);
	    }
	  },
	  open: function open(callback) {
	    this.setOpen(true, callback);
	  },
	  close: function close(callback) {
	    this.setOpen(false, callback);
	  },
	  focus: function focus() {
	    if (!this.state.open) {
	      _reactDom2['default'].findDOMNode(this).focus();
	    }
	  },
	  focusCalendar: function focusCalendar() {
	    if (this.state.open && this.calendarInstance !== null) {
	      this.calendarInstance.focus();
	    }
	  },
	  render: function render() {
	    var props = this.props;
	    var prefixCls = props.prefixCls,
	        placement = props.placement,
	        style = props.style,
	        getCalendarContainer = props.getCalendarContainer,
	        align = props.align,
	        animation = props.animation,
	        disabled = props.disabled,
	        transitionName = props.transitionName,
	        children = props.children;
	
	    var state = this.state;
	    return _react2['default'].createElement(
	      _rcTrigger2['default'],
	      {
	        popup: this.getCalendarElement(),
	        popupAlign: align,
	        builtinPlacements: _placements2['default'],
	        popupPlacement: placement,
	        action: disabled && !state.open ? [] : ['click'],
	        destroyPopupOnHide: true,
	        getPopupContainer: getCalendarContainer,
	        popupStyle: style,
	        popupAnimation: animation,
	        popupTransitionName: transitionName,
	        popupVisible: state.open,
	        onPopupVisibleChange: this.onVisibleChange,
	        prefixCls: prefixCls
	      },
	      _react2['default'].cloneElement(children(state, props), { onKeyDown: this.onKeyDown })
	    );
	  }
	});
	
	exports['default'] = Picker;
	module.exports = exports['default'];

/***/ }),
/* 243 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _createReactClass = __webpack_require__(14);
	
	var _createReactClass2 = _interopRequireDefault(_createReactClass);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _MonthPanel = __webpack_require__(251);
	
	var _MonthPanel2 = _interopRequireDefault(_MonthPanel);
	
	var _YearPanel = __webpack_require__(253);
	
	var _YearPanel2 = _interopRequireDefault(_YearPanel);
	
	var _mapSelf = __webpack_require__(282);
	
	var _mapSelf2 = _interopRequireDefault(_mapSelf);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function goMonth(direction) {
	  var next = this.props.value.clone();
	  next.add(direction, 'months');
	  this.props.onValueChange(next);
	}
	
	function goYear(direction) {
	  var next = this.props.value.clone();
	  next.add(direction, 'years');
	  this.props.onValueChange(next);
	}
	
	function showIf(condition, el) {
	  return condition ? el : null;
	}
	
	var CalendarHeader = (0, _createReactClass2['default'])({
	  displayName: 'CalendarHeader',
	
	  propTypes: {
	    prefixCls: _propTypes2['default'].string,
	    value: _propTypes2['default'].object,
	    onValueChange: _propTypes2['default'].func,
	    showTimePicker: _propTypes2['default'].bool,
	    showMonthPanel: _propTypes2['default'].bool,
	    showYearPanel: _propTypes2['default'].bool,
	    onPanelChange: _propTypes2['default'].func,
	    locale: _propTypes2['default'].object,
	    enablePrev: _propTypes2['default'].any,
	    enableNext: _propTypes2['default'].any,
	    disabledMonth: _propTypes2['default'].func
	  },
	
	  getDefaultProps: function getDefaultProps() {
	    return {
	      enableNext: 1,
	      enablePrev: 1,
	      onPanelChange: function onPanelChange() {},
	      onValueChange: function onValueChange() {}
	    };
	  },
	  getInitialState: function getInitialState() {
	    this.nextMonth = goMonth.bind(this, 1);
	    this.previousMonth = goMonth.bind(this, -1);
	    this.nextYear = goYear.bind(this, 1);
	    this.previousYear = goYear.bind(this, -1);
	    var _props = this.props,
	        showMonthPanel = _props.showMonthPanel,
	        showYearPanel = _props.showYearPanel;
	
	    return { showMonthPanel: showMonthPanel, showYearPanel: showYearPanel };
	  },
	  componentWillReceiveProps: function componentWillReceiveProps() {
	    var props = this.props;
	    if ('showMonthpanel' in props) {
	      this.setState({ showMonthPanel: props.showMonthPanel });
	    }
	    if ('showYearpanel' in props) {
	      this.setState({ showYearPanel: props.showYearPanel });
	    }
	  },
	  onSelect: function onSelect(value) {
	    this.triggerPanelChange({
	      showMonthPanel: 0,
	      showYearPanel: 0
	    });
	    this.props.onValueChange(value);
	  },
	  triggerPanelChange: function triggerPanelChange(panelStatus) {
	    if (!('showMonthPanel' in this.props)) {
	      this.setState({ showMonthPanel: panelStatus.showMonthPanel });
	    }
	    if (!('showYearPanel' in this.props)) {
	      this.setState({ showYearPanel: panelStatus.showYearPanel });
	    }
	    this.props.onPanelChange(panelStatus);
	  },
	  monthYearElement: function monthYearElement(showTimePicker) {
	    var props = this.props;
	    var prefixCls = props.prefixCls;
	    var locale = props.locale;
	    var value = props.value;
	    var localeData = value.localeData();
	    var monthBeforeYear = locale.monthBeforeYear;
	    var selectClassName = prefixCls + '-' + (monthBeforeYear ? 'my-select' : 'ym-select');
	    var year = _react2['default'].createElement(
	      'a',
	      {
	        className: prefixCls + '-year-select',
	        role: 'button',
	        onClick: showTimePicker ? null : this.showYearPanel,
	        title: locale.yearSelect
	      },
	      value.format(locale.yearFormat)
	    );
	    var month = _react2['default'].createElement(
	      'a',
	      {
	        className: prefixCls + '-month-select',
	        role: 'button',
	        onClick: showTimePicker ? null : this.showMonthPanel,
	        title: locale.monthSelect
	      },
	      localeData.monthsShort(value)
	    );
	    var day = void 0;
	    if (showTimePicker) {
	      day = _react2['default'].createElement(
	        'a',
	        {
	          className: prefixCls + '-day-select',
	          role: 'button'
	        },
	        value.format(locale.dayFormat)
	      );
	    }
	    var my = [];
	    if (monthBeforeYear) {
	      my = [month, day, year];
	    } else {
	      my = [year, month, day];
	    }
	    return _react2['default'].createElement(
	      'span',
	      { className: selectClassName },
	      (0, _mapSelf2['default'])(my)
	    );
	  },
	  showMonthPanel: function showMonthPanel() {
	    this.triggerPanelChange({
	      showMonthPanel: 1,
	      showYearPanel: 0
	    });
	  },
	  showYearPanel: function showYearPanel() {
	    this.triggerPanelChange({
	      showMonthPanel: 0,
	      showYearPanel: 1
	    });
	  },
	  render: function render() {
	    var props = this.props,
	        state = this.state;
	    var prefixCls = props.prefixCls,
	        locale = props.locale,
	        value = props.value,
	        showTimePicker = props.showTimePicker,
	        enableNext = props.enableNext,
	        enablePrev = props.enablePrev,
	        disabledMonth = props.disabledMonth;
	
	
	    var panel = null;
	    if (state.showMonthPanel) {
	      panel = _react2['default'].createElement(_MonthPanel2['default'], {
	        locale: locale,
	        defaultValue: value,
	        rootPrefixCls: prefixCls,
	        onSelect: this.onSelect,
	        disabledDate: disabledMonth
	      });
	    } else if (state.showYearPanel) {
	      panel = _react2['default'].createElement(_YearPanel2['default'], {
	        locale: locale,
	        defaultValue: value,
	        rootPrefixCls: prefixCls,
	        onSelect: this.onSelect
	      });
	    }
	
	    return _react2['default'].createElement(
	      'div',
	      { className: prefixCls + '-header' },
	      _react2['default'].createElement(
	        'div',
	        { style: { position: 'relative' } },
	        showIf(enablePrev && !showTimePicker, _react2['default'].createElement('a', {
	          className: prefixCls + '-prev-year-btn',
	          role: 'button',
	          onClick: this.previousYear,
	          title: locale.previousYear
	        })),
	        showIf(enablePrev && !showTimePicker, _react2['default'].createElement('a', {
	          className: prefixCls + '-prev-month-btn',
	          role: 'button',
	          onClick: this.previousMonth,
	          title: locale.previousMonth
	        })),
	        this.monthYearElement(showTimePicker),
	        showIf(enableNext && !showTimePicker, _react2['default'].createElement('a', {
	          className: prefixCls + '-next-month-btn',
	          onClick: this.nextMonth,
	          title: locale.nextMonth
	        })),
	        showIf(enableNext && !showTimePicker, _react2['default'].createElement('a', {
	          className: prefixCls + '-next-year-btn',
	          onClick: this.nextYear,
	          title: locale.nextYear
	        }))
	      ),
	      panel
	    );
	  }
	});
	
	exports['default'] = CalendarHeader;
	module.exports = exports['default'];

/***/ }),
/* 244 */
/***/ (function(module, exports, __webpack_require__) {

	"use strict";
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports["default"] = OkButton;
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
	
	function OkButton(_ref) {
	  var prefixCls = _ref.prefixCls,
	      locale = _ref.locale,
	      okDisabled = _ref.okDisabled,
	      onOk = _ref.onOk;
	
	  var className = prefixCls + "-ok-btn";
	  if (okDisabled) {
	    className += " " + prefixCls + "-ok-btn-disabled";
	  }
	  return _react2["default"].createElement(
	    "a",
	    {
	      className: className,
	      role: "button",
	      onClick: okDisabled ? null : onOk
	    },
	    locale.ok
	  );
	}
	module.exports = exports['default'];

/***/ }),
/* 245 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	exports['default'] = TimePickerButton;
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _classnames2 = __webpack_require__(8);
	
	var _classnames3 = _interopRequireDefault(_classnames2);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function TimePickerButton(_ref) {
	  var _classnames;
	
	  var prefixCls = _ref.prefixCls,
	      locale = _ref.locale,
	      showTimePicker = _ref.showTimePicker,
	      onOpenTimePicker = _ref.onOpenTimePicker,
	      onCloseTimePicker = _ref.onCloseTimePicker,
	      timePickerDisabled = _ref.timePickerDisabled;
	
	  var className = (0, _classnames3['default'])((_classnames = {}, (0, _defineProperty3['default'])(_classnames, prefixCls + '-time-picker-btn', true), (0, _defineProperty3['default'])(_classnames, prefixCls + '-time-picker-btn-disabled', timePickerDisabled), _classnames));
	  var onClick = null;
	  if (!timePickerDisabled) {
	    onClick = showTimePicker ? onCloseTimePicker : onOpenTimePicker;
	  }
	  return _react2['default'].createElement(
	    'a',
	    {
	      className: className,
	      role: 'button',
	      onClick: onClick
	    },
	    showTimePicker ? locale.dateSelect : locale.timeSelect
	  );
	}
	module.exports = exports['default'];

/***/ }),
/* 246 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports['default'] = TodayButton;
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _util = __webpack_require__(44);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function TodayButton(_ref) {
	  var prefixCls = _ref.prefixCls,
	      locale = _ref.locale,
	      value = _ref.value,
	      timePicker = _ref.timePicker,
	      disabled = _ref.disabled,
	      disabledDate = _ref.disabledDate,
	      onToday = _ref.onToday,
	      text = _ref.text;
	
	  var localeNow = (!text && timePicker ? locale.now : text) || locale.today;
	  var disabledToday = disabledDate && !(0, _util.isAllowedDate)((0, _util.getTodayTime)(value), disabledDate);
	  var isDisabled = disabledToday || disabled;
	  var disabledTodayClass = isDisabled ? prefixCls + '-today-btn-disabled' : '';
	  return _react2['default'].createElement(
	    'a',
	    {
	      className: prefixCls + '-today-btn ' + disabledTodayClass,
	      role: 'button',
	      onClick: isDisabled ? null : onToday,
	      title: (0, _util.getTodayTimeStr)(value)
	    },
	    localeNow
	  );
	}
	module.exports = exports['default'];

/***/ }),
/* 247 */
/***/ (function(module, exports) {

	"use strict";
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports["default"] = {
	  DATE_ROW_COUNT: 6,
	  DATE_COL_COUNT: 7
	};
	module.exports = exports['default'];

/***/ }),
/* 248 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _reactDom = __webpack_require__(10);
	
	var _reactDom2 = _interopRequireDefault(_reactDom);
	
	var _createReactClass = __webpack_require__(14);
	
	var _createReactClass2 = _interopRequireDefault(_createReactClass);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _moment = __webpack_require__(13);
	
	var _moment2 = _interopRequireDefault(_moment);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var DateInput = (0, _createReactClass2['default'])({
	  displayName: 'DateInput',
	
	  propTypes: {
	    prefixCls: _propTypes2['default'].string,
	    timePicker: _propTypes2['default'].object,
	    value: _propTypes2['default'].object,
	    disabledTime: _propTypes2['default'].any,
	    format: _propTypes2['default'].string,
	    locale: _propTypes2['default'].object,
	    disabledDate: _propTypes2['default'].func,
	    onChange: _propTypes2['default'].func,
	    onClear: _propTypes2['default'].func,
	    placeholder: _propTypes2['default'].string,
	    onSelect: _propTypes2['default'].func,
	    selectedValue: _propTypes2['default'].object
	  },
	
	  getInitialState: function getInitialState() {
	    var selectedValue = this.props.selectedValue;
	    return {
	      str: selectedValue && selectedValue.format(this.props.format) || '',
	      invalid: false
	    };
	  },
	  componentWillReceiveProps: function componentWillReceiveProps(nextProps) {
	    // when popup show, click body will call this, bug!
	    var selectedValue = nextProps.selectedValue;
	    this.setState({
	      str: selectedValue && selectedValue.format(nextProps.format) || '',
	      invalid: false
	    });
	  },
	  onInputChange: function onInputChange(event) {
	    var str = event.target.value;
	    this.setState({
	      str: str
	    });
	    var value = void 0;
	    var _props = this.props,
	        disabledDate = _props.disabledDate,
	        format = _props.format,
	        onChange = _props.onChange;
	
	    if (str) {
	      var parsed = (0, _moment2['default'])(str, format, true);
	      if (!parsed.isValid()) {
	        this.setState({
	          invalid: true
	        });
	        return;
	      }
	      value = this.props.value.clone();
	      value.year(parsed.year()).month(parsed.month()).date(parsed.date()).hour(parsed.hour()).minute(parsed.minute()).second(parsed.second());
	
	      if (value && (!disabledDate || !disabledDate(value))) {
	        var originalValue = this.props.selectedValue;
	        if (originalValue && value) {
	          if (!originalValue.isSame(value)) {
	            onChange(value);
	          }
	        } else if (originalValue !== value) {
	          onChange(value);
	        }
	      } else {
	        this.setState({
	          invalid: true
	        });
	        return;
	      }
	    } else {
	      onChange(null);
	    }
	    this.setState({
	      invalid: false
	    });
	  },
	  onClear: function onClear() {
	    this.setState({
	      str: ''
	    });
	    this.props.onClear(null);
	  },
	  getRootDOMNode: function getRootDOMNode() {
	    return _reactDom2['default'].findDOMNode(this);
	  },
	  focus: function focus() {
	    if (this.dateInputInstance) {
	      this.dateInputInstance.focus();
	    }
	  },
	  saveDateInput: function saveDateInput(dateInput) {
	    this.dateInputInstance = dateInput;
	  },
	  render: function render() {
	    var props = this.props;
	    var _state = this.state,
	        invalid = _state.invalid,
	        str = _state.str;
	    var locale = props.locale,
	        prefixCls = props.prefixCls,
	        placeholder = props.placeholder;
	
	    var invalidClass = invalid ? prefixCls + '-input-invalid' : '';
	    return _react2['default'].createElement(
	      'div',
	      { className: prefixCls + '-input-wrap' },
	      _react2['default'].createElement(
	        'div',
	        { className: prefixCls + '-date-input-wrap' },
	        _react2['default'].createElement('input', {
	          ref: this.saveDateInput,
	          className: prefixCls + '-input ' + invalidClass,
	          value: str,
	          disabled: props.disabled,
	          placeholder: placeholder,
	          onChange: this.onInputChange
	        })
	      ),
	      props.showClear ? _react2['default'].createElement('a', {
	        className: prefixCls + '-clear-btn',
	        role: 'button',
	        title: locale.clear,
	        onClick: this.onClear
	      }) : null
	    );
	  }
	});
	
	exports['default'] = DateInput;
	module.exports = exports['default'];

/***/ }),
/* 249 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _Calendar = __webpack_require__(660);
	
	var _Calendar2 = _interopRequireDefault(_Calendar);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	exports['default'] = _Calendar2['default'];
	module.exports = exports['default'];

/***/ }),
/* 250 */
/***/ (function(module, exports) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports['default'] = {
	  today: '今天',
	  now: '此刻',
	  backToToday: '返回今天',
	  ok: '确定',
	  timeSelect: '选择时间',
	  dateSelect: '选择日期',
	  clear: '清除',
	  month: '月',
	  year: '年',
	  previousMonth: '上个月 (翻页上键)',
	  nextMonth: '下个月 (翻页下键)',
	  monthSelect: '选择月份',
	  yearSelect: '选择年份',
	  decadeSelect: '选择年代',
	  yearFormat: 'YYYY年',
	  dayFormat: 'D日',
	  dateFormat: 'YYYY年M月D日',
	  dateTimeFormat: 'YYYY年M月D日 HH时mm分ss秒',
	  previousYear: '上一年 (Control键加左方向键)',
	  nextYear: '下一年 (Control键加右方向键)',
	  previousDecade: '上一年代',
	  nextDecade: '下一年代',
	  previousCentury: '上一世纪',
	  nextCentury: '下一世纪'
	};
	module.exports = exports['default'];

/***/ }),
/* 251 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _createReactClass = __webpack_require__(14);
	
	var _createReactClass2 = _interopRequireDefault(_createReactClass);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _YearPanel = __webpack_require__(253);
	
	var _YearPanel2 = _interopRequireDefault(_YearPanel);
	
	var _MonthTable = __webpack_require__(252);
	
	var _MonthTable2 = _interopRequireDefault(_MonthTable);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function goYear(direction) {
	  var next = this.state.value.clone();
	  next.add(direction, 'year');
	  this.setAndChangeValue(next);
	}
	
	function noop() {}
	
	var MonthPanel = (0, _createReactClass2['default'])({
	  displayName: 'MonthPanel',
	
	  propTypes: {
	    onChange: _propTypes2['default'].func,
	    disabledDate: _propTypes2['default'].func,
	    onSelect: _propTypes2['default'].func
	  },
	
	  getDefaultProps: function getDefaultProps() {
	    return {
	      onChange: noop,
	      onSelect: noop
	    };
	  },
	  getInitialState: function getInitialState() {
	    var props = this.props;
	    // bind methods
	    this.nextYear = goYear.bind(this, 1);
	    this.previousYear = goYear.bind(this, -1);
	    this.prefixCls = props.rootPrefixCls + '-month-panel';
	    return {
	      value: props.value || props.defaultValue
	    };
	  },
	  componentWillReceiveProps: function componentWillReceiveProps(nextProps) {
	    if ('value' in nextProps) {
	      this.setState({
	        value: nextProps.value
	      });
	    }
	  },
	  onYearPanelSelect: function onYearPanelSelect(current) {
	    this.setState({
	      showYearPanel: 0
	    });
	    this.setAndChangeValue(current);
	  },
	  setAndChangeValue: function setAndChangeValue(value) {
	    this.setValue(value);
	    this.props.onChange(value);
	  },
	  setAndSelectValue: function setAndSelectValue(value) {
	    this.setValue(value);
	    this.props.onSelect(value);
	  },
	  setValue: function setValue(value) {
	    if (!('value' in this.props)) {
	      this.setState({
	        value: value
	      });
	    }
	  },
	  showYearPanel: function showYearPanel() {
	    this.setState({
	      showYearPanel: 1
	    });
	  },
	  render: function render() {
	    var props = this.props;
	    var value = this.state.value;
	    var cellRender = props.cellRender;
	    var contentRender = props.contentRender;
	    var locale = props.locale;
	    var year = value.year();
	    var prefixCls = this.prefixCls;
	    var yearPanel = void 0;
	    if (this.state.showYearPanel) {
	      yearPanel = _react2['default'].createElement(_YearPanel2['default'], {
	        locale: locale,
	        value: value,
	        rootPrefixCls: props.rootPrefixCls,
	        onSelect: this.onYearPanelSelect
	      });
	    }
	    return _react2['default'].createElement(
	      'div',
	      { className: prefixCls, style: props.style },
	      _react2['default'].createElement(
	        'div',
	        null,
	        _react2['default'].createElement(
	          'div',
	          { className: prefixCls + '-header' },
	          _react2['default'].createElement('a', {
	            className: prefixCls + '-prev-year-btn',
	            role: 'button',
	            onClick: this.previousYear,
	            title: locale.previousYear
	          }),
	          _react2['default'].createElement(
	            'a',
	            {
	              className: prefixCls + '-year-select',
	              role: 'button',
	              onClick: this.showYearPanel,
	              title: locale.yearSelect
	            },
	            _react2['default'].createElement(
	              'span',
	              { className: prefixCls + '-year-select-content' },
	              year
	            ),
	            _react2['default'].createElement(
	              'span',
	              { className: prefixCls + '-year-select-arrow' },
	              'x'
	            )
	          ),
	          _react2['default'].createElement('a', {
	            className: prefixCls + '-next-year-btn',
	            role: 'button',
	            onClick: this.nextYear,
	            title: locale.nextYear
	          })
	        ),
	        _react2['default'].createElement(
	          'div',
	          { className: prefixCls + '-body' },
	          _react2['default'].createElement(_MonthTable2['default'], {
	            disabledDate: props.disabledDate,
	            onSelect: this.setAndSelectValue,
	            locale: locale,
	            value: value,
	            cellRender: cellRender,
	            contentRender: contentRender,
	            prefixCls: prefixCls
	          })
	        )
	      ),
	      yearPanel
	    );
	  }
	});
	
	exports['default'] = MonthPanel;
	module.exports = exports['default'];

/***/ }),
/* 252 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _index = __webpack_require__(44);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var ROW = 4;
	var COL = 3;
	
	function chooseMonth(month) {
	  var next = this.state.value.clone();
	  next.month(month);
	  this.setAndSelectValue(next);
	}
	
	function noop() {}
	
	var MonthTable = function (_Component) {
	  (0, _inherits3['default'])(MonthTable, _Component);
	
	  function MonthTable(props) {
	    (0, _classCallCheck3['default'])(this, MonthTable);
	
	    var _this = (0, _possibleConstructorReturn3['default'])(this, (MonthTable.__proto__ || Object.getPrototypeOf(MonthTable)).call(this, props));
	
	    _this.state = {
	      value: props.value
	    };
	    return _this;
	  }
	
	  (0, _createClass3['default'])(MonthTable, [{
	    key: 'componentWillReceiveProps',
	    value: function componentWillReceiveProps(nextProps) {
	      if ('value' in nextProps) {
	        this.setState({
	          value: nextProps.value
	        });
	      }
	    }
	  }, {
	    key: 'setAndSelectValue',
	    value: function setAndSelectValue(value) {
	      this.setState({
	        value: value
	      });
	      this.props.onSelect(value);
	    }
	  }, {
	    key: 'months',
	    value: function months() {
	      var value = this.state.value;
	      var current = value.clone();
	      var months = [];
	      var index = 0;
	      for (var rowIndex = 0; rowIndex < ROW; rowIndex++) {
	        months[rowIndex] = [];
	        for (var colIndex = 0; colIndex < COL; colIndex++) {
	          current.month(index);
	          var content = (0, _index.getMonthName)(current);
	          months[rowIndex][colIndex] = {
	            value: index,
	            content: content,
	            title: content
	          };
	          index++;
	        }
	      }
	      return months;
	    }
	  }, {
	    key: 'render',
	    value: function render() {
	      var _this2 = this;
	
	      var props = this.props;
	      var value = this.state.value;
	      var today = (0, _index.getTodayTime)(value);
	      var months = this.months();
	      var currentMonth = value.month();
	      var prefixCls = props.prefixCls,
	          locale = props.locale,
	          contentRender = props.contentRender,
	          cellRender = props.cellRender;
	
	      var monthsEls = months.map(function (month, index) {
	        var tds = month.map(function (monthData) {
	          var _classNameMap;
	
	          var disabled = false;
	          if (props.disabledDate) {
	            var testValue = value.clone();
	            testValue.month(monthData.value);
	            disabled = props.disabledDate(testValue);
	          }
	          var classNameMap = (_classNameMap = {}, (0, _defineProperty3['default'])(_classNameMap, prefixCls + '-cell', 1), (0, _defineProperty3['default'])(_classNameMap, prefixCls + '-cell-disabled', disabled), (0, _defineProperty3['default'])(_classNameMap, prefixCls + '-selected-cell', monthData.value === currentMonth), (0, _defineProperty3['default'])(_classNameMap, prefixCls + '-current-cell', today.year() === value.year() && monthData.value === today.month()), _classNameMap);
	          var cellEl = void 0;
	          if (cellRender) {
	            var currentValue = value.clone();
	            currentValue.month(monthData.value);
	            cellEl = cellRender(currentValue, locale);
	          } else {
	            var content = void 0;
	            if (contentRender) {
	              var _currentValue = value.clone();
	              _currentValue.month(monthData.value);
	              content = contentRender(_currentValue, locale);
	            } else {
	              content = monthData.content;
	            }
	            cellEl = _react2['default'].createElement(
	              'a',
	              { className: prefixCls + '-month' },
	              content
	            );
	          }
	          return _react2['default'].createElement(
	            'td',
	            {
	              role: 'gridcell',
	              key: monthData.value,
	              onClick: disabled ? null : chooseMonth.bind(_this2, monthData.value),
	              title: monthData.title,
	              className: (0, _classnames2['default'])(classNameMap)
	            },
	            cellEl
	          );
	        });
	        return _react2['default'].createElement(
	          'tr',
	          { key: index, role: 'row' },
	          tds
	        );
	      });
	
	      return _react2['default'].createElement(
	        'table',
	        { className: prefixCls + '-table', cellSpacing: '0', role: 'grid' },
	        _react2['default'].createElement(
	          'tbody',
	          { className: prefixCls + '-tbody' },
	          monthsEls
	        )
	      );
	    }
	  }]);
	  return MonthTable;
	}(_react.Component);
	
	MonthTable.defaultProps = {
	  onSelect: noop
	};
	MonthTable.propTypes = {
	  onSelect: _propTypes2['default'].func,
	  cellRender: _propTypes2['default'].func,
	  prefixCls: _propTypes2['default'].string,
	  value: _propTypes2['default'].object
	};
	exports['default'] = MonthTable;
	module.exports = exports['default'];

/***/ }),
/* 253 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _DecadePanel = __webpack_require__(666);
	
	var _DecadePanel2 = _interopRequireDefault(_DecadePanel);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var ROW = 4;
	var COL = 3;
	
	function goYear(direction) {
	  var value = this.state.value.clone();
	  value.add(direction, 'year');
	  this.setState({
	    value: value
	  });
	}
	
	function chooseYear(year) {
	  var value = this.state.value.clone();
	  value.year(year);
	  value.month(this.state.value.month());
	  this.props.onSelect(value);
	}
	
	var YearPanel = function (_React$Component) {
	  (0, _inherits3['default'])(YearPanel, _React$Component);
	
	  function YearPanel(props) {
	    (0, _classCallCheck3['default'])(this, YearPanel);
	
	    var _this = (0, _possibleConstructorReturn3['default'])(this, (YearPanel.__proto__ || Object.getPrototypeOf(YearPanel)).call(this, props));
	
	    _this.prefixCls = props.rootPrefixCls + '-year-panel';
	    _this.state = {
	      value: props.value || props.defaultValue
	    };
	    _this.nextDecade = goYear.bind(_this, 10);
	    _this.previousDecade = goYear.bind(_this, -10);
	    ['showDecadePanel', 'onDecadePanelSelect'].forEach(function (method) {
	      _this[method] = _this[method].bind(_this);
	    });
	    return _this;
	  }
	
	  (0, _createClass3['default'])(YearPanel, [{
	    key: 'onDecadePanelSelect',
	    value: function onDecadePanelSelect(current) {
	      this.setState({
	        value: current,
	        showDecadePanel: 0
	      });
	    }
	  }, {
	    key: 'years',
	    value: function years() {
	      var value = this.state.value;
	      var currentYear = value.year();
	      var startYear = parseInt(currentYear / 10, 10) * 10;
	      var previousYear = startYear - 1;
	      var years = [];
	      var index = 0;
	      for (var rowIndex = 0; rowIndex < ROW; rowIndex++) {
	        years[rowIndex] = [];
	        for (var colIndex = 0; colIndex < COL; colIndex++) {
	          var year = previousYear + index;
	          var content = String(year);
	          years[rowIndex][colIndex] = {
	            content: content,
	            year: year,
	            title: content
	          };
	          index++;
	        }
	      }
	      return years;
	    }
	  }, {
	    key: 'showDecadePanel',
	    value: function showDecadePanel() {
	      this.setState({
	        showDecadePanel: 1
	      });
	    }
	  }, {
	    key: 'render',
	    value: function render() {
	      var _this2 = this;
	
	      var props = this.props;
	      var value = this.state.value;
	      var locale = props.locale;
	      var years = this.years();
	      var currentYear = value.year();
	      var startYear = parseInt(currentYear / 10, 10) * 10;
	      var endYear = startYear + 9;
	      var prefixCls = this.prefixCls;
	
	      var yeasEls = years.map(function (row, index) {
	        var tds = row.map(function (yearData) {
	          var _classNameMap;
	
	          var classNameMap = (_classNameMap = {}, (0, _defineProperty3['default'])(_classNameMap, prefixCls + '-cell', 1), (0, _defineProperty3['default'])(_classNameMap, prefixCls + '-selected-cell', yearData.year === currentYear), (0, _defineProperty3['default'])(_classNameMap, prefixCls + '-last-decade-cell', yearData.year < startYear), (0, _defineProperty3['default'])(_classNameMap, prefixCls + '-next-decade-cell', yearData.year > endYear), _classNameMap);
	          var clickHandler = void 0;
	          if (yearData.year < startYear) {
	            clickHandler = _this2.previousDecade;
	          } else if (yearData.year > endYear) {
	            clickHandler = _this2.nextDecade;
	          } else {
	            clickHandler = chooseYear.bind(_this2, yearData.year);
	          }
	          return _react2['default'].createElement(
	            'td',
	            {
	              role: 'gridcell',
	              title: yearData.title,
	              key: yearData.content,
	              onClick: clickHandler,
	              className: (0, _classnames2['default'])(classNameMap)
	            },
	            _react2['default'].createElement(
	              'a',
	              {
	                className: prefixCls + '-year'
	              },
	              yearData.content
	            )
	          );
	        });
	        return _react2['default'].createElement(
	          'tr',
	          { key: index, role: 'row' },
	          tds
	        );
	      });
	
	      var decadePanel = void 0;
	      if (this.state.showDecadePanel) {
	        decadePanel = _react2['default'].createElement(_DecadePanel2['default'], {
	          locale: locale,
	          value: value,
	          rootPrefixCls: props.rootPrefixCls,
	          onSelect: this.onDecadePanelSelect
	        });
	      }
	
	      return _react2['default'].createElement(
	        'div',
	        { className: this.prefixCls },
	        _react2['default'].createElement(
	          'div',
	          null,
	          _react2['default'].createElement(
	            'div',
	            { className: prefixCls + '-header' },
	            _react2['default'].createElement('a', {
	              className: prefixCls + '-prev-decade-btn',
	              role: 'button',
	              onClick: this.previousDecade,
	              title: locale.previousDecade
	            }),
	            _react2['default'].createElement(
	              'a',
	              {
	                className: prefixCls + '-decade-select',
	                role: 'button',
	                onClick: this.showDecadePanel,
	                title: locale.decadeSelect
	              },
	              _react2['default'].createElement(
	                'span',
	                { className: prefixCls + '-decade-select-content' },
	                startYear,
	                '-',
	                endYear
	              ),
	              _react2['default'].createElement(
	                'span',
	                { className: prefixCls + '-decade-select-arrow' },
	                'x'
	              )
	            ),
	            _react2['default'].createElement('a', {
	              className: prefixCls + '-next-decade-btn',
	              role: 'button',
	              onClick: this.nextDecade,
	              title: locale.nextDecade
	            })
	          ),
	          _react2['default'].createElement(
	            'div',
	            { className: prefixCls + '-body' },
	            _react2['default'].createElement(
	              'table',
	              { className: prefixCls + '-table', cellSpacing: '0', role: 'grid' },
	              _react2['default'].createElement(
	                'tbody',
	                { className: prefixCls + '-tbody' },
	                yeasEls
	              )
	            )
	          )
	        ),
	        decadePanel
	      );
	    }
	  }]);
	  return YearPanel;
	}(_react2['default'].Component);
	
	exports['default'] = YearPanel;
	
	
	YearPanel.propTypes = {
	  rootPrefixCls: _propTypes2['default'].string,
	  value: _propTypes2['default'].object,
	  defaultValue: _propTypes2['default'].object
	};
	
	YearPanel.defaultProps = {
	  onSelect: function onSelect() {}
	};
	module.exports = exports['default'];

/***/ }),
/* 254 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _Checkbox = __webpack_require__(673);
	
	Object.defineProperty(exports, 'default', {
	  enumerable: true,
	  get: function get() {
	    return _interopRequireDefault(_Checkbox)['default'];
	  }
	});
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	module.exports = exports['default'];

/***/ }),
/* 255 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
	
	var Nav = function Nav(props) {
	  return _react2["default"].createElement('div', props);
	};
	
	exports["default"] = Nav;
	module.exports = exports['default'];

/***/ }),
/* 256 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports["default"] = getMentions;
	
	var _getRegExp = __webpack_require__(258);
	
	var _getRegExp2 = _interopRequireDefault(_getRegExp);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
	
	function getMentions(contentState) {
	  var prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '@';
	
	  var regex = (0, _getRegExp2["default"])(prefix);
	  var entities = [];
	  contentState.getBlockMap().forEach(function (block) {
	    var blockText = block.getText();
	    var matchArr = void 0;
	    while ((matchArr = regex.exec(blockText)) !== null) {
	      // eslint-disable-line
	      entities.push(matchArr[0].trim());
	    }
	  });
	  return entities;
	}
	module.exports = exports['default'];

/***/ }),
/* 257 */
/***/ (function(module, exports) {

	"use strict";
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports["default"] = getOffset;
	function getOffset(element, container) {
	  var rect = element.getBoundingClientRect();
	  if (rect.width || rect.height) {
	    var elementContainer = container || element.parentElement;
	    return {
	      top: rect.top - elementContainer.clientTop,
	      left: rect.left - elementContainer.clientLeft
	    };
	  }
	  return rect;
	}
	module.exports = exports['default'];

/***/ }),
/* 258 */
/***/ (function(module, exports) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports["default"] = getRegExp;
	function getRegExp(prefix) {
	  var prefixArray = Array.isArray(prefix) ? prefix : [prefix];
	  var prefixToken = prefixArray.join('').replace(/(\$|\^)/g, '\\$1');
	
	  if (prefixArray.length > 1) {
	    prefixToken = '[' + prefixToken + ']';
	  }
	
	  return new RegExp('(\\s|^)(' + prefixToken + ')[^\\s]*', 'g');
	}
	module.exports = exports['default'];

/***/ }),
/* 259 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _objectWithoutProperties2 = __webpack_require__(20);
	
	var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _toConsumableArray2 = __webpack_require__(31);
	
	var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _createReactClass = __webpack_require__(14);
	
	var _createReactClass2 = _interopRequireDefault(_createReactClass);
	
	var _asyncValidator = __webpack_require__(292);
	
	var _asyncValidator2 = _interopRequireDefault(_asyncValidator);
	
	var _warning = __webpack_require__(35);
	
	var _warning2 = _interopRequireDefault(_warning);
	
	var _get = __webpack_require__(234);
	
	var _get2 = _interopRequireDefault(_get);
	
	var _has = __webpack_require__(139);
	
	var _has2 = _interopRequireDefault(_has);
	
	var _set = __webpack_require__(238);
	
	var _set2 = _interopRequireDefault(_set);
	
	var _createFieldsStore = __webpack_require__(706);
	
	var _createFieldsStore2 = _interopRequireDefault(_createFieldsStore);
	
	var _utils = __webpack_require__(147);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var DEFAULT_TRIGGER = 'onChange';
	
	function createBaseForm() {
	  var option = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
	  var mixins = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
	  var mapPropsToFields = option.mapPropsToFields,
	      onFieldsChange = option.onFieldsChange,
	      onValuesChange = option.onValuesChange,
	      fieldNameProp = option.fieldNameProp,
	      fieldMetaProp = option.fieldMetaProp,
	      validateMessages = option.validateMessages,
	      _option$mapProps = option.mapProps,
	      mapProps = _option$mapProps === undefined ? _utils.mirror : _option$mapProps,
	      _option$formPropName = option.formPropName,
	      formPropName = _option$formPropName === undefined ? 'form' : _option$formPropName,
	      withRef = option.withRef;
	
	
	  function decorate(WrappedComponent) {
	    var Form = (0, _createReactClass2['default'])({
	      displayName: 'Form',
	
	      mixins: mixins,
	
	      getInitialState: function getInitialState() {
	        var _this = this;
	
	        var fields = mapPropsToFields && mapPropsToFields(this.props);
	        this.fieldsStore = (0, _createFieldsStore2['default'])(fields || {});
	
	        this.instances = {};
	        this.cachedBind = {};
	        // HACK: https://github.com/ant-design/ant-design/issues/6406
	        ['getFieldsValue', 'getFieldValue', 'setFieldsInitialValue', 'getFieldsError', 'getFieldError', 'isFieldValidating', 'isFieldsValidating', 'isFieldsTouched', 'isFieldTouched'].forEach(function (key) {
	          return _this[key] = function () {
	            var _fieldsStore;
	
	            (0, _warning2['default'])(false, 'you should not use `ref` on enhanced form, please use `wrappedComponentRef`. ' + 'See: https://github.com/react-component/form#note-use-wrappedcomponentref-instead-of-withref-after-rc-form140');
	            return (_fieldsStore = _this.fieldsStore)[key].apply(_fieldsStore, arguments);
	          };
	        });
	
	        return {
	          submitting: false
	        };
	      },
	      componentWillReceiveProps: function componentWillReceiveProps(nextProps) {
	        if (mapPropsToFields) {
	          this.fieldsStore.updateFields(mapPropsToFields(nextProps));
	        }
	      },
	      onCollectCommon: function onCollectCommon(name_, action, args) {
	        var name = name_;
	        var fieldMeta = this.fieldsStore.getFieldMeta(name);
	        if (fieldMeta[action]) {
	          fieldMeta[action].apply(fieldMeta, (0, _toConsumableArray3['default'])(args));
	        } else if (fieldMeta.originalProps && fieldMeta.originalProps[action]) {
	          var _fieldMeta$originalPr;
	
	          (_fieldMeta$originalPr = fieldMeta.originalProps)[action].apply(_fieldMeta$originalPr, (0, _toConsumableArray3['default'])(args));
	        }
	        var value = fieldMeta.getValueFromEvent ? fieldMeta.getValueFromEvent.apply(fieldMeta, (0, _toConsumableArray3['default'])(args)) : _utils.getValueFromEvent.apply(undefined, (0, _toConsumableArray3['default'])(args));
	        if (onValuesChange && value !== this.fieldsStore.getFieldValue(name)) {
	          onValuesChange(this.props, (0, _set2['default'])({}, name, value));
	        }
	        var nameKeyObj = (0, _utils.getNameIfNested)(name);
	        if (this.fieldsStore.getFieldMeta(nameKeyObj.name).exclusive) {
	          name = nameKeyObj.name;
	        }
	        var field = this.fieldsStore.getField(name);
	        return { name: name, field: (0, _extends3['default'])({}, field, { value: value, touched: true }), fieldMeta: fieldMeta };
	      },
	      onCollect: function onCollect(name_, action) {
	        for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
	          args[_key - 2] = arguments[_key];
	        }
	
	        var _onCollectCommon = this.onCollectCommon(name_, action, args),
	            name = _onCollectCommon.name,
	            field = _onCollectCommon.field,
	            fieldMeta = _onCollectCommon.fieldMeta;
	
	        var validate = fieldMeta.validate;
	
	        var fieldContent = (0, _extends3['default'])({}, field, {
	          dirty: (0, _utils.hasRules)(validate)
	        });
	        this.setFields((0, _defineProperty3['default'])({}, name, fieldContent));
	      },
	      onCollectValidate: function onCollectValidate(name_, action) {
	        for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
	          args[_key2 - 2] = arguments[_key2];
	        }
	
	        var _onCollectCommon2 = this.onCollectCommon(name_, action, args),
	            field = _onCollectCommon2.field,
	            fieldMeta = _onCollectCommon2.fieldMeta;
	
	        var fieldContent = (0, _extends3['default'])({}, field, {
	          dirty: true
	        });
	        this.validateFieldsInternal([fieldContent], {
	          action: action,
	          options: {
	            firstFields: !!fieldMeta.validateFirst
	          }
	        });
	      },
	      getCacheBind: function getCacheBind(name, action, fn) {
	        var cache = this.cachedBind[name] = this.cachedBind[name] || {};
	        if (!cache[action]) {
	          cache[action] = fn.bind(this, name, action);
	        }
	        return cache[action];
	      },
	      getFieldDecorator: function getFieldDecorator(name, fieldOption) {
	        var _this2 = this;
	
	        var props = this.getFieldProps(name, fieldOption);
	        return function (fieldElem) {
	          var fieldMeta = _this2.fieldsStore.getFieldMeta(name);
	          var originalProps = fieldElem.props;
	          if (true) {
	            var valuePropName = fieldMeta.valuePropName;
	            (0, _warning2['default'])(!(valuePropName in originalProps), '`getFieldDecorator` will override `' + valuePropName + '`, ' + ('so please don\'t set `' + valuePropName + '` directly ') + 'and use `setFieldsValue` to set it.');
	            var defaultValuePropName = 'default' + valuePropName[0].toUpperCase() + valuePropName.slice(1);
	            (0, _warning2['default'])(!(defaultValuePropName in originalProps), '`' + defaultValuePropName + '` is invalid ' + ('for `getFieldDecorator` will set `' + valuePropName + '`,') + ' please use `option.initialValue` instead.');
	          }
	          fieldMeta.originalProps = originalProps;
	          fieldMeta.ref = fieldElem.ref;
	          return _react2['default'].cloneElement(fieldElem, (0, _extends3['default'])({}, props, _this2.fieldsStore.getFieldValuePropValue(fieldMeta)));
	        };
	      },
	      getFieldProps: function getFieldProps(name) {
	        var _this3 = this;
	
	        var usersFieldOption = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
	
	        if (!name) {
	          throw new Error('Must call `getFieldProps` with valid name string!');
	        }
	
	        var nameIfNested = (0, _utils.getNameIfNested)(name);
	        var leadingName = nameIfNested.name;
	        var fieldOption = (0, _extends3['default'])({
	          valuePropName: 'value',
	          validate: [],
	          trigger: DEFAULT_TRIGGER,
	          leadingName: leadingName,
	          name: name
	        }, usersFieldOption);
	
	        var rules = fieldOption.rules,
	            trigger = fieldOption.trigger,
	            _fieldOption$validate = fieldOption.validateTrigger,
	            validateTrigger = _fieldOption$validate === undefined ? trigger : _fieldOption$validate,
	            exclusive = fieldOption.exclusive,
	            validate = fieldOption.validate;
	
	
	        var fieldMeta = this.fieldsStore.getFieldMeta(name);
	        if ('initialValue' in fieldOption) {
	          fieldMeta.initialValue = fieldOption.initialValue;
	        }
	
	        var leadingFieldMeta = this.fieldsStore.getFieldMeta(leadingName);
	        if (nameIfNested.isNested) {
	          leadingFieldMeta.virtual = !exclusive;
	          // exclusive allow getFieldProps('x', {initialValue})
	          // non-exclusive does not allow getFieldProps('x', {initialValue})
	          leadingFieldMeta.hidden = !exclusive;
	          leadingFieldMeta.exclusive = exclusive;
	        }
	
	        var inputProps = (0, _extends3['default'])({}, this.fieldsStore.getFieldValuePropValue(fieldOption), {
	          ref: this.getCacheBind(name, name + '__ref', this.saveRef)
	        });
	        if (fieldNameProp) {
	          inputProps[fieldNameProp] = name;
	        }
	
	        var validateRules = (0, _utils.normalizeValidateRules)(validate, rules, validateTrigger);
	        var validateTriggers = validateRules.filter(function (item) {
	          return !!item.rules && item.rules.length;
	        }).map(function (item) {
	          return item.trigger;
	        }).reduce(function (pre, curr) {
	          return pre.concat(curr);
	        }, []);
	        validateTriggers.forEach(function (action) {
	          if (inputProps[action]) return;
	          inputProps[action] = _this3.getCacheBind(name, action, _this3.onCollectValidate);
	        });
	
	        // make sure that the value will be collect
	        if (trigger && validateTriggers.indexOf(trigger) === -1) {
	          inputProps[trigger] = this.getCacheBind(name, trigger, this.onCollect);
	        }
	
	        var meta = (0, _extends3['default'])({}, fieldMeta, fieldOption, {
	          validate: validateRules
	        });
	        this.fieldsStore.setFieldMeta(name, meta);
	        if (fieldMetaProp) {
	          inputProps[fieldMetaProp] = meta;
	        }
	
	        return inputProps;
	      },
	      getFieldInstance: function getFieldInstance(name) {
	        return this.instances[name];
	      },
	      getRules: function getRules(fieldMeta, action) {
	        var actionRules = fieldMeta.validate.filter(function (item) {
	          return !action || item.trigger.indexOf(action) >= 0;
	        }).map(function (item) {
	          return item.rules;
	        });
	        return (0, _utils.flattenArray)(actionRules);
	      },
	      setFields: function setFields(fields) {
	        var _this4 = this;
	
	        this.fieldsStore.setFields(fields);
	        if (onFieldsChange) {
	          var changedFields = {};
	          Object.keys(fields).forEach(function (f) {
	            changedFields[f] = _this4.fieldsStore.getField(f);
	          });
	          onFieldsChange(this.props, changedFields);
	        }
	        this.forceUpdate();
	      },
	      resetFields: function resetFields(ns) {
	        var newFields = this.fieldsStore.resetFields(ns);
	        if (Object.keys(newFields).length > 0) {
	          this.setFields(newFields);
	        }
	      },
	      setFieldsValue: function setFieldsValue(fieldsValue) {
	        if (onValuesChange) {
	          onValuesChange(this.props, fieldsValue);
	        }
	        var newFields = {};
	        var _fieldsStore2 = this.fieldsStore,
	            fieldsMeta = _fieldsStore2.fieldsMeta,
	            fields = _fieldsStore2.fields;
	
	        var virtualPaths = (0, _utils.getVirtualPaths)(fieldsMeta);
	        Object.keys(fieldsValue).forEach(function (name) {
	          var value = fieldsValue[name];
	          if (fieldsMeta[name] && fieldsMeta[name].virtual) {
	            (0, _utils.clearVirtualField)(name, fields, fieldsMeta);
	            for (var i = 0, len = virtualPaths[name].length; i < len; i++) {
	              var path = virtualPaths[name][i];
	              if ((0, _has2['default'])(fieldsValue, path)) {
	                newFields[path] = {
	                  name: path,
	                  value: (0, _get2['default'])(fieldsValue, path)
	                };
	              }
	            }
	          } else if (fieldsMeta[name]) {
	            newFields[name] = {
	              name: name,
	              value: value
	            };
	          } else {
	            (0, _warning2['default'])(false, 'Cannot use `setFieldsValue` until ' + 'you use `getFieldDecorator` or `getFieldProps` to register it.');
	          }
	        });
	        this.setFields(newFields);
	      },
	      saveRef: function saveRef(name, _, component) {
	        if (!component) {
	          // after destroy, delete data
	          this.fieldsStore.clearField(name);
	          delete this.instances[name];
	          delete this.cachedBind[name];
	          return;
	        }
	        var fieldMeta = this.fieldsStore.getFieldMeta(name);
	        if (fieldMeta) {
	          var ref = fieldMeta.ref;
	          if (ref) {
	            if (typeof ref === 'string') {
	              throw new Error('can not set ref string for ' + name);
	            }
	            ref(component);
	          }
	        }
	        this.instances[name] = component;
	      },
	      validateFieldsInternal: function validateFieldsInternal(fields, _ref, callback) {
	        var _this5 = this;
	
	        var fieldNames = _ref.fieldNames,
	            action = _ref.action,
	            _ref$options = _ref.options,
	            options = _ref$options === undefined ? {} : _ref$options;
	
	        var allRules = {};
	        var allValues = {};
	        var allFields = {};
	        var alreadyErrors = {};
	        fields.forEach(function (field) {
	          var name = field.name;
	          if (options.force !== true && field.dirty === false) {
	            if (field.errors) {
	              (0, _set2['default'])(alreadyErrors, name, { errors: field.errors });
	            }
	            return;
	          }
	          var fieldMeta = _this5.fieldsStore.getFieldMeta(name);
	          var newField = (0, _extends3['default'])({}, field);
	          newField.errors = undefined;
	          newField.validating = true;
	          newField.dirty = true;
	          allRules[name] = _this5.getRules(fieldMeta, action);
	          allValues[name] = newField.value;
	          allFields[name] = newField;
	        });
	        this.setFields(allFields);
	        // in case normalize
	        Object.keys(allValues).forEach(function (f) {
	          allValues[f] = _this5.fieldsStore.getFieldValue(f);
	        });
	        if (callback && (0, _utils.isEmptyObject)(allFields)) {
	          callback((0, _utils.isEmptyObject)(alreadyErrors) ? null : alreadyErrors, this.fieldsStore.getFieldsValue((0, _utils.flatFieldNames)(fieldNames)));
	          return;
	        }
	        var validator = new _asyncValidator2['default'](allRules);
	        if (validateMessages) {
	          validator.messages(validateMessages);
	        }
	        validator.validate(allValues, options, function (errors) {
	          var errorsGroup = (0, _extends3['default'])({}, alreadyErrors);
	          if (errors && errors.length) {
	            errors.forEach(function (e) {
	              var fieldName = e.field;
	              if (!(0, _has2['default'])(errorsGroup, fieldName)) {
	                (0, _set2['default'])(errorsGroup, fieldName, { errors: [] });
	              }
	              var fieldErrors = (0, _get2['default'])(errorsGroup, fieldName.concat('.errors'));
	              fieldErrors.push(e);
	            });
	          }
	          var expired = [];
	          var nowAllFields = {};
	          Object.keys(allRules).forEach(function (name) {
	            var fieldErrors = (0, _get2['default'])(errorsGroup, name);
	            var nowField = _this5.fieldsStore.getField(name);
	            // avoid concurrency problems
	            if (nowField.value !== allValues[name]) {
	              expired.push({
	                name: name
	              });
	            } else {
	              nowField.errors = fieldErrors && fieldErrors.errors;
	              nowField.value = allValues[name];
	              nowField.validating = false;
	              nowField.dirty = false;
	              nowAllFields[name] = nowField;
	            }
	          });
	          _this5.setFields(nowAllFields);
	          if (callback) {
	            if (expired.length) {
	              expired.forEach(function (_ref2) {
	                var name = _ref2.name;
	
	                var fieldErrors = [{
	                  message: name + ' need to revalidate',
	                  field: name
	                }];
	                (0, _set2['default'])(errorsGroup, name, {
	                  expired: true,
	                  errors: fieldErrors
	                });
	              });
	            }
	
	            callback((0, _utils.isEmptyObject)(errorsGroup) ? null : errorsGroup, _this5.fieldsStore.getFieldsValue((0, _utils.flatFieldNames)(fieldNames)));
	          }
	        });
	      },
	      validateFields: function validateFields(ns, opt, cb) {
	        var _this6 = this;
	
	        var _getParams = (0, _utils.getParams)(ns, opt, cb),
	            names = _getParams.names,
	            callback = _getParams.callback,
	            options = _getParams.options;
	
	        var fieldNames = names || this.fieldsStore.getValidFieldsName();
	        var fields = fieldNames.filter(function (name) {
	          var fieldMeta = _this6.fieldsStore.getFieldMeta(name);
	          return (0, _utils.hasRules)(fieldMeta.validate);
	        }).map(function (name) {
	          var field = _this6.fieldsStore.getField(name);
	          field.value = _this6.fieldsStore.getFieldValue(name);
	          return field;
	        });
	        if (!fields.length) {
	          if (callback) {
	            callback(null, this.fieldsStore.getFieldsValue((0, _utils.flatFieldNames)(fieldNames)));
	          }
	          return;
	        }
	        if (!('firstFields' in options)) {
	          options.firstFields = fieldNames.filter(function (name) {
	            var fieldMeta = _this6.fieldsStore.getFieldMeta(name);
	            return !!fieldMeta.validateFirst;
	          });
	        }
	        this.validateFieldsInternal(fields, {
	          fieldNames: fieldNames,
	          options: options
	        }, callback);
	      },
	      isSubmitting: function isSubmitting() {
	        return this.state.submitting;
	      },
	      submit: function submit(callback) {
	        var _this7 = this;
	
	        var fn = function fn() {
	          _this7.setState({
	            submitting: false
	          });
	        };
	        this.setState({
	          submitting: true
	        });
	        callback(fn);
	      },
	      render: function render() {
	        var _props = this.props,
	            wrappedComponentRef = _props.wrappedComponentRef,
	            restProps = (0, _objectWithoutProperties3['default'])(_props, ['wrappedComponentRef']);
	
	        var formProps = (0, _defineProperty3['default'])({}, formPropName, this.getForm());
	        function innerestWrappedComponentRef() {
	          if (wrappedComponentRef && !innerestWrappedComponentRef.called) {
	            wrappedComponentRef.apply(undefined, arguments);
	            innerestWrappedComponentRef.called = true;
	          }
	        }
	        if (withRef) {
	          (0, _warning2['default'])(false, '`withRef` is deprecated, please use `wrappedComponentRef` instead. ' + 'See: https://github.com/react-component/form#note-use-wrappedcomponentref-instead-of-withref-after-rc-form140');
	          formProps.ref = 'wrappedComponent';
	        } else if (wrappedComponentRef) {
	          formProps.ref = innerestWrappedComponentRef;
	        }
	        var props = mapProps.call(this, (0, _extends3['default'])({}, formProps, restProps, {
	          wrappedComponentRef: innerestWrappedComponentRef
	        }));
	        return _react2['default'].createElement(WrappedComponent, props);
	      }
	    });
	
	    return (0, _utils.argumentContainer)(Form, WrappedComponent);
	  }
	
	  return decorate;
	}
	
	exports['default'] = createBaseForm;
	module.exports = exports['default'];

/***/ }),
/* 260 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _reactDom = __webpack_require__(10);
	
	var _reactDom2 = _interopRequireDefault(_reactDom);
	
	var _KeyCode = __webpack_require__(29);
	
	var _KeyCode2 = _interopRequireDefault(_KeyCode);
	
	var _createChainedFunction = __webpack_require__(153);
	
	var _createChainedFunction2 = _interopRequireDefault(_createChainedFunction);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _domScrollIntoView = __webpack_require__(88);
	
	var _domScrollIntoView2 = _interopRequireDefault(_domScrollIntoView);
	
	var _util = __webpack_require__(97);
	
	var _DOMWrap = __webpack_require__(711);
	
	var _DOMWrap2 = _interopRequireDefault(_DOMWrap);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
	
	function allDisabled(arr) {
	  if (!arr.length) {
	    return true;
	  }
	  return arr.every(function (c) {
	    return !!c.props.disabled;
	  });
	}
	
	function getActiveKey(props, originalActiveKey) {
	  var activeKey = originalActiveKey;
	  var children = props.children,
	      eventKey = props.eventKey;
	
	  if (activeKey) {
	    var found = void 0;
	    (0, _util.loopMenuItem)(children, function (c, i) {
	      if (c && !c.props.disabled && activeKey === (0, _util.getKeyFromChildrenIndex)(c, eventKey, i)) {
	        found = true;
	      }
	    });
	    if (found) {
	      return activeKey;
	    }
	  }
	  activeKey = null;
	  if (props.defaultActiveFirst) {
	    (0, _util.loopMenuItem)(children, function (c, i) {
	      if (!activeKey && c && !c.props.disabled) {
	        activeKey = (0, _util.getKeyFromChildrenIndex)(c, eventKey, i);
	      }
	    });
	    return activeKey;
	  }
	  return activeKey;
	}
	
	function saveRef(index, subIndex, c) {
	  if (c) {
	    if (subIndex !== undefined) {
	      this.instanceArray[index] = this.instanceArray[index] || [];
	      this.instanceArray[index][subIndex] = c;
	    } else {
	      this.instanceArray[index] = c;
	    }
	  }
	}
	
	var MenuMixin = {
	  propTypes: {
	    focusable: _propTypes2["default"].bool,
	    multiple: _propTypes2["default"].bool,
	    style: _propTypes2["default"].object,
	    defaultActiveFirst: _propTypes2["default"].bool,
	    visible: _propTypes2["default"].bool,
	    activeKey: _propTypes2["default"].string,
	    selectedKeys: _propTypes2["default"].arrayOf(_propTypes2["default"].string),
	    defaultSelectedKeys: _propTypes2["default"].arrayOf(_propTypes2["default"].string),
	    defaultOpenKeys: _propTypes2["default"].arrayOf(_propTypes2["default"].string),
	    openKeys: _propTypes2["default"].arrayOf(_propTypes2["default"].string),
	    children: _propTypes2["default"].any
	  },
	
	  getDefaultProps: function getDefaultProps() {
	    return {
	      prefixCls: 'rc-menu',
	      className: '',
	      mode: 'vertical',
	      level: 1,
	      inlineIndent: 24,
	      visible: true,
	      focusable: true,
	      style: {}
	    };
	  },
	  getInitialState: function getInitialState() {
	    var props = this.props;
	    return {
	      activeKey: getActiveKey(props, props.activeKey)
	    };
	  },
	  componentWillReceiveProps: function componentWillReceiveProps(nextProps) {
	    var props = void 0;
	    if ('activeKey' in nextProps) {
	      props = {
	        activeKey: getActiveKey(nextProps, nextProps.activeKey)
	      };
	    } else {
	      var originalActiveKey = this.state.activeKey;
	      var activeKey = getActiveKey(nextProps, originalActiveKey);
	      // fix: this.setState(), parent.render(),
	      if (activeKey !== originalActiveKey) {
	        props = {
	          activeKey: activeKey
	        };
	      }
	    }
	    if (props) {
	      this.setState(props);
	    }
	  },
	  shouldComponentUpdate: function shouldComponentUpdate(nextProps) {
	    return this.props.visible || nextProps.visible;
	  },
	  componentWillMount: function componentWillMount() {
	    this.instanceArray = [];
	  },
	
	
	  // all keyboard events callbacks run from here at first
	  onKeyDown: function onKeyDown(e) {
	    var _this = this;
	
	    var keyCode = e.keyCode;
	    var handled = void 0;
	    this.getFlatInstanceArray().forEach(function (obj) {
	      if (obj && obj.props.active && obj.onKeyDown) {
	        handled = obj.onKeyDown(e);
	      }
	    });
	    if (handled) {
	      return 1;
	    }
	    var activeItem = null;
	    if (keyCode === _KeyCode2["default"].UP || keyCode === _KeyCode2["default"].DOWN) {
	      activeItem = this.step(keyCode === _KeyCode2["default"].UP ? -1 : 1);
	    }
	    if (activeItem) {
	      e.preventDefault();
	      this.setState({
	        activeKey: activeItem.props.eventKey
	      }, function () {
	        (0, _domScrollIntoView2["default"])(_reactDom2["default"].findDOMNode(activeItem), _reactDom2["default"].findDOMNode(_this), {
	          onlyScrollIfNeeded: true
	        });
	      });
	      return 1;
	    } else if (activeItem === undefined) {
	      e.preventDefault();
	      this.setState({
	        activeKey: null
	      });
	      return 1;
	    }
	  },
	  getOpenChangesOnItemHover: function getOpenChangesOnItemHover(e) {
	    var mode = this.props.mode;
	    var key = e.key,
	        hover = e.hover,
	        trigger = e.trigger;
	
	    var activeKey = this.state.activeKey;
	    if (!trigger || hover || this.props.closeSubMenuOnMouseLeave || !e.item.isSubMenu || mode === 'inline') {
	      this.setState({
	        activeKey: hover ? key : null
	      });
	    } else {}
	    // keep active for sub menu for click active
	    // empty
	
	    // clear last open status
	    if (hover && mode !== 'inline') {
	      var activeItem = this.getFlatInstanceArray().filter(function (c) {
	        return c && c.props.eventKey === activeKey;
	      })[0];
	      if (activeItem && activeItem.isSubMenu && activeItem.props.eventKey !== key) {
	        return {
	          item: activeItem,
	          originalEvent: e,
	          key: activeItem.props.eventKey,
	          open: false
	        };
	      }
	    }
	    return [];
	  },
	  getFlatInstanceArray: function getFlatInstanceArray() {
	    var instanceArray = this.instanceArray;
	    var hasInnerArray = instanceArray.some(function (a) {
	      return Array.isArray(a);
	    });
	    if (hasInnerArray) {
	      instanceArray = [];
	      this.instanceArray.forEach(function (a) {
	        if (Array.isArray(a)) {
	          instanceArray.push.apply(instanceArray, a);
	        } else {
	          instanceArray.push(a);
	        }
	      });
	      this.instanceArray = instanceArray;
	    }
	    return instanceArray;
	  },
	  renderCommonMenuItem: function renderCommonMenuItem(child, i, subIndex, extraProps) {
	    var state = this.state;
	    var props = this.props;
	    var key = (0, _util.getKeyFromChildrenIndex)(child, props.eventKey, i);
	    var childProps = child.props;
	    var isActive = key === state.activeKey;
	    var newChildProps = (0, _extends3["default"])({
	      mode: props.mode,
	      level: props.level,
	      inlineIndent: props.inlineIndent,
	      renderMenuItem: this.renderMenuItem,
	      rootPrefixCls: props.prefixCls,
	      index: i,
	      parentMenu: this,
	      ref: childProps.disabled ? undefined : (0, _createChainedFunction2["default"])(child.ref, saveRef.bind(this, i, subIndex)),
	      eventKey: key,
	      closeSubMenuOnMouseLeave: props.closeSubMenuOnMouseLeave,
	      onItemHover: this.onItemHover,
	      active: !childProps.disabled && isActive,
	      multiple: props.multiple,
	      onClick: this.onClick,
	      openTransitionName: this.getOpenTransitionName(),
	      openAnimation: props.openAnimation,
	      onOpenChange: this.onOpenChange,
	      onDeselect: this.onDeselect,
	      onDestroy: this.onDestroy,
	      onSelect: this.onSelect
	    }, extraProps);
	    if (props.mode === 'inline') {
	      newChildProps.closeSubMenuOnMouseLeave = newChildProps.openSubMenuOnMouseEnter = false;
	    }
	    return _react2["default"].cloneElement(child, newChildProps);
	  },
	  renderRoot: function renderRoot(props) {
	    var _classes;
	
	    this.instanceArray = [];
	    var classes = (_classes = {}, (0, _defineProperty3["default"])(_classes, props.prefixCls, 1), (0, _defineProperty3["default"])(_classes, props.prefixCls + '-' + props.mode, 1), (0, _defineProperty3["default"])(_classes, props.className, !!props.className), _classes);
	    var domProps = {
	      className: (0, _classnames2["default"])(classes),
	      role: 'menu',
	      'aria-activedescendant': ''
	    };
	    if (props.id) {
	      domProps.id = props.id;
	    }
	    if (props.focusable) {
	      domProps.tabIndex = '0';
	      domProps.onKeyDown = this.onKeyDown;
	    }
	    return (
	      // ESLint is not smart enough to know that the type of `children` was checked.
	      /* eslint-disable */
	      _react2["default"].createElement(
	        _DOMWrap2["default"],
	        (0, _extends3["default"])({
	          style: props.style,
	          tag: 'ul',
	          hiddenClassName: props.prefixCls + '-hidden',
	          visible: props.visible
	        }, domProps),
	        _react2["default"].Children.map(props.children, this.renderMenuItem)
	      )
	      /*eslint-enable */
	
	    );
	  },
	  step: function step(direction) {
	    var children = this.getFlatInstanceArray();
	    var activeKey = this.state.activeKey;
	    var len = children.length;
	    if (!len) {
	      return null;
	    }
	    if (direction < 0) {
	      children = children.concat().reverse();
	    }
	    // find current activeIndex
	    var activeIndex = -1;
	    children.every(function (c, ci) {
	      if (c && c.props.eventKey === activeKey) {
	        activeIndex = ci;
	        return false;
	      }
	      return true;
	    });
	    if (!this.props.defaultActiveFirst && activeIndex !== -1) {
	      if (allDisabled(children.slice(activeIndex, len - 1))) {
	        return undefined;
	      }
	    }
	    var start = (activeIndex + 1) % len;
	    var i = start;
	    for (;;) {
	      var child = children[i];
	      if (!child || child.props.disabled) {
	        i = (i + 1 + len) % len;
	        // complete a loop
	        if (i === start) {
	          return null;
	        }
	      } else {
	        return child;
	      }
	    }
	  }
	};
	
	exports["default"] = MenuMixin;
	module.exports = exports['default'];

/***/ }),
/* 261 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _Notification = __webpack_require__(720);
	
	var _Notification2 = _interopRequireDefault(_Notification);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	exports['default'] = _Notification2['default'];
	module.exports = exports['default'];

/***/ }),
/* 262 */
/***/ (function(module, exports) {

	"use strict";
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports["default"] = {
	  ZERO: 48,
	  NINE: 57,
	
	  NUMPAD_ZERO: 96,
	  NUMPAD_NINE: 105,
	
	  BACKSPACE: 8,
	  DELETE: 46,
	  ENTER: 13,
	
	  ARROW_UP: 38,
	  ARROW_DOWN: 40
	};
	module.exports = exports['default'];

/***/ }),
/* 263 */
/***/ (function(module, exports) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports['default'] = {
	  // Options.jsx
	  items_per_page: '条/页',
	  jump_to: '跳至',
	  jump_to_confirm: '确定',
	  page: '页',
	
	  // Pagination.jsx
	  prev_page: '上一页',
	  next_page: '下一页',
	  prev_5: '向前 5 页',
	  next_5: '向后 5 页',
	  prev_3: '向前 3 页',
	  next_3: '向后 3 页'
	};
	module.exports = exports['default'];

/***/ }),
/* 264 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	exports.__esModule = true;
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var enhancer = function enhancer(WrappedComponent) {
	  return function (_WrappedComponent) {
	    (0, _inherits3['default'])(Progress, _WrappedComponent);
	
	    function Progress() {
	      (0, _classCallCheck3['default'])(this, Progress);
	      return (0, _possibleConstructorReturn3['default'])(this, _WrappedComponent.apply(this, arguments));
	    }
	
	    Progress.prototype.componentDidUpdate = function componentDidUpdate() {
	      if (!this.path) {
	        return;
	      }
	      var pathStyle = this.path.style;
	      pathStyle.transitionDuration = '.3s, .3s, .3s, .06s';
	      var now = Date.now();
	      if (this.prevTimeStamp && now - this.prevTimeStamp < 100) {
	        pathStyle.transitionDuration = '0s, 0s';
	      }
	      this.prevTimeStamp = Date.now();
	    };
	
	    Progress.prototype.render = function render() {
	      return _WrappedComponent.prototype.render.call(this);
	    };
	
	    return Progress;
	  }(WrappedComponent);
	};
	
	exports['default'] = enhancer;
	module.exports = exports['default'];

/***/ }),
/* 265 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	exports.__esModule = true;
	exports.propTypes = exports.defaultProps = undefined;
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var defaultProps = exports.defaultProps = {
	  className: '',
	  percent: 0,
	  prefixCls: 'rc-progress',
	  strokeColor: '#2db7f5',
	  strokeLinecap: 'round',
	  strokeWidth: 1,
	  style: {},
	  trailColor: '#D9D9D9',
	  trailWidth: 1
	};
	
	var propTypes = exports.propTypes = {
	  className: _propTypes2['default'].string,
	  percent: _propTypes2['default'].oneOfType([_propTypes2['default'].number, _propTypes2['default'].string]),
	  prefixCls: _propTypes2['default'].string,
	  strokeColor: _propTypes2['default'].string,
	  strokeLinecap: _propTypes2['default'].oneOf(['butt', 'round', 'square']),
	  strokeWidth: _propTypes2['default'].oneOfType([_propTypes2['default'].number, _propTypes2['default'].string]),
	  style: _propTypes2['default'].object,
	  trailColor: _propTypes2['default'].string,
	  trailWidth: _propTypes2['default'].oneOfType([_propTypes2['default'].number, _propTypes2['default'].string])
	};

/***/ }),
/* 266 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.SelectPropTypes = undefined;
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function valueType(props, propName, componentName) {
	  var labelInValueShape = _propTypes2['default'].shape({
	    key: _propTypes2['default'].string.isRequired,
	    label: _propTypes2['default'].string
	  });
	  if (props.labelInValue) {
	    var validate = _propTypes2['default'].oneOfType([_propTypes2['default'].arrayOf(labelInValueShape), labelInValueShape]);
	    var error = validate.apply(undefined, arguments);
	    if (error) {
	      return new Error('Invalid prop `' + propName + '` supplied to `' + componentName + '`, ' + ('when you set `labelInValue` to `true`, `' + propName + '` should in ') + 'shape of `{ key: string, label?: string }`.');
	    }
	  } else if ((props.mode === 'multiple' || props.mode === 'tags' || props.multiple || props.tags) && props[propName] === '') {
	    return new Error('Invalid prop `' + propName + '` of type `string` supplied to `' + componentName + '`, ' + 'expected `array` when `multiple` or `tags` is `true`.');
	  } else {
	    var _validate = _propTypes2['default'].oneOfType([_propTypes2['default'].arrayOf(_propTypes2['default'].string), _propTypes2['default'].string]);
	    return _validate.apply(undefined, arguments);
	  }
	}
	
	var SelectPropTypes = exports.SelectPropTypes = {
	  defaultActiveFirstOption: _propTypes2['default'].bool,
	  multiple: _propTypes2['default'].bool,
	  filterOption: _propTypes2['default'].any,
	  children: _propTypes2['default'].any,
	  showSearch: _propTypes2['default'].bool,
	  disabled: _propTypes2['default'].bool,
	  allowClear: _propTypes2['default'].bool,
	  showArrow: _propTypes2['default'].bool,
	  tags: _propTypes2['default'].bool,
	  prefixCls: _propTypes2['default'].string,
	  className: _propTypes2['default'].string,
	  transitionName: _propTypes2['default'].string,
	  optionLabelProp: _propTypes2['default'].string,
	  optionFilterProp: _propTypes2['default'].string,
	  animation: _propTypes2['default'].string,
	  choiceTransitionName: _propTypes2['default'].string,
	  onChange: _propTypes2['default'].func,
	  onBlur: _propTypes2['default'].func,
	  onFocus: _propTypes2['default'].func,
	  onSelect: _propTypes2['default'].func,
	  onSearch: _propTypes2['default'].func,
	  placeholder: _propTypes2['default'].any,
	  onDeselect: _propTypes2['default'].func,
	  labelInValue: _propTypes2['default'].bool,
	  value: valueType,
	  defaultValue: valueType,
	  dropdownStyle: _propTypes2['default'].object,
	  maxTagTextLength: _propTypes2['default'].number,
	  tokenSeparators: _propTypes2['default'].arrayOf(_propTypes2['default'].string),
	  getInputElement: _propTypes2['default'].func
	};

/***/ }),
/* 267 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.SelectPropTypes = exports.OptGroup = exports.Option = undefined;
	
	var _Select = __webpack_require__(735);
	
	var _Select2 = _interopRequireDefault(_Select);
	
	var _Option = __webpack_require__(734);
	
	var _Option2 = _interopRequireDefault(_Option);
	
	var _PropTypes = __webpack_require__(266);
	
	var _OptGroup = __webpack_require__(733);
	
	var _OptGroup2 = _interopRequireDefault(_OptGroup);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	_Select2['default'].Option = _Option2['default'];
	_Select2['default'].OptGroup = _OptGroup2['default'];
	exports.Option = _Option2['default'];
	exports.OptGroup = _OptGroup2['default'];
	exports.SelectPropTypes = _PropTypes.SelectPropTypes;
	exports['default'] = _Select2['default'];

/***/ }),
/* 268 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _objectWithoutProperties2 = __webpack_require__(20);
	
	var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var Handle = function (_React$Component) {
	  (0, _inherits3['default'])(Handle, _React$Component);
	
	  function Handle() {
	    (0, _classCallCheck3['default'])(this, Handle);
	    return (0, _possibleConstructorReturn3['default'])(this, (Handle.__proto__ || Object.getPrototypeOf(Handle)).apply(this, arguments));
	  }
	
	  (0, _createClass3['default'])(Handle, [{
	    key: 'render',
	    value: function render() {
	      var _props = this.props,
	          className = _props.className,
	          vertical = _props.vertical,
	          offset = _props.offset,
	          style = _props.style,
	          disabled = _props.disabled,
	          min = _props.min,
	          max = _props.max,
	          value = _props.value,
	          restProps = (0, _objectWithoutProperties3['default'])(_props, ['className', 'vertical', 'offset', 'style', 'disabled', 'min', 'max', 'value']);
	
	
	      var postionStyle = vertical ? { bottom: offset + '%' } : { left: offset + '%' };
	      var elStyle = (0, _extends3['default'])({}, style, postionStyle);
	      var ariaProps = {};
	      if (value !== undefined) {
	        ariaProps = (0, _extends3['default'])({}, ariaProps, {
	          'aria-valuemin': min,
	          'aria-valuemax': max,
	          'aria-valuenow': value,
	          'aria-disabled': !!disabled
	        });
	      }
	      return _react2['default'].createElement('div', (0, _extends3['default'])({
	        role: 'slider',
	        tabIndex: '0'
	      }, ariaProps, restProps, {
	        className: className,
	        style: elStyle
	      }));
	    }
	  }]);
	  return Handle;
	}(_react2['default'].Component);
	
	exports['default'] = Handle;
	
	
	Handle.propTypes = {
	  className: _propTypes2['default'].string,
	  vertical: _propTypes2['default'].bool,
	  offset: _propTypes2['default'].number,
	  style: _propTypes2['default'].object,
	  disabled: _propTypes2['default'].bool,
	  min: _propTypes2['default'].number,
	  max: _propTypes2['default'].number,
	  value: _propTypes2['default'].number
	};
	module.exports = exports['default'];

/***/ }),
/* 269 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var Track = function Track(props) {
	  var className = props.className,
	      included = props.included,
	      vertical = props.vertical,
	      offset = props.offset,
	      length = props.length,
	      style = props.style;
	
	
	  var positonStyle = vertical ? {
	    bottom: offset + '%',
	    height: length + '%'
	  } : {
	    left: offset + '%',
	    width: length + '%'
	  };
	
	  var elStyle = (0, _extends3['default'])({
	    visibility: included ? 'visible' : 'hidden'
	  }, style, positonStyle);
	  return _react2['default'].createElement('div', { className: className, style: elStyle });
	}; /* eslint-disable react/prop-types */
	exports['default'] = Track;
	module.exports = exports['default'];

/***/ }),
/* 270 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _objectWithoutProperties2 = __webpack_require__(20);
	
	var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _get2 = __webpack_require__(420);
	
	var _get3 = _interopRequireDefault(_get2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	exports['default'] = createSlider;
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _addEventListener = __webpack_require__(34);
	
	var _addEventListener2 = _interopRequireDefault(_addEventListener);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _warning = __webpack_require__(35);
	
	var _warning2 = _interopRequireDefault(_warning);
	
	var _Steps = __webpack_require__(740);
	
	var _Steps2 = _interopRequireDefault(_Steps);
	
	var _Marks = __webpack_require__(739);
	
	var _Marks2 = _interopRequireDefault(_Marks);
	
	var _Handle = __webpack_require__(268);
	
	var _Handle2 = _interopRequireDefault(_Handle);
	
	var _utils = __webpack_require__(149);
	
	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 noop() {}
	
	function createSlider(Component) {
	  var _class, _temp;
	
	  return _temp = _class = function (_Component) {
	    (0, _inherits3['default'])(ComponentEnhancer, _Component);
	
	    function ComponentEnhancer(props) {
	      (0, _classCallCheck3['default'])(this, ComponentEnhancer);
	
	      var _this = (0, _possibleConstructorReturn3['default'])(this, (ComponentEnhancer.__proto__ || Object.getPrototypeOf(ComponentEnhancer)).call(this, props));
	
	      _this.onMouseDown = function (e) {
	        if (e.button !== 0) {
	          return;
	        }
	
	        var isVertical = _this.props.vertical;
	        var position = utils.getMousePosition(isVertical, e);
	        if (!utils.isEventFromHandle(e, _this.handlesRefs)) {
	          _this.dragOffset = 0;
	        } else {
	          var handlePosition = utils.getHandleCenterPosition(isVertical, e.target);
	          _this.dragOffset = position - handlePosition;
	          position = handlePosition;
	        }
	        _this.removeDocumentEvents();
	        _this.onStart(position);
	        _this.addDocumentMouseEvents();
	        utils.pauseEvent(e);
	      };
	
	      _this.onTouchStart = function (e) {
	        if (utils.isNotTouchEvent(e)) return;
	
	        var isVertical = _this.props.vertical;
	        var position = utils.getTouchPosition(isVertical, e);
	        if (!utils.isEventFromHandle(e, _this.handlesRefs)) {
	          _this.dragOffset = 0;
	        } else {
	          var handlePosition = utils.getHandleCenterPosition(isVertical, e.target);
	          _this.dragOffset = position - handlePosition;
	          position = handlePosition;
	        }
	        _this.onStart(position);
	        _this.addDocumentTouchEvents();
	        utils.pauseEvent(e);
	      };
	
	      _this.onFocus = function (e) {
	        var isVertical = _this.props.vertical;
	
	        if (utils.isEventFromHandle(e, _this.handlesRefs)) {
	          var handlePosition = utils.getHandleCenterPosition(isVertical, e.target);
	
	          _this.dragOffset = 0;
	          _this.onStart(handlePosition);
	          utils.pauseEvent(e);
	        }
	      };
	
	      _this.onBlur = function (e) {
	        _this.onEnd(e);
	      };
	
	      _this.onMouseUp = function () {
	        _this.onEnd();
	        _this.removeDocumentEvents();
	      };
	
	      _this.onMouseMove = function (e) {
	        if (!_this.sliderRef) {
	          _this.onEnd();
	          return;
	        }
	        var position = utils.getMousePosition(_this.props.vertical, e);
	        _this.onMove(e, position - _this.dragOffset);
	      };
	
	      _this.onTouchMove = function (e) {
	        if (utils.isNotTouchEvent(e) || !_this.sliderRef) {
	          _this.onEnd();
	          return;
	        }
	
	        var position = utils.getTouchPosition(_this.props.vertical, e);
	        _this.onMove(e, position - _this.dragOffset);
	      };
	
	      _this.onKeyDown = function (e) {
	        if (_this.sliderRef && utils.isEventFromHandle(e, _this.handlesRefs)) {
	          _this.onKeyboard(e);
	        }
	      };
	
	      _this.saveSlider = function (slider) {
	        _this.sliderRef = slider;
	      };
	
	      if (true) {
	        var step = props.step,
	            max = props.max,
	            min = props.min;
	
	        (0, _warning2['default'])(step && Math.floor(step) === step ? (max - min) % step === 0 : true, 'Slider[max] - Slider[min] (%s) should be a multiple of Slider[step] (%s)', max - min, step);
	      }
	      _this.handlesRefs = {};
	      return _this;
	    }
	
	    (0, _createClass3['default'])(ComponentEnhancer, [{
	      key: 'componentWillUnmount',
	      value: function componentWillUnmount() {
	        if ((0, _get3['default'])(ComponentEnhancer.prototype.__proto__ || Object.getPrototypeOf(ComponentEnhancer.prototype), 'componentWillUnmount', this)) (0, _get3['default'])(ComponentEnhancer.prototype.__proto__ || Object.getPrototypeOf(ComponentEnhancer.prototype), 'componentWillUnmount', this).call(this);
	        this.removeDocumentEvents();
	      }
	    }, {
	      key: 'componentDidMount',
	      value: function componentDidMount() {
	        this.document = this.sliderRef.ownerDocument;
	      }
	    }, {
	      key: 'addDocumentTouchEvents',
	      value: function addDocumentTouchEvents() {
	        // just work for Chrome iOS Safari and Android Browser
	        this.onTouchMoveListener = (0, _addEventListener2['default'])(this.document, 'touchmove', this.onTouchMove);
	        this.onTouchUpListener = (0, _addEventListener2['default'])(this.document, 'touchend', this.onEnd);
	      }
	    }, {
	      key: 'addDocumentMouseEvents',
	      value: function addDocumentMouseEvents() {
	        this.onMouseMoveListener = (0, _addEventListener2['default'])(this.document, 'mousemove', this.onMouseMove);
	        this.onMouseUpListener = (0, _addEventListener2['default'])(this.document, 'mouseup', this.onEnd);
	      }
	    }, {
	      key: 'removeDocumentEvents',
	      value: function removeDocumentEvents() {
	        /* eslint-disable no-unused-expressions */
	        this.onTouchMoveListener && this.onTouchMoveListener.remove();
	        this.onTouchUpListener && this.onTouchUpListener.remove();
	
	        this.onMouseMoveListener && this.onMouseMoveListener.remove();
	        this.onMouseUpListener && this.onMouseUpListener.remove();
	        /* eslint-enable no-unused-expressions */
	      }
	    }, {
	      key: 'getSliderStart',
	      value: function getSliderStart() {
	        var slider = this.sliderRef;
	        var rect = slider.getBoundingClientRect();
	
	        return this.props.vertical ? rect.top : rect.left;
	      }
	    }, {
	      key: 'getSliderLength',
	      value: function getSliderLength() {
	        var slider = this.sliderRef;
	        if (!slider) {
	          return 0;
	        }
	
	        var coords = slider.getBoundingClientRect();
	        return this.props.vertical ? coords.height : coords.width;
	      }
	    }, {
	      key: 'calcValue',
	      value: function calcValue(offset) {
	        var _props = this.props,
	            vertical = _props.vertical,
	            min = _props.min,
	            max = _props.max;
	
	        var ratio = Math.abs(Math.max(offset, 0) / this.getSliderLength());
	        var value = vertical ? (1 - ratio) * (max - min) + min : ratio * (max - min) + min;
	        return value;
	      }
	    }, {
	      key: 'calcValueByPos',
	      value: function calcValueByPos(position) {
	        var pixelOffset = position - this.getSliderStart();
	        var nextValue = this.trimAlignValue(this.calcValue(pixelOffset));
	        return nextValue;
	      }
	    }, {
	      key: 'calcOffset',
	      value: function calcOffset(value) {
	        var _props2 = this.props,
	            min = _props2.min,
	            max = _props2.max;
	
	        var ratio = (value - min) / (max - min);
	        return ratio * 100;
	      }
	    }, {
	      key: 'saveHandle',
	      value: function saveHandle(index, handle) {
	        this.handlesRefs[index] = handle;
	      }
	    }, {
	      key: 'render',
	      value: function render() {
	        var _classNames;
	
	        var _props3 = this.props,
	            prefixCls = _props3.prefixCls,
	            className = _props3.className,
	            marks = _props3.marks,
	            dots = _props3.dots,
	            step = _props3.step,
	            included = _props3.included,
	            disabled = _props3.disabled,
	            vertical = _props3.vertical,
	            min = _props3.min,
	            max = _props3.max,
	            children = _props3.children,
	            maximumTrackStyle = _props3.maximumTrackStyle,
	            style = _props3.style,
	            railStyle = _props3.railStyle,
	            dotStyle = _props3.dotStyle,
	            activeDotStyle = _props3.activeDotStyle;
	
	        var _get$call = (0, _get3['default'])(ComponentEnhancer.prototype.__proto__ || Object.getPrototypeOf(ComponentEnhancer.prototype), 'render', this).call(this),
	            tracks = _get$call.tracks,
	            handles = _get$call.handles;
	
	        var sliderClassName = (0, _classnames2['default'])(prefixCls, (_classNames = {}, (0, _defineProperty3['default'])(_classNames, prefixCls + '-with-marks', Object.keys(marks).length), (0, _defineProperty3['default'])(_classNames, prefixCls + '-disabled', disabled), (0, _defineProperty3['default'])(_classNames, prefixCls + '-vertical', vertical), (0, _defineProperty3['default'])(_classNames, className, className), _classNames));
	        return _react2['default'].createElement(
	          'div',
	          {
	            ref: this.saveSlider,
	            className: sliderClassName,
	            onTouchStart: disabled ? noop : this.onTouchStart,
	            onMouseDown: disabled ? noop : this.onMouseDown,
	            onMouseUp: disabled ? noop : this.onMouseUp,
	            onKeyDown: disabled ? noop : this.onKeyDown,
	            onFocus: disabled ? noop : this.onFocus,
	            onBlur: disabled ? noop : this.onBlur,
	            style: style
	          },
	          _react2['default'].createElement('div', {
	            className: prefixCls + '-rail',
	            style: (0, _extends3['default'])({}, maximumTrackStyle, railStyle)
	          }),
	          tracks,
	          _react2['default'].createElement(_Steps2['default'], {
	            prefixCls: prefixCls,
	            vertical: vertical,
	            marks: marks,
	            dots: dots,
	            step: step,
	            included: included,
	            lowerBound: this.getLowerBound(),
	            upperBound: this.getUpperBound(),
	            max: max,
	            min: min,
	            dotStyle: dotStyle,
	            activeDotStyle: activeDotStyle
	          }),
	          handles,
	          _react2['default'].createElement(_Marks2['default'], {
	            className: prefixCls + '-mark',
	            vertical: vertical,
	            marks: marks,
	            included: included,
	            lowerBound: this.getLowerBound(),
	            upperBound: this.getUpperBound(),
	            max: max,
	            min: min
	          }),
	          children
	        );
	      }
	    }]);
	    return ComponentEnhancer;
	  }(Component), _class.displayName = 'ComponentEnhancer(' + Component.displayName + ')', _class.propTypes = (0, _extends3['default'])({}, Component.propTypes, {
	    min: _propTypes2['default'].number,
	    max: _propTypes2['default'].number,
	    step: _propTypes2['default'].number,
	    marks: _propTypes2['default'].object,
	    included: _propTypes2['default'].bool,
	    className: _propTypes2['default'].string,
	    prefixCls: _propTypes2['default'].string,
	    disabled: _propTypes2['default'].bool,
	    children: _propTypes2['default'].any,
	    onBeforeChange: _propTypes2['default'].func,
	    onChange: _propTypes2['default'].func,
	    onAfterChange: _propTypes2['default'].func,
	    handle: _propTypes2['default'].func,
	    dots: _propTypes2['default'].bool,
	    vertical: _propTypes2['default'].bool,
	    style: _propTypes2['default'].object,
	    minimumTrackStyle: _propTypes2['default'].object, // just for compatibility, will be deperecate
	    maximumTrackStyle: _propTypes2['default'].object, // just for compatibility, will be deperecate
	    handleStyle: _propTypes2['default'].oneOfType([_propTypes2['default'].object, _propTypes2['default'].arrayOf(_propTypes2['default'].object)]),
	    trackStyle: _propTypes2['default'].oneOfType([_propTypes2['default'].object, _propTypes2['default'].arrayOf(_propTypes2['default'].object)]),
	    railStyle: _propTypes2['default'].object,
	    dotStyle: _propTypes2['default'].object,
	    activeDotStyle: _propTypes2['default'].object
	  }), _class.defaultProps = (0, _extends3['default'])({}, Component.defaultProps, {
	    prefixCls: 'rc-slider',
	    className: '',
	    min: 0,
	    max: 100,
	    step: 1,
	    marks: {},
	    handle: function handle(_ref) {
	      var index = _ref.index,
	          restProps = (0, _objectWithoutProperties3['default'])(_ref, ['index']);
	
	      delete restProps.dragging;
	      return _react2['default'].createElement(_Handle2['default'], (0, _extends3['default'])({}, restProps, { key: index }));
	    },
	
	    onBeforeChange: noop,
	    onChange: noop,
	    onAfterChange: noop,
	    included: true,
	    disabled: false,
	    dots: false,
	    vertical: false,
	    trackStyle: [{}],
	    handleStyle: [{}],
	    railStyle: {},
	    dotStyle: {},
	    activeDotStyle: {}
	  }), _temp;
	}
	module.exports = exports['default'];

/***/ }),
/* 271 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _createReactClass = __webpack_require__(14);
	
	var _createReactClass2 = _interopRequireDefault(_createReactClass);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _classnames2 = __webpack_require__(8);
	
	var _classnames3 = _interopRequireDefault(_classnames2);
	
	var _utils = __webpack_require__(66);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var TabContent = (0, _createReactClass2['default'])({
	  displayName: 'TabContent',
	  propTypes: {
	    animated: _propTypes2['default'].bool,
	    animatedWithMargin: _propTypes2['default'].bool,
	    prefixCls: _propTypes2['default'].string,
	    children: _propTypes2['default'].any,
	    activeKey: _propTypes2['default'].string,
	    style: _propTypes2['default'].any,
	    tabBarPosition: _propTypes2['default'].string
	  },
	  getDefaultProps: function getDefaultProps() {
	    return {
	      animated: true
	    };
	  },
	  getTabPanes: function getTabPanes() {
	    var props = this.props;
	    var activeKey = props.activeKey;
	    var children = props.children;
	    var newChildren = [];
	
	    _react2['default'].Children.forEach(children, function (child) {
	      if (!child) {
	        return;
	      }
	      var key = child.key;
	      var active = activeKey === key;
	      newChildren.push(_react2['default'].cloneElement(child, {
	        active: active,
	        destroyInactiveTabPane: props.destroyInactiveTabPane,
	        rootPrefixCls: props.prefixCls
	      }));
	    });
	
	    return newChildren;
	  },
	  render: function render() {
	    var _classnames;
	
	    var props = this.props;
	    var prefixCls = props.prefixCls,
	        children = props.children,
	        activeKey = props.activeKey,
	        tabBarPosition = props.tabBarPosition,
	        animated = props.animated,
	        animatedWithMargin = props.animatedWithMargin;
	    var style = props.style;
	
	    var classes = (0, _classnames3['default'])((_classnames = {}, (0, _defineProperty3['default'])(_classnames, prefixCls + '-content', true), (0, _defineProperty3['default'])(_classnames, animated ? prefixCls + '-content-animated' : prefixCls + '-content-no-animated', true), _classnames));
	    if (animated) {
	      var activeIndex = (0, _utils.getActiveIndex)(children, activeKey);
	      if (activeIndex !== -1) {
	        var animatedStyle = animatedWithMargin ? (0, _utils.getMarginStyle)(activeIndex, tabBarPosition) : (0, _utils.getTransformPropValue)((0, _utils.getTransformByIndex)(activeIndex, tabBarPosition));
	        style = (0, _extends3['default'])({}, style, animatedStyle);
	      } else {
	        style = (0, _extends3['default'])({}, style, {
	          display: 'none'
	        });
	      }
	    }
	    return _react2['default'].createElement(
	      'div',
	      {
	        className: classes,
	        style: style
	      },
	      this.getTabPanes()
	    );
	  }
	});
	
	exports['default'] = TabContent;
	module.exports = exports['default'];

/***/ }),
/* 272 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _objectWithoutProperties2 = __webpack_require__(20);
	
	var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _createReactClass = __webpack_require__(14);
	
	var _createReactClass2 = _interopRequireDefault(_createReactClass);
	
	var _classnames2 = __webpack_require__(8);
	
	var _classnames3 = _interopRequireDefault(_classnames2);
	
	var _utils = __webpack_require__(66);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var TabPane = (0, _createReactClass2['default'])({
	  displayName: 'TabPane',
	  propTypes: {
	    className: _propTypes2['default'].string,
	    active: _propTypes2['default'].bool,
	    style: _propTypes2['default'].any,
	    destroyInactiveTabPane: _propTypes2['default'].bool,
	    forceRender: _propTypes2['default'].bool,
	    placeholder: _propTypes2['default'].node
	  },
	  getDefaultProps: function getDefaultProps() {
	    return { placeholder: null };
	  },
	  render: function render() {
	    var _classnames;
	
	    var _props = this.props,
	        className = _props.className,
	        destroyInactiveTabPane = _props.destroyInactiveTabPane,
	        active = _props.active,
	        forceRender = _props.forceRender,
	        rootPrefixCls = _props.rootPrefixCls,
	        style = _props.style,
	        children = _props.children,
	        placeholder = _props.placeholder,
	        restProps = (0, _objectWithoutProperties3['default'])(_props, ['className', 'destroyInactiveTabPane', 'active', 'forceRender', 'rootPrefixCls', 'style', 'children', 'placeholder']);
	
	    this._isActived = this._isActived || active;
	    var prefixCls = rootPrefixCls + '-tabpane';
	    var cls = (0, _classnames3['default'])((_classnames = {}, (0, _defineProperty3['default'])(_classnames, prefixCls, 1), (0, _defineProperty3['default'])(_classnames, prefixCls + '-inactive', !active), (0, _defineProperty3['default'])(_classnames, prefixCls + '-active', active), (0, _defineProperty3['default'])(_classnames, className, className), _classnames));
	    var isRender = destroyInactiveTabPane ? active : this._isActived;
	    return _react2['default'].createElement(
	      'div',
	      (0, _extends3['default'])({
	        style: style,
	        role: 'tabpanel',
	        'aria-hidden': active ? 'false' : 'true',
	        className: cls
	      }, (0, _utils.getDataAttr)(restProps)),
	      isRender || forceRender ? children : placeholder
	    );
	  }
	});
	
	exports['default'] = TabPane;
	module.exports = exports['default'];

/***/ }),
/* 273 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _Header = __webpack_require__(766);
	
	var _Header2 = _interopRequireDefault(_Header);
	
	var _Combobox = __webpack_require__(765);
	
	var _Combobox2 = _interopRequireDefault(_Combobox);
	
	var _moment = __webpack_require__(13);
	
	var _moment2 = _interopRequireDefault(_moment);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function noop() {}
	
	function generateOptions(length, disabledOptions, hideDisabledOptions) {
	  var arr = [];
	  for (var value = 0; value < length; value++) {
	    if (!disabledOptions || disabledOptions.indexOf(value) < 0 || !hideDisabledOptions) {
	      arr.push(value);
	    }
	  }
	  return arr;
	}
	
	var Panel = function (_Component) {
	  (0, _inherits3['default'])(Panel, _Component);
	
	  function Panel(props) {
	    (0, _classCallCheck3['default'])(this, Panel);
	
	    var _this = (0, _possibleConstructorReturn3['default'])(this, (Panel.__proto__ || Object.getPrototypeOf(Panel)).call(this, props));
	
	    _this.onChange = function (newValue) {
	      _this.setState({ value: newValue });
	      _this.props.onChange(newValue);
	    };
	
	    _this.onCurrentSelectPanelChange = function (currentSelectPanel) {
	      _this.setState({ currentSelectPanel: currentSelectPanel });
	    };
	
	    _this.state = {
	      value: props.value,
	      selectionRange: []
	    };
	    return _this;
	  }
	
	  (0, _createClass3['default'])(Panel, [{
	    key: 'componentWillReceiveProps',
	    value: function componentWillReceiveProps(nextProps) {
	      var value = nextProps.value;
	      if (value) {
	        this.setState({
	          value: value
	        });
	      }
	    }
	  }, {
	    key: 'close',
	
	
	    // https://github.com/ant-design/ant-design/issues/5829
	    value: function close() {
	      this.props.onEsc();
	    }
	  }, {
	    key: 'render',
	    value: function render() {
	      var _classNames;
	
	      var _props = this.props,
	          prefixCls = _props.prefixCls,
	          className = _props.className,
	          placeholder = _props.placeholder,
	          disabledHours = _props.disabledHours,
	          disabledMinutes = _props.disabledMinutes,
	          disabledSeconds = _props.disabledSeconds,
	          hideDisabledOptions = _props.hideDisabledOptions,
	          allowEmpty = _props.allowEmpty,
	          showHour = _props.showHour,
	          showMinute = _props.showMinute,
	          showSecond = _props.showSecond,
	          format = _props.format,
	          defaultOpenValue = _props.defaultOpenValue,
	          clearText = _props.clearText,
	          onEsc = _props.onEsc,
	          addon = _props.addon,
	          use12Hours = _props.use12Hours,
	          onClear = _props.onClear;
	      var _state = this.state,
	          value = _state.value,
	          currentSelectPanel = _state.currentSelectPanel;
	
	      var disabledHourOptions = disabledHours();
	      var disabledMinuteOptions = disabledMinutes(value ? value.hour() : null);
	      var disabledSecondOptions = disabledSeconds(value ? value.hour() : null, value ? value.minute() : null);
	      var hourOptions = generateOptions(24, disabledHourOptions, hideDisabledOptions);
	      var minuteOptions = generateOptions(60, disabledMinuteOptions, hideDisabledOptions);
	      var secondOptions = generateOptions(60, disabledSecondOptions, hideDisabledOptions);
	
	      return _react2['default'].createElement(
	        'div',
	        { className: (0, _classnames2['default'])((_classNames = {}, (0, _defineProperty3['default'])(_classNames, prefixCls + '-inner', true), (0, _defineProperty3['default'])(_classNames, className, !!className), _classNames)) },
	        _react2['default'].createElement(_Header2['default'], {
	          clearText: clearText,
	          prefixCls: prefixCls,
	          defaultOpenValue: defaultOpenValue,
	          value: value,
	          currentSelectPanel: currentSelectPanel,
	          onEsc: onEsc,
	          format: format,
	          placeholder: placeholder,
	          hourOptions: hourOptions,
	          minuteOptions: minuteOptions,
	          secondOptions: secondOptions,
	          disabledHours: disabledHours,
	          disabledMinutes: disabledMinutes,
	          disabledSeconds: disabledSeconds,
	          onChange: this.onChange,
	          onClear: onClear,
	          allowEmpty: allowEmpty
	        }),
	        _react2['default'].createElement(_Combobox2['default'], {
	          prefixCls: prefixCls,
	          value: value,
	          defaultOpenValue: defaultOpenValue,
	          format: format,
	          onChange: this.onChange,
	          showHour: showHour,
	          showMinute: showMinute,
	          showSecond: showSecond,
	          hourOptions: hourOptions,
	          minuteOptions: minuteOptions,
	          secondOptions: secondOptions,
	          disabledHours: disabledHours,
	          disabledMinutes: disabledMinutes,
	          disabledSeconds: disabledSeconds,
	          onCurrentSelectPanelChange: this.onCurrentSelectPanelChange,
	          use12Hours: use12Hours
	        }),
	        addon(this)
	      );
	    }
	  }]);
	  return Panel;
	}(_react.Component);
	
	Panel.propTypes = {
	  clearText: _propTypes2['default'].string,
	  prefixCls: _propTypes2['default'].string,
	  className: _propTypes2['default'].string,
	  defaultOpenValue: _propTypes2['default'].object,
	  value: _propTypes2['default'].object,
	  placeholder: _propTypes2['default'].string,
	  format: _propTypes2['default'].string,
	  disabledHours: _propTypes2['default'].func,
	  disabledMinutes: _propTypes2['default'].func,
	  disabledSeconds: _propTypes2['default'].func,
	  hideDisabledOptions: _propTypes2['default'].bool,
	  onChange: _propTypes2['default'].func,
	  onEsc: _propTypes2['default'].func,
	  allowEmpty: _propTypes2['default'].bool,
	  showHour: _propTypes2['default'].bool,
	  showMinute: _propTypes2['default'].bool,
	  showSecond: _propTypes2['default'].bool,
	  onClear: _propTypes2['default'].func,
	  use12Hours: _propTypes2['default'].bool,
	  addon: _propTypes2['default'].func
	};
	Panel.defaultProps = {
	  prefixCls: 'rc-time-picker-panel',
	  onChange: noop,
	  onClear: noop,
	  disabledHours: noop,
	  disabledMinutes: noop,
	  disabledSeconds: noop,
	  defaultOpenValue: (0, _moment2['default'])(),
	  use12Hours: false,
	  addon: noop
	};
	exports['default'] = Panel;
	module.exports = exports['default'];

/***/ }),
/* 274 */
/***/ (function(module, exports) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	var autoAdjustOverflow = {
	  adjustX: 1,
	  adjustY: 1
	};
	
	var targetOffset = [0, 0];
	
	var placements = exports.placements = {
	  left: {
	    points: ['cr', 'cl'],
	    overflow: autoAdjustOverflow,
	    offset: [-4, 0],
	    targetOffset: targetOffset
	  },
	  right: {
	    points: ['cl', 'cr'],
	    overflow: autoAdjustOverflow,
	    offset: [4, 0],
	    targetOffset: targetOffset
	  },
	  top: {
	    points: ['bc', 'tc'],
	    overflow: autoAdjustOverflow,
	    offset: [0, -4],
	    targetOffset: targetOffset
	  },
	  bottom: {
	    points: ['tc', 'bc'],
	    overflow: autoAdjustOverflow,
	    offset: [0, 4],
	    targetOffset: targetOffset
	  },
	  topLeft: {
	    points: ['bl', 'tl'],
	    overflow: autoAdjustOverflow,
	    offset: [0, -4],
	    targetOffset: targetOffset
	  },
	  leftTop: {
	    points: ['tr', 'tl'],
	    overflow: autoAdjustOverflow,
	    offset: [-4, 0],
	    targetOffset: targetOffset
	  },
	  topRight: {
	    points: ['br', 'tr'],
	    overflow: autoAdjustOverflow,
	    offset: [0, -4],
	    targetOffset: targetOffset
	  },
	  rightTop: {
	    points: ['tl', 'tr'],
	    overflow: autoAdjustOverflow,
	    offset: [4, 0],
	    targetOffset: targetOffset
	  },
	  bottomRight: {
	    points: ['tr', 'br'],
	    overflow: autoAdjustOverflow,
	    offset: [0, 4],
	    targetOffset: targetOffset
	  },
	  rightBottom: {
	    points: ['bl', 'br'],
	    overflow: autoAdjustOverflow,
	    offset: [4, 0],
	    targetOffset: targetOffset
	  },
	  bottomLeft: {
	    points: ['tl', 'bl'],
	    overflow: autoAdjustOverflow,
	    offset: [0, 4],
	    targetOffset: targetOffset
	  },
	  leftBottom: {
	    points: ['br', 'bl'],
	    overflow: autoAdjustOverflow,
	    offset: [-4, 0],
	    targetOffset: targetOffset
	  }
	};
	
	exports['default'] = placements;

/***/ }),
/* 275 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	exports.__esModule = true;
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var TreeNode = function (_React$Component) {
	  (0, _inherits3['default'])(TreeNode, _React$Component);
	
	  function TreeNode() {
	    (0, _classCallCheck3['default'])(this, TreeNode);
	    return (0, _possibleConstructorReturn3['default'])(this, _React$Component.apply(this, arguments));
	  }
	
	  return TreeNode;
	}(_react2['default'].Component);
	
	TreeNode.propTypes = {
	  value: _propTypes2['default'].string
	};
	exports['default'] = TreeNode;
	module.exports = exports['default'];

/***/ }),
/* 276 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	exports.__esModule = true;
	exports.UNSELECTABLE_ATTRIBUTE = exports.UNSELECTABLE_STYLE = undefined;
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	exports.getValuePropValue = getValuePropValue;
	exports.getPropValue = getPropValue;
	exports.isCombobox = isCombobox;
	exports.isMultipleOrTags = isMultipleOrTags;
	exports.isMultipleOrTagsOrCombobox = isMultipleOrTagsOrCombobox;
	exports.isSingleMode = isSingleMode;
	exports.toArray = toArray;
	exports.preventDefaultEvent = preventDefaultEvent;
	exports.labelCompatible = labelCompatible;
	exports.isInclude = isInclude;
	exports.loopAllChildren = loopAllChildren;
	exports.flatToHierarchy = flatToHierarchy;
	exports.filterParentPosition = filterParentPosition;
	exports.handleCheckState = handleCheckState;
	exports.getTreeNodesStates = getTreeNodesStates;
	exports.recursiveCloneChildren = recursiveCloneChildren;
	exports.filterAllCheckedData = filterAllCheckedData;
	exports.processSimpleTreeData = processSimpleTreeData;
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function getValuePropValue(child) {
	  var props = child.props;
	  if ('value' in props) {
	    return props.value;
	  }
	  if (child.key) {
	    return child.key;
	  }
	  throw new Error('no key or value for ' + child);
	} /* eslint no-loop-func: 0*/
	function getPropValue(child, prop) {
	  if (prop === 'value') {
	    return getValuePropValue(child);
	  }
	  return child.props[prop];
	}
	
	function isCombobox(props) {
	  return props.combobox;
	}
	
	function isMultipleOrTags(props) {
	  return !!(props.multiple || props.tags || props.treeCheckable);
	}
	
	function isMultipleOrTagsOrCombobox(props) {
	  return isMultipleOrTags(props) || isCombobox(props);
	}
	
	function isSingleMode(props) {
	  return !isMultipleOrTagsOrCombobox(props);
	}
	
	function toArray(value) {
	  var ret = value;
	  if (value === undefined) {
	    ret = [];
	  } else if (!Array.isArray(value)) {
	    ret = [value];
	  }
	  return ret;
	}
	
	function preventDefaultEvent(e) {
	  e.preventDefault();
	}
	
	var UNSELECTABLE_STYLE = exports.UNSELECTABLE_STYLE = {
	  userSelect: 'none',
	  WebkitUserSelect: 'none'
	};
	
	var UNSELECTABLE_ATTRIBUTE = exports.UNSELECTABLE_ATTRIBUTE = {
	  unselectable: 'unselectable'
	};
	
	function labelCompatible(prop) {
	  var newProp = prop;
	  if (newProp === 'label') {
	    newProp = 'title';
	  }
	  return newProp;
	}
	
	function isInclude(smallArray, bigArray) {
	  // attention: [0,0,1] [0,0,10]
	  return smallArray.every(function (ii, i) {
	    return ii === bigArray[i];
	  });
	}
	
	/*
	export function getCheckedKeys(node, checkedKeys, allCheckedNodesKeys) {
	  const nodeKey = node.props.eventKey;
	  let newCks = [...checkedKeys];
	  let nodePos;
	  const unCheck = allCheckedNodesKeys.some(item => {
	    if (item.key === nodeKey) {
	      nodePos = item.pos;
	      return true;
	    }
	  });
	  if (unCheck) {
	    const nArr = nodePos.split('-');
	    newCks = [];
	    allCheckedNodesKeys.forEach(item => {
	      const iArr = item.pos.split('-');
	      if (item.pos === nodePos ||
	        nArr.length > iArr.length && isInclude(iArr, nArr) ||
	        nArr.length < iArr.length && isInclude(nArr, iArr)) {
	        return;
	      }
	      newCks.push(item.key);
	    });
	  } else {
	    newCks.push(nodeKey);
	  }
	  return newCks;
	}
	*/
	
	function getChildrenlength(children) {
	  var len = 1;
	  if (Array.isArray(children)) {
	    len = children.length;
	  }
	  return len;
	}
	
	function getSiblingPosition(index, len, siblingPosition) {
	  if (len === 1) {
	    siblingPosition.first = true;
	    siblingPosition.last = true;
	  } else {
	    siblingPosition.first = index === 0;
	    siblingPosition.last = index === len - 1;
	  }
	  return siblingPosition;
	}
	
	function loopAllChildren(childs, callback, parent) {
	  var loop = function loop(children, level, _parent) {
	    var len = getChildrenlength(children);
	    _react2['default'].Children.forEach(children, function handler(item, index) {
	      // eslint-disable-line
	      var pos = level + '-' + index;
	      if (item && item.props.children && item.type) {
	        loop(item.props.children, pos, { node: item, pos: pos });
	      }
	      if (item) {
	        callback(item, index, pos, item.key || pos, getSiblingPosition(index, len, {}), _parent);
	      }
	    });
	  };
	  loop(childs, 0, parent);
	}
	
	// export function loopAllChildren(childs, callback) {
	//   const loop = (children, level) => {
	//     React.Children.forEach(children, (item, index) => {
	//       const pos = `${level}-${index}`;
	//       if (item && item.props.children) {
	//         loop(item.props.children, pos);
	//       }
	//       if (item) {
	//         callback(item, index, pos, getValuePropValue(item));
	//       }
	//     });
	//   };
	//   loop(childs, 0);
	// }
	
	function flatToHierarchy(arr) {
	  if (!arr.length) {
	    return arr;
	  }
	  var hierarchyNodes = [];
	  var levelObj = {};
	  arr.forEach(function (item) {
	    if (!item.pos) {
	      return;
	    }
	    var posLen = item.pos.split('-').length;
	    if (!levelObj[posLen]) {
	      levelObj[posLen] = [];
	    }
	    levelObj[posLen].push(item);
	  });
	  var levelArr = Object.keys(levelObj).sort(function (a, b) {
	    return b - a;
	  });
	  // const s = Date.now();
	  // todo: there are performance issues!
	  levelArr.reduce(function (pre, cur) {
	    if (cur && cur !== pre) {
	      levelObj[pre].forEach(function (item) {
	        var haveParent = false;
	        levelObj[cur].forEach(function (ii) {
	          if (isInclude(ii.pos.split('-'), item.pos.split('-'))) {
	            haveParent = true;
	            if (!ii.children) {
	              ii.children = [];
	            }
	            ii.children.push(item);
	          }
	        });
	        if (!haveParent) {
	          hierarchyNodes.push(item);
	        }
	      });
	    }
	    return cur;
	  });
	  // console.log(Date.now() - s);
	  return levelObj[levelArr[levelArr.length - 1]].concat(hierarchyNodes);
	}
	
	// arr.length === 628, use time: ~20ms
	function filterParentPosition(arr) {
	  var levelObj = {};
	  arr.forEach(function (item) {
	    var posLen = item.split('-').length;
	    if (!levelObj[posLen]) {
	      levelObj[posLen] = [];
	    }
	    levelObj[posLen].push(item);
	  });
	  var levelArr = Object.keys(levelObj).sort();
	
	  var _loop = function _loop(i) {
	    if (levelArr[i + 1]) {
	      levelObj[levelArr[i]].forEach(function (ii) {
	        var _loop2 = function _loop2(j) {
	          levelObj[levelArr[j]].forEach(function (_i, index) {
	            if (isInclude(ii.split('-'), _i.split('-'))) {
	              levelObj[levelArr[j]][index] = null;
	            }
	          });
	          levelObj[levelArr[j]] = levelObj[levelArr[j]].filter(function (p) {
	            return p;
	          });
	        };
	
	        for (var j = i + 1; j < levelArr.length; j++) {
	          _loop2(j);
	        }
	      });
	    }
	  };
	
	  for (var i = 0; i < levelArr.length; i++) {
	    _loop(i);
	  }
	  var nArr = [];
	  levelArr.forEach(function (i) {
	    nArr = nArr.concat(levelObj[i]);
	  });
	  return nArr;
	}
	// console.log(filterParentPosition(
	// ['0-2', '0-3-3', '0-10', '0-10-0', '0-0-1', '0-0', '0-1-1', '0-1']
	// ));
	
	function stripTail(str) {
	  var arr = str.match(/(.+)(-[^-]+)$/);
	  var st = '';
	  if (arr && arr.length === 3) {
	    st = arr[1];
	  }
	  return st;
	}
	function splitPosition(pos) {
	  return pos.split('-');
	}
	
	// todo: do optimization.
	function handleCheckState(obj, checkedPositionArr, checkIt) {
	  // console.log(stripTail('0-101-000'));
	  // let s = Date.now();
	  var objKeys = Object.keys(obj);
	
	  objKeys.forEach(function (i, index) {
	    var iArr = splitPosition(i);
	    var saved = false;
	    checkedPositionArr.forEach(function (_pos) {
	      var _posArr = splitPosition(_pos);
	      if (iArr.length > _posArr.length && isInclude(_posArr, iArr)) {
	        obj[i].halfChecked = false;
	        obj[i].checked = checkIt;
	        objKeys[index] = null;
	      }
	      if (iArr[0] === _posArr[0] && iArr[1] === _posArr[1]) {
	        saved = true;
	      }
	    });
	    if (!saved) {
	      objKeys[index] = null;
	    }
	  });
	  objKeys = objKeys.filter(function (i) {
	    return i;
	  }); // filter non null;
	
	  var _loop3 = function _loop3(_pIndex) {
	    // loop to set ancestral nodes's `checked` or `halfChecked`
	    var loop = function loop(__pos) {
	      var _posLen = splitPosition(__pos).length;
	      if (_posLen <= 2) {
	        // e.g. '0-0', '0-1'
	        return;
	      }
	      var sibling = 0;
	      var siblingChecked = 0;
	      var parentPosition = stripTail(__pos);
	      objKeys.forEach(function (i /* , index*/) {
	        var iArr = splitPosition(i);
	        if (iArr.length === _posLen && isInclude(splitPosition(parentPosition), iArr)) {
	          sibling++;
	          if (obj[i].checked) {
	            siblingChecked++;
	            var _i = checkedPositionArr.indexOf(i);
	            if (_i > -1) {
	              checkedPositionArr.splice(_i, 1);
	              if (_i <= _pIndex) {
	                _pIndex--;
	              }
	            }
	          } else if (obj[i].halfChecked) {
	            siblingChecked += 0.5;
	          }
	          // objKeys[index] = null;
	        }
	      });
	      // objKeys = objKeys.filter(i => i); // filter non null;
	      var parent = obj[parentPosition];
	      // not check, checked, halfChecked
	      if (siblingChecked === 0) {
	        parent.checked = false;
	        parent.halfChecked = false;
	      } else if (siblingChecked === sibling) {
	        parent.checked = true;
	        parent.halfChecked = false;
	      } else {
	        parent.halfChecked = true;
	        parent.checked = false;
	      }
	      loop(parentPosition);
	    };
	    loop(checkedPositionArr[_pIndex], _pIndex);
	    pIndex = _pIndex;
	  };
	
	  for (var pIndex = 0; pIndex < checkedPositionArr.length; pIndex++) {
	    _loop3(pIndex);
	  }
	  // console.log(Date.now()-s, objKeys.length, checkIt);
	}
	
	function getCheck(treeNodesStates, checkedPositions) {
	  var halfCheckedKeys = [];
	  var checkedKeys = [];
	  var checkedNodes = [];
	  Object.keys(treeNodesStates).forEach(function (item) {
	    var itemObj = treeNodesStates[item];
	    if (itemObj.checked) {
	      checkedKeys.push(itemObj.key);
	      // checkedNodes.push(getValuePropValue(itemObj.node));
	      checkedNodes.push((0, _extends3['default'])({}, itemObj, { pos: item }));
	    } else if (itemObj.halfChecked) {
	      halfCheckedKeys.push(itemObj.key);
	    }
	  });
	  return {
	    halfCheckedKeys: halfCheckedKeys, checkedKeys: checkedKeys, checkedNodes: checkedNodes, treeNodesStates: treeNodesStates, checkedPositions: checkedPositions
	  };
	}
	
	function getTreeNodesStates(children, values) {
	  var checkedPositions = [];
	  var treeNodesStates = {};
	  loopAllChildren(children, function (item, index, pos, keyOrPos, siblingPosition) {
	    treeNodesStates[pos] = {
	      node: item,
	      key: keyOrPos,
	      checked: false,
	      halfChecked: false,
	      siblingPosition: siblingPosition
	    };
	    if (values.indexOf(getValuePropValue(item)) !== -1) {
	      treeNodesStates[pos].checked = true;
	      checkedPositions.push(pos);
	    }
	  });
	
	  handleCheckState(treeNodesStates, filterParentPosition(checkedPositions.sort()), true);
	
	  return getCheck(treeNodesStates, checkedPositions);
	}
	
	// can add extra prop to every node.
	function recursiveCloneChildren(children) {
	  var cb = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function (ch) {
	    return ch;
	  };
	
	  // return React.Children.map(children, child => {
	  return Array.from(children).map(function (child) {
	    var newChild = cb(child);
	    if (newChild && newChild.props && newChild.props.children) {
	      return _react2['default'].cloneElement(newChild, {}, recursiveCloneChildren(newChild.props.children, cb));
	    }
	    return newChild;
	  });
	}
	// const newChildren = recursiveCloneChildren(children, child => {
	//   const extraProps = {};
	//   if (child && child.type && child.type.xxx) {
	//     extraProps._prop = true;
	//     return React.cloneElement(child, extraProps);
	//   }
	//   return child;
	// });
	
	
	function recursiveGen(children) {
	  var level = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
	
	  return _react2['default'].Children.map(children, function (child, index) {
	    var pos = level + '-' + index;
	    var o = {
	      title: child.props.title,
	      label: child.props.label || child.props.title,
	      value: child.props.value,
	      key: child.key,
	      _pos: pos
	    };
	    if (child.props.children) {
	      o.children = recursiveGen(child.props.children, pos);
	    }
	    return o;
	  });
	}
	
	function recursive(children, cb) {
	  children.forEach(function (item) {
	    cb(item);
	    if (item.children) {
	      recursive(item.children, cb);
	    }
	  });
	}
	
	// Get the tree's checkedNodes (todo: can merge to the `handleCheckState` function)
	// If one node checked, it's all children nodes checked.
	// If sibling nodes all checked, the parent checked.
	function filterAllCheckedData(vs, treeNodes) {
	  var vals = [].concat(vs);
	  if (!vals.length) {
	    return vals;
	  }
	
	  var data = recursiveGen(treeNodes);
	  var checkedNodesPositions = [];
	
	  function checkChildren(children) {
	    children.forEach(function (item) {
	      if (item.__checked) {
	        return;
	      }
	      var ci = vals.indexOf(item.value);
	      var childs = item.children;
	      if (ci > -1) {
	        item.__checked = true;
	        checkedNodesPositions.push({ node: item, pos: item._pos });
	        vals.splice(ci, 1);
	        if (childs) {
	          recursive(childs, function (child) {
	            child.__checked = true;
	            checkedNodesPositions.push({ node: child, pos: child._pos });
	          });
	        }
	      } else {
	        if (childs) {
	          checkChildren(childs);
	        }
	      }
	    });
	  }
	
	  function checkParent(children) {
	    var parent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : { root: true };
	
	    var siblingChecked = 0;
	    children.forEach(function (item) {
	      var childs = item.children;
	      if (childs && !item.__checked && !item.__halfChecked) {
	        var p = checkParent(childs, item);
	        if (p.__checked) {
	          siblingChecked++;
	        } else if (p.__halfChecked) {
	          siblingChecked += 0.5;
	        }
	      } else if (item.__checked) {
	        siblingChecked++;
	      } else if (item.__halfChecked) {
	        siblingChecked += 0.5;
	      }
	    });
	    var len = children.length;
	    if (siblingChecked === len) {
	      parent.__checked = true;
	      checkedNodesPositions.push({ node: parent, pos: parent._pos });
	    } else if (siblingChecked < len && siblingChecked > 0) {
	      parent.__halfChecked = true;
	    }
	    if (parent.root) {
	      return children;
	    }
	    return parent;
	  }
	  checkChildren(data);
	  checkParent(data);
	
	  checkedNodesPositions.forEach(function (i, index) {
	    // clear private metadata
	    delete checkedNodesPositions[index].node.__checked;
	    delete checkedNodesPositions[index].node._pos;
	    // create the same structure of `onCheck`'s return.
	    checkedNodesPositions[index].node.props = {
	      title: checkedNodesPositions[index].node.title,
	      label: checkedNodesPositions[index].node.label || checkedNodesPositions[index].node.title,
	      value: checkedNodesPositions[index].node.value
	    };
	    if (checkedNodesPositions[index].node.children) {
	      checkedNodesPositions[index].node.props.children = checkedNodesPositions[index].node.children;
	    }
	    delete checkedNodesPositions[index].node.title;
	    delete checkedNodesPositions[index].node.label;
	    delete checkedNodesPositions[index].node.value;
	    delete checkedNodesPositions[index].node.children;
	  });
	  return checkedNodesPositions;
	}
	
	function processSimpleTreeData(treeData, format) {
	  function unflatten2(array) {
	    var _ref;
	
	    var parent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : (_ref = {}, _ref[format.id] = format.rootPId, _ref);
	
	    var children = [];
	    for (var i = 0; i < array.length; i++) {
	      array[i] = (0, _extends3['default'])({}, array[i]); // copy, can not corrupts original data
	      if (array[i][format.pId] === parent[format.id]) {
	        array[i].key = array[i][format.id];
	        children.push(array[i]);
	        array.splice(i--, 1);
	      }
	    }
	    if (children.length) {
	      parent.children = children;
	      children.forEach(function (child) {
	        return unflatten2(array, child);
	      });
	    }
	    if (parent[format.id] === format.rootPId) {
	      return children;
	    }
	  }
	  return unflatten2(treeData);
	}

/***/ }),
/* 277 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	exports.__esModule = true;
	exports.contextTypes = undefined;
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _warning = __webpack_require__(35);
	
	var _warning2 = _interopRequireDefault(_warning);
	
	var _util = __webpack_require__(779);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function noop() {}
	
	var contextTypes = exports.contextTypes = {
	  rcTree: _propTypes2['default'].shape({
	    selectable: _propTypes2['default'].bool
	  })
	};
	
	var Tree = function (_React$Component) {
	  (0, _inherits3['default'])(Tree, _React$Component);
	
	  function Tree(props) {
	    (0, _classCallCheck3['default'])(this, Tree);
	
	    var _this = (0, _possibleConstructorReturn3['default'])(this, _React$Component.call(this, props));
	
	    _initialiseProps.call(_this);
	
	    var checkedKeys = _this.calcCheckedKeys(props);
	    _this.state = {
	      expandedKeys: _this.calcExpandedKeys(props),
	      checkedKeys: checkedKeys.checkedKeys,
	      halfCheckedKeys: checkedKeys.halfCheckedKeys,
	      selectedKeys: _this.calcSelectedKeys(props),
	      dragNodesKeys: '',
	      dragOverNodeKey: '',
	      dropNodeKey: ''
	    };
	    return _this;
	  }
	
	  Tree.prototype.getChildContext = function getChildContext() {
	    var selectable = this.props.selectable;
	
	    return {
	      rcTree: {
	        selectable: selectable
	      }
	    };
	  };
	
	  Tree.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {
	    var props = this.props;
	
	    var newState = {};
	    var expandedKeys = nextProps.expandedKeys !== props.expandedKeys ? this.calcExpandedKeys(nextProps, true) : undefined;
	    if (expandedKeys) {
	      newState.expandedKeys = expandedKeys;
	    }
	
	    var checkedKeys = nextProps.checkedKeys !== props.checkedKeys || props.loadData ? this.calcCheckedKeys(nextProps, true) : undefined;
	    if (checkedKeys) {
	      newState.checkedKeys = checkedKeys.checkedKeys;
	      newState.halfCheckedKeys = checkedKeys.halfCheckedKeys;
	    }
	
	    var selectedKeys = nextProps.selectedKeys !== props.selectedKeys ? this.calcSelectedKeys(nextProps, true) : undefined;
	    if (selectedKeys) {
	      newState.selectedKeys = selectedKeys;
	    }
	    this.setState(newState);
	  };
	
	  Tree.prototype.onDragStart = function onDragStart(e, treeNode) {
	    this.dragNode = treeNode;
	    var newState = {
	      dragNodesKeys: this.getDragNodesKeys(treeNode)
	    };
	    var expandedKeys = this.getExpandedKeys(treeNode, false);
	    if (expandedKeys) {
	      newState.expandedKeys = expandedKeys;
	    }
	    this.setState(newState);
	    this.props.onDragStart({
	      event: e,
	      node: treeNode
	    });
	  };
	
	  Tree.prototype.onDragEnter = function onDragEnter(e, treeNode) {
	    var _this2 = this;
	
	    var dropPosition = this.calcDropPosition(e, treeNode);
	    if (this.dragNode.props.eventKey === treeNode.props.eventKey && dropPosition === 0) {
	      this.setState({
	        dragOverNodeKey: '',
	        dropPosition: null
	      });
	      return;
	    }
	    this.setState({
	      dragOverNodeKey: treeNode.props.eventKey,
	      dropPosition: dropPosition
	    });
	
	    if (!this.delayedDragEnterLogic) {
	      this.delayedDragEnterLogic = {};
	    }
	    Object.keys(this.delayedDragEnterLogic).forEach(function (key) {
	      clearTimeout(_this2.delayedDragEnterLogic[key]);
	    });
	    this.delayedDragEnterLogic[treeNode.props.pos] = setTimeout(function () {
	      var expandedKeys = _this2.getExpandedKeys(treeNode, true);
	      if (expandedKeys) {
	        _this2.setState({ expandedKeys: expandedKeys });
	      }
	      _this2.props.onDragEnter({
	        event: e,
	        node: treeNode,
	        expandedKeys: expandedKeys && [].concat(expandedKeys) || [].concat(_this2.state.expandedKeys)
	      });
	    }, 400);
	  };
	
	  Tree.prototype.onDragOver = function onDragOver(e, treeNode) {
	    this.props.onDragOver({ event: e, node: treeNode });
	  };
	
	  Tree.prototype.onDragLeave = function onDragLeave(e, treeNode) {
	    this.props.onDragLeave({ event: e, node: treeNode });
	  };
	
	  Tree.prototype.onDrop = function onDrop(e, treeNode) {
	    var state = this.state;
	
	    var eventKey = treeNode.props.eventKey;
	    this.setState({
	      dragOverNodeKey: '',
	      dropNodeKey: eventKey
	    });
	    if (state.dragNodesKeys.indexOf(eventKey) > -1) {
	      (0, _warning2['default'])(false, 'Can not drop to dragNode(include it\'s children node)');
	      return;
	    }
	
	    var posArr = treeNode.props.pos.split('-');
	    var res = {
	      event: e,
	      node: treeNode,
	      dragNode: this.dragNode,
	      dragNodesKeys: [].concat(state.dragNodesKeys),
	      dropPosition: state.dropPosition + Number(posArr[posArr.length - 1])
	    };
	    if (state.dropPosition !== 0) {
	      res.dropToGap = true;
	    }
	    this.props.onDrop(res);
	  };
	
	  Tree.prototype.onDragEnd = function onDragEnd(e, treeNode) {
	    this.setState({
	      dragOverNodeKey: ''
	    });
	    this.props.onDragEnd({ event: e, node: treeNode });
	  };
	
	  Tree.prototype.onExpand = function onExpand(treeNode) {
	    var _this3 = this;
	
	    var props = this.props,
	        state = this.state;
	
	    var expanded = !treeNode.props.expanded;
	    var expandedKeys = [].concat(state.expandedKeys);
	    var eventKey = treeNode.props.eventKey;
	
	    var index = expandedKeys.indexOf(eventKey);
	    if (expanded && index === -1) {
	      expandedKeys.push(eventKey);
	    } else if (!expanded && index > -1) {
	      expandedKeys.splice(index, 1);
	    }
	
	    var controlled = 'expandedKeys' in props;
	    if (!controlled) {
	      this.setState({ expandedKeys: expandedKeys });
	    }
	    props.onExpand(expandedKeys, { node: treeNode, expanded: expanded });
	
	    // After data loaded, need set new expandedKeys
	    if (expanded && props.loadData) {
	      return props.loadData(treeNode).then(function () {
	        if (!controlled) {
	          _this3.setState({ expandedKeys: expandedKeys });
	        }
	      });
	    }
	  };
	
	  Tree.prototype.onSelect = function onSelect(treeNode) {
	    var props = this.props,
	        state = this.state;
	
	    var eventKey = treeNode.props.eventKey;
	    var selected = !treeNode.props.selected;
	
	    var selectedKeys = [].concat(state.selectedKeys);
	    if (!selected) {
	      var index = selectedKeys.indexOf(eventKey);
	      selectedKeys.splice(index, 1);
	    } else if (!props.multiple) {
	      selectedKeys = [eventKey];
	    } else {
	      selectedKeys.push(eventKey);
	    }
	
	    // TODO: can be optimized if we remove selectedNodes in API
	    var selectedNodes = [];
	    if (selectedKeys.length) {
	      (0, _util.traverseTreeNodes)(props.children, function (item) {
	        if (selectedKeys.indexOf(item.key) !== -1) {
	          selectedNodes.push(item);
	        }
	      });
	    }
	
	    if (!('selectedKeys' in props)) {
	      this.setState({
	        selectedKeys: selectedKeys
	      });
	    }
	
	    var eventObj = {
	      event: 'select',
	      selected: selected,
	      node: treeNode,
	      selectedNodes: selectedNodes
	    };
	    props.onSelect(selectedKeys, eventObj);
	  };
	
	  Tree.prototype.onMouseEnter = function onMouseEnter(e, treeNode) {
	    this.props.onMouseEnter({ event: e, node: treeNode });
	  };
	
	  Tree.prototype.onMouseLeave = function onMouseLeave(e, treeNode) {
	    this.props.onMouseLeave({ event: e, node: treeNode });
	  };
	
	  Tree.prototype.onContextMenu = function onContextMenu(e, treeNode) {
	    if (this.props.onRightClick) {
	      e.preventDefault();
	      this.props.onRightClick({ event: e, node: treeNode });
	    }
	  };
	
	  // all keyboard events callbacks run from here at first
	
	
	  Tree.prototype.getOpenTransitionName = function getOpenTransitionName() {
	    var props = this.props;
	    var transitionName = props.openTransitionName;
	    var animationName = props.openAnimation;
	    if (!transitionName && typeof animationName === 'string') {
	      return props.prefixCls + '-open-' + animationName;
	    }
	    return transitionName;
	  };
	
	  Tree.prototype.getDragNodesKeys = function getDragNodesKeys(treeNode) {
	    var dragNodesKeys = [];
	    (0, _util.traverseTreeNodes)(treeNode.props.children, function (item, index, pos, key) {
	      if ((0, _util.isPositionPrefix)(treeNode.props.pos, pos)) {
	        dragNodesKeys.push(key);
	      }
	    });
	    dragNodesKeys.push(treeNode.props.eventKey || treeNode.props.pos);
	    return dragNodesKeys;
	  };
	
	  Tree.prototype.getExpandedKeys = function getExpandedKeys(treeNode, expand) {
	    var eventKey = treeNode.props.eventKey;
	    var expandedKeys = this.state.expandedKeys;
	    var expandedIndex = expandedKeys.indexOf(eventKey);
	    if (!expand && expandedIndex > -1) {
	      var exKeys = [].concat(expandedKeys);
	      exKeys.splice(expandedIndex, 1);
	      return exKeys;
	    }
	    if (expand && expandedKeys.indexOf(eventKey) === -1) {
	      return expandedKeys.concat([eventKey]);
	    }
	  };
	
	  Tree.prototype.generateTreeNodesStates = function generateTreeNodesStates(children, checkedKeys) {
	    var checkedPositions = [];
	    var treeNodesStates = {};
	    (0, _util.traverseTreeNodes)(children, function (item, _, pos, key, childrenPos, parentPos) {
	      treeNodesStates[pos] = {
	        node: item,
	        key: key,
	        checked: false,
	        halfChecked: false,
	        disabled: item.props.disabled,
	        disableCheckbox: item.props.disableCheckbox,
	        childrenPos: childrenPos,
	        parentPos: parentPos
	      };
	      if (checkedKeys.indexOf(key) !== -1) {
	        treeNodesStates[pos].checked = true;
	        checkedPositions.push(pos);
	      }
	    });
	    checkedPositions.forEach(function (checkedPosition) {
	      (0, _util.updateCheckState)(treeNodesStates, checkedPosition, true);
	    });
	    return treeNodesStates;
	  };
	
	  Tree.prototype.calcExpandedKeys = function calcExpandedKeys(props, isNotInit) {
	    var expandedKeys = props.expandedKeys || (isNotInit ? undefined : props.defaultExpandedKeys);
	    if (!expandedKeys) {
	      return undefined;
	    }
	    var expandAll = isNotInit ? false : props.defaultExpandAll;
	    if (!expandAll && !props.autoExpandParent) {
	      return expandedKeys;
	    }
	
	    var expandedPositionArr = [];
	    if (props.autoExpandParent) {
	      (0, _util.traverseTreeNodes)(props.children, function (item, index, pos, key) {
	        if (expandedKeys.indexOf(key) > -1) {
	          expandedPositionArr.push(pos);
	        }
	      });
	    }
	    var filterExpandedKeysSet = {};
	    (0, _util.traverseTreeNodes)(props.children, function (item, index, pos, key) {
	      if (expandAll) {
	        filterExpandedKeysSet[key] = true;
	      } else if (props.autoExpandParent) {
	        var isCurrentParentOfExpanded = expandedPositionArr.some(function (p) {
	          return (0, _util.isPositionPrefix)(pos, p);
	        });
	        if (isCurrentParentOfExpanded) {
	          filterExpandedKeysSet[key] = true;
	        }
	      }
	    });
	    var filterExpandedKeys = Object.keys(filterExpandedKeysSet);
	    return filterExpandedKeys.length ? filterExpandedKeys : expandedKeys;
	  };
	
	  Tree.prototype.calcCheckedKeys = function calcCheckedKeys(props, isNotInit) {
	    if (!props.checkable) {
	      return { checkedKeys: [], halfCheckedKeys: [] };
	    }
	
	    var checkedKeys = props.checkedKeys || (isNotInit && !props.loadData ? undefined : props.defaultCheckedKeys);
	    if (!checkedKeys) {
	      return undefined;
	    }
	    if (Array.isArray(checkedKeys)) {
	      checkedKeys = { checkedKeys: checkedKeys, halfCheckedKeys: [] };
	    } else if (typeof checkedKeys === 'object') {
	      checkedKeys = { checkedKeys: checkedKeys.checked, halfCheckedKeys: checkedKeys.halfChecked };
	    }
	
	    if (!props.checkStrictly) {
	      var checked = checkedKeys.checkedKeys || [];
	      var treeNodesStates = this.generateTreeNodesStates(props.children, checked);
	      return (0, _util.getCheck)(treeNodesStates);
	    }
	
	    return checkedKeys;
	  };
	
	  Tree.prototype.calcSelectedKeys = function calcSelectedKeys(props, isNotInit) {
	    var selectedKeys = props.selectedKeys || (isNotInit ? undefined : props.defaultSelectedKeys);
	    if (!selectedKeys) {
	      return undefined;
	    }
	    if (props.multiple) {
	      return [].concat(selectedKeys);
	    }
	    if (selectedKeys.length) {
	      return [selectedKeys[0]];
	    }
	    return selectedKeys;
	  };
	
	  Tree.prototype.calcDropPosition = function calcDropPosition(e, treeNode) {
	    var offsetTop = (0, _util.getOffset)(treeNode.selectHandle).top;
	    var offsetHeight = treeNode.selectHandle.offsetHeight;
	    var pageY = e.pageY;
	    var gapHeight = 2; // TODO: remove hard code
	    if (pageY > offsetTop + offsetHeight - gapHeight) {
	      return 1;
	    }
	    if (pageY < offsetTop + gapHeight) {
	      return -1;
	    }
	    return 0;
	  };
	
	  Tree.prototype.renderTreeNode = function renderTreeNode(child, index) {
	    var level = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
	    var state = this.state,
	        props = this.props;
	
	    var pos = level + '-' + index;
	    var key = child.key || pos;
	
	    var childProps = {
	      root: this,
	      eventKey: key,
	      pos: pos,
	      loadData: props.loadData,
	      prefixCls: props.prefixCls,
	      showIcon: props.showIcon,
	      draggable: props.draggable,
	      dragOver: state.dragOverNodeKey === key && state.dropPosition === 0,
	      dragOverGapTop: state.dragOverNodeKey === key && state.dropPosition === -1,
	      dragOverGapBottom: state.dragOverNodeKey === key && state.dropPosition === 1,
	      expanded: state.expandedKeys.indexOf(key) !== -1,
	      selected: state.selectedKeys.indexOf(key) !== -1,
	      openTransitionName: this.getOpenTransitionName(),
	      openAnimation: props.openAnimation,
	      filterTreeNode: this.filterTreeNode
	    };
	    if (props.checkable) {
	      childProps.checkable = props.checkable;
	      childProps.checked = state.checkedKeys.indexOf(key) !== -1;
	      childProps.halfChecked = state.halfCheckedKeys.indexOf(key) !== -1;
	    }
	    return _react2['default'].cloneElement(child, childProps);
	  };
	
	  Tree.prototype.render = function render() {
	    var _classNames;
	
	    var props = this.props;
	    var className = (0, _classnames2['default'])(props.prefixCls, props.className, (_classNames = {}, _classNames[props.prefixCls + '-show-line'] = props.showLine, _classNames));
	    var domProps = {};
	    if (props.focusable) {
	      domProps.tabIndex = '0';
	      domProps.onKeyDown = this.onKeyDown;
	    }
	
	    return _react2['default'].createElement(
	      'ul',
	      (0, _extends3['default'])({}, domProps, {
	        className: className,
	        role: 'tree-node',
	        unselectable: 'on'
	      }),
	      _react2['default'].Children.map(props.children, this.renderTreeNode, this)
	    );
	  };
	
	  return Tree;
	}(_react2['default'].Component);
	
	Tree.propTypes = {
	  prefixCls: _propTypes2['default'].string,
	  children: _propTypes2['default'].any,
	  showLine: _propTypes2['default'].bool,
	  showIcon: _propTypes2['default'].bool,
	  selectable: _propTypes2['default'].bool,
	  multiple: _propTypes2['default'].bool,
	  checkable: _propTypes2['default'].oneOfType([_propTypes2['default'].bool, _propTypes2['default'].node]),
	  checkStrictly: _propTypes2['default'].bool,
	  draggable: _propTypes2['default'].bool,
	  autoExpandParent: _propTypes2['default'].bool,
	  defaultExpandAll: _propTypes2['default'].bool,
	  defaultExpandedKeys: _propTypes2['default'].arrayOf(_propTypes2['default'].string),
	  expandedKeys: _propTypes2['default'].arrayOf(_propTypes2['default'].string),
	  defaultCheckedKeys: _propTypes2['default'].arrayOf(_propTypes2['default'].string),
	  checkedKeys: _propTypes2['default'].oneOfType([_propTypes2['default'].arrayOf(_propTypes2['default'].string), _propTypes2['default'].object]),
	  defaultSelectedKeys: _propTypes2['default'].arrayOf(_propTypes2['default'].string),
	  selectedKeys: _propTypes2['default'].arrayOf(_propTypes2['default'].string),
	  onExpand: _propTypes2['default'].func,
	  onCheck: _propTypes2['default'].func,
	  onSelect: _propTypes2['default'].func,
	  loadData: _propTypes2['default'].func,
	  onMouseEnter: _propTypes2['default'].func,
	  onMouseLeave: _propTypes2['default'].func,
	  onRightClick: _propTypes2['default'].func,
	  onDragStart: _propTypes2['default'].func,
	  onDragEnter: _propTypes2['default'].func,
	  onDragOver: _propTypes2['default'].func,
	  onDragLeave: _propTypes2['default'].func,
	  onDrop: _propTypes2['default'].func,
	  onDragEnd: _propTypes2['default'].func,
	  filterTreeNode: _propTypes2['default'].func,
	  openTransitionName: _propTypes2['default'].string,
	  openAnimation: _propTypes2['default'].oneOfType([_propTypes2['default'].string, _propTypes2['default'].object])
	};
	Tree.childContextTypes = contextTypes;
	Tree.defaultProps = {
	  prefixCls: 'rc-tree',
	  showLine: false,
	  showIcon: true,
	  selectable: true,
	  multiple: false,
	  checkable: false,
	  checkStrictly: false,
	  draggable: false,
	  autoExpandParent: true,
	  defaultExpandAll: false,
	  defaultExpandedKeys: [],
	  defaultCheckedKeys: [],
	  defaultSelectedKeys: [],
	  onExpand: noop,
	  onCheck: noop,
	  onSelect: noop,
	  onDragStart: noop,
	  onDragEnter: noop,
	  onDragOver: noop,
	  onDragLeave: noop,
	  onDrop: noop,
	  onDragEnd: noop,
	  onMouseEnter: noop,
	  onMouseLeave: noop
	};
	
	var _initialiseProps = function _initialiseProps() {
	  var _this4 = this;
	
	  this.onCheck = function (treeNode) {
	    var props = _this4.props,
	        state = _this4.state;
	
	    var checked = !treeNode.props.checked || treeNode.props.halfChecked;
	    var eventObj = {
	      event: 'check',
	      node: treeNode,
	      checked: checked
	    };
	
	    if (props.checkStrictly) {
	      var eventKey = treeNode.props.eventKey;
	      var checkedKeys = [].concat(state.checkedKeys);
	      var index = checkedKeys.indexOf(eventKey);
	      if (checked && index === -1) {
	        checkedKeys.push(eventKey);
	      }
	      if (!checked && index > -1) {
	        checkedKeys.splice(index, 1);
	      }
	
	      eventObj.checkedNodes = [];
	      (0, _util.traverseTreeNodes)(props.children, function (item) {
	        if (checkedKeys.indexOf(item.key) !== -1) {
	          eventObj.checkedNodes.push(item);
	        }
	      });
	
	      if (!('checkedKeys' in props)) {
	        _this4.setState({
	          checkedKeys: checkedKeys
	        });
	      }
	      props.onCheck((0, _util.getStrictlyValue)(checkedKeys, state.halfCheckedKeys), eventObj);
	    } else {
	      var treeNodesStates = _this4.generateTreeNodesStates(props.children, state.checkedKeys);
	      treeNodesStates[treeNode.props.pos].checked = checked;
	      treeNodesStates[treeNode.props.pos].halfChecked = false;
	      (0, _util.updateCheckState)(treeNodesStates, treeNode.props.pos, checked);
	
	      var checkKeys = (0, _util.getCheck)(treeNodesStates);
	      eventObj.checkedNodes = checkKeys.checkedNodes;
	      eventObj.checkedNodesPositions = checkKeys.checkedNodesPositions; // TODO: not in API
	      eventObj.halfCheckedKeys = checkKeys.halfCheckedKeys; // TODO: not in API
	
	      if (!('checkedKeys' in props)) {
	        _this4.setState({
	          checkedKeys: checkKeys.checkedKeys,
	          halfCheckedKeys: checkKeys.halfCheckedKeys
	        });
	      }
	      props.onCheck(checkKeys.checkedKeys, eventObj);
	    }
	  };
	
	  this.onKeyDown = function (e) {
	    e.preventDefault();
	  };
	
	  this.filterTreeNode = function (treeNode) {
	    var filterTreeNode = _this4.props.filterTreeNode;
	    if (typeof filterTreeNode !== 'function' || treeNode.props.disabled) {
	      return false;
	    }
	    return filterTreeNode.call(_this4, treeNode);
	  };
	};
	
	exports['default'] = Tree;

/***/ }),
/* 278 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	exports.__esModule = true;
	exports.TreeNode = undefined;
	
	var _Tree = __webpack_require__(277);
	
	var _Tree2 = _interopRequireDefault(_Tree);
	
	var _TreeNode = __webpack_require__(778);
	
	var _TreeNode2 = _interopRequireDefault(_TreeNode);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	_Tree2['default'].TreeNode = _TreeNode2['default'];
	
	exports.TreeNode = _TreeNode2['default'];
	exports['default'] = _Tree2['default'];

/***/ }),
/* 279 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _objectWithoutProperties2 = __webpack_require__(20);
	
	var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var LazyRenderBox = function (_Component) {
	  (0, _inherits3['default'])(LazyRenderBox, _Component);
	
	  function LazyRenderBox() {
	    (0, _classCallCheck3['default'])(this, LazyRenderBox);
	    return (0, _possibleConstructorReturn3['default'])(this, (LazyRenderBox.__proto__ || Object.getPrototypeOf(LazyRenderBox)).apply(this, arguments));
	  }
	
	  (0, _createClass3['default'])(LazyRenderBox, [{
	    key: 'shouldComponentUpdate',
	    value: function shouldComponentUpdate(nextProps) {
	      return nextProps.hiddenClassName || nextProps.visible;
	    }
	  }, {
	    key: 'render',
	    value: function render() {
	      var _props = this.props,
	          hiddenClassName = _props.hiddenClassName,
	          visible = _props.visible,
	          props = (0, _objectWithoutProperties3['default'])(_props, ['hiddenClassName', 'visible']);
	
	
	      if (hiddenClassName || _react2['default'].Children.count(props.children) > 1) {
	        if (!visible && hiddenClassName) {
	          props.className += ' ' + hiddenClassName;
	        }
	        return _react2['default'].createElement('div', props);
	      }
	
	      return _react2['default'].Children.only(props.children);
	    }
	  }]);
	  return LazyRenderBox;
	}(_react.Component);
	
	LazyRenderBox.propTypes = {
	  children: _propTypes2['default'].any,
	  className: _propTypes2['default'].string,
	  visible: _propTypes2['default'].bool,
	  hiddenClassName: _propTypes2['default'].string
	};
	exports['default'] = LazyRenderBox;
	module.exports = exports['default'];

/***/ }),
/* 280 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	exports.getAlignFromPlacement = getAlignFromPlacement;
	exports.getPopupClassNameFromAlign = getPopupClassNameFromAlign;
	exports.saveRef = saveRef;
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function isPointsEq(a1, a2) {
	  return a1[0] === a2[0] && a1[1] === a2[1];
	}
	
	function getAlignFromPlacement(builtinPlacements, placementStr, align) {
	  var baseAlign = builtinPlacements[placementStr] || {};
	  return (0, _extends3['default'])({}, baseAlign, align);
	}
	
	function getPopupClassNameFromAlign(builtinPlacements, prefixCls, align) {
	  var points = align.points;
	  for (var placement in builtinPlacements) {
	    if (builtinPlacements.hasOwnProperty(placement)) {
	      if (isPointsEq(builtinPlacements[placement].points, points)) {
	        return prefixCls + '-placement-' + placement;
	      }
	    }
	  }
	  return '';
	}
	
	function saveRef(name, component) {
	  this[name] = component;
	}

/***/ }),
/* 281 */
/***/ (function(module, exports) {

	"use strict";
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports["default"] = uid;
	var now = +new Date();
	var index = 0;
	
	function uid() {
	  return "rc-upload-" + now + "-" + ++index;
	}
	module.exports = exports['default'];

/***/ }),
/* 282 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports['default'] = mapSelf;
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function mirror(o) {
	  return o;
	}
	
	function mapSelf(children) {
	  // return ReactFragment
	  return _react2['default'].Children.map(children, mirror);
	}
	module.exports = exports['default'];

/***/ }),
/* 283 */
/***/ (function(module, exports) {

	"use strict";
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports["default"] = contains;
	function contains(root, n) {
	  var node = n;
	  while (node) {
	    if (node === root) {
	      return true;
	    }
	    node = node.parentNode;
	  }
	
	  return false;
	}
	module.exports = exports['default'];

/***/ }),
/* 284 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	exports['default'] = getContainerRenderMixin;
	
	var _reactDom = __webpack_require__(10);
	
	var _reactDom2 = _interopRequireDefault(_reactDom);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function defaultGetContainer() {
	  var container = document.createElement('div');
	  document.body.appendChild(container);
	  return container;
	}
	
	function getContainerRenderMixin(config) {
	  var _config$autoMount = config.autoMount,
	      autoMount = _config$autoMount === undefined ? true : _config$autoMount,
	      _config$autoDestroy = config.autoDestroy,
	      autoDestroy = _config$autoDestroy === undefined ? true : _config$autoDestroy,
	      isVisible = config.isVisible,
	      isForceRender = config.isForceRender,
	      getComponent = config.getComponent,
	      _config$getContainer = config.getContainer,
	      getContainer = _config$getContainer === undefined ? defaultGetContainer : _config$getContainer;
	
	
	  var mixin = void 0;
	
	  function _renderComponent(instance, componentArg, ready) {
	    if (!isVisible || instance._component || isVisible(instance) || isForceRender && isForceRender(instance)) {
	      if (!instance._container) {
	        instance._container = getContainer(instance);
	      }
	      var component = void 0;
	      if (instance.getComponent) {
	        component = instance.getComponent(componentArg);
	      } else {
	        component = getComponent(instance, componentArg);
	      }
	      _reactDom2['default'].unstable_renderSubtreeIntoContainer(instance, component, instance._container, function callback() {
	        instance._component = this;
	        if (ready) {
	          ready.call(this);
	        }
	      });
	    }
	  }
	
	  if (autoMount) {
	    mixin = (0, _extends3['default'])({}, mixin, {
	      componentDidMount: function componentDidMount() {
	        _renderComponent(this);
	      },
	      componentDidUpdate: function componentDidUpdate() {
	        _renderComponent(this);
	      }
	    });
	  }
	
	  if (!autoMount || !autoDestroy) {
	    mixin = (0, _extends3['default'])({}, mixin, {
	      renderComponent: function renderComponent(componentArg, ready) {
	        _renderComponent(this, componentArg, ready);
	      }
	    });
	  }
	
	  function _removeContainer(instance) {
	    if (instance._container) {
	      var container = instance._container;
	      _reactDom2['default'].unmountComponentAtNode(container);
	      container.parentNode.removeChild(container);
	      instance._container = null;
	    }
	  }
	
	  if (autoDestroy) {
	    mixin = (0, _extends3['default'])({}, mixin, {
	      componentWillUnmount: function componentWillUnmount() {
	        _removeContainer(this);
	      }
	    });
	  } else {
	    mixin = (0, _extends3['default'])({}, mixin, {
	      removeContainer: function removeContainer() {
	        _removeContainer(this);
	      }
	    });
	  }
	
	  return mixin;
	}
	module.exports = exports['default'];

/***/ }),
/* 285 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
	
	var defaultProps = {
	    className: '',
	    accessibility: true,
	    adaptiveHeight: false,
	    arrows: true,
	    autoplay: false,
	    autoplaySpeed: 3000,
	    centerMode: false,
	    centerPadding: '50px',
	    cssEase: 'ease',
	    customPaging: function customPaging(i) {
	        return _react2.default.createElement(
	            'button',
	            null,
	            i + 1
	        );
	    },
	    dots: false,
	    dotsClass: 'slick-dots',
	    draggable: true,
	    easing: 'linear',
	    edgeFriction: 0.35,
	    fade: false,
	    focusOnSelect: false,
	    infinite: true,
	    initialSlide: 0,
	    lazyLoad: false,
	    pauseOnHover: true,
	    responsive: null,
	    rtl: false,
	    slide: 'div',
	    slidesToShow: 1,
	    slidesToScroll: 1,
	    speed: 500,
	    swipe: true,
	    swipeToSlide: false,
	    touchMove: true,
	    touchThreshold: 5,
	    useCSS: true,
	    variableWidth: false,
	    vertical: false,
	    waitForAnimate: true,
	    afterChange: null,
	    beforeChange: null,
	    edgeEvent: null,
	    init: null,
	    swipeEvent: null,
	    // nextArrow, prevArrow are react componets
	    nextArrow: null,
	    prevArrow: null
	};
	
	module.exports = defaultProps;

/***/ }),
/* 286 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	exports.__esModule = true;
	exports.getTrackLeft = exports.getTrackAnimateCSS = exports.getTrackCSS = undefined;
	
	var _reactDom = __webpack_require__(10);
	
	var _reactDom2 = _interopRequireDefault(_reactDom);
	
	var _objectAssign = __webpack_require__(18);
	
	var _objectAssign2 = _interopRequireDefault(_objectAssign);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
	
	var checkSpecKeys = function checkSpecKeys(spec, keysArray) {
	  return keysArray.reduce(function (value, key) {
	    return value && spec.hasOwnProperty(key);
	  }, true) ? null : console.error('Keys Missing', spec);
	};
	
	var getTrackCSS = exports.getTrackCSS = function getTrackCSS(spec) {
	  checkSpecKeys(spec, ['left', 'variableWidth', 'slideCount', 'slidesToShow', 'slideWidth']);
	
	  var trackWidth, trackHeight;
	
	  var trackChildren = spec.slideCount + 2 * spec.slidesToShow;
	
	  if (!spec.vertical) {
	    if (spec.variableWidth) {
	      trackWidth = (spec.slideCount + 2 * spec.slidesToShow) * spec.slideWidth;
	    } else if (spec.centerMode) {
	      trackWidth = (spec.slideCount + 2 * (spec.slidesToShow + 1)) * spec.slideWidth;
	    } else {
	      trackWidth = (spec.slideCount + 2 * spec.slidesToShow) * spec.slideWidth;
	    }
	  } else {
	    trackHeight = trackChildren * spec.slideHeight;
	  }
	
	  var style = {
	    opacity: 1,
	    WebkitTransform: !spec.vertical ? 'translate3d(' + spec.left + 'px, 0px, 0px)' : 'translate3d(0px, ' + spec.left + 'px, 0px)',
	    transform: !spec.vertical ? 'translate3d(' + spec.left + 'px, 0px, 0px)' : 'translate3d(0px, ' + spec.left + 'px, 0px)',
	    transition: '',
	    WebkitTransition: '',
	    msTransform: !spec.vertical ? 'translateX(' + spec.left + 'px)' : 'translateY(' + spec.left + 'px)'
	  };
	
	  if (trackWidth) {
	    (0, _objectAssign2.default)(style, { width: trackWidth });
	  }
	
	  if (trackHeight) {
	    (0, _objectAssign2.default)(style, { height: trackHeight });
	  }
	
	  // Fallback for IE8
	  if (window && !window.addEventListener && window.attachEvent) {
	    if (!spec.vertical) {
	      style.marginLeft = spec.left + 'px';
	    } else {
	      style.marginTop = spec.left + 'px';
	    }
	  }
	
	  return style;
	};
	
	var getTrackAnimateCSS = exports.getTrackAnimateCSS = function getTrackAnimateCSS(spec) {
	  checkSpecKeys(spec, ['left', 'variableWidth', 'slideCount', 'slidesToShow', 'slideWidth', 'speed', 'cssEase']);
	
	  var style = getTrackCSS(spec);
	  // useCSS is true by default so it can be undefined
	  style.WebkitTransition = '-webkit-transform ' + spec.speed + 'ms ' + spec.cssEase;
	  style.transition = 'transform ' + spec.speed + 'ms ' + spec.cssEase;
	  return style;
	};
	
	var getTrackLeft = exports.getTrackLeft = function getTrackLeft(spec) {
	
	  checkSpecKeys(spec, ['slideIndex', 'trackRef', 'infinite', 'centerMode', 'slideCount', 'slidesToShow', 'slidesToScroll', 'slideWidth', 'listWidth', 'variableWidth', 'slideHeight']);
	
	  var slideOffset = 0;
	  var targetLeft;
	  var targetSlide;
	  var verticalOffset = 0;
	
	  if (spec.fade) {
	    return 0;
	  }
	
	  if (spec.infinite) {
	    if (spec.slideCount >= spec.slidesToShow) {
	      slideOffset = spec.slideWidth * spec.slidesToShow * -1;
	      verticalOffset = spec.slideHeight * spec.slidesToShow * -1;
	    }
	    if (spec.slideCount % spec.slidesToScroll !== 0) {
	      if (spec.slideIndex + spec.slidesToScroll > spec.slideCount && spec.slideCount > spec.slidesToShow) {
	        if (spec.slideIndex > spec.slideCount) {
	          slideOffset = (spec.slidesToShow - (spec.slideIndex - spec.slideCount)) * spec.slideWidth * -1;
	          verticalOffset = (spec.slidesToShow - (spec.slideIndex - spec.slideCount)) * spec.slideHeight * -1;
	        } else {
	          slideOffset = spec.slideCount % spec.slidesToScroll * spec.slideWidth * -1;
	          verticalOffset = spec.slideCount % spec.slidesToScroll * spec.slideHeight * -1;
	        }
	      }
	    }
	  } else {
	
	    if (spec.slideCount % spec.slidesToScroll !== 0) {
	      if (spec.slideIndex + spec.slidesToScroll > spec.slideCount && spec.slideCount > spec.slidesToShow) {
	        var slidesToOffset = spec.slidesToShow - spec.slideCount % spec.slidesToScroll;
	        slideOffset = slidesToOffset * spec.slideWidth;
	      }
	    }
	  }
	
	  if (spec.centerMode) {
	    if (spec.infinite) {
	      slideOffset += spec.slideWidth * Math.floor(spec.slidesToShow / 2);
	    } else {
	      slideOffset = spec.slideWidth * Math.floor(spec.slidesToShow / 2);
	    }
	  }
	
	  if (!spec.vertical) {
	    targetLeft = spec.slideIndex * spec.slideWidth * -1 + slideOffset;
	  } else {
	    targetLeft = spec.slideIndex * spec.slideHeight * -1 + verticalOffset;
	  }
	
	  if (spec.variableWidth === true) {
	    var targetSlideIndex;
	    if (spec.slideCount <= spec.slidesToShow || spec.infinite === false) {
	      targetSlide = _reactDom2.default.findDOMNode(spec.trackRef).childNodes[spec.slideIndex];
	    } else {
	      targetSlideIndex = spec.slideIndex + spec.slidesToShow;
	      targetSlide = _reactDom2.default.findDOMNode(spec.trackRef).childNodes[targetSlideIndex];
	    }
	    targetLeft = targetSlide ? targetSlide.offsetLeft * -1 : 0;
	    if (spec.centerMode === true) {
	      if (spec.infinite === false) {
	        targetSlide = _reactDom2.default.findDOMNode(spec.trackRef).children[spec.slideIndex];
	      } else {
	        targetSlide = _reactDom2.default.findDOMNode(spec.trackRef).children[spec.slideIndex + spec.slidesToShow + 1];
	      }
	
	      if (targetSlide) {
	        targetLeft = targetSlide.offsetLeft * -1 + (spec.listWidth - targetSlide.offsetWidth) / 2;
	      }
	    }
	  }
	
	  return targetLeft;
	};

/***/ }),
/* 287 */
/***/ (function(module, exports, __webpack_require__) {

	/* WEBPACK VAR INJECTION */(function(global) {var scope = (typeof global !== "undefined" && global) ||
	            (typeof self !== "undefined" && self) ||
	            window;
	var apply = Function.prototype.apply;
	
	// DOM APIs, for completeness
	
	exports.setTimeout = function() {
	  return new Timeout(apply.call(setTimeout, scope, arguments), clearTimeout);
	};
	exports.setInterval = function() {
	  return new Timeout(apply.call(setInterval, scope, arguments), clearInterval);
	};
	exports.clearTimeout =
	exports.clearInterval = function(timeout) {
	  if (timeout) {
	    timeout.close();
	  }
	};
	
	function Timeout(id, clearFn) {
	  this._id = id;
	  this._clearFn = clearFn;
	}
	Timeout.prototype.unref = Timeout.prototype.ref = function() {};
	Timeout.prototype.close = function() {
	  this._clearFn.call(scope, this._id);
	};
	
	// Does not start the time, just sets up the members needed.
	exports.enroll = function(item, msecs) {
	  clearTimeout(item._idleTimeoutId);
	  item._idleTimeout = msecs;
	};
	
	exports.unenroll = function(item) {
	  clearTimeout(item._idleTimeoutId);
	  item._idleTimeout = -1;
	};
	
	exports._unrefActive = exports.active = function(item) {
	  clearTimeout(item._idleTimeoutId);
	
	  var msecs = item._idleTimeout;
	  if (msecs >= 0) {
	    item._idleTimeoutId = setTimeout(function onTimeout() {
	      if (item._onTimeout)
	        item._onTimeout();
	    }, msecs);
	  }
	};
	
	// setimmediate attaches itself to the global object
	__webpack_require__(155);
	// On some exotic environments, it's not clear which object `setimmediate` was
	// able to install onto.  Search each possibility in the same order as the
	// `setimmediate` library.
	exports.setImmediate = (typeof self !== "undefined" && self.setImmediate) ||
	                       (typeof global !== "undefined" && global.setImmediate) ||
	                       (this && this.setImmediate);
	exports.clearImmediate = (typeof self !== "undefined" && self.clearImmediate) ||
	                         (typeof global !== "undefined" && global.clearImmediate) ||
	                         (this && this.clearImmediate);
	
	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))

/***/ }),
/* 288 */
[1078, 1018],
/* 289 */
/***/ (function(module, exports) {

	"use strict";
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	/**
	 * @ignore
	 * base event object for custom and dom event.
	 * @author yiminghe@gmail.com
	 */
	
	function returnFalse() {
	  return false;
	}
	
	function returnTrue() {
	  return true;
	}
	
	function EventBaseObject() {
	  this.timeStamp = Date.now();
	  this.target = undefined;
	  this.currentTarget = undefined;
	}
	
	EventBaseObject.prototype = {
	  isEventObject: 1,
	
	  constructor: EventBaseObject,
	
	  isDefaultPrevented: returnFalse,
	
	  isPropagationStopped: returnFalse,
	
	  isImmediatePropagationStopped: returnFalse,
	
	  preventDefault: function preventDefault() {
	    this.isDefaultPrevented = returnTrue;
	  },
	  stopPropagation: function stopPropagation() {
	    this.isPropagationStopped = returnTrue;
	  },
	  stopImmediatePropagation: function stopImmediatePropagation() {
	    this.isImmediatePropagationStopped = returnTrue;
	    // fixed 1.2
	    // call stopPropagation implicitly
	    this.stopPropagation();
	  },
	  halt: function halt(immediate) {
	    if (immediate) {
	      this.stopImmediatePropagation();
	    } else {
	      this.stopPropagation();
	    }
	    this.preventDefault();
	  }
	};
	
	exports["default"] = EventBaseObject;
	module.exports = exports['default'];

/***/ }),
/* 290 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _EventBaseObject = __webpack_require__(289);
	
	var _EventBaseObject2 = _interopRequireDefault(_EventBaseObject);
	
	var _objectAssign = __webpack_require__(18);
	
	var _objectAssign2 = _interopRequireDefault(_objectAssign);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
	
	/**
	 * @ignore
	 * event object for dom
	 * @author yiminghe@gmail.com
	 */
	
	var TRUE = true;
	var FALSE = false;
	var commonProps = ['altKey', 'bubbles', 'cancelable', 'ctrlKey', 'currentTarget', 'eventPhase', 'metaKey', 'shiftKey', 'target', 'timeStamp', 'view', 'type'];
	
	function isNullOrUndefined(w) {
	  return w === null || w === undefined;
	}
	
	var eventNormalizers = [{
	  reg: /^key/,
	  props: ['char', 'charCode', 'key', 'keyCode', 'which'],
	  fix: function fix(event, nativeEvent) {
	    if (isNullOrUndefined(event.which)) {
	      event.which = !isNullOrUndefined(nativeEvent.charCode) ? nativeEvent.charCode : nativeEvent.keyCode;
	    }
	
	    // add metaKey to non-Mac browsers (use ctrl for PC 's and Meta for Macs)
	    if (event.metaKey === undefined) {
	      event.metaKey = event.ctrlKey;
	    }
	  }
	}, {
	  reg: /^touch/,
	  props: ['touches', 'changedTouches', 'targetTouches']
	}, {
	  reg: /^hashchange$/,
	  props: ['newURL', 'oldURL']
	}, {
	  reg: /^gesturechange$/i,
	  props: ['rotation', 'scale']
	}, {
	  reg: /^(mousewheel|DOMMouseScroll)$/,
	  props: [],
	  fix: function fix(event, nativeEvent) {
	    var deltaX = void 0;
	    var deltaY = void 0;
	    var delta = void 0;
	    var wheelDelta = nativeEvent.wheelDelta;
	    var axis = nativeEvent.axis;
	    var wheelDeltaY = nativeEvent.wheelDeltaY;
	    var wheelDeltaX = nativeEvent.wheelDeltaX;
	    var detail = nativeEvent.detail;
	
	    // ie/webkit
	    if (wheelDelta) {
	      delta = wheelDelta / 120;
	    }
	
	    // gecko
	    if (detail) {
	      // press control e.detail == 1 else e.detail == 3
	      delta = 0 - (detail % 3 === 0 ? detail / 3 : detail);
	    }
	
	    // Gecko
	    if (axis !== undefined) {
	      if (axis === event.HORIZONTAL_AXIS) {
	        deltaY = 0;
	        deltaX = 0 - delta;
	      } else if (axis === event.VERTICAL_AXIS) {
	        deltaX = 0;
	        deltaY = delta;
	      }
	    }
	
	    // Webkit
	    if (wheelDeltaY !== undefined) {
	      deltaY = wheelDeltaY / 120;
	    }
	    if (wheelDeltaX !== undefined) {
	      deltaX = -1 * wheelDeltaX / 120;
	    }
	
	    // 默认 deltaY (ie)
	    if (!deltaX && !deltaY) {
	      deltaY = delta;
	    }
	
	    if (deltaX !== undefined) {
	      /**
	       * deltaX of mousewheel event
	       * @property deltaX
	       * @member Event.DomEvent.Object
	       */
	      event.deltaX = deltaX;
	    }
	
	    if (deltaY !== undefined) {
	      /**
	       * deltaY of mousewheel event
	       * @property deltaY
	       * @member Event.DomEvent.Object
	       */
	      event.deltaY = deltaY;
	    }
	
	    if (delta !== undefined) {
	      /**
	       * delta of mousewheel event
	       * @property delta
	       * @member Event.DomEvent.Object
	       */
	      event.delta = delta;
	    }
	  }
	}, {
	  reg: /^mouse|contextmenu|click|mspointer|(^DOMMouseScroll$)/i,
	  props: ['buttons', 'clientX', 'clientY', 'button', 'offsetX', 'relatedTarget', 'which', 'fromElement', 'toElement', 'offsetY', 'pageX', 'pageY', 'screenX', 'screenY'],
	  fix: function fix(event, nativeEvent) {
	    var eventDoc = void 0;
	    var doc = void 0;
	    var body = void 0;
	    var target = event.target;
	    var button = nativeEvent.button;
	
	    // Calculate pageX/Y if missing and clientX/Y available
	    if (target && isNullOrUndefined(event.pageX) && !isNullOrUndefined(nativeEvent.clientX)) {
	      eventDoc = target.ownerDocument || document;
	      doc = eventDoc.documentElement;
	      body = eventDoc.body;
	      event.pageX = nativeEvent.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0);
	      event.pageY = nativeEvent.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc && doc.clientTop || body && body.clientTop || 0);
	    }
	
	    // which for click: 1 === left; 2 === middle; 3 === right
	    // do not use button
	    if (!event.which && button !== undefined) {
	      if (button & 1) {
	        event.which = 1;
	      } else if (button & 2) {
	        event.which = 3;
	      } else if (button & 4) {
	        event.which = 2;
	      } else {
	        event.which = 0;
	      }
	    }
	
	    // add relatedTarget, if necessary
	    if (!event.relatedTarget && event.fromElement) {
	      event.relatedTarget = event.fromElement === target ? event.toElement : event.fromElement;
	    }
	
	    return event;
	  }
	}];
	
	function retTrue() {
	  return TRUE;
	}
	
	function retFalse() {
	  return FALSE;
	}
	
	function DomEventObject(nativeEvent) {
	  var type = nativeEvent.type;
	
	  var isNative = typeof nativeEvent.stopPropagation === 'function' || typeof nativeEvent.cancelBubble === 'boolean';
	
	  _EventBaseObject2["default"].call(this);
	
	  this.nativeEvent = nativeEvent;
	
	  // in case dom event has been mark as default prevented by lower dom node
	  var isDefaultPrevented = retFalse;
	  if ('defaultPrevented' in nativeEvent) {
	    isDefaultPrevented = nativeEvent.defaultPrevented ? retTrue : retFalse;
	  } else if ('getPreventDefault' in nativeEvent) {
	    // https://bugzilla.mozilla.org/show_bug.cgi?id=691151
	    isDefaultPrevented = nativeEvent.getPreventDefault() ? retTrue : retFalse;
	  } else if ('returnValue' in nativeEvent) {
	    isDefaultPrevented = nativeEvent.returnValue === FALSE ? retTrue : retFalse;
	  }
	
	  this.isDefaultPrevented = isDefaultPrevented;
	
	  var fixFns = [];
	  var fixFn = void 0;
	  var l = void 0;
	  var prop = void 0;
	  var props = commonProps.concat();
	
	  eventNormalizers.forEach(function (normalizer) {
	    if (type.match(normalizer.reg)) {
	      props = props.concat(normalizer.props);
	      if (normalizer.fix) {
	        fixFns.push(normalizer.fix);
	      }
	    }
	  });
	
	  l = props.length;
	
	  // clone properties of the original event object
	  while (l) {
	    prop = props[--l];
	    this[prop] = nativeEvent[prop];
	  }
	
	  // fix target property, if necessary
	  if (!this.target && isNative) {
	    this.target = nativeEvent.srcElement || document; // srcElement might not be defined either
	  }
	
	  // check if target is a text node (safari)
	  if (this.target && this.target.nodeType === 3) {
	    this.target = this.target.parentNode;
	  }
	
	  l = fixFns.length;
	
	  while (l) {
	    fixFn = fixFns[--l];
	    fixFn(this, nativeEvent);
	  }
	
	  this.timeStamp = nativeEvent.timeStamp || Date.now();
	}
	
	var EventBaseObjectProto = _EventBaseObject2["default"].prototype;
	
	(0, _objectAssign2["default"])(DomEventObject.prototype, EventBaseObjectProto, {
	  constructor: DomEventObject,
	
	  preventDefault: function preventDefault() {
	    var e = this.nativeEvent;
	
	    // if preventDefault exists run it on the original event
	    if (e.preventDefault) {
	      e.preventDefault();
	    } else {
	      // otherwise set the returnValue property of the original event to FALSE (IE)
	      e.returnValue = FALSE;
	    }
	
	    EventBaseObjectProto.preventDefault.call(this);
	  },
	  stopPropagation: function stopPropagation() {
	    var e = this.nativeEvent;
	
	    // if stopPropagation exists run it on the original event
	    if (e.stopPropagation) {
	      e.stopPropagation();
	    } else {
	      // otherwise set the cancelBubble property of the original event to TRUE (IE)
	      e.cancelBubble = TRUE;
	    }
	
	    EventBaseObjectProto.stopPropagation.call(this);
	  }
	});
	
	exports["default"] = DomEventObject;
	module.exports = exports['default'];

/***/ }),
/* 291 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports["default"] = addEventListener;
	
	var _EventObject = __webpack_require__(290);
	
	var _EventObject2 = _interopRequireDefault(_EventObject);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
	
	function addEventListener(target, eventType, callback) {
	  function wrapCallback(e) {
	    var ne = new _EventObject2["default"](e);
	    callback.call(target, ne);
	  }
	
	  if (target.addEventListener) {
	    target.addEventListener(eventType, wrapCallback, false);
	    return {
	      remove: function remove() {
	        target.removeEventListener(eventType, wrapCallback, false);
	      }
	    };
	  } else if (target.attachEvent) {
	    target.attachEvent('on' + eventType, wrapCallback);
	    return {
	      remove: function remove() {
	        target.detachEvent('on' + eventType, wrapCallback);
	      }
	    };
	  }
	}
	module.exports = exports['default'];

/***/ }),
/* 292 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _typeof2 = __webpack_require__(21);
	
	var _typeof3 = _interopRequireDefault(_typeof2);
	
	var _util = __webpack_require__(19);
	
	var _validator = __webpack_require__(304);
	
	var _validator2 = _interopRequireDefault(_validator);
	
	var _messages2 = __webpack_require__(293);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	/**
	 *  Encapsulates a validation schema.
	 *
	 *  @param descriptor An object declaring validation rules
	 *  for this schema.
	 */
	function Schema(descriptor) {
	  this.rules = null;
	  this._messages = _messages2.messages;
	  this.define(descriptor);
	}
	
	Schema.prototype = {
	  messages: function messages(_messages) {
	    if (_messages) {
	      this._messages = (0, _util.deepMerge)((0, _messages2.newMessages)(), _messages);
	    }
	    return this._messages;
	  },
	  define: function define(rules) {
	    if (!rules) {
	      throw new Error('Cannot configure a schema with no rules');
	    }
	    if ((typeof rules === 'undefined' ? 'undefined' : (0, _typeof3['default'])(rules)) !== 'object' || Array.isArray(rules)) {
	      throw new Error('Rules must be an object');
	    }
	    this.rules = {};
	    var z = void 0;
	    var item = void 0;
	    for (z in rules) {
	      if (rules.hasOwnProperty(z)) {
	        item = rules[z];
	        this.rules[z] = Array.isArray(item) ? item : [item];
	      }
	    }
	  },
	  validate: function validate(source_) {
	    var _this = this;
	
	    var o = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
	    var oc = arguments[2];
	
	    var source = source_;
	    var options = o;
	    var callback = oc;
	    if (typeof options === 'function') {
	      callback = options;
	      options = {};
	    }
	    if (!this.rules || Object.keys(this.rules).length === 0) {
	      if (callback) {
	        callback();
	      }
	      return;
	    }
	    function complete(results) {
	      var i = void 0;
	      var field = void 0;
	      var errors = [];
	      var fields = {};
	
	      function add(e) {
	        if (Array.isArray(e)) {
	          errors = errors.concat.apply(errors, e);
	        } else {
	          errors.push(e);
	        }
	      }
	
	      for (i = 0; i < results.length; i++) {
	        add(results[i]);
	      }
	      if (!errors.length) {
	        errors = null;
	        fields = null;
	      } else {
	        for (i = 0; i < errors.length; i++) {
	          field = errors[i].field;
	          fields[field] = fields[field] || [];
	          fields[field].push(errors[i]);
	        }
	      }
	      callback(errors, fields);
	    }
	
	    if (options.messages) {
	      var messages = this.messages();
	      if (messages === _messages2.messages) {
	        messages = (0, _messages2.newMessages)();
	      }
	      (0, _util.deepMerge)(messages, options.messages);
	      options.messages = messages;
	    } else {
	      options.messages = this.messages();
	    }
	    var arr = void 0;
	    var value = void 0;
	    var series = {};
	    var keys = options.keys || Object.keys(this.rules);
	    keys.forEach(function (z) {
	      arr = _this.rules[z];
	      value = source[z];
	      arr.forEach(function (r) {
	        var rule = r;
	        if (typeof rule.transform === 'function') {
	          if (source === source_) {
	            source = (0, _extends3['default'])({}, source);
	          }
	          value = source[z] = rule.transform(value);
	        }
	        if (typeof rule === 'function') {
	          rule = {
	            validator: rule
	          };
	        } else {
	          rule = (0, _extends3['default'])({}, rule);
	        }
	        rule.validator = _this.getValidationMethod(rule);
	        rule.field = z;
	        rule.fullField = rule.fullField || z;
	        rule.type = _this.getType(rule);
	        if (!rule.validator) {
	          return;
	        }
	        series[z] = series[z] || [];
	        series[z].push({
	          rule: rule,
	          value: value,
	          source: source,
	          field: z
	        });
	      });
	    });
	    var errorFields = {};
	    (0, _util.asyncMap)(series, options, function (data, doIt) {
	      var rule = data.rule;
	      var deep = (rule.type === 'object' || rule.type === 'array') && ((0, _typeof3['default'])(rule.fields) === 'object' || (0, _typeof3['default'])(rule.defaultField) === 'object');
	      deep = deep && (rule.required || !rule.required && data.value);
	      rule.field = data.field;
	      function addFullfield(key, schema) {
	        return (0, _extends3['default'])({}, schema, {
	          fullField: rule.fullField + '.' + key
	        });
	      }
	
	      function cb() {
	        var e = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
	
	        var errors = e;
	        if (!Array.isArray(errors)) {
	          errors = [errors];
	        }
	        if (errors.length) {
	          (0, _util.warning)('async-validator:', errors);
	        }
	        if (errors.length && rule.message) {
	          errors = [].concat(rule.message);
	        }
	
	        errors = errors.map((0, _util.complementError)(rule));
	
	        if (options.first && errors.length) {
	          errorFields[rule.field] = 1;
	          return doIt(errors);
	        }
	        if (!deep) {
	          doIt(errors);
	        } else {
	          // if rule is required but the target object
	          // does not exist fail at the rule level and don't
	          // go deeper
	          if (rule.required && !data.value) {
	            if (rule.message) {
	              errors = [].concat(rule.message).map((0, _util.complementError)(rule));
	            } else if (options.error) {
	              errors = [options.error(rule, (0, _util.format)(options.messages.required, rule.field))];
	            } else {
	              errors = [];
	            }
	            return doIt(errors);
	          }
	
	          var fieldsSchema = {};
	          if (rule.defaultField) {
	            for (var k in data.value) {
	              if (data.value.hasOwnProperty(k)) {
	                fieldsSchema[k] = rule.defaultField;
	              }
	            }
	          }
	          fieldsSchema = (0, _extends3['default'])({}, fieldsSchema, data.rule.fields);
	          for (var f in fieldsSchema) {
	            if (fieldsSchema.hasOwnProperty(f)) {
	              var fieldSchema = Array.isArray(fieldsSchema[f]) ? fieldsSchema[f] : [fieldsSchema[f]];
	              fieldsSchema[f] = fieldSchema.map(addFullfield.bind(null, f));
	            }
	          }
	          var schema = new Schema(fieldsSchema);
	          schema.messages(options.messages);
	          if (data.rule.options) {
	            data.rule.options.messages = options.messages;
	            data.rule.options.error = options.error;
	          }
	          schema.validate(data.value, data.rule.options || options, function (errs) {
	            doIt(errs && errs.length ? errors.concat(errs) : errs);
	          });
	        }
	      }
	
	      var res = rule.validator(rule, data.value, cb, data.source, options);
	      if (res && res.then) {
	        res.then(function () {
	          return cb();
	        }, function (e) {
	          return cb(e);
	        });
	      }
	    }, function (results) {
	      complete(results);
	    });
	  },
	  getType: function getType(rule) {
	    if (rule.type === undefined && rule.pattern instanceof RegExp) {
	      rule.type = 'pattern';
	    }
	    if (typeof rule.validator !== 'function' && rule.type && !_validator2['default'].hasOwnProperty(rule.type)) {
	      throw new Error((0, _util.format)('Unknown rule type %s', rule.type));
	    }
	    return rule.type || 'string';
	  },
	  getValidationMethod: function getValidationMethod(rule) {
	    if (typeof rule.validator === 'function') {
	      return rule.validator;
	    }
	    var keys = Object.keys(rule);
	    var messageIndex = keys.indexOf('message');
	    if (messageIndex !== -1) {
	      keys.splice(messageIndex, 1);
	    }
	    if (keys.length === 1 && keys[0] === 'required') {
	      return _validator2['default'].required;
	    }
	    return _validator2['default'][this.getType(rule)] || false;
	  }
	};
	
	Schema.register = function register(type, validator) {
	  if (typeof validator !== 'function') {
	    throw new Error('Cannot register a validator by type, validator is not a function');
	  }
	  _validator2['default'][type] = validator;
	};
	
	Schema.messages = _messages2.messages;
	
	exports['default'] = Schema;
	module.exports = exports['default'];

/***/ }),
/* 293 */
/***/ (function(module, exports) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.newMessages = newMessages;
	function newMessages() {
	  return {
	    'default': 'Validation error on field %s',
	    required: '%s is required',
	    'enum': '%s must be one of %s',
	    whitespace: '%s cannot be empty',
	    date: {
	      format: '%s date %s is invalid for format %s',
	      parse: '%s date could not be parsed, %s is invalid ',
	      invalid: '%s date %s is invalid'
	    },
	    types: {
	      string: '%s is not a %s',
	      method: '%s is not a %s (function)',
	      array: '%s is not an %s',
	      object: '%s is not an %s',
	      number: '%s is not a %s',
	      date: '%s is not a %s',
	      boolean: '%s is not a %s',
	      integer: '%s is not an %s',
	      float: '%s is not a %s',
	      regexp: '%s is not a valid %s',
	      email: '%s is not a valid %s',
	      url: '%s is not a valid %s',
	      hex: '%s is not a valid %s'
	    },
	    string: {
	      len: '%s must be exactly %s characters',
	      min: '%s must be at least %s characters',
	      max: '%s cannot be longer than %s characters',
	      range: '%s must be between %s and %s characters'
	    },
	    number: {
	      len: '%s must equal %s',
	      min: '%s cannot be less than %s',
	      max: '%s cannot be greater than %s',
	      range: '%s must be between %s and %s'
	    },
	    array: {
	      len: '%s must be exactly %s in length',
	      min: '%s cannot be less than %s in length',
	      max: '%s cannot be greater than %s in length',
	      range: '%s must be between %s and %s in length'
	    },
	    pattern: {
	      mismatch: '%s value %s does not match pattern %s'
	    },
	    clone: function clone() {
	      var cloned = JSON.parse(JSON.stringify(this));
	      cloned.clone = this.clone;
	      return cloned;
	    }
	  };
	}
	
	var messages = exports.messages = newMessages();

/***/ }),
/* 294 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _util = __webpack_require__(19);
	
	var util = _interopRequireWildcard(_util);
	
	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; } }
	
	var ENUM = 'enum';
	
	/**
	 *  Rule for validating a value exists in an enumerable list.
	 *
	 *  @param rule The validation rule.
	 *  @param value The value of the field on the source object.
	 *  @param source The source object being validated.
	 *  @param errors An array of errors that this rule may add
	 *  validation errors to.
	 *  @param options The validation options.
	 *  @param options.messages The validation messages.
	 */
	function enumerable(rule, value, source, errors, options) {
	  rule[ENUM] = Array.isArray(rule[ENUM]) ? rule[ENUM] : [];
	  if (rule[ENUM].indexOf(value) === -1) {
	    errors.push(util.format(options.messages[ENUM], rule.fullField, rule[ENUM].join(', ')));
	  }
	}
	
	exports['default'] = enumerable;
	module.exports = exports['default'];

/***/ }),
/* 295 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _util = __webpack_require__(19);
	
	var util = _interopRequireWildcard(_util);
	
	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; } }
	
	/**
	 *  Rule for validating a regular expression pattern.
	 *
	 *  @param rule The validation rule.
	 *  @param value The value of the field on the source object.
	 *  @param source The source object being validated.
	 *  @param errors An array of errors that this rule may add
	 *  validation errors to.
	 *  @param options The validation options.
	 *  @param options.messages The validation messages.
	 */
	function pattern(rule, value, source, errors, options) {
	  if (rule.pattern) {
	    if (rule.pattern instanceof RegExp) {
	      // if a RegExp instance is passed, reset `lastIndex` in case its `global`
	      // flag is accidentally set to `true`, which in a validation scenario
	      // is not necessary and the result might be misleading
	      rule.pattern.lastIndex = 0;
	      if (!rule.pattern.test(value)) {
	        errors.push(util.format(options.messages.pattern.mismatch, rule.fullField, value, rule.pattern));
	      }
	    } else if (typeof rule.pattern === 'string') {
	      var _pattern = new RegExp(rule.pattern);
	      if (!_pattern.test(value)) {
	        errors.push(util.format(options.messages.pattern.mismatch, rule.fullField, value, rule.pattern));
	      }
	    }
	  }
	}
	
	exports['default'] = pattern;
	module.exports = exports['default'];

/***/ }),
/* 296 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _util = __webpack_require__(19);
	
	var util = _interopRequireWildcard(_util);
	
	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; } }
	
	/**
	 *  Rule for validating minimum and maximum allowed values.
	 *
	 *  @param rule The validation rule.
	 *  @param value The value of the field on the source object.
	 *  @param source The source object being validated.
	 *  @param errors An array of errors that this rule may add
	 *  validation errors to.
	 *  @param options The validation options.
	 *  @param options.messages The validation messages.
	 */
	function range(rule, value, source, errors, options) {
	  var len = typeof rule.len === 'number';
	  var min = typeof rule.min === 'number';
	  var max = typeof rule.max === 'number';
	  var val = value;
	  var key = null;
	  var num = typeof value === 'number';
	  var str = typeof value === 'string';
	  var arr = Array.isArray(value);
	  if (num) {
	    key = 'number';
	  } else if (str) {
	    key = 'string';
	  } else if (arr) {
	    key = 'array';
	  }
	  // if the value is not of a supported type for range validation
	  // the validation rule rule should use the
	  // type property to also test for a particular type
	  if (!key) {
	    return false;
	  }
	  if (str || arr) {
	    val = value.length;
	  }
	  if (len) {
	    if (val !== rule.len) {
	      errors.push(util.format(options.messages[key].len, rule.fullField, rule.len));
	    }
	  } else if (min && !max && val < rule.min) {
	    errors.push(util.format(options.messages[key].min, rule.fullField, rule.min));
	  } else if (max && !min && val > rule.max) {
	    errors.push(util.format(options.messages[key].max, rule.fullField, rule.max));
	  } else if (min && max && (val < rule.min || val > rule.max)) {
	    errors.push(util.format(options.messages[key].range, rule.fullField, rule.min, rule.max));
	  }
	}
	
	exports['default'] = range;
	module.exports = exports['default'];

/***/ }),
/* 297 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _typeof2 = __webpack_require__(21);
	
	var _typeof3 = _interopRequireDefault(_typeof2);
	
	var _util = __webpack_require__(19);
	
	var util = _interopRequireWildcard(_util);
	
	var _required = __webpack_require__(157);
	
	var _required2 = _interopRequireDefault(_required);
	
	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 }; }
	
	/* eslint max-len:0 */
	
	var pattern = {
	  // http://emailregex.com/
	  email: /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/,
	  url: new RegExp('^(?!mailto:)(?:(?:http|https|ftp)://|//)(?:\\S+(?::\\S*)?@)?(?:(?:(?:[1-9]\\d?|1\\d\\d|2[01]\\d|22[0-3])(?:\\.(?:1?\\d{1,2}|2[0-4]\\d|25[0-5])){2}(?:\\.(?:[0-9]\\d?|1\\d\\d|2[0-4]\\d|25[0-4]))|(?:(?:[a-z\\u00a1-\\uffff0-9]+-?)*[a-z\\u00a1-\\uffff0-9]+)(?:\\.(?:[a-z\\u00a1-\\uffff0-9]+-?)*[a-z\\u00a1-\\uffff0-9]+)*(?:\\.(?:[a-z\\u00a1-\\uffff]{2,})))|localhost)(?::\\d{2,5})?(?:(/|\\?|#)[^\\s]*)?$', 'i'),
	  hex: /^#?([a-f0-9]{6}|[a-f0-9]{3})$/i
	};
	
	var types = {
	  integer: function integer(value) {
	    return types.number(value) && parseInt(value, 10) === value;
	  },
	  float: function float(value) {
	    return types.number(value) && !types.integer(value);
	  },
	  array: function array(value) {
	    return Array.isArray(value);
	  },
	  regexp: function regexp(value) {
	    if (value instanceof RegExp) {
	      return true;
	    }
	    try {
	      return !!new RegExp(value);
	    } catch (e) {
	      return false;
	    }
	  },
	  date: function date(value) {
	    return typeof value.getTime === 'function' && typeof value.getMonth === 'function' && typeof value.getYear === 'function';
	  },
	  number: function number(value) {
	    if (isNaN(value)) {
	      return false;
	    }
	    return typeof value === 'number';
	  },
	  object: function object(value) {
	    return (typeof value === 'undefined' ? 'undefined' : (0, _typeof3['default'])(value)) === 'object' && !types.array(value);
	  },
	  method: function method(value) {
	    return typeof value === 'function';
	  },
	  email: function email(value) {
	    return typeof value === 'string' && !!value.match(pattern.email) && value.length < 255;
	  },
	  url: function url(value) {
	    return typeof value === 'string' && !!value.match(pattern.url);
	  },
	  hex: function hex(value) {
	    return typeof value === 'string' && !!value.match(pattern.hex);
	  }
	};
	
	/**
	 *  Rule for validating the type of a value.
	 *
	 *  @param rule The validation rule.
	 *  @param value The value of the field on the source object.
	 *  @param source The source object being validated.
	 *  @param errors An array of errors that this rule may add
	 *  validation errors to.
	 *  @param options The validation options.
	 *  @param options.messages The validation messages.
	 */
	function type(rule, value, source, errors, options) {
	  if (rule.required && value === undefined) {
	    (0, _required2['default'])(rule, value, source, errors, options);
	    return;
	  }
	  var custom = ['integer', 'float', 'array', 'regexp', 'object', 'method', 'email', 'number', 'date', 'url', 'hex'];
	  var ruleType = rule.type;
	  if (custom.indexOf(ruleType) > -1) {
	    if (!types[ruleType](value)) {
	      errors.push(util.format(options.messages.types[ruleType], rule.fullField, rule.type));
	    }
	    // straight typeof check
	  } else if (ruleType && (typeof value === 'undefined' ? 'undefined' : (0, _typeof3['default'])(value)) !== rule.type) {
	    errors.push(util.format(options.messages.types[ruleType], rule.fullField, rule.type));
	  }
	}
	
	exports['default'] = type;
	module.exports = exports['default'];

/***/ }),
/* 298 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _util = __webpack_require__(19);
	
	var util = _interopRequireWildcard(_util);
	
	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; } }
	
	/**
	 *  Rule for validating whitespace.
	 *
	 *  @param rule The validation rule.
	 *  @param value The value of the field on the source object.
	 *  @param source The source object being validated.
	 *  @param errors An array of errors that this rule may add
	 *  validation errors to.
	 *  @param options The validation options.
	 *  @param options.messages The validation messages.
	 */
	function whitespace(rule, value, source, errors, options) {
	  if (/^\s+$/.test(value) || value === '') {
	    errors.push(util.format(options.messages.whitespace, rule.fullField));
	  }
	}
	
	exports['default'] = whitespace;
	module.exports = exports['default'];

/***/ }),
/* 299 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _rule = __webpack_require__(23);
	
	var _rule2 = _interopRequireDefault(_rule);
	
	var _util = __webpack_require__(19);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	/**
	 *  Validates an array.
	 *
	 *  @param rule The validation rule.
	 *  @param value The value of the field on the source object.
	 *  @param callback The callback function.
	 *  @param source The source object being validated.
	 *  @param options The validation options.
	 *  @param options.messages The validation messages.
	 */
	function array(rule, value, callback, source, options) {
	  var errors = [];
	  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
	  if (validate) {
	    if ((0, _util.isEmptyValue)(value, 'array') && !rule.required) {
	      return callback();
	    }
	    _rule2['default'].required(rule, value, source, errors, options, 'array');
	    if (!(0, _util.isEmptyValue)(value, 'array')) {
	      _rule2['default'].type(rule, value, source, errors, options);
	      _rule2['default'].range(rule, value, source, errors, options);
	    }
	  }
	  callback(errors);
	}
	
	exports['default'] = array;
	module.exports = exports['default'];

/***/ }),
/* 300 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _util = __webpack_require__(19);
	
	var _rule = __webpack_require__(23);
	
	var _rule2 = _interopRequireDefault(_rule);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	/**
	 *  Validates a boolean.
	 *
	 *  @param rule The validation rule.
	 *  @param value The value of the field on the source object.
	 *  @param callback The callback function.
	 *  @param source The source object being validated.
	 *  @param options The validation options.
	 *  @param options.messages The validation messages.
	 */
	function boolean(rule, value, callback, source, options) {
	  var errors = [];
	  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
	  if (validate) {
	    if ((0, _util.isEmptyValue)(value) && !rule.required) {
	      return callback();
	    }
	    _rule2['default'].required(rule, value, source, errors, options);
	    if (value !== undefined) {
	      _rule2['default'].type(rule, value, source, errors, options);
	    }
	  }
	  callback(errors);
	}
	
	exports['default'] = boolean;
	module.exports = exports['default'];

/***/ }),
/* 301 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _rule = __webpack_require__(23);
	
	var _rule2 = _interopRequireDefault(_rule);
	
	var _util = __webpack_require__(19);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function date(rule, value, callback, source, options) {
	  // console.log('integer rule called %j', rule);
	  var errors = [];
	  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
	  // console.log('validate on %s value', value);
	  if (validate) {
	    if ((0, _util.isEmptyValue)(value) && !rule.required) {
	      return callback();
	    }
	    _rule2['default'].required(rule, value, source, errors, options);
	    if (!(0, _util.isEmptyValue)(value)) {
	      _rule2['default'].type(rule, value, source, errors, options);
	      if (value) {
	        _rule2['default'].range(rule, value.getTime(), source, errors, options);
	      }
	    }
	  }
	  callback(errors);
	}
	
	exports['default'] = date;
	module.exports = exports['default'];

/***/ }),
/* 302 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _rule = __webpack_require__(23);
	
	var _rule2 = _interopRequireDefault(_rule);
	
	var _util = __webpack_require__(19);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var ENUM = 'enum';
	
	/**
	 *  Validates an enumerable list.
	 *
	 *  @param rule The validation rule.
	 *  @param value The value of the field on the source object.
	 *  @param callback The callback function.
	 *  @param source The source object being validated.
	 *  @param options The validation options.
	 *  @param options.messages The validation messages.
	 */
	function enumerable(rule, value, callback, source, options) {
	  var errors = [];
	  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
	  if (validate) {
	    if ((0, _util.isEmptyValue)(value) && !rule.required) {
	      return callback();
	    }
	    _rule2['default'].required(rule, value, source, errors, options);
	    if (value) {
	      _rule2['default'][ENUM](rule, value, source, errors, options);
	    }
	  }
	  callback(errors);
	}
	
	exports['default'] = enumerable;
	module.exports = exports['default'];

/***/ }),
/* 303 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _rule = __webpack_require__(23);
	
	var _rule2 = _interopRequireDefault(_rule);
	
	var _util = __webpack_require__(19);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	/**
	 *  Validates a number is a floating point number.
	 *
	 *  @param rule The validation rule.
	 *  @param value The value of the field on the source object.
	 *  @param callback The callback function.
	 *  @param source The source object being validated.
	 *  @param options The validation options.
	 *  @param options.messages The validation messages.
	 */
	function floatFn(rule, value, callback, source, options) {
	  var errors = [];
	  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
	  if (validate) {
	    if ((0, _util.isEmptyValue)(value) && !rule.required) {
	      return callback();
	    }
	    _rule2['default'].required(rule, value, source, errors, options);
	    if (value !== undefined) {
	      _rule2['default'].type(rule, value, source, errors, options);
	      _rule2['default'].range(rule, value, source, errors, options);
	    }
	  }
	  callback(errors);
	}
	
	exports['default'] = floatFn;
	module.exports = exports['default'];

/***/ }),
/* 304 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _string = __webpack_require__(312);
	
	var _string2 = _interopRequireDefault(_string);
	
	var _method = __webpack_require__(306);
	
	var _method2 = _interopRequireDefault(_method);
	
	var _number = __webpack_require__(307);
	
	var _number2 = _interopRequireDefault(_number);
	
	var _boolean = __webpack_require__(300);
	
	var _boolean2 = _interopRequireDefault(_boolean);
	
	var _regexp = __webpack_require__(310);
	
	var _regexp2 = _interopRequireDefault(_regexp);
	
	var _integer = __webpack_require__(305);
	
	var _integer2 = _interopRequireDefault(_integer);
	
	var _float = __webpack_require__(303);
	
	var _float2 = _interopRequireDefault(_float);
	
	var _array = __webpack_require__(299);
	
	var _array2 = _interopRequireDefault(_array);
	
	var _object = __webpack_require__(308);
	
	var _object2 = _interopRequireDefault(_object);
	
	var _enum = __webpack_require__(302);
	
	var _enum2 = _interopRequireDefault(_enum);
	
	var _pattern = __webpack_require__(309);
	
	var _pattern2 = _interopRequireDefault(_pattern);
	
	var _date = __webpack_require__(301);
	
	var _date2 = _interopRequireDefault(_date);
	
	var _required = __webpack_require__(311);
	
	var _required2 = _interopRequireDefault(_required);
	
	var _type = __webpack_require__(313);
	
	var _type2 = _interopRequireDefault(_type);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	exports['default'] = {
	  string: _string2['default'],
	  method: _method2['default'],
	  number: _number2['default'],
	  boolean: _boolean2['default'],
	  regexp: _regexp2['default'],
	  integer: _integer2['default'],
	  float: _float2['default'],
	  array: _array2['default'],
	  object: _object2['default'],
	  'enum': _enum2['default'],
	  pattern: _pattern2['default'],
	  date: _date2['default'],
	  url: _type2['default'],
	  hex: _type2['default'],
	  email: _type2['default'],
	  required: _required2['default']
	};
	module.exports = exports['default'];

/***/ }),
/* 305 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _rule = __webpack_require__(23);
	
	var _rule2 = _interopRequireDefault(_rule);
	
	var _util = __webpack_require__(19);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	/**
	 *  Validates a number is an integer.
	 *
	 *  @param rule The validation rule.
	 *  @param value The value of the field on the source object.
	 *  @param callback The callback function.
	 *  @param source The source object being validated.
	 *  @param options The validation options.
	 *  @param options.messages The validation messages.
	 */
	function integer(rule, value, callback, source, options) {
	  var errors = [];
	  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
	  if (validate) {
	    if ((0, _util.isEmptyValue)(value) && !rule.required) {
	      return callback();
	    }
	    _rule2['default'].required(rule, value, source, errors, options);
	    if (value !== undefined) {
	      _rule2['default'].type(rule, value, source, errors, options);
	      _rule2['default'].range(rule, value, source, errors, options);
	    }
	  }
	  callback(errors);
	}
	
	exports['default'] = integer;
	module.exports = exports['default'];

/***/ }),
/* 306 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _rule = __webpack_require__(23);
	
	var _rule2 = _interopRequireDefault(_rule);
	
	var _util = __webpack_require__(19);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	/**
	 *  Validates a function.
	 *
	 *  @param rule The validation rule.
	 *  @param value The value of the field on the source object.
	 *  @param callback The callback function.
	 *  @param source The source object being validated.
	 *  @param options The validation options.
	 *  @param options.messages The validation messages.
	 */
	function method(rule, value, callback, source, options) {
	  var errors = [];
	  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
	  if (validate) {
	    if ((0, _util.isEmptyValue)(value) && !rule.required) {
	      return callback();
	    }
	    _rule2['default'].required(rule, value, source, errors, options);
	    if (value !== undefined) {
	      _rule2['default'].type(rule, value, source, errors, options);
	    }
	  }
	  callback(errors);
	}
	
	exports['default'] = method;
	module.exports = exports['default'];

/***/ }),
/* 307 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _rule = __webpack_require__(23);
	
	var _rule2 = _interopRequireDefault(_rule);
	
	var _util = __webpack_require__(19);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	/**
	 *  Validates a number.
	 *
	 *  @param rule The validation rule.
	 *  @param value The value of the field on the source object.
	 *  @param callback The callback function.
	 *  @param source The source object being validated.
	 *  @param options The validation options.
	 *  @param options.messages The validation messages.
	 */
	function number(rule, value, callback, source, options) {
	  var errors = [];
	  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
	  if (validate) {
	    if ((0, _util.isEmptyValue)(value) && !rule.required) {
	      return callback();
	    }
	    _rule2['default'].required(rule, value, source, errors, options);
	    if (value !== undefined) {
	      _rule2['default'].type(rule, value, source, errors, options);
	      _rule2['default'].range(rule, value, source, errors, options);
	    }
	  }
	  callback(errors);
	}
	
	exports['default'] = number;
	module.exports = exports['default'];

/***/ }),
/* 308 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _rule = __webpack_require__(23);
	
	var _rule2 = _interopRequireDefault(_rule);
	
	var _util = __webpack_require__(19);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	/**
	 *  Validates an object.
	 *
	 *  @param rule The validation rule.
	 *  @param value The value of the field on the source object.
	 *  @param callback The callback function.
	 *  @param source The source object being validated.
	 *  @param options The validation options.
	 *  @param options.messages The validation messages.
	 */
	function object(rule, value, callback, source, options) {
	  var errors = [];
	  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
	  if (validate) {
	    if ((0, _util.isEmptyValue)(value) && !rule.required) {
	      return callback();
	    }
	    _rule2['default'].required(rule, value, source, errors, options);
	    if (value !== undefined) {
	      _rule2['default'].type(rule, value, source, errors, options);
	    }
	  }
	  callback(errors);
	}
	
	exports['default'] = object;
	module.exports = exports['default'];

/***/ }),
/* 309 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _rule = __webpack_require__(23);
	
	var _rule2 = _interopRequireDefault(_rule);
	
	var _util = __webpack_require__(19);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	/**
	 *  Validates a regular expression pattern.
	 *
	 *  Performs validation when a rule only contains
	 *  a pattern property but is not declared as a string type.
	 *
	 *  @param rule The validation rule.
	 *  @param value The value of the field on the source object.
	 *  @param callback The callback function.
	 *  @param source The source object being validated.
	 *  @param options The validation options.
	 *  @param options.messages The validation messages.
	 */
	function pattern(rule, value, callback, source, options) {
	  var errors = [];
	  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
	  if (validate) {
	    if ((0, _util.isEmptyValue)(value, 'string') && !rule.required) {
	      return callback();
	    }
	    _rule2['default'].required(rule, value, source, errors, options);
	    if (!(0, _util.isEmptyValue)(value, 'string')) {
	      _rule2['default'].pattern(rule, value, source, errors, options);
	    }
	  }
	  callback(errors);
	}
	
	exports['default'] = pattern;
	module.exports = exports['default'];

/***/ }),
/* 310 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _rule = __webpack_require__(23);
	
	var _rule2 = _interopRequireDefault(_rule);
	
	var _util = __webpack_require__(19);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	/**
	 *  Validates the regular expression type.
	 *
	 *  @param rule The validation rule.
	 *  @param value The value of the field on the source object.
	 *  @param callback The callback function.
	 *  @param source The source object being validated.
	 *  @param options The validation options.
	 *  @param options.messages The validation messages.
	 */
	function regexp(rule, value, callback, source, options) {
	  var errors = [];
	  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
	  if (validate) {
	    if ((0, _util.isEmptyValue)(value) && !rule.required) {
	      return callback();
	    }
	    _rule2['default'].required(rule, value, source, errors, options);
	    if (!(0, _util.isEmptyValue)(value)) {
	      _rule2['default'].type(rule, value, source, errors, options);
	    }
	  }
	  callback(errors);
	}
	
	exports['default'] = regexp;
	module.exports = exports['default'];

/***/ }),
/* 311 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _typeof2 = __webpack_require__(21);
	
	var _typeof3 = _interopRequireDefault(_typeof2);
	
	var _rule = __webpack_require__(23);
	
	var _rule2 = _interopRequireDefault(_rule);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function required(rule, value, callback, source, options) {
	  var errors = [];
	  var type = Array.isArray(value) ? 'array' : typeof value === 'undefined' ? 'undefined' : (0, _typeof3['default'])(value);
	  _rule2['default'].required(rule, value, source, errors, options, type);
	  callback(errors);
	}
	
	exports['default'] = required;
	module.exports = exports['default'];

/***/ }),
/* 312 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _rule = __webpack_require__(23);
	
	var _rule2 = _interopRequireDefault(_rule);
	
	var _util = __webpack_require__(19);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	/**
	 *  Performs validation for string types.
	 *
	 *  @param rule The validation rule.
	 *  @param value The value of the field on the source object.
	 *  @param callback The callback function.
	 *  @param source The source object being validated.
	 *  @param options The validation options.
	 *  @param options.messages The validation messages.
	 */
	function string(rule, value, callback, source, options) {
	  var errors = [];
	  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
	  if (validate) {
	    if ((0, _util.isEmptyValue)(value, 'string') && !rule.required) {
	      return callback();
	    }
	    _rule2['default'].required(rule, value, source, errors, options, 'string');
	    if (!(0, _util.isEmptyValue)(value, 'string')) {
	      _rule2['default'].type(rule, value, source, errors, options);
	      _rule2['default'].range(rule, value, source, errors, options);
	      _rule2['default'].pattern(rule, value, source, errors, options);
	      if (rule.whitespace === true) {
	        _rule2['default'].whitespace(rule, value, source, errors, options);
	      }
	    }
	  }
	  callback(errors);
	}
	
	exports['default'] = string;
	module.exports = exports['default'];

/***/ }),
/* 313 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _rule = __webpack_require__(23);
	
	var _rule2 = _interopRequireDefault(_rule);
	
	var _util = __webpack_require__(19);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function type(rule, value, callback, source, options) {
	  var ruleType = rule.type;
	  var errors = [];
	  var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
	  if (validate) {
	    if ((0, _util.isEmptyValue)(value, ruleType) && !rule.required) {
	      return callback();
	    }
	    _rule2['default'].required(rule, value, source, errors, options, ruleType);
	    if (!(0, _util.isEmptyValue)(value, ruleType)) {
	      _rule2['default'].type(rule, value, source, errors, options);
	    }
	  }
	  callback(errors);
	}
	
	exports['default'] = type;
	module.exports = exports['default'];

/***/ }),
/* 314 */
/***/ (function(module, exports) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	var animation = void 0;
	function isCssAnimationSupported() {
	    if (animation !== undefined) {
	        return animation;
	    }
	    var domPrefixes = 'Webkit Moz O ms Khtml'.split(' ');
	    var elm = document.createElement('div');
	    if (elm.style.animationName !== undefined) {
	        animation = true;
	    }
	    if (animation !== undefined) {
	        for (var i = 0; i < domPrefixes.length; i++) {
	            if (elm.style[domPrefixes[i] + 'AnimationName'] !== undefined) {
	                animation = true;
	                break;
	            }
	        }
	    }
	    animation = animation || false;
	    return animation;
	}
	exports['default'] = isCssAnimationSupported;
	module.exports = exports['default'];

/***/ }),
/* 315 */
/***/ (function(module, exports) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	exports['default'] = isFlexSupported;
	function isFlexSupported() {
	    if (typeof window !== 'undefined' && window.document && window.document.documentElement) {
	        var documentElement = window.document.documentElement;
	
	        return 'flex' in documentElement.style || 'webkitFlex' in documentElement.style || 'Flex' in documentElement.style || 'msFlex' in documentElement.style;
	    }
	    return false;
	}
	module.exports = exports['default'];

/***/ }),
/* 316 */
/***/ (function(module, exports) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	exports['default'] = triggerEvent;
	function triggerEvent(el, type) {
	    if ('createEvent' in document) {
	        // modern browsers, IE9+
	        var e = document.createEvent('HTMLEvents');
	        e.initEvent(type, false, true);
	        el.dispatchEvent(e);
	    }
	}
	module.exports = exports['default'];

/***/ }),
/* 317 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _reactDom = __webpack_require__(10);
	
	var _reactDom2 = _interopRequireDefault(_reactDom);
	
	var _rcAnimate = __webpack_require__(22);
	
	var _rcAnimate2 = _interopRequireDefault(_rcAnimate);
	
	var _icon = __webpack_require__(16);
	
	var _icon2 = _interopRequireDefault(_icon);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function noop() {}
	
	var Alert = function (_React$Component) {
	    (0, _inherits3['default'])(Alert, _React$Component);
	
	    function Alert(props) {
	        (0, _classCallCheck3['default'])(this, Alert);
	
	        var _this = (0, _possibleConstructorReturn3['default'])(this, (Alert.__proto__ || Object.getPrototypeOf(Alert)).call(this, props));
	
	        _this.handleClose = function (e) {
	            e.preventDefault();
	            var dom = _reactDom2['default'].findDOMNode(_this);
	            dom.style.height = dom.offsetHeight + 'px';
	            // Magic code
	            // 重复一次后才能正确设置 height
	            dom.style.height = dom.offsetHeight + 'px';
	            _this.setState({
	                closing: false
	            });
	            (_this.props.onClose || noop)(e);
	        };
	        _this.animationEnd = function () {
	            _this.setState({
	                closed: true,
	                closing: true
	            });
	        };
	        _this.state = {
	            closing: true,
	            closed: false
	        };
	        return _this;
	    }
	
	    (0, _createClass3['default'])(Alert, [{
	        key: 'render',
	        value: function render() {
	            var _classNames;
	
	            var _props = this.props,
	                closable = _props.closable,
	                description = _props.description,
	                type = _props.type,
	                _props$prefixCls = _props.prefixCls,
	                prefixCls = _props$prefixCls === undefined ? 'ant-alert' : _props$prefixCls,
	                message = _props.message,
	                closeText = _props.closeText,
	                showIcon = _props.showIcon,
	                banner = _props.banner,
	                _props$className = _props.className,
	                className = _props$className === undefined ? '' : _props$className,
	                style = _props.style;
	            // banner模式默认有 Icon
	
	            showIcon = banner && showIcon === undefined ? true : showIcon;
	            // banner模式默认为警告
	            type = banner && type === undefined ? 'warning' : type || 'info';
	            var iconType = '';
	            switch (type) {
	                case 'success':
	                    iconType = 'check-circle';
	                    break;
	                case 'info':
	                    iconType = 'info-circle';
	                    break;
	                case 'error':
	                    iconType = 'cross-circle';
	                    break;
	                case 'warning':
	                    iconType = 'exclamation-circle';
	                    break;
	                default:
	                    iconType = 'default';
	            }
	            // use outline icon in alert with description
	            if (!!description) {
	                iconType += '-o';
	            }
	            var alertCls = (0, _classnames2['default'])(prefixCls, (_classNames = {}, (0, _defineProperty3['default'])(_classNames, prefixCls + '-' + type, true), (0, _defineProperty3['default'])(_classNames, prefixCls + '-close', !this.state.closing), (0, _defineProperty3['default'])(_classNames, prefixCls + '-with-description', !!description), (0, _defineProperty3['default'])(_classNames, prefixCls + '-no-icon', !showIcon), (0, _defineProperty3['default'])(_classNames, prefixCls + '-banner', !!banner), _classNames), className);
	            // closeable when closeText is assigned
	            if (closeText) {
	                closable = true;
	            }
	            var closeIcon = closable ? _react2['default'].createElement(
	                'a',
	                { onClick: this.handleClose, className: prefixCls + '-close-icon' },
	                closeText || _react2['default'].createElement(_icon2['default'], { type: 'cross' })
	            ) : null;
	            return this.state.closed ? null : _react2['default'].createElement(
	                _rcAnimate2['default'],
	                { component: '', showProp: 'data-show', transitionName: prefixCls + '-slide-up', onEnd: this.animationEnd },
	                _react2['default'].createElement(
	                    'div',
	                    { 'data-show': this.state.closing, className: alertCls, style: style },
	                    showIcon ? _react2['default'].createElement(_icon2['default'], { className: prefixCls + '-icon', type: iconType }) : null,
	                    _react2['default'].createElement(
	                        'span',
	                        { className: prefixCls + '-message' },
	                        message
	                    ),
	                    _react2['default'].createElement(
	                        'span',
	                        { className: prefixCls + '-description' },
	                        description
	                    ),
	                    closeIcon
	                )
	            );
	        }
	    }]);
	    return Alert;
	}(_react2['default'].Component);
	
	exports['default'] = Alert;
	module.exports = exports['default'];

/***/ }),
/* 318 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _reactDom = __webpack_require__(10);
	
	var _reactDom2 = _interopRequireDefault(_reactDom);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _addEventListener = __webpack_require__(34);
	
	var _addEventListener2 = _interopRequireDefault(_addEventListener);
	
	var _affix = __webpack_require__(159);
	
	var _affix2 = _interopRequireDefault(_affix);
	
	var _getScroll = __webpack_require__(100);
	
	var _getScroll2 = _interopRequireDefault(_getScroll);
	
	var _getRequestAnimationFrame = __webpack_require__(80);
	
	var _getRequestAnimationFrame2 = _interopRequireDefault(_getRequestAnimationFrame);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function getDefaultTarget() {
	    return window;
	}
	function getOffsetTop(element) {
	    if (!element) {
	        return 0;
	    }
	    if (!element.getClientRects().length) {
	        return 0;
	    }
	    var rect = element.getBoundingClientRect();
	    if (rect.width || rect.height) {
	        var doc = element.ownerDocument;
	        var docElem = doc.documentElement;
	        return rect.top - docElem.clientTop;
	    }
	    return rect.top;
	}
	function easeInOutCubic(t, b, c, d) {
	    var cc = c - b;
	    t /= d / 2;
	    if (t < 1) {
	        return cc / 2 * t * t * t + b;
	    }
	    return cc / 2 * ((t -= 2) * t * t + 2) + b;
	}
	var reqAnimFrame = (0, _getRequestAnimationFrame2['default'])();
	var sharpMatcherRegx = /#([^#]+)$/;
	function scrollTo(href) {
	    var offsetTop = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
	    var target = arguments[2];
	    var callback = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : function () {};
	
	    var scrollTop = (0, _getScroll2['default'])(target(), true);
	    var sharpLinkMatch = sharpMatcherRegx.exec(href);
	    if (!sharpLinkMatch) {
	        return;
	    }
	    var targetElement = document.getElementById(sharpLinkMatch[1]);
	    if (!targetElement) {
	        return;
	    }
	    var eleOffsetTop = getOffsetTop(targetElement);
	    var targetScrollTop = scrollTop + eleOffsetTop - offsetTop;
	    var startTime = Date.now();
	    var frameFunc = function frameFunc() {
	        var timestamp = Date.now();
	        var time = timestamp - startTime;
	        window.scrollTo(window.pageXOffset, easeInOutCubic(time, scrollTop, targetScrollTop, 450));
	        if (time < 450) {
	            reqAnimFrame(frameFunc);
	        } else {
	            callback();
	        }
	    };
	    reqAnimFrame(frameFunc);
	    history.pushState(null, '', href);
	}
	
	var Anchor = function (_React$Component) {
	    (0, _inherits3['default'])(Anchor, _React$Component);
	
	    function Anchor(props) {
	        (0, _classCallCheck3['default'])(this, Anchor);
	
	        var _this = (0, _possibleConstructorReturn3['default'])(this, (Anchor.__proto__ || Object.getPrototypeOf(Anchor)).call(this, props));
	
	        _this.handleScroll = function () {
	            if (_this.animating) {
	                return;
	            }
	            var _this$props = _this.props,
	                offsetTop = _this$props.offsetTop,
	                bounds = _this$props.bounds;
	
	            _this.setState({
	                activeLink: _this.getCurrentAnchor(offsetTop, bounds)
	            });
	        };
	        _this.handleScrollTo = function (link) {
	            var _this$props2 = _this.props,
	                offsetTop = _this$props2.offsetTop,
	                _this$props2$target = _this$props2.target,
	                target = _this$props2$target === undefined ? getDefaultTarget : _this$props2$target;
	
	            _this.animating = true;
	            _this.setState({ activeLink: link });
	            scrollTo(link, offsetTop, target, function () {
	                _this.animating = false;
	            });
	        };
	        _this.updateInk = function () {
	            if (typeof document === 'undefined') {
	                return;
	            }
	            var prefixCls = _this.props.prefixCls;
	
	            var linkNode = _reactDom2['default'].findDOMNode(_this).getElementsByClassName(prefixCls + '-link-title-active')[0];
	            if (linkNode) {
	                _this.refs.ink.style.top = linkNode.offsetTop + linkNode.clientHeight / 2 - 4.5 + 'px';
	            }
	        };
	        _this.state = {
	            activeLink: null
	        };
	        _this.links = [];
	        return _this;
	    }
	
	    (0, _createClass3['default'])(Anchor, [{
	        key: 'getChildContext',
	        value: function getChildContext() {
	            var _this2 = this;
	
	            return {
	                antAnchor: {
	                    registerLink: function registerLink(link) {
	                        if (!_this2.links.includes(link)) {
	                            _this2.links.push(link);
	                        }
	                    },
	                    unregisterLink: function unregisterLink(link) {
	                        var index = _this2.links.indexOf(link);
	                        if (index !== -1) {
	                            _this2.links.splice(index, 1);
	                        }
	                    },
	                    activeLink: this.state.activeLink,
	                    scrollTo: this.handleScrollTo
	                }
	            };
	        }
	    }, {
	        key: 'componentDidMount',
	        value: function componentDidMount() {
	            var getTarget = this.props.target || getDefaultTarget;
	            this.scrollEvent = (0, _addEventListener2['default'])(getTarget(), 'scroll', this.handleScroll);
	            this.handleScroll();
	        }
	    }, {
	        key: 'componentWillUnmount',
	        value: function componentWillUnmount() {
	            if (this.scrollEvent) {
	                this.scrollEvent.remove();
	            }
	        }
	    }, {
	        key: 'componentDidUpdate',
	        value: function componentDidUpdate() {
	            this.updateInk();
	        }
	    }, {
	        key: 'getCurrentAnchor',
	        value: function getCurrentAnchor() {
	            var offsetTop = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
	            var bounds = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 5;
	
	            var activeLink = '';
	            if (typeof document === 'undefined') {
	                return activeLink;
	            }
	            var linkSections = [];
	            this.links.forEach(function (link) {
	                var sharpLinkMatch = sharpMatcherRegx.exec(link.toString());
	                if (!sharpLinkMatch) {
	                    return;
	                }
	                var target = document.getElementById(sharpLinkMatch[1]);
	                if (target && getOffsetTop(target) < offsetTop + bounds) {
	                    var top = getOffsetTop(target);
	                    linkSections.push({
	                        link: link,
	                        top: top
	                    });
	                }
	            });
	            if (linkSections.length) {
	                var maxSection = linkSections.reduce(function (prev, curr) {
	                    return curr.top > prev.top ? curr : prev;
	                });
	                return maxSection.link;
	            }
	            return '';
	        }
	    }, {
	        key: 'render',
	        value: function render() {
	            var _props = this.props,
	                prefixCls = _props.prefixCls,
	                _props$className = _props.className,
	                className = _props$className === undefined ? '' : _props$className,
	                style = _props.style,
	                offsetTop = _props.offsetTop,
	                affix = _props.affix,
	                showInkInFixed = _props.showInkInFixed,
	                children = _props.children;
	            var activeLink = this.state.activeLink;
	
	            var inkClass = (0, _classnames2['default'])(prefixCls + '-ink-ball', {
	                visible: activeLink
	            });
	            var wrapperClass = (0, _classnames2['default'])(className, prefixCls + '-wrapper');
	            var anchorClass = (0, _classnames2['default'])(prefixCls, {
	                'fixed': !affix && !showInkInFixed
	            });
	            var anchorContent = _react2['default'].createElement(
	                'div',
	                { className: wrapperClass, style: style },
	                _react2['default'].createElement(
	                    'div',
	                    { className: anchorClass },
	                    _react2['default'].createElement(
	                        'div',
	                        { className: prefixCls + '-ink' },
	                        _react2['default'].createElement('span', { className: inkClass, ref: 'ink' })
	                    ),
	                    children
	                )
	            );
	            return !affix ? anchorContent : _react2['default'].createElement(
	                _affix2['default'],
	                { offsetTop: offsetTop },
	                anchorContent
	            );
	        }
	    }]);
	    return Anchor;
	}(_react2['default'].Component);
	
	exports['default'] = Anchor;
	
	Anchor.defaultProps = {
	    prefixCls: 'ant-anchor',
	    affix: true,
	    showInkInFixed: false
	};
	Anchor.childContextTypes = {
	    antAnchor: _propTypes2['default'].object
	};
	module.exports = exports['default'];

/***/ }),
/* 319 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var AnchorLink = function (_React$Component) {
	    (0, _inherits3['default'])(AnchorLink, _React$Component);
	
	    function AnchorLink() {
	        (0, _classCallCheck3['default'])(this, AnchorLink);
	
	        var _this = (0, _possibleConstructorReturn3['default'])(this, (AnchorLink.__proto__ || Object.getPrototypeOf(AnchorLink)).apply(this, arguments));
	
	        _this.handleClick = function () {
	            _this.context.antAnchor.scrollTo(_this.props.href);
	        };
	        return _this;
	    }
	
	    (0, _createClass3['default'])(AnchorLink, [{
	        key: 'componentDidMount',
	        value: function componentDidMount() {
	            this.context.antAnchor.registerLink(this.props.href);
	        }
	    }, {
	        key: 'componentWillUnmount',
	        value: function componentWillUnmount() {
	            this.context.antAnchor.unregisterLink(this.props.href);
	        }
	    }, {
	        key: 'render',
	        value: function render() {
	            var _props = this.props,
	                prefixCls = _props.prefixCls,
	                href = _props.href,
	                title = _props.title,
	                children = _props.children;
	
	            var active = this.context.antAnchor.activeLink === href;
	            var wrapperClassName = (0, _classnames2['default'])(prefixCls + '-link', (0, _defineProperty3['default'])({}, prefixCls + '-link-active', active));
	            var titleClassName = (0, _classnames2['default'])(prefixCls + '-link-title', (0, _defineProperty3['default'])({}, prefixCls + '-link-title-active', active));
	            return _react2['default'].createElement(
	                'div',
	                { className: wrapperClassName },
	                _react2['default'].createElement(
	                    'a',
	                    { className: titleClassName, href: href, title: typeof title === 'string' ? title : '', onClick: this.handleClick },
	                    title
	                ),
	                children
	            );
	        }
	    }]);
	    return AnchorLink;
	}(_react2['default'].Component);
	
	exports['default'] = AnchorLink;
	
	AnchorLink.defaultProps = {
	    prefixCls: 'ant-anchor',
	    href: '#'
	};
	AnchorLink.contextTypes = {
	    antAnchor: _propTypes2['default'].object
	};
	module.exports = exports['default'];

/***/ }),
/* 320 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _Anchor = __webpack_require__(318);
	
	var _Anchor2 = _interopRequireDefault(_Anchor);
	
	var _AnchorLink = __webpack_require__(319);
	
	var _AnchorLink2 = _interopRequireDefault(_AnchorLink);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	_Anchor2['default'].Link = _AnchorLink2['default'];
	exports['default'] = _Anchor2['default'];
	module.exports = exports['default'];

/***/ }),
/* 321 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _reactDom = __webpack_require__(10);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var InputElement = function (_React$Component) {
	    (0, _inherits3['default'])(InputElement, _React$Component);
	
	    function InputElement() {
	        (0, _classCallCheck3['default'])(this, InputElement);
	
	        var _this = (0, _possibleConstructorReturn3['default'])(this, (InputElement.__proto__ || Object.getPrototypeOf(InputElement)).apply(this, arguments));
	
	        _this.focus = function () {
	            _this.ele.focus ? _this.ele.focus() : (0, _reactDom.findDOMNode)(_this.ele).focus();
	        };
	        _this.blur = function () {
	            _this.ele.blur ? _this.ele.blur() : (0, _reactDom.findDOMNode)(_this.ele).blur();
	        };
	        _this.saveRef = function (ele) {
	            _this.ele = ele;
	            var childRef = _this.props.children.ref;
	            if (typeof childRef === 'function') {
	                childRef(ele);
	            }
	        };
	        return _this;
	    }
	
	    (0, _createClass3['default'])(InputElement, [{
	        key: 'render',
	        value: function render() {
	            return _react2['default'].cloneElement(this.props.children, (0, _extends3['default'])({}, this.props, { ref: this.saveRef }), null);
	        }
	    }]);
	    return InputElement;
	}(_react2['default'].Component);
	
	exports['default'] = InputElement;
	module.exports = exports['default'];

/***/ }),
/* 322 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _typeof2 = __webpack_require__(21);
	
	var _typeof3 = _interopRequireDefault(_typeof2);
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _rcSelect = __webpack_require__(267);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _select = __webpack_require__(68);
	
	var _select2 = _interopRequireDefault(_select);
	
	var _input = __webpack_require__(81);
	
	var _input2 = _interopRequireDefault(_input);
	
	var _InputElement = __webpack_require__(321);
	
	var _InputElement2 = _interopRequireDefault(_InputElement);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function isSelectOptionOrSelectOptGroup(child) {
	    return child && child.type && (child.type.isSelectOption || child.type.isSelectOptGroup);
	}
	
	var AutoComplete = function (_React$Component) {
	    (0, _inherits3['default'])(AutoComplete, _React$Component);
	
	    function AutoComplete() {
	        (0, _classCallCheck3['default'])(this, AutoComplete);
	
	        var _this = (0, _possibleConstructorReturn3['default'])(this, (AutoComplete.__proto__ || Object.getPrototypeOf(AutoComplete)).apply(this, arguments));
	
	        _this.getInputElement = function () {
	            var children = _this.props.children;
	
	            var element = children && _react2['default'].isValidElement(children) && children.type !== _rcSelect.Option ? _react2['default'].Children.only(_this.props.children) : _react2['default'].createElement(_input2['default'], null);
	            var elementProps = (0, _extends3['default'])({}, element.props);
	            // https://github.com/ant-design/ant-design/pull/7742
	            delete elementProps.children;
	            return _react2['default'].createElement(
	                _InputElement2['default'],
	                elementProps,
	                element
	            );
	        };
	        return _this;
	    }
	
	    (0, _createClass3['default'])(AutoComplete, [{
	        key: 'render',
	        value: function render() {
	            var _classNames;
	
	            var _props = this.props,
	                size = _props.size,
	                _props$className = _props.className,
	                className = _props$className === undefined ? '' : _props$className,
	                notFoundContent = _props.notFoundContent,
	                prefixCls = _props.prefixCls,
	                optionLabelProp = _props.optionLabelProp,
	                dataSource = _props.dataSource,
	                children = _props.children;
	
	            var cls = (0, _classnames2['default'])((_classNames = {}, (0, _defineProperty3['default'])(_classNames, prefixCls + '-lg', size === 'large'), (0, _defineProperty3['default'])(_classNames, prefixCls + '-sm', size === 'small'), (0, _defineProperty3['default'])(_classNames, className, !!className), (0, _defineProperty3['default'])(_classNames, prefixCls + '-show-search', true), (0, _defineProperty3['default'])(_classNames, prefixCls + '-auto-complete', true), _classNames));
	            var options = void 0;
	            var childArray = _react2['default'].Children.toArray(children);
	            if (childArray.length && isSelectOptionOrSelectOptGroup(childArray[0])) {
	                options = children;
	            } else {
	                options = dataSource ? dataSource.map(function (item) {
	                    if (_react2['default'].isValidElement(item)) {
	                        return item;
	                    }
	                    switch (typeof item === 'undefined' ? 'undefined' : (0, _typeof3['default'])(item)) {
	                        case 'string':
	                            return _react2['default'].createElement(
	                                _rcSelect.Option,
	                                { key: item },
	                                item
	                            );
	                        case 'object':
	                            return _react2['default'].createElement(
	                                _rcSelect.Option,
	                                { key: item.value },
	                                item.text
	                            );
	                        default:
	                            throw new Error('AutoComplete[dataSource] only supports type `string[] | Object[]`.');
	                    }
	                }) : [];
	            }
	            return _react2['default'].createElement(
	                _select2['default'],
	                (0, _extends3['default'])({}, this.props, { className: cls, mode: 'combobox', optionLabelProp: optionLabelProp, getInputElement: this.getInputElement, notFoundContent: notFoundContent }),
	                options
	            );
	        }
	    }]);
	    return AutoComplete;
	}(_react2['default'].Component);
	
	exports['default'] = AutoComplete;
	
	AutoComplete.Option = _rcSelect.Option;
	AutoComplete.OptGroup = _rcSelect.OptGroup;
	AutoComplete.defaultProps = {
	    prefixCls: 'ant-select',
	    transitionName: 'slide-up',
	    optionLabelProp: 'children',
	    choiceTransitionName: 'zoom',
	    showSearch: false,
	    filterOption: false
	};
	module.exports = exports['default'];

/***/ }),
/* 323 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _reactDom = __webpack_require__(10);
	
	var _reactDom2 = _interopRequireDefault(_reactDom);
	
	var _icon = __webpack_require__(16);
	
	var _icon2 = _interopRequireDefault(_icon);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var __rest = undefined && undefined.__rest || function (s, e) {
	    var t = {};
	    for (var p in s) {
	        if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
	    }if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	        if (e.indexOf(p[i]) < 0) t[p[i]] = s[p[i]];
	    }return t;
	};
	
	var Avatar = function (_React$Component) {
	    (0, _inherits3['default'])(Avatar, _React$Component);
	
	    function Avatar(props) {
	        (0, _classCallCheck3['default'])(this, Avatar);
	
	        var _this = (0, _possibleConstructorReturn3['default'])(this, (Avatar.__proto__ || Object.getPrototypeOf(Avatar)).call(this, props));
	
	        _this.setScale = function () {
	            var childrenNode = _this.avatarChildren;
	            if (childrenNode) {
	                var childrenWidth = childrenNode.offsetWidth;
	                var avatarWidth = _reactDom2['default'].findDOMNode(_this).getBoundingClientRect().width;
	                // add 4px gap for each side to get better performance
	                if (avatarWidth - 8 < childrenWidth) {
	                    _this.setState({
	                        scale: (avatarWidth - 8) / childrenWidth
	                    });
	                } else {
	                    _this.setState({
	                        scale: 1
	                    });
	                }
	            }
	        };
	        _this.handleImgLoadError = function () {
	            return _this.setState({ isImgExist: false });
	        };
	        _this.state = {
	            scale: 1,
	            isImgExist: true
	        };
	        return _this;
	    }
	
	    (0, _createClass3['default'])(Avatar, [{
	        key: 'componentDidMount',
	        value: function componentDidMount() {
	            this.setScale();
	        }
	    }, {
	        key: 'componentDidUpdate',
	        value: function componentDidUpdate(prevProps, prevState) {
	            if (prevProps.children !== this.props.children || prevState.scale !== this.state.scale && this.state.scale === 1) {
	                this.setScale();
	            }
	        }
	    }, {
	        key: 'render',
	        value: function render() {
	            var _classNames,
	                _classNames2,
	                _this2 = this;
	
	            var _a = this.props,
	                prefixCls = _a.prefixCls,
	                shape = _a.shape,
	                size = _a.size,
	                src = _a.src,
	                icon = _a.icon,
	                className = _a.className,
	                others = __rest(_a, ["prefixCls", "shape", "size", "src", "icon", "className"]);
	            var sizeCls = (0, _classnames2['default'])((_classNames = {}, (0, _defineProperty3['default'])(_classNames, prefixCls + '-lg', size === 'large'), (0, _defineProperty3['default'])(_classNames, prefixCls + '-sm', size === 'small'), _classNames));
	            var classString = (0, _classnames2['default'])(prefixCls, className, sizeCls, (_classNames2 = {}, (0, _defineProperty3['default'])(_classNames2, prefixCls + '-' + shape, shape), (0, _defineProperty3['default'])(_classNames2, prefixCls + '-image', src), (0, _defineProperty3['default'])(_classNames2, prefixCls + '-icon', icon), _classNames2));
	            var children = this.props.children;
	            if (src && this.state.isImgExist) {
	                children = _react2['default'].createElement('img', { src: src, onError: this.handleImgLoadError });
	            } else if (icon) {
	                children = _react2['default'].createElement(_icon2['default'], { type: icon });
	            } else {
	                var childrenNode = this.avatarChildren;
	                if (childrenNode || this.state.scale !== 1) {
	                    var childrenStyle = {
	                        msTransform: 'scale(' + this.state.scale + ')',
	                        WebkitTransform: 'scale(' + this.state.scale + ')',
	                        transform: 'scale(' + this.state.scale + ')',
	                        position: 'absolute',
	                        display: 'inline-block',
	                        left: 'calc(50% - ' + Math.round(childrenNode.offsetWidth / 2) + 'px)'
	                    };
	                    children = _react2['default'].createElement(
	                        'span',
	                        { className: prefixCls + '-string', ref: function ref(span) {
	                                return _this2.avatarChildren = span;
	                            }, style: childrenStyle },
	                        children
	                    );
	                } else {
	                    children = _react2['default'].createElement(
	                        'span',
	                        { className: prefixCls + '-string', ref: function ref(span) {
	                                return _this2.avatarChildren = span;
	                            } },
	                        children
	                    );
	                }
	            }
	            return _react2['default'].createElement(
	                'span',
	                (0, _extends3['default'])({}, others, { className: classString }),
	                children
	            );
	        }
	    }]);
	    return Avatar;
	}(_react2['default'].Component);
	
	exports['default'] = Avatar;
	
	Avatar.defaultProps = {
	    prefixCls: 'ant-avatar',
	    shape: 'circle',
	    size: 'default'
	};
	module.exports = exports['default'];

/***/ }),
/* 324 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _rcAnimate = __webpack_require__(22);
	
	var _rcAnimate2 = _interopRequireDefault(_rcAnimate);
	
	var _addEventListener = __webpack_require__(34);
	
	var _addEventListener2 = _interopRequireDefault(_addEventListener);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _omit = __webpack_require__(28);
	
	var _omit2 = _interopRequireDefault(_omit);
	
	var _icon = __webpack_require__(16);
	
	var _icon2 = _interopRequireDefault(_icon);
	
	var _getScroll = __webpack_require__(100);
	
	var _getScroll2 = _interopRequireDefault(_getScroll);
	
	var _getRequestAnimationFrame = __webpack_require__(80);
	
	var _getRequestAnimationFrame2 = _interopRequireDefault(_getRequestAnimationFrame);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var reqAnimFrame = (0, _getRequestAnimationFrame2['default'])();
	var easeInOutCubic = function easeInOutCubic(t, b, c, d) {
	    var cc = c - b;
	    t /= d / 2;
	    if (t < 1) {
	        return cc / 2 * t * t * t + b;
	    } else {
	        return cc / 2 * ((t -= 2) * t * t + 2) + b;
	    }
	};
	function noop() {}
	function getDefaultTarget() {
	    return window;
	}
	
	var BackTop = function (_React$Component) {
	    (0, _inherits3['default'])(BackTop, _React$Component);
	
	    function BackTop(props) {
	        (0, _classCallCheck3['default'])(this, BackTop);
	
	        var _this = (0, _possibleConstructorReturn3['default'])(this, (BackTop.__proto__ || Object.getPrototypeOf(BackTop)).call(this, props));
	
	        _this.getCurrentScrollTop = function () {
	            var getTarget = _this.props.target || getDefaultTarget;
	            var targetNode = getTarget();
	            if (targetNode === window) {
	                return window.pageYOffset || document.body.scrollTop || document.documentElement.scrollTop;
	            }
	            return targetNode.scrollTop;
	        };
	        _this.scrollToTop = function (e) {
	            var scrollTop = _this.getCurrentScrollTop();
	            var startTime = Date.now();
	            var frameFunc = function frameFunc() {
	                var timestamp = Date.now();
	                var time = timestamp - startTime;
	                _this.setScrollTop(easeInOutCubic(time, scrollTop, 0, 450));
	                if (time < 450) {
	                    reqAnimFrame(frameFunc);
	                }
	            };
	            reqAnimFrame(frameFunc);
	            (_this.props.onClick || noop)(e);
	        };
	        _this.handleScroll = function () {
	            var _this$props = _this.props,
	                visibilityHeight = _this$props.visibilityHeight,
	                _this$props$target = _this$props.target,
	                target = _this$props$target === undefined ? getDefaultTarget : _this$props$target;
	
	            var scrollTop = (0, _getScroll2['default'])(target(), true);
	            _this.setState({
	                visible: scrollTop > visibilityHeight
	            });
	        };
	        _this.state = {
	            visible: false
	        };
	        return _this;
	    }
	
	    (0, _createClass3['default'])(BackTop, [{
	        key: 'setScrollTop',
	        value: function setScrollTop(value) {
	            var getTarget = this.props.target || getDefaultTarget;
	            var targetNode = getTarget();
	            if (targetNode === window) {
	                document.body.scrollTop = value;
	                document.documentElement.scrollTop = value;
	            } else {
	                targetNode.scrollTop = value;
	            }
	        }
	    }, {
	        key: 'componentDidMount',
	        value: function componentDidMount() {
	            var getTarget = this.props.target || getDefaultTarget;
	            this.scrollEvent = (0, _addEventListener2['default'])(getTarget(), 'scroll', this.handleScroll);
	            this.handleScroll();
	        }
	    }, {
	        key: 'componentWillUnmount',
	        value: function componentWillUnmount() {
	            if (this.scrollEvent) {
	                this.scrollEvent.remove();
	            }
	        }
	    }, {
	        key: 'render',
	        value: function render() {
	            var _props = this.props,
	                _props$prefixCls = _props.prefixCls,
	                prefixCls = _props$prefixCls === undefined ? 'ant-back-top' : _props$prefixCls,
	                _props$className = _props.className,
	                className = _props$className === undefined ? '' : _props$className,
	                children = _props.children;
	
	            var classString = (0, _classnames2['default'])(prefixCls, className);
	            var defaultElement = _react2['default'].createElement(
	                'div',
	                { className: prefixCls + '-content' },
	                _react2['default'].createElement(_icon2['default'], { className: prefixCls + '-icon', type: 'to-top' })
	            );
	            // fix https://fb.me/react-unknown-prop
	            var divProps = (0, _omit2['default'])(this.props, ['prefixCls', 'className', 'children', 'visibilityHeight']);
	            var backTopBtn = this.state.visible ? _react2['default'].createElement(
	                'div',
	                (0, _extends3['default'])({}, divProps, { className: classString, onClick: this.scrollToTop }),
	                children || defaultElement
	            ) : null;
	            return _react2['default'].createElement(
	                _rcAnimate2['default'],
	                { component: '', transitionName: 'fade' },
	                backTopBtn
	            );
	        }
	    }]);
	    return BackTop;
	}(_react2['default'].Component);
	
	exports['default'] = BackTop;
	
	BackTop.defaultProps = {
	    visibilityHeight: 400
	};
	module.exports = exports['default'];

/***/ }),
/* 325 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _omit = __webpack_require__(28);
	
	var _omit2 = _interopRequireDefault(_omit);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function getNumberArray(num) {
	    return num ? num.toString().split('').reverse().map(function (i) {
	        return Number(i);
	    }) : [];
	}
	
	var ScrollNumber = function (_Component) {
	    (0, _inherits3['default'])(ScrollNumber, _Component);
	
	    function ScrollNumber(props) {
	        (0, _classCallCheck3['default'])(this, ScrollNumber);
	
	        var _this = (0, _possibleConstructorReturn3['default'])(this, (ScrollNumber.__proto__ || Object.getPrototypeOf(ScrollNumber)).call(this, props));
	
	        _this.state = {
	            animateStarted: true,
	            count: props.count
	        };
	        return _this;
	    }
	
	    (0, _createClass3['default'])(ScrollNumber, [{
	        key: 'getPositionByNum',
	        value: function getPositionByNum(num, i) {
	            if (this.state.animateStarted) {
	                return 10 + num;
	            }
	            var currentDigit = getNumberArray(this.state.count)[i];
	            var lastDigit = getNumberArray(this.lastCount)[i];
	            // 同方向则在同一侧切换数字
	            if (this.state.count > this.lastCount) {
	                if (currentDigit >= lastDigit) {
	                    return 10 + num;
	                }
	                return 20 + num;
	            }
	            if (currentDigit <= lastDigit) {
	                return 10 + num;
	            }
	            return num;
	        }
	    }, {
	        key: 'componentWillReceiveProps',
	        value: function componentWillReceiveProps(nextProps) {
	            var _this2 = this;
	
	            if ('count' in nextProps) {
	                if (this.state.count === nextProps.count) {
	                    return;
	                }
	                this.lastCount = this.state.count;
	                // 复原数字初始位置
	                this.setState({
	                    animateStarted: true
	                }, function () {
	                    // 等待数字位置复原完毕
	                    // 开始设置完整的数字
	                    setTimeout(function () {
	                        _this2.setState({
	                            animateStarted: false,
	                            count: nextProps.count
	                        }, function () {
	                            var onAnimated = _this2.props.onAnimated;
	                            if (onAnimated) {
	                                onAnimated();
	                            }
	                        });
	                    }, 5);
	                });
	            }
	        }
	    }, {
	        key: 'renderNumberList',
	        value: function renderNumberList(position) {
	            var childrenToReturn = [];
	            for (var i = 0; i < 30; i++) {
	                var currentClassName = position === i ? 'current' : '';
	                childrenToReturn.push(_react2['default'].createElement(
	                    'p',
	                    { key: i.toString(), className: currentClassName },
	                    i % 10
	                ));
	            }
	            return childrenToReturn;
	        }
	    }, {
	        key: 'renderCurrentNumber',
	        value: function renderCurrentNumber(num, i) {
	            var position = this.getPositionByNum(num, i);
	            var removeTransition = this.state.animateStarted || getNumberArray(this.lastCount)[i] === undefined;
	            return (0, _react.createElement)('span', {
	                className: this.props.prefixCls + '-only',
	                style: {
	                    transition: removeTransition && 'none',
	                    msTransform: 'translateY(' + -position * 100 + '%)',
	                    WebkitTransform: 'translateY(' + -position * 100 + '%)',
	                    transform: 'translateY(' + -position * 100 + '%)'
	                },
	                key: i
	            }, this.renderNumberList(position));
	        }
	    }, {
	        key: 'renderNumberElement',
	        value: function renderNumberElement() {
	            var _this3 = this;
	
	            var state = this.state;
	            if (!state.count || isNaN(state.count)) {
	                return state.count;
	            }
	            return getNumberArray(state.count).map(function (num, i) {
	                return _this3.renderCurrentNumber(num, i);
	            }).reverse();
	        }
	    }, {
	        key: 'render',
	        value: function render() {
	            var _props = this.props,
	                prefixCls = _props.prefixCls,
	                className = _props.className,
	                style = _props.style,
	                title = _props.title,
	                _props$component = _props.component,
	                component = _props$component === undefined ? 'sup' : _props$component;
	            // fix https://fb.me/react-unknown-prop
	
	            var restProps = (0, _omit2['default'])(this.props, ['count', 'onAnimated', 'component', 'prefixCls']);
	            var newProps = (0, _extends3['default'])({}, restProps, { className: (0, _classnames2['default'])(prefixCls, className), title: title });
	            // allow specify the border
	            // mock border-color by box-shadow for compatible with old usage:
	            // <Badge count={4} style={{ backgroundColor: '#fff', color: '#999', borderColor: '#d9d9d9' }} />
	            if (style && style.borderColor) {
	                newProps.style.boxShadow = '0 0 0 1px ' + style.borderColor + ' inset';
	            }
	            return (0, _react.createElement)(component, newProps, this.renderNumberElement());
	        }
	    }]);
	    return ScrollNumber;
	}(_react.Component);
	
	exports['default'] = ScrollNumber;
	
	ScrollNumber.defaultProps = {
	    prefixCls: 'ant-scroll-number',
	    count: null,
	    onAnimated: function onAnimated() {}
	};
	module.exports = exports['default'];

/***/ }),
/* 326 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _rcAnimate = __webpack_require__(22);
	
	var _rcAnimate2 = _interopRequireDefault(_rcAnimate);
	
	var _ScrollNumber = __webpack_require__(325);
	
	var _ScrollNumber2 = _interopRequireDefault(_ScrollNumber);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _warning = __webpack_require__(24);
	
	var _warning2 = _interopRequireDefault(_warning);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var __rest = undefined && undefined.__rest || function (s, e) {
	    var t = {};
	    for (var p in s) {
	        if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
	    }if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	        if (e.indexOf(p[i]) < 0) t[p[i]] = s[p[i]];
	    }return t;
	};
	
	var Badge = function (_React$Component) {
	    (0, _inherits3['default'])(Badge, _React$Component);
	
	    function Badge() {
	        (0, _classCallCheck3['default'])(this, Badge);
	        return (0, _possibleConstructorReturn3['default'])(this, (Badge.__proto__ || Object.getPrototypeOf(Badge)).apply(this, arguments));
	    }
	
	    (0, _createClass3['default'])(Badge, [{
	        key: 'render',
	        value: function render() {
	            var _classNames, _classNames2;
	
	            var _a = this.props,
	                count = _a.count,
	                showZero = _a.showZero,
	                prefixCls = _a.prefixCls,
	                scrollNumberPrefixCls = _a.scrollNumberPrefixCls,
	                overflowCount = _a.overflowCount,
	                className = _a.className,
	                style = _a.style,
	                children = _a.children,
	                dot = _a.dot,
	                status = _a.status,
	                text = _a.text,
	                restProps = __rest(_a, ["count", "showZero", "prefixCls", "scrollNumberPrefixCls", "overflowCount", "className", "style", "children", "dot", "status", "text"]);
	            var isDot = dot || status;
	            var displayCount = count > overflowCount ? overflowCount + '+' : count;
	            // dot mode don't need count
	            if (isDot) {
	                displayCount = '';
	            }
	            var isZero = displayCount === '0' || displayCount === 0;
	            var isEmpty = displayCount === null || displayCount === undefined || displayCount === '';
	            var hidden = (isEmpty || isZero && !showZero) && !isDot;
	            var scrollNumberCls = (0, _classnames2['default'])((_classNames = {}, (0, _defineProperty3['default'])(_classNames, prefixCls + '-dot', isDot), (0, _defineProperty3['default'])(_classNames, prefixCls + '-count', !isDot), _classNames));
	            var badgeCls = (0, _classnames2['default'])(className, prefixCls, (_classNames2 = {}, (0, _defineProperty3['default'])(_classNames2, prefixCls + '-status', !!status), (0, _defineProperty3['default'])(_classNames2, prefixCls + '-not-a-wrapper', !children), _classNames2));
	            (0, _warning2['default'])(!(children && status), '`Badge[children]` and `Badge[status]` cannot be used at the same time.');
	            // <Badge status="success" />
	            if (!children && status) {
	                var _classNames3;
	
	                var statusCls = (0, _classnames2['default'])((_classNames3 = {}, (0, _defineProperty3['default'])(_classNames3, prefixCls + '-status-dot', !!status), (0, _defineProperty3['default'])(_classNames3, prefixCls + '-status-' + status, true), _classNames3));
	                return _react2['default'].createElement(
	                    'span',
	                    { className: badgeCls },
	                    _react2['default'].createElement('span', { className: statusCls }),
	                    _react2['default'].createElement(
	                        'span',
	                        { className: prefixCls + '-status-text' },
	                        text
	                    )
	                );
	            }
	            var scrollNumber = hidden ? null : _react2['default'].createElement(_ScrollNumber2['default'], { prefixCls: scrollNumberPrefixCls, 'data-show': !hidden, className: scrollNumberCls, count: displayCount, title: count, style: style });
	            var statusText = hidden || !text ? null : _react2['default'].createElement(
	                'span',
	                { className: prefixCls + '-status-text' },
	                text
	            );
	            return _react2['default'].createElement(
	                'span',
	                (0, _extends3['default'])({}, restProps, { className: badgeCls }),
	                children,
	                _react2['default'].createElement(
	                    _rcAnimate2['default'],
	                    { component: '', showProp: 'data-show', transitionName: children ? prefixCls + '-zoom' : '', transitionAppear: true },
	                    scrollNumber
	                ),
	                statusText
	            );
	        }
	    }]);
	    return Badge;
	}(_react2['default'].Component);
	
	exports['default'] = Badge;
	
	Badge.defaultProps = {
	    prefixCls: 'ant-badge',
	    scrollNumberPrefixCls: 'ant-scroll-number',
	    count: null,
	    showZero: false,
	    dot: false,
	    overflowCount: 99
	};
	Badge.propTypes = {
	    count: _propTypes2['default'].oneOfType([_propTypes2['default'].string, _propTypes2['default'].number]),
	    showZero: _propTypes2['default'].bool,
	    dot: _propTypes2['default'].bool,
	    overflowCount: _propTypes2['default'].number
	};
	module.exports = exports['default'];

/***/ }),
/* 327 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _warning = __webpack_require__(24);
	
	var _warning2 = _interopRequireDefault(_warning);
	
	var _BreadcrumbItem = __webpack_require__(160);
	
	var _BreadcrumbItem2 = _interopRequireDefault(_BreadcrumbItem);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function getBreadcrumbName(route, params) {
	    if (!route.breadcrumbName) {
	        return null;
	    }
	    var paramsKeys = Object.keys(params).join('|');
	    var name = route.breadcrumbName.replace(new RegExp(':(' + paramsKeys + ')', 'g'), function (replacement, key) {
	        return params[key] || replacement;
	    });
	    return name;
	}
	function defaultItemRender(route, params, routes, paths) {
	    var isLastItem = routes.indexOf(route) === routes.length - 1;
	    var name = getBreadcrumbName(route, params);
	    return isLastItem ? _react2['default'].createElement(
	        'span',
	        null,
	        name
	    ) : _react2['default'].createElement(
	        'a',
	        { href: '#/' + paths.join('/') },
	        name
	    );
	}
	
	var Breadcrumb = function (_React$Component) {
	    (0, _inherits3['default'])(Breadcrumb, _React$Component);
	
	    function Breadcrumb() {
	        (0, _classCallCheck3['default'])(this, Breadcrumb);
	        return (0, _possibleConstructorReturn3['default'])(this, (Breadcrumb.__proto__ || Object.getPrototypeOf(Breadcrumb)).apply(this, arguments));
	    }
	
	    (0, _createClass3['default'])(Breadcrumb, [{
	        key: 'componentDidMount',
	        value: function componentDidMount() {
	            var props = this.props;
	            (0, _warning2['default'])(!('linkRender' in props || 'nameRender' in props), '`linkRender` and `nameRender` are removed, please use `itemRender` instead, ' + 'see: https://u.ant.design/item-render.');
	        }
	    }, {
	        key: 'render',
	        value: function render() {
	            var crumbs = void 0;
	            var _props = this.props,
	                separator = _props.separator,
	                prefixCls = _props.prefixCls,
	                style = _props.style,
	                className = _props.className,
	                routes = _props.routes,
	                _props$params = _props.params,
	                params = _props$params === undefined ? {} : _props$params,
	                children = _props.children,
	                _props$itemRender = _props.itemRender,
	                itemRender = _props$itemRender === undefined ? defaultItemRender : _props$itemRender;
	
	            if (routes && routes.length > 0) {
	                var paths = [];
	                crumbs = routes.map(function (route) {
	                    route.path = route.path || '';
	                    var path = route.path.replace(/^\//, '');
	                    Object.keys(params).forEach(function (key) {
	                        path = path.replace(':' + key, params[key]);
	                    });
	                    if (path) {
	                        paths.push(path);
	                    }
	                    return _react2['default'].createElement(
	                        _BreadcrumbItem2['default'],
	                        { separator: separator, key: route.breadcrumbName || path },
	                        itemRender(route, params, routes, paths)
	                    );
	                });
	            } else if (children) {
	                crumbs = _react2['default'].Children.map(children, function (element, index) {
	                    if (!element) {
	                        return element;
	                    }
	                    (0, _warning2['default'])(element.type && element.type.__ANT_BREADCRUMB_ITEM, 'Breadcrumb only accepts Breadcrumb.Item as it\'s children');
	                    return (0, _react.cloneElement)(element, {
	                        separator: separator,
	                        key: index
	                    });
	                });
	            }
	            return _react2['default'].createElement(
	                'div',
	                { className: (0, _classnames2['default'])(className, prefixCls), style: style },
	                crumbs
	            );
	        }
	    }]);
	    return Breadcrumb;
	}(_react2['default'].Component);
	
	exports['default'] = Breadcrumb;
	
	Breadcrumb.defaultProps = {
	    prefixCls: 'ant-breadcrumb',
	    separator: '/'
	};
	Breadcrumb.propTypes = {
	    prefixCls: _propTypes2['default'].string,
	    separator: _propTypes2['default'].node,
	    routes: _propTypes2['default'].array,
	    params: _propTypes2['default'].object,
	    linkRender: _propTypes2['default'].func,
	    nameRender: _propTypes2['default'].func
	};
	module.exports = exports['default'];

/***/ }),
/* 328 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _Breadcrumb = __webpack_require__(327);
	
	var _Breadcrumb2 = _interopRequireDefault(_Breadcrumb);
	
	var _BreadcrumbItem = __webpack_require__(160);
	
	var _BreadcrumbItem2 = _interopRequireDefault(_BreadcrumbItem);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	_Breadcrumb2['default'].Item = _BreadcrumbItem2['default'];
	exports['default'] = _Breadcrumb2['default'];
	module.exports = exports['default'];

/***/ }),
/* 329 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var __rest = undefined && undefined.__rest || function (s, e) {
	    var t = {};
	    for (var p in s) {
	        if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
	    }if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	        if (e.indexOf(p[i]) < 0) t[p[i]] = s[p[i]];
	    }return t;
	};
	
	var ButtonGroup = function ButtonGroup(props) {
	    var _props$prefixCls = props.prefixCls,
	        prefixCls = _props$prefixCls === undefined ? 'ant-btn-group' : _props$prefixCls,
	        size = props.size,
	        className = props.className,
	        others = __rest(props, ["prefixCls", "size", "className"]);
	    // large => lg
	    // small => sm
	
	
	    var sizeCls = '';
	    switch (size) {
	        case 'large':
	            sizeCls = 'lg';
	            break;
	        case 'small':
	            sizeCls = 'sm';
	        default:
	            break;
	    }
	    var classes = (0, _classnames2['default'])(prefixCls, (0, _defineProperty3['default'])({}, prefixCls + '-' + sizeCls, sizeCls), className);
	    return _react2['default'].createElement('div', (0, _extends3['default'])({}, others, { className: classes }));
	};
	exports['default'] = ButtonGroup;
	module.exports = exports['default'];

/***/ }),
/* 330 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _omit = __webpack_require__(28);
	
	var _omit2 = _interopRequireDefault(_omit);
	
	var _icon = __webpack_require__(16);
	
	var _icon2 = _interopRequireDefault(_icon);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var __rest = undefined && undefined.__rest || function (s, e) {
	    var t = {};
	    for (var p in s) {
	        if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
	    }if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	        if (e.indexOf(p[i]) < 0) t[p[i]] = s[p[i]];
	    }return t;
	};
	
	var rxTwoCNChar = /^[\u4e00-\u9fa5]{2}$/;
	var isTwoCNChar = rxTwoCNChar.test.bind(rxTwoCNChar);
	function isString(str) {
	    return typeof str === 'string';
	}
	// Insert one space between two chinese characters automatically.
	function insertSpace(child, needInserted) {
	    // Check the child if is undefined or null.
	    if (child == null) {
	        return;
	    }
	    var SPACE = needInserted ? ' ' : '';
	    // strictNullChecks oops.
	    if (typeof child !== 'string' && typeof child !== 'number' && isString(child.type) && isTwoCNChar(child.props.children)) {
	        return _react2['default'].cloneElement(child, {}, child.props.children.split('').join(SPACE));
	    }
	    if (typeof child === 'string') {
	        if (isTwoCNChar(child)) {
	            child = child.split('').join(SPACE);
	        }
	        return _react2['default'].createElement(
	            'span',
	            null,
	            child
	        );
	    }
	    return child;
	}
	
	var Button = function (_React$Component) {
	    (0, _inherits3['default'])(Button, _React$Component);
	
	    function Button(props) {
	        (0, _classCallCheck3['default'])(this, Button);
	
	        var _this = (0, _possibleConstructorReturn3['default'])(this, (Button.__proto__ || Object.getPrototypeOf(Button)).call(this, props));
	
	        _this.handleClick = function (e) {
	            // Add click effect
	            _this.setState({ clicked: true });
	            clearTimeout(_this.timeout);
	            _this.timeout = setTimeout(function () {
	                return _this.setState({ clicked: false });
	            }, 500);
	            var onClick = _this.props.onClick;
	            if (onClick) {
	                onClick(e);
	            }
	        };
	        _this.state = {
	            loading: props.loading,
	            clicked: false
	        };
	        return _this;
	    }
	
	    (0, _createClass3['default'])(Button, [{
	        key: 'componentWillReceiveProps',
	        value: function componentWillReceiveProps(nextProps) {
	            var _this2 = this;
	
	            var currentLoading = this.props.loading;
	            var loading = nextProps.loading;
	            if (currentLoading) {
	                clearTimeout(this.delayTimeout);
	            }
	            if (typeof loading !== 'boolean' && loading && loading.delay) {
	                this.delayTimeout = setTimeout(function () {
	                    return _this2.setState({ loading: loading });
	                }, loading.delay);
	            } else {
	                this.setState({ loading: loading });
	            }
	        }
	    }, {
	        key: 'componentWillUnmount',
	        value: function componentWillUnmount() {
	            if (this.timeout) {
	                clearTimeout(this.timeout);
	            }
	            if (this.delayTimeout) {
	                clearTimeout(this.delayTimeout);
	            }
	        }
	    }, {
	        key: 'render',
	        value: function render() {
	            var _classNames;
	
	            var _a = this.props,
	                type = _a.type,
	                shape = _a.shape,
	                size = _a.size,
	                className = _a.className,
	                htmlType = _a.htmlType,
	                children = _a.children,
	                icon = _a.icon,
	                prefixCls = _a.prefixCls,
	                ghost = _a.ghost,
	                others = __rest(_a, ["type", "shape", "size", "className", "htmlType", "children", "icon", "prefixCls", "ghost"]);var _state = this.state,
	                loading = _state.loading,
	                clicked = _state.clicked;
	            // large => lg
	            // small => sm
	
	            var sizeCls = '';
	            switch (size) {
	                case 'large':
	                    sizeCls = 'lg';
	                    break;
	                case 'small':
	                    sizeCls = 'sm';
	                default:
	                    break;
	            }
	            var classes = (0, _classnames2['default'])(prefixCls, className, (_classNames = {}, (0, _defineProperty3['default'])(_classNames, prefixCls + '-' + type, type), (0, _defineProperty3['default'])(_classNames, prefixCls + '-' + shape, shape), (0, _defineProperty3['default'])(_classNames, prefixCls + '-' + sizeCls, sizeCls), (0, _defineProperty3['default'])(_classNames, prefixCls + '-icon-only', !children && icon), (0, _defineProperty3['default'])(_classNames, prefixCls + '-loading', loading), (0, _defineProperty3['default'])(_classNames, prefixCls + '-clicked', clicked), (0, _defineProperty3['default'])(_classNames, prefixCls + '-background-ghost', ghost), _classNames));
	            var iconType = loading ? 'loading' : icon;
	            var iconNode = iconType ? _react2['default'].createElement(_icon2['default'], { type: iconType }) : null;
	            var needInserted = _react2['default'].Children.count(children) === 1 && (!iconType || iconType === 'loading');
	            var kids = _react2['default'].Children.map(children, function (child) {
	                return insertSpace(child, needInserted);
	            });
	            return _react2['default'].createElement(
	                'button',
	                (0, _extends3['default'])({}, (0, _omit2['default'])(others, ['loading']), { type: htmlType || 'button', className: classes, onClick: this.handleClick }),
	                iconNode,
	                kids
	            );
	        }
	    }]);
	    return Button;
	}(_react2['default'].Component);
	
	exports['default'] = Button;
	
	Button.__ANT_BUTTON = true;
	Button.defaultProps = {
	    prefixCls: 'ant-btn',
	    loading: false,
	    ghost: false
	};
	Button.propTypes = {
	    type: _propTypes2['default'].string,
	    shape: _propTypes2['default'].oneOf(['circle', 'circle-outline']),
	    size: _propTypes2['default'].oneOf(['large', 'default', 'small']),
	    htmlType: _propTypes2['default'].oneOf(['submit', 'button', 'reset']),
	    onClick: _propTypes2['default'].func,
	    loading: _propTypes2['default'].oneOfType([_propTypes2['default'].bool, _propTypes2['default'].object]),
	    className: _propTypes2['default'].string,
	    icon: _propTypes2['default'].string
	};
	module.exports = exports['default'];

/***/ }),
/* 331 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _Constants = __webpack_require__(162);
	
	var _select = __webpack_require__(68);
	
	var _select2 = _interopRequireDefault(_select);
	
	var _radio = __webpack_require__(82);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var Option = _select2['default'].Option;
	
	var Header = function (_React$Component) {
	    (0, _inherits3['default'])(Header, _React$Component);
	
	    function Header() {
	        (0, _classCallCheck3['default'])(this, Header);
	
	        var _this = (0, _possibleConstructorReturn3['default'])(this, (Header.__proto__ || Object.getPrototypeOf(Header)).apply(this, arguments));
	
	        _this.onYearChange = function (year) {
	            var newValue = _this.props.value.clone();
	            newValue.year(parseInt(year, 10));
	            var onValueChange = _this.props.onValueChange;
	            if (onValueChange) {
	                onValueChange(newValue);
	            }
	        };
	        _this.onMonthChange = function (month) {
	            var newValue = _this.props.value.clone();
	            newValue.month(parseInt(month, 10));
	            var onValueChange = _this.props.onValueChange;
	            if (onValueChange) {
	                onValueChange(newValue);
	            }
	        };
	        _this.onTypeChange = function (e) {
	            var onTypeChange = _this.props.onTypeChange;
	            if (onTypeChange) {
	                onTypeChange(e.target.value);
	            }
	        };
	        _this.getCalenderHeaderNode = function (node) {
	            _this.calenderHeaderNode = node;
	        };
	        return _this;
	    }
	
	    (0, _createClass3['default'])(Header, [{
	        key: 'getYearSelectElement',
	        value: function getYearSelectElement(year) {
	            var _this2 = this;
	
	            var _props = this.props,
	                yearSelectOffset = _props.yearSelectOffset,
	                yearSelectTotal = _props.yearSelectTotal,
	                locale = _props.locale,
	                prefixCls = _props.prefixCls,
	                fullscreen = _props.fullscreen;
	
	            var start = year - yearSelectOffset;
	            var end = start + yearSelectTotal;
	            var suffix = locale.year === '年' ? '年' : '';
	            var options = [];
	            for (var index = start; index < end; index++) {
	                options.push(_react2['default'].createElement(
	                    Option,
	                    { key: '' + index },
	                    index + suffix
	                ));
	            }
	            return _react2['default'].createElement(
	                _select2['default'],
	                { size: fullscreen ? 'default' : 'small', dropdownMatchSelectWidth: false, className: prefixCls + '-year-select', onChange: this.onYearChange, value: String(year), getPopupContainer: function getPopupContainer() {
	                        return _this2.calenderHeaderNode;
	                    } },
	                options
	            );
	        }
	    }, {
	        key: 'getMonthsLocale',
	        value: function getMonthsLocale(value) {
	            var current = value.clone();
	            var localeData = value.localeData();
	            var months = [];
	            for (var i = 0; i < 12; i++) {
	                current.month(i);
	                months.push(localeData.monthsShort(current));
	            }
	            return months;
	        }
	    }, {
	        key: 'getMonthSelectElement',
	        value: function getMonthSelectElement(month, months) {
	            var _this3 = this;
	
	            var props = this.props;
	            var prefixCls = props.prefixCls,
	                fullscreen = props.fullscreen;
	
	            var options = [];
	            for (var index = 0; index < 12; index++) {
	                options.push(_react2['default'].createElement(
	                    Option,
	                    { key: '' + index },
	                    months[index]
	                ));
	            }
	            return _react2['default'].createElement(
	                _select2['default'],
	                { size: fullscreen ? 'default' : 'small', dropdownMatchSelectWidth: false, className: prefixCls + '-month-select', value: String(month), onChange: this.onMonthChange, getPopupContainer: function getPopupContainer() {
	                        return _this3.calenderHeaderNode;
	                    } },
	                options
	            );
	        }
	    }, {
	        key: 'render',
	        value: function render() {
	            var _props2 = this.props,
	                type = _props2.type,
	                value = _props2.value,
	                prefixCls = _props2.prefixCls,
	                locale = _props2.locale,
	                fullscreen = _props2.fullscreen;
	
	            var yearSelect = this.getYearSelectElement(value.year());
	            var monthSelect = type === 'date' ? this.getMonthSelectElement(value.month(), this.getMonthsLocale(value)) : null;
	            var size = fullscreen ? 'default' : 'small';
	            var typeSwitch = _react2['default'].createElement(
	                _radio.Group,
	                { onChange: this.onTypeChange, value: type, size: size },
	                _react2['default'].createElement(
	                    _radio.Button,
	                    { value: 'date' },
	                    locale.month
	                ),
	                _react2['default'].createElement(
	                    _radio.Button,
	                    { value: 'month' },
	                    locale.year
	                )
	            );
	            return _react2['default'].createElement(
	                'div',
	                { className: prefixCls + '-header', ref: this.getCalenderHeaderNode },
	                yearSelect,
	                monthSelect,
	                typeSwitch
	            );
	        }
	    }]);
	    return Header;
	}(_react2['default'].Component);
	
	exports['default'] = Header;
	
	Header.defaultProps = {
	    prefixCls: _Constants.PREFIX_CLS + '-header',
	    yearSelectOffset: 10,
	    yearSelectTotal: 20
	};
	module.exports = exports['default'];

/***/ }),
/* 332 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _moment = __webpack_require__(13);
	
	var _moment2 = _interopRequireDefault(_moment);
	
	var _FullCalendar = __webpack_require__(661);
	
	var _FullCalendar2 = _interopRequireDefault(_FullCalendar);
	
	var _Constants = __webpack_require__(162);
	
	var _Header = __webpack_require__(331);
	
	var _Header2 = _interopRequireDefault(_Header);
	
	var _getLocale = __webpack_require__(79);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function noop() {
	    return null;
	}
	function zerofixed(v) {
	    if (v < 10) {
	        return '0' + v;
	    }
	    return '' + v;
	}
	
	var Calendar = function (_React$Component) {
	    (0, _inherits3['default'])(Calendar, _React$Component);
	
	    function Calendar(props, context) {
	        (0, _classCallCheck3['default'])(this, Calendar);
	
	        var _this = (0, _possibleConstructorReturn3['default'])(this, (Calendar.__proto__ || Object.getPrototypeOf(Calendar)).call(this, props, context));
	
	        _this.monthCellRender = function (value) {
	            var _this$props = _this.props,
	                prefixCls = _this$props.prefixCls,
	                _this$props$monthCell = _this$props.monthCellRender,
	                monthCellRender = _this$props$monthCell === undefined ? noop : _this$props$monthCell;
	
	            return _react2['default'].createElement(
	                'div',
	                { className: prefixCls + '-month' },
	                _react2['default'].createElement(
	                    'div',
	                    { className: prefixCls + '-value' },
	                    value.localeData().monthsShort(value)
	                ),
	                _react2['default'].createElement(
	                    'div',
	                    { className: prefixCls + '-content' },
	                    monthCellRender(value)
	                )
	            );
	        };
	        _this.dateCellRender = function (value) {
	            var _this$props2 = _this.props,
	                prefixCls = _this$props2.prefixCls,
	                _this$props2$dateCell = _this$props2.dateCellRender,
	                dateCellRender = _this$props2$dateCell === undefined ? noop : _this$props2$dateCell;
	
	            return _react2['default'].createElement(
	                'div',
	                { className: prefixCls + '-date' },
	                _react2['default'].createElement(
	                    'div',
	                    { className: prefixCls + '-value' },
	                    zerofixed(value.date())
	                ),
	                _react2['default'].createElement(
	                    'div',
	                    { className: prefixCls + '-content' },
	                    dateCellRender(value)
	                )
	            );
	        };
	        _this.setValue = function (value, way) {
	            if (!('value' in _this.props)) {
	                _this.setState({ value: value });
	            }
	            if (way === 'select') {
	                if (_this.props.onSelect) {
	                    _this.props.onSelect(value);
	                }
	            } else if (way === 'changePanel') {
	                _this.onPanelChange(value, _this.state.mode);
	            }
	        };
	        _this.setType = function (type) {
	            var mode = type === 'date' ? 'month' : 'year';
	            if (_this.state.mode !== mode) {
	                _this.setState({ mode: mode });
	                _this.onPanelChange(_this.state.value, mode);
	            }
	        };
	        _this.onHeaderValueChange = function (value) {
	            _this.setValue(value, 'changePanel');
	        };
	        _this.onHeaderTypeChange = function (type) {
	            _this.setType(type);
	        };
	        _this.onSelect = function (value) {
	            _this.setValue(value, 'select');
	        };
	        // Make sure that moment locale had be set correctly.
	        (0, _getLocale.getComponentLocale)(props, context, 'Calendar', function () {
	            return __webpack_require__(163);
	        });
	        var value = props.value || props.defaultValue || (0, _moment2['default'])();
	        if (!_moment2['default'].isMoment(value)) {
	            throw new Error('The value/defaultValue of Calendar must be a moment object after `antd@2.0`, ' + 'see: https://u.ant.design/calendar-value');
	        }
	        _this.state = {
	            value: value,
	            mode: props.mode
	        };
	        return _this;
	    }
	
	    (0, _createClass3['default'])(Calendar, [{
	        key: 'componentWillReceiveProps',
	        value: function componentWillReceiveProps(nextProps) {
	            if ('value' in nextProps) {
	                this.setState({
	                    value: nextProps.value
	                });
	            }
	        }
	    }, {
	        key: 'onPanelChange',
	        value: function onPanelChange(value, mode) {
	            var onPanelChange = this.props.onPanelChange;
	
	            if (onPanelChange) {
	                onPanelChange(value, mode);
	            }
	        }
	    }, {
	        key: 'render',
	        value: function render() {
	            var state = this.state,
	                props = this.props,
	                context = this.context;
	            var value = state.value,
	                mode = state.mode;
	
	            var localeCode = (0, _getLocale.getLocaleCode)(context);
	            if (value && localeCode) {
	                value.locale(localeCode);
	            }
	            var prefixCls = props.prefixCls,
	                style = props.style,
	                className = props.className,
	                fullscreen = props.fullscreen,
	                dateFullCellRender = props.dateFullCellRender,
	                monthFullCellRender = props.monthFullCellRender;
	
	            var type = mode === 'year' ? 'month' : 'date';
	            var locale = (0, _getLocale.getComponentLocale)(props, context, 'Calendar', function () {
	                return __webpack_require__(163);
	            });
	            var cls = className || '';
	            if (fullscreen) {
	                cls += ' ' + prefixCls + '-fullscreen';
	            }
	            var monthCellRender = monthFullCellRender || this.monthCellRender;
	            var dateCellRender = dateFullCellRender || this.dateCellRender;
	            return _react2['default'].createElement(
	                'div',
	                { className: cls, style: style },
	                _react2['default'].createElement(_Header2['default'], { fullscreen: fullscreen, type: type, value: value, locale: locale.lang, prefixCls: prefixCls, onTypeChange: this.onHeaderTypeChange, onValueChange: this.onHeaderValueChange }),
	                _react2['default'].createElement(_FullCalendar2['default'], (0, _extends3['default'])({}, props, { Select: noop, locale: locale.lang, type: type, prefixCls: prefixCls, showHeader: false, value: value, monthCellRender: monthCellRender, dateCellRender: dateCellRender, onSelect: this.onSelect }))
	            );
	        }
	    }]);
	    return Calendar;
	}(_react2['default'].Component);
	
	exports['default'] = Calendar;
	
	Calendar.defaultProps = {
	    locale: {},
	    fullscreen: true,
	    prefixCls: _Constants.PREFIX_CLS,
	    mode: 'month',
	    onSelect: noop,
	    onPanelChange: noop
	};
	Calendar.propTypes = {
	    monthCellRender: _propTypes2['default'].func,
	    dateCellRender: _propTypes2['default'].func,
	    monthFullCellRender: _propTypes2['default'].func,
	    dateFullCellRender: _propTypes2['default'].func,
	    fullscreen: _propTypes2['default'].bool,
	    locale: _propTypes2['default'].object,
	    prefixCls: _propTypes2['default'].string,
	    className: _propTypes2['default'].string,
	    style: _propTypes2['default'].object,
	    onPanelChange: _propTypes2['default'].func,
	    value: _propTypes2['default'].object,
	    onSelect: _propTypes2['default'].func
	};
	Calendar.contextTypes = {
	    antLocale: _propTypes2['default'].object
	};
	module.exports = exports['default'];

/***/ }),
/* 333 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var __rest = undefined && undefined.__rest || function (s, e) {
	    var t = {};
	    for (var p in s) {
	        if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
	    }if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	        if (e.indexOf(p[i]) < 0) t[p[i]] = s[p[i]];
	    }return t;
	};
	
	exports['default'] = function (props) {
	    var _props$prefixCls = props.prefixCls,
	        prefixCls = _props$prefixCls === undefined ? 'ant-card' : _props$prefixCls,
	        className = props.className,
	        others = __rest(props, ["prefixCls", "className"]);
	
	    var classString = (0, _classnames2['default'])(prefixCls + '-grid', className);
	    return _react2['default'].createElement('div', (0, _extends3['default'])({}, others, { className: classString }));
	};
	
	module.exports = exports['default'];

/***/ }),
/* 334 */
/***/ (function(module, exports, __webpack_require__) {

	"use strict";
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _typeof2 = __webpack_require__(21);
	
	var _typeof3 = _interopRequireDefault(_typeof2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _addEventListener = __webpack_require__(34);
	
	var _addEventListener2 = _interopRequireDefault(_addEventListener);
	
	var _Grid = __webpack_require__(333);
	
	var _Grid2 = _interopRequireDefault(_Grid);
	
	var _throttleByAnimationFrame = __webpack_require__(158);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
	
	var __decorate = undefined && undefined.__decorate || function (decorators, target, key, desc) {
	    var c = arguments.length,
	        r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc,
	        d;
	    if ((typeof Reflect === "undefined" ? "undefined" : (0, _typeof3["default"])(Reflect)) === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);else for (var i = decorators.length - 1; i >= 0; i--) {
	        if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	    }return c > 3 && r && Object.defineProperty(target, key, r), r;
	};
	var __rest = undefined && undefined.__rest || function (s, e) {
	    var t = {};
	    for (var p in s) {
	        if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
	    }if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	        if (e.indexOf(p[i]) < 0) t[p[i]] = s[p[i]];
	    }return t;
	};
	
	var Card = function (_Component) {
	    (0, _inherits3["default"])(Card, _Component);
	
	    function Card() {
	        (0, _classCallCheck3["default"])(this, Card);
	
	        var _this = (0, _possibleConstructorReturn3["default"])(this, (Card.__proto__ || Object.getPrototypeOf(Card)).apply(this, arguments));
	
	        _this.state = {
	            widerPadding: false
	        };
	        _this.saveRef = function (node) {
	            _this.container = node;
	        };
	        return _this;
	    }
	
	    (0, _createClass3["default"])(Card, [{
	        key: "componentDidMount",
	        value: function componentDidMount() {
	            this.updateWiderPadding();
	            this.resizeEvent = (0, _addEventListener2["default"])(window, 'resize', this.updateWiderPadding);
	        }
	    }, {
	        key: "componentWillUnmount",
	        value: function componentWillUnmount() {
	            if (this.resizeEvent) {
	                this.resizeEvent.remove();
	            }
	            this.updateWiderPadding.cancel();
	        }
	    }, {
	        key: "updateWiderPadding",
	        value: function updateWiderPadding() {
	            var _this2 = this;
	
	            if (!this.container) {
	                return;
	            }
	            // 936 is a magic card width pixer number indicated by designer
	            var WIDTH_BOUDARY_PX = 936;
	            if (this.container.offsetWidth >= WIDTH_BOUDARY_PX && !this.state.widerPadding) {
	                this.setState({ widerPadding: true }, function () {
	                    _this2.updateWiderPaddingCalled = true; // first render without css transition
	                });
	            }
	            if (this.container.offsetWidth < WIDTH_BOUDARY_PX && this.state.widerPadding) {
	                this.setState({ widerPadding: false }, function () {
	                    _this2.updateWiderPaddingCalled = true; // first render without css transition
	                });
	            }
	        }
	    }, {
	        key: "isContainGrid",
	        value: function isContainGrid() {
	            var containGrid = void 0;
	            _react.Children.forEach(this.props.children, function (element) {
	                if (element && element.type && element.type === _Grid2["default"]) {
	                    containGrid = true;
	                }
	            });
	            return containGrid;
	        }
	    }, {
	        key: "render",
	        value: function render() {
	            var _classNames;
	
	            var _a = this.props,
	                _a$prefixCls = _a.prefixCls,
	                prefixCls = _a$prefixCls === undefined ? 'ant-card' : _a$prefixCls,
	                className = _a.className,
	                extra = _a.extra,
	                bodyStyle = _a.bodyStyle,
	                noHovering = _a.noHovering,
	                title = _a.title,
	                loading = _a.loading,
	                _a$bordered = _a.bordered,
	                bordered = _a$bordered === undefined ? true : _a$bordered,
	                others = __rest(_a, ["prefixCls", "className", "extra", "bodyStyle", "noHovering", "title", "loading", "bordered"]);
	            var children = this.props.children;
	            var classString = (0, _classnames2["default"])(prefixCls, className, (_classNames = {}, (0, _defineProperty3["default"])(_classNames, prefixCls + "-loading", loading), (0, _defineProperty3["default"])(_classNames, prefixCls + "-bordered", bordered), (0, _defineProperty3["default"])(_classNames, prefixCls + "-no-hovering", noHovering), (0, _defineProperty3["default"])(_classNames, prefixCls + "-wider-padding", this.state.widerPadding), (0, _defineProperty3["default"])(_classNames, prefixCls + "-padding-transition", this.updateWiderPaddingCalled), (0, _defineProperty3["default"])(_classNames, prefixCls + "-contain-grid", this.isContainGrid()), _classNames));
	            if (loading) {
	                children = _react2["default"].createElement(
	                    "div",
	                    { className: prefixCls + "-loading-content" },
	                    _react2["default"].createElement("p", { className: prefixCls + "-loading-block", style: { width: '94%' } }),
	                    _react2["default"].createElement(
	                        "p",
	                        null,
	                        _react2["default"].createElement("span", { className: prefixCls + "-loading-block", style: { width: '28%' } }),
	                        _react2["default"].createElement("span", { className: prefixCls + "-loading-block", style: { width: '62%' } })
	                    ),
	                    _react2["default"].createElement(
	                        "p",
	                        null,
	                        _react2["default"].createElement("span", { className: prefixCls + "-loading-block", style: { width: '22%' } }),
	                        _react2["default"].createElement("span", { className: prefixCls + "-loading-block", style: { width: '66%' } })
	                    ),
	                    _react2["default"].createElement(
	                        "p",
	                        null,
	                        _react2["default"].createElement("span", { className: prefixCls + "-loading-block", style: { width: '56%' } }),
	                        _react2["default"].createElement("span", { className: prefixCls + "-loading-block", style: { width: '39%' } })
	                    ),
	                    _react2["default"].createElement(
	                        "p",
	                        null,
	                        _react2["default"].createElement("span", { className: prefixCls + "-loading-block", style: { width: '21%' } }),
	                        _react2["default"].createElement("span", { className: prefixCls + "-loading-block", style: { width: '15%' } }),
	                        _react2["default"].createElement("span", { className: prefixCls + "-loading-block", style: { width: '40%' } })
	                    )
	                );
	            }
	            var head = void 0;
	            if (title || extra) {
	                head = _react2["default"].createElement(
	                    "div",
	                    { className: prefixCls + "-head" },
	                    title ? _react2["default"].createElement(
	                        "div",
	                        { className: prefixCls + "-head-title" },
	                        title
	                    ) : null,
	                    extra ? _react2["default"].createElement(
	                        "div",
	                        { className: prefixCls + "-extra" },
	                        extra
	                    ) : null
	                );
	            }
	            return _react2["default"].createElement(
	                "div",
	                (0, _extends3["default"])({}, others, { className: classString, ref: this.saveRef }),
	                head,
	                _react2["default"].createElement(
	                    "div",
	                    { className: prefixCls + "-body", style: bodyStyle },
	                    children
	                )
	            );
	        }
	    }]);
	    return Card;
	}(_react.Component);
	
	exports["default"] = Card;
	
	Card.Grid = _Grid2["default"];
	__decorate([(0, _throttleByAnimationFrame.throttleByAnimationFrameDecorator)()], Card.prototype, "updateWiderPadding", null);
	module.exports = exports["default"];

/***/ }),
/* 335 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _lodash = __webpack_require__(91);
	
	var _lodash2 = _interopRequireDefault(_lodash);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	// matchMedia polyfill for
	// https://github.com/WickyNilliams/enquire.js/issues/82
	if (typeof window !== 'undefined') {
	    var matchMediaPolyfill = function matchMediaPolyfill(mediaQuery) {
	        return {
	            media: mediaQuery,
	            matches: false,
	            addListener: function addListener() {},
	            removeListener: function removeListener() {}
	        };
	    };
	    window.matchMedia = window.matchMedia || matchMediaPolyfill;
	}
	// Use require over import (will be lifted up)
	// make sure matchMedia polyfill run before require('react-slick')
	// Fix https://github.com/ant-design/ant-design/issues/6560
	// Fix https://github.com/ant-design/ant-design/issues/3308
	var SlickCarousel = __webpack_require__(797)['default'];
	
	var Carousel = function (_React$Component) {
	    (0, _inherits3['default'])(Carousel, _React$Component);
	
	    function Carousel(props) {
	        (0, _classCallCheck3['default'])(this, Carousel);
	
	        var _this = (0, _possibleConstructorReturn3['default'])(this, (Carousel.__proto__ || Object.getPrototypeOf(Carousel)).call(this, props));
	
	        _this.onWindowResized = function () {
	            // Fix https://github.com/ant-design/ant-design/issues/2550
	            var slick = _this.refs.slick;
	            var autoplay = _this.props.autoplay;
	
	            if (autoplay && slick && slick.innerSlider && slick.innerSlider.autoPlay) {
	                slick.innerSlider.autoPlay();
	            }
	        };
	        _this.onWindowResized = (0, _lodash2['default'])(_this.onWindowResized, 500, {
	            leading: false
	        });
	        return _this;
	    }
	
	    (0, _createClass3['default'])(Carousel, [{
	        key: 'componentDidMount',
	        value: function componentDidMount() {
	            var autoplay = this.props.autoplay;
	
	            if (autoplay) {
	                window.addEventListener('resize', this.onWindowResized);
	            }
	            var slick = this.refs.slick;
	            // https://github.com/ant-design/ant-design/issues/7191
	
	            this.innerSlider = slick && slick.innerSlider;
	        }
	    }, {
	        key: 'componentWillUnmount',
	        value: function componentWillUnmount() {
	            var autoplay = this.props.autoplay;
	
	            if (autoplay) {
	                window.removeEventListener('resize', this.onWindowResized);
	                this.onWindowResized.cancel();
	            }
	        }
	    }, {
	        key: 'render',
	        value: function render() {
	            var props = (0, _extends3['default'])({}, this.props);
	            if (props.effect === 'fade') {
	                props.fade = true;
	            }
	            var className = props.prefixCls;
	            if (props.vertical) {
	                className = className + ' ' + className + '-vertical';
	            }
	            return _react2['default'].createElement(
	                'div',
	                { className: className },
	                _react2['default'].createElement(SlickCarousel, (0, _extends3['default'])({ ref: 'slick' }, props))
	            );
	        }
	    }]);
	    return Carousel;
	}(_react2['default'].Component);
	
	exports['default'] = Carousel;
	
	Carousel.defaultProps = {
	    dots: true,
	    arrows: false,
	    prefixCls: 'ant-carousel',
	    draggable: false
	};
	module.exports = exports['default'];

/***/ }),
/* 336 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _rcCascader = __webpack_require__(672);
	
	var _rcCascader2 = _interopRequireDefault(_rcCascader);
	
	var _arrayTreeFilter = __webpack_require__(99);
	
	var _arrayTreeFilter2 = _interopRequireDefault(_arrayTreeFilter);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _omit = __webpack_require__(28);
	
	var _omit2 = _interopRequireDefault(_omit);
	
	var _KeyCode = __webpack_require__(29);
	
	var _KeyCode2 = _interopRequireDefault(_KeyCode);
	
	var _input = __webpack_require__(81);
	
	var _input2 = _interopRequireDefault(_input);
	
	var _icon = __webpack_require__(16);
	
	var _icon2 = _interopRequireDefault(_icon);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var __rest = undefined && undefined.__rest || function (s, e) {
	    var t = {};
	    for (var p in s) {
	        if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
	    }if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	        if (e.indexOf(p[i]) < 0) t[p[i]] = s[p[i]];
	    }return t;
	};
	
	function highlightKeyword(str, keyword, prefixCls) {
	    return str.split(keyword).map(function (node, index) {
	        return index === 0 ? node : [_react2['default'].createElement(
	            'span',
	            { className: prefixCls + '-menu-item-keyword', key: 'seperator' },
	            keyword
	        ), node];
	    });
	}
	function defaultFilterOption(inputValue, path) {
	    return path.some(function (option) {
	        return option.label.indexOf(inputValue) > -1;
	    });
	}
	function defaultRenderFilteredOption(inputValue, path, prefixCls) {
	    return path.map(function (_ref, index) {
	        var label = _ref.label;
	
	        var node = label.indexOf(inputValue) > -1 ? highlightKeyword(label, inputValue, prefixCls) : label;
	        return index === 0 ? node : [' / ', node];
	    });
	}
	function defaultSortFilteredOption(a, b, inputValue) {
	    function callback(elem) {
	        return elem.label.indexOf(inputValue) > -1;
	    }
	    return a.findIndex(callback) - b.findIndex(callback);
	}
	var defaultDisplayRender = function defaultDisplayRender(label) {
	    return label.join(' / ');
	};
	
	var Cascader = function (_React$Component) {
	    (0, _inherits3['default'])(Cascader, _React$Component);
	
	    function Cascader(props) {
	        (0, _classCallCheck3['default'])(this, Cascader);
	
	        var _this = (0, _possibleConstructorReturn3['default'])(this, (Cascader.__proto__ || Object.getPrototypeOf(Cascader)).call(this, props));
	
	        _this.handleChange = function (value, selectedOptions) {
	            _this.setState({ inputValue: '' });
	            if (selectedOptions[0].__IS_FILTERED_OPTION) {
	                var unwrappedValue = value[0];
	                var unwrappedSelectedOptions = selectedOptions[0].path;
	                _this.setValue(unwrappedValue, unwrappedSelectedOptions);
	                return;
	            }
	            _this.setValue(value, selectedOptions);
	        };
	        _this.handlePopupVisibleChange = function (popupVisible) {
	            if (!('popupVisible' in _this.props)) {
	                _this.setState({
	                    popupVisible: popupVisible,
	                    inputFocused: popupVisible,
	                    inputValue: popupVisible ? _this.state.inputValue : ''
	                });
	            }
	            var onPopupVisibleChange = _this.props.onPopupVisibleChange;
	            if (onPopupVisibleChange) {
	                onPopupVisibleChange(popupVisible);
	            }
	        };
	        _this.handleInputBlur = function () {
	            _this.setState({
	                inputFocused: false
	            });
	        };
	        _this.handleInputClick = function (e) {
	            var _this$state = _this.state,
	                inputFocused = _this$state.inputFocused,
	                popupVisible = _this$state.popupVisible;
	            // Prevent `Trigger` behaviour.
	
	            if (inputFocused || popupVisible) {
	                e.stopPropagation();
	                e.nativeEvent.stopImmediatePropagation();
	            }
	        };
	        _this.handleKeyDown = function (e) {
	            if (e.keyCode === _KeyCode2['default'].BACKSPACE) {
	                e.stopPropagation();
	            }
	        };
	        _this.handleInputChange = function (e) {
	            var inputValue = e.target.value;
	            _this.setState({ inputValue: inputValue });
	        };
	        _this.setValue = function (value) {
	            var selectedOptions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
	
	            if (!('value' in _this.props)) {
	                _this.setState({ value: value });
	            }
	            var onChange = _this.props.onChange;
	            if (onChange) {
	                onChange(value, selectedOptions);
	            }
	        };
	        _this.clearSelection = function (e) {
	            e.preventDefault();
	            e.stopPropagation();
	            if (!_this.state.inputValue) {
	                _this.setValue([]);
	                _this.handlePopupVisibleChange(false);
	            } else {
	                _this.setState({ inputValue: '' });
	            }
	        };
	        _this.state = {
	            value: props.value || props.defaultValue || [],
	            inputValue: '',
	            inputFocused: false,
	            popupVisible: props.popupVisible,
	            flattenOptions: props.showSearch && _this.flattenTree(props.options, props.changeOnSelect)
	        };
	        return _this;
	    }
	
	    (0, _createClass3['default'])(Cascader, [{
	        key: 'componentWillReceiveProps',
	        value: function componentWillReceiveProps(nextProps) {
	            if ('value' in nextProps) {
	                this.setState({ value: nextProps.value || [] });
	            }
	            if ('popupVisible' in nextProps) {
	                this.setState({ popupVisible: nextProps.popupVisible });
	            }
	            if (nextProps.showSearch && this.props.options !== nextProps.options) {
	                this.setState({ flattenOptions: this.flattenTree(nextProps.options, nextProps.changeOnSelect) });
	            }
	        }
	    }, {
	        key: 'getLabel',
	        value: function getLabel() {
	            var _props = this.props,
	                options = _props.options,
	                _props$displayRender = _props.displayRender,
	                displayRender = _props$displayRender === undefined ? defaultDisplayRender : _props$displayRender;
	
	            var value = this.state.value;
	            var unwrappedValue = Array.isArray(value[0]) ? value[0] : value;
	            var selectedOptions = (0, _arrayTreeFilter2['default'])(options, function (o, level) {
	                return o.value === unwrappedValue[level];
	            });
	            var label = selectedOptions.map(function (o) {
	                return o.label;
	            });
	            return displayRender(label, selectedOptions);
	        }
	    }, {
	        key: 'flattenTree',
	        value: function flattenTree(options, changeOnSelect) {
	            var _this2 = this;
	
	            var ancestor = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
	
	            var flattenOptions = [];
	            options.forEach(function (option) {
	                var path = ancestor.concat(option);
	                if (changeOnSelect || !option.children || !option.children.length) {
	                    flattenOptions.push(path);
	                }
	                if (option.children) {
	                    flattenOptions = flattenOptions.concat(_this2.flattenTree(option.children, changeOnSelect, path));
	                }
	            });
	            return flattenOptions;
	        }
	    }, {
	        key: 'generateFilteredOptions',
	        value: function generateFilteredOptions(prefixCls) {
	            var _this3 = this;
	
	            var _props2 = this.props,
	                showSearch = _props2.showSearch,
	                notFoundContent = _props2.notFoundContent;
	            var _showSearch$filter = showSearch.filter,
	                filter = _showSearch$filter === undefined ? defaultFilterOption : _showSearch$filter,
	                _showSearch$render = showSearch.render,
	                render = _showSearch$render === undefined ? defaultRenderFilteredOption : _showSearch$render,
	                _showSearch$sort = showSearch.sort,
	                sort = _showSearch$sort === undefined ? defaultSortFilteredOption : _showSearch$sort;
	            var _state = this.state,
	                flattenOptions = _state.flattenOptions,
	                inputValue = _state.inputValue;
	
	            var filtered = flattenOptions.filter(function (path) {
	                return filter(_this3.state.inputValue, path);
	            }).sort(function (a, b) {
	                return sort(a, b, inputValue);
	            });
	            if (filtered.length > 0) {
	                return filtered.map(function (path) {
	                    return {
	                        __IS_FILTERED_OPTION: true,
	                        path: path,
	                        label: render(inputValue, path, prefixCls),
	                        value: path.map(function (o) {
	                            return o.value;
	                        }),
	                        disabled: path.some(function (o) {
	                            return o.disabled;
	                        })
	                    };
	                });
	            }
	            return [{ label: notFoundContent, value: 'ANT_CASCADER_NOT_FOUND', disabled: true }];
	        }
	    }, {
	        key: 'render',
	        value: function render() {
	            var _classNames, _classNames2, _classNames3;
	
	            var props = this.props,
	                state = this.state;
	
	            var prefixCls = props.prefixCls,
	                inputPrefixCls = props.inputPrefixCls,
	                children = props.children,
	                placeholder = props.placeholder,
	                size = props.size,
	                disabled = props.disabled,
	                className = props.className,
	                style = props.style,
	                allowClear = props.allowClear,
	                _props$showSearch = props.showSearch,
	                showSearch = _props$showSearch === undefined ? false : _props$showSearch,
	                otherProps = __rest(props, ["prefixCls", "inputPrefixCls", "children", "placeholder", "size", "disabled", "className", "style", "allowClear", "showSearch"]);
	
	            var value = state.value;
	            var sizeCls = (0, _classnames2['default'])((_classNames = {}, (0, _defineProperty3['default'])(_classNames, inputPrefixCls + '-lg', size === 'large'), (0, _defineProperty3['default'])(_classNames, inputPrefixCls + '-sm', size === 'small'), _classNames));
	            var clearIcon = allowClear && !disabled && value.length > 0 || state.inputValue ? _react2['default'].createElement(_icon2['default'], { type: 'cross-circle', className: prefixCls + '-picker-clear', onClick: this.clearSelection }) : null;
	            var arrowCls = (0, _classnames2['default'])((_classNames2 = {}, (0, _defineProperty3['default'])(_classNames2, prefixCls + '-picker-arrow', true), (0, _defineProperty3['default'])(_classNames2, prefixCls + '-picker-arrow-expand', state.popupVisible), _classNames2));
	            var pickerCls = (0, _classnames2['default'])(className, (_classNames3 = {}, (0, _defineProperty3['default'])(_classNames3, prefixCls + '-picker', true), (0, _defineProperty3['default'])(_classNames3, prefixCls + '-picker-with-value', state.inputValue), (0, _defineProperty3['default'])(_classNames3, prefixCls + '-picker-disabled', disabled), _classNames3));
	            // Fix bug of https://github.com/facebook/react/pull/5004
	            // and https://fb.me/react-unknown-prop
	            var inputProps = (0, _omit2['default'])(otherProps, ['onChange', 'options', 'popupPlacement', 'transitionName', 'displayRender', 'onPopupVisibleChange', 'changeOnSelect', 'expandTrigger', 'popupVisible', 'getPopupContainer', 'loadData', 'popupClassName', 'filterOption', 'renderFilteredOption', 'sortFilteredOption', 'notFoundContent']);
	            var options = props.options;
	            if (state.inputValue) {
	                options = this.generateFilteredOptions(prefixCls);
	            }
	            // Dropdown menu should keep previous status until it is fully closed.
	            if (!state.popupVisible) {
	                options = this.cachedOptions;
	            } else {
	                this.cachedOptions = options;
	            }
	            var dropdownMenuColumnStyle = {};
	            var isNotFound = (options || []).length === 1 && options[0].value === 'ANT_CASCADER_NOT_FOUND';
	            if (isNotFound) {
	                dropdownMenuColumnStyle.height = 'auto'; // Height of one row.
	            }
	            // The default value of `matchInputWidth` is `true`
	            var resultListMatchInputWidth = showSearch.matchInputWidth === false ? false : true;
	            if (resultListMatchInputWidth && state.inputValue && this.refs.input) {
	                dropdownMenuColumnStyle.width = this.refs.input.refs.input.offsetWidth;
	            }
	            var input = children || _react2['default'].createElement(
	                'span',
	                { style: style, className: pickerCls },
	                _react2['default'].createElement(
	                    'span',
	                    { className: prefixCls + '-picker-label' },
	                    this.getLabel()
	                ),
	                _react2['default'].createElement(_input2['default'], (0, _extends3['default'])({}, inputProps, { ref: 'input', prefixCls: inputPrefixCls, placeholder: value && value.length > 0 ? undefined : placeholder, className: prefixCls + '-input ' + sizeCls, value: state.inputValue, disabled: disabled, readOnly: !showSearch, autoComplete: 'off', onClick: showSearch ? this.handleInputClick : undefined, onBlur: showSearch ? this.handleInputBlur : undefined, onKeyDown: this.handleKeyDown, onChange: showSearch ? this.handleInputChange : undefined })),
	                clearIcon,
	                _react2['default'].createElement(_icon2['default'], { type: 'down', className: arrowCls })
	            );
	            return _react2['default'].createElement(
	                _rcCascader2['default'],
	                (0, _extends3['default'])({}, props, { options: options, value: value, popupVisible: state.popupVisible, onPopupVisibleChange: this.handlePopupVisibleChange, onChange: this.handleChange, dropdownMenuColumnStyle: dropdownMenuColumnStyle }),
	                input
	            );
	        }
	    }]);
	    return Cascader;
	}(_react2['default'].Component);
	
	exports['default'] = Cascader;
	
	Cascader.defaultProps = {
	    prefixCls: 'ant-cascader',
	    inputPrefixCls: 'ant-input',
	    placeholder: 'Please select',
	    transitionName: 'slide-up',
	    popupPlacement: 'bottomLeft',
	    options: [],
	    disabled: false,
	    allowClear: true,
	    notFoundContent: 'Not Found'
	};
	module.exports = exports['default'];

/***/ }),
/* 337 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _toConsumableArray2 = __webpack_require__(31);
	
	var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _shallowequal = __webpack_require__(45);
	
	var _shallowequal2 = _interopRequireDefault(_shallowequal);
	
	var _Checkbox = __webpack_require__(164);
	
	var _Checkbox2 = _interopRequireDefault(_Checkbox);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var CheckboxGroup = function (_React$Component) {
	    (0, _inherits3['default'])(CheckboxGroup, _React$Component);
	
	    function CheckboxGroup(props) {
	        (0, _classCallCheck3['default'])(this, CheckboxGroup);
	
	        var _this = (0, _possibleConstructorReturn3['default'])(this, (CheckboxGroup.__proto__ || Object.getPrototypeOf(CheckboxGroup)).call(this, props));
	
	        _this.toggleOption = function (option) {
	            var optionIndex = _this.state.value.indexOf(option.value);
	            var value = [].concat((0, _toConsumableArray3['default'])(_this.state.value));
	            if (optionIndex === -1) {
	                value.push(option.value);
	            } else {
	                value.splice(optionIndex, 1);
	            }
	            if (!('value' in _this.props)) {
	                _this.setState({ value: value });
	            }
	            var onChange = _this.props.onChange;
	            if (onChange) {
	                onChange(value);
	            }
	        };
	        _this.state = {
	            value: props.value || props.defaultValue || []
	        };
	        return _this;
	    }
	
	    (0, _createClass3['default'])(CheckboxGroup, [{
	        key: 'getChildContext',
	        value: function getChildContext() {
	            return {
	                checkboxGroup: {
	                    toggleOption: this.toggleOption,
	                    value: this.state.value,
	                    disabled: this.props.disabled
	                }
	            };
	        }
	    }, {
	        key: 'componentWillReceiveProps',
	        value: function componentWillReceiveProps(nextProps) {
	            if ('value' in nextProps) {
	                this.setState({
	                    value: nextProps.value || []
	                });
	            }
	        }
	    }, {
	        key: 'shouldComponentUpdate',
	        value: function shouldComponentUpdate(nextProps, nextState) {
	            return !(0, _shallowequal2['default'])(this.props, nextProps) || !(0, _shallowequal2['default'])(this.state, nextState);
	        }
	    }, {
	        key: 'getOptions',
	        value: function getOptions() {
	            var options = this.props.options;
	            // https://github.com/Microsoft/TypeScript/issues/7960
	
	            return options.map(function (option) {
	                if (typeof option === 'string') {
	                    return {
	                        label: option,
	                        value: option
	                    };
	                }
	                return option;
	            });
	        }
	    }, {
	        key: 'render',
	        value: function render() {
	            var _this2 = this;
	
	            var props = this.props,
	                state = this.state;
	            var prefixCls = props.prefixCls,
	                className = props.className,
	                options = props.options;
	
	            var children = props.children;
	            if (options && options.length > 0) {
	                children = this.getOptions().map(function (option) {
	                    return _react2['default'].createElement(
	                        _Checkbox2['default'],
	                        { key: option.value, disabled: 'disabled' in option ? option.disabled : props.disabled, value: option.value, checked: state.value.indexOf(option.value) !== -1, onChange: function onChange() {
	                                return _this2.toggleOption(option);
	                            }, className: prefixCls + '-item' },
	                        option.label
	                    );
	                });
	            }
	            var classString = (0, _classnames2['default'])(prefixCls, className);
	            return _react2['default'].createElement(
	                'div',
	                { className: classString },
	                children
	            );
	        }
	    }]);
	    return CheckboxGroup;
	}(_react2['default'].Component);
	
	exports['default'] = CheckboxGroup;
	
	CheckboxGroup.defaultProps = {
	    options: [],
	    prefixCls: 'ant-checkbox-group'
	};
	CheckboxGroup.propTypes = {
	    defaultValue: _propTypes2['default'].array,
	    value: _propTypes2['default'].array,
	    options: _propTypes2['default'].array.isRequired,
	    onChange: _propTypes2['default'].func
	};
	CheckboxGroup.childContextTypes = {
	    checkboxGroup: _propTypes2['default'].any
	};
	module.exports = exports['default'];

/***/ }),
/* 338 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _grid = __webpack_require__(170);
	
	exports['default'] = _grid.Col;
	module.exports = exports['default'];

/***/ }),
/* 339 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	exports.CollapsePanel = undefined;
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _rcCollapse = __webpack_require__(677);
	
	var _rcCollapse2 = _interopRequireDefault(_rcCollapse);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _openAnimation = __webpack_require__(101);
	
	var _openAnimation2 = _interopRequireDefault(_openAnimation);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var CollapsePanel = exports.CollapsePanel = function (_React$Component) {
	    (0, _inherits3['default'])(CollapsePanel, _React$Component);
	
	    function CollapsePanel() {
	        (0, _classCallCheck3['default'])(this, CollapsePanel);
	        return (0, _possibleConstructorReturn3['default'])(this, (CollapsePanel.__proto__ || Object.getPrototypeOf(CollapsePanel)).apply(this, arguments));
	    }
	
	    return CollapsePanel;
	}(_react2['default'].Component);
	
	var Collapse = function (_React$Component2) {
	    (0, _inherits3['default'])(Collapse, _React$Component2);
	
	    function Collapse() {
	        (0, _classCallCheck3['default'])(this, Collapse);
	        return (0, _possibleConstructorReturn3['default'])(this, (Collapse.__proto__ || Object.getPrototypeOf(Collapse)).apply(this, arguments));
	    }
	
	    (0, _createClass3['default'])(Collapse, [{
	        key: 'render',
	        value: function render() {
	            var _props = this.props,
	                prefixCls = _props.prefixCls,
	                _props$className = _props.className,
	                className = _props$className === undefined ? '' : _props$className,
	                bordered = _props.bordered;
	
	            var collapseClassName = (0, _classnames2['default'])((0, _defineProperty3['default'])({}, prefixCls + '-borderless', !bordered), className);
	            return _react2['default'].createElement(_rcCollapse2['default'], (0, _extends3['default'])({}, this.props, { className: collapseClassName }));
	        }
	    }]);
	    return Collapse;
	}(_react2['default'].Component);
	
	exports['default'] = Collapse;
	
	Collapse.Panel = _rcCollapse2['default'].Panel;
	Collapse.defaultProps = {
	    prefixCls: 'ant-collapse',
	    bordered: true,
	    openAnimation: (0, _extends3['default'])({}, _openAnimation2['default'], {
	        appear: function appear() {}
	    })
	};

/***/ }),
/* 340 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _Collapse = __webpack_require__(339);
	
	var _Collapse2 = _interopRequireDefault(_Collapse);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	exports['default'] = _Collapse2['default'];
	module.exports = exports['default'];

/***/ }),
/* 341 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _zh_CN = __webpack_require__(250);
	
	var _zh_CN2 = _interopRequireDefault(_zh_CN);
	
	var _rcCalendar = __webpack_require__(249);
	
	var _rcCalendar2 = _interopRequireDefault(_rcCalendar);
	
	var _warning = __webpack_require__(35);
	
	var _warning2 = _interopRequireDefault(_warning);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var Calendar = function (_React$Component) {
	    (0, _inherits3['default'])(Calendar, _React$Component);
	
	    function Calendar() {
	        (0, _classCallCheck3['default'])(this, Calendar);
	        return (0, _possibleConstructorReturn3['default'])(this, (Calendar.__proto__ || Object.getPrototypeOf(Calendar)).apply(this, arguments));
	    }
	
	    (0, _createClass3['default'])(Calendar, [{
	        key: 'render',
	        value: function render() {
	            (0, _warning2['default'])(false, 'DatePicker.Calendar is deprecated, use Calendar instead.');
	            return _react2['default'].createElement(_rcCalendar2['default'], this.props);
	        }
	    }]);
	    return Calendar;
	}(_react2['default'].Component);
	
	exports['default'] = Calendar;
	
	Calendar.defaultProps = {
	    locale: _zh_CN2['default'],
	    prefixCls: 'ant-calendar'
	};
	module.exports = exports['default'];

/***/ }),
/* 342 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _slicedToArray2 = __webpack_require__(186);
	
	var _slicedToArray3 = _interopRequireDefault(_slicedToArray2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _moment = __webpack_require__(13);
	
	var _moment2 = _interopRequireDefault(_moment);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _RangeCalendar = __webpack_require__(662);
	
	var _RangeCalendar2 = _interopRequireDefault(_RangeCalendar);
	
	var _Picker = __webpack_require__(242);
	
	var _Picker2 = _interopRequireDefault(_Picker);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _icon = __webpack_require__(16);
	
	var _icon2 = _interopRequireDefault(_icon);
	
	var _getLocale = __webpack_require__(79);
	
	var _warning = __webpack_require__(24);
	
	var _warning2 = _interopRequireDefault(_warning);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function getShowDateFromValue(value) {
	    var _value = (0, _slicedToArray3['default'])(value, 2),
	        start = _value[0],
	        end = _value[1];
	    // value could be an empty array, then we should not reset showDate
	
	
	    if (!start && !end) {
	        return;
	    }
	    var newEnd = end && end.isSame(start, 'month') ? end.clone().add(1, 'month') : end;
	    return [start, newEnd];
	} /* tslint:disable jsx-no-multiline-js */
	
	function formatValue(value, format) {
	    return value && value.format(format) || '';
	}
	function pickerValueAdapter(value) {
	    if (!value) {
	        return;
	    }
	    if (Array.isArray(value)) {
	        return value;
	    }
	    return [value, value.clone().add(1, 'month')];
	}
	function isEmptyArray(arr) {
	    if (Array.isArray(arr)) {
	        return arr.length === 0 || arr.every(function (i) {
	            return !i;
	        });
	    }
	    return false;
	}
	
	var RangePicker = function (_React$Component) {
	    (0, _inherits3['default'])(RangePicker, _React$Component);
	
	    function RangePicker(props) {
	        (0, _classCallCheck3['default'])(this, RangePicker);
	
	        var _this = (0, _possibleConstructorReturn3['default'])(this, (RangePicker.__proto__ || Object.getPrototypeOf(RangePicker)).call(this, props));
	
	        _this.clearSelection = function (e) {
	            e.preventDefault();
	            e.stopPropagation();
	            _this.setState({ value: [] });
	            _this.handleChange([]);
	        };
	        _this.clearHoverValue = function () {
	            return _this.setState({ hoverValue: [] });
	        };
	        _this.handleChange = function (value) {
	            var props = _this.props;
	            if (!('value' in props)) {
	                _this.setState(function (_ref) {
	                    var showDate = _ref.showDate;
	                    return {
	                        value: value,
	                        showDate: getShowDateFromValue(value) || showDate
	                    };
	                });
	            }
	            props.onChange(value, [formatValue(value[0], props.format), formatValue(value[1], props.format)]);
	        };
	        _this.handleOpenChange = function (open) {
	            if (!('open' in _this.props)) {
	                _this.setState({ open: open });
	            }
	            var onOpenChange = _this.props.onOpenChange;
	
	            if (onOpenChange) {
	                onOpenChange(open);
	            }
	        };
	        _this.handleShowDateChange = function (showDate) {
	            return _this.setState({ showDate: showDate });
	        };
	        _this.handleHoverChange = function (hoverValue) {
	            return _this.setState({ hoverValue: hoverValue });
	        };
	        _this.renderFooter = function () {
	            var _this$props = _this.props,
	                prefixCls = _this$props.prefixCls,
	                ranges = _this$props.ranges,
	                renderExtraFooter = _this$props.renderExtraFooter;
	
	            if (!ranges && !renderExtraFooter) {
	                return null;
	            }
	            var customFooter = renderExtraFooter ? _react2['default'].createElement(
	                'div',
	                { className: prefixCls + '-footer-extra', key: 'extra' },
	                renderExtraFooter.apply(undefined, arguments)
	            ) : null;
	            var operations = Object.keys(ranges || {}).map(function (range) {
	                var value = ranges[range];
	                return _react2['default'].createElement(
	                    'a',
	                    { key: range, onClick: function onClick() {
	                            return _this.setValue(value, true);
	                        }, onMouseEnter: function onMouseEnter() {
	                            return _this.setState({ hoverValue: value });
	                        }, onMouseLeave: _this.clearHoverValue },
	                    range
	                );
	            });
	            var rangeNode = _react2['default'].createElement(
	                'div',
	                { className: prefixCls + '-footer-extra ' + prefixCls + '-range-quick-selector', key: 'range' },
	                operations
	            );
	            return [rangeNode, customFooter];
	        };
	        var value = props.value || props.defaultValue || [];
	        if (value[0] && !_moment2['default'].isMoment(value[0]) || value[1] && !_moment2['default'].isMoment(value[1])) {
	            throw new Error('The value/defaultValue of RangePicker must be a moment object array after `antd@2.0`, ' + 'see: https://u.ant.design/date-picker-value');
	        }
	        var pickerValue = !value || isEmptyArray(value) ? props.defaultPickerValue : value;
	        _this.state = {
	            value: value,
	            showDate: pickerValueAdapter(pickerValue || (0, _moment2['default'])()),
	            open: props.open,
	            hoverValue: []
	        };
	        return _this;
	    }
	
	    (0, _createClass3['default'])(RangePicker, [{
	        key: 'componentWillReceiveProps',
	        value: function componentWillReceiveProps(nextProps) {
	            if ('value' in nextProps) {
	                var state = this.state;
	                var value = nextProps.value || [];
	                this.setState({
	                    value: value,
	                    showDate: getShowDateFromValue(value) || state.showDate
	                });
	            }
	            if ('open' in nextProps) {
	                this.setState({
	                    open: nextProps.open
	                });
	            }
	        }
	    }, {
	        key: 'setValue',
	        value: function setValue(value, hidePanel) {
	            this.handleChange(value);
	            if ((hidePanel || !this.props.showTime) && !('open' in this.props)) {
	                this.setState({ open: false });
	            }
	        }
	    }, {
	        key: 'render',
	        value: function render() {
	            var _classNames,
	                _this2 = this;
	
	            var state = this.state,
	                props = this.props,
	                context = this.context;
	            var value = state.value,
	                showDate = state.showDate,
	                hoverValue = state.hoverValue,
	                open = state.open;
	
	            var localeCode = (0, _getLocale.getLocaleCode)(context);
	            if (value && localeCode) {
	                if (value[0]) {
	                    value[0].locale(localeCode);
	                }
	                if (value[1]) {
	                    value[1].locale(localeCode);
	                }
	            }
	            var prefixCls = props.prefixCls,
	                popupStyle = props.popupStyle,
	                style = props.style,
	                disabledDate = props.disabledDate,
	                disabledTime = props.disabledTime,
	                showTime = props.showTime,
	                showToday = props.showToday,
	                ranges = props.ranges,
	                onOk = props.onOk,
	                locale = props.locale,
	                format = props.format;
	
	            (0, _warning2['default'])(!('onOK' in props), 'It should be `RangePicker[onOk]`, instead of `onOK`!');
	            var calendarClassName = (0, _classnames2['default'])((_classNames = {}, (0, _defineProperty3['default'])(_classNames, prefixCls + '-time', showTime), (0, _defineProperty3['default'])(_classNames, prefixCls + '-range-with-ranges', ranges), _classNames));
	            // 需要选择时间时，点击 ok 时才触发 onChange
	            var pickerChangeHandler = {
	                onChange: this.handleChange
	            };
	            var calendarHandler = {
	                onOk: this.handleChange
	            };
	            if (props.timePicker) {
	                pickerChangeHandler.onChange = function (changedValue) {
	                    return _this2.handleChange(changedValue);
	                };
	            } else {
	                calendarHandler = {};
	            }
	            var startPlaceholder = 'placeholder' in props ? props.placeholder[0] : locale.lang.rangePlaceholder[0];
	            var endPlaceholder = 'placeholder' in props ? props.placeholder[1] : locale.lang.rangePlaceholder[1];
	            var calendar = _react2['default'].createElement(_RangeCalendar2['default'], (0, _extends3['default'])({}, calendarHandler, { format: format, prefixCls: prefixCls, className: calendarClassName, renderFooter: this.renderFooter, timePicker: props.timePicker, disabledDate: disabledDate, disabledTime: disabledTime, dateInputPlaceholder: [startPlaceholder, endPlaceholder], locale: locale.lang, onOk: onOk, value: showDate, onValueChange: this.handleShowDateChange, hoverValue: hoverValue, onHoverChange: this.handleHoverChange, showToday: showToday }));
	            // default width for showTime
	            var pickerStyle = {};
	            if (props.showTime) {
	                pickerStyle.width = style && style.width || 300;
	            }
	            var clearIcon = !props.disabled && props.allowClear && value && (value[0] || value[1]) ? _react2['default'].createElement(_icon2['default'], { type: 'cross-circle', className: prefixCls + '-picker-clear', onClick: this.clearSelection }) : null;
	            var input = function input(_ref2) {
	                var inputValue = _ref2.value;
	
	                var start = inputValue[0];
	                var end = inputValue[1];
	                return _react2['default'].createElement(
	                    'span',
	                    { className: props.pickerInputClass },
	                    _react2['default'].createElement('input', { disabled: props.disabled, readOnly: true, value: start && start.format(props.format) || '', placeholder: startPlaceholder, className: prefixCls + '-range-picker-input' }),
	                    _react2['default'].createElement(
	                        'span',
	                        { className: prefixCls + '-range-picker-separator' },
	                        ' ~ '
	                    ),
	                    _react2['default'].createElement('input', { disabled: props.disabled, readOnly: true, value: end && end.format(props.format) || '', placeholder: endPlaceholder, className: prefixCls + '-range-picker-input' }),
	                    clearIcon,
	                    _react2['default'].createElement('span', { className: prefixCls + '-picker-icon' })
	                );
	            };
	            return _react2['default'].createElement(
	                'span',
	                { className: (0, _classnames2['default'])(props.className, props.pickerClass), style: (0, _extends3['default'])({}, style, pickerStyle) },
	                _react2['default'].createElement(
	                    _Picker2['default'],
	                    (0, _extends3['default'])({}, props, pickerChangeHandler, { calendar: calendar, value: value, open: open, onOpenChange: this.handleOpenChange, prefixCls: prefixCls + '-picker-container', style: popupStyle }),
	                    input
	                )
	            );
	        }
	    }]);
	    return RangePicker;
	}(_react2['default'].Component);
	
	exports['default'] = RangePicker;
	
	RangePicker.contextTypes = {
	    antLocale: _propTypes2['default'].object
	};
	RangePicker.defaultProps = {
	    prefixCls: 'ant-calendar',
	    allowClear: true,
	    showToday: false
	};
	module.exports = exports['default'];

/***/ }),
/* 343 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	exports['default'] = createPicker;
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _moment = __webpack_require__(13);
	
	var _moment2 = _interopRequireDefault(_moment);
	
	var _MonthCalendar = __webpack_require__(241);
	
	var _MonthCalendar2 = _interopRequireDefault(_MonthCalendar);
	
	var _Picker = __webpack_require__(242);
	
	var _Picker2 = _interopRequireDefault(_Picker);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _omit = __webpack_require__(28);
	
	var _omit2 = _interopRequireDefault(_omit);
	
	var _icon = __webpack_require__(16);
	
	var _icon2 = _interopRequireDefault(_icon);
	
	var _getLocale = __webpack_require__(79);
	
	var _warning = __webpack_require__(24);
	
	var _warning2 = _interopRequireDefault(_warning);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function createPicker(TheCalendar) {
	    return _a = function (_React$Component) {
	        (0, _inherits3['default'])(CalenderWrapper, _React$Component);
	
	        function CalenderWrapper(props) {
	            (0, _classCallCheck3['default'])(this, CalenderWrapper);
	
	            var _this = (0, _possibleConstructorReturn3['default'])(this, (CalenderWrapper.__proto__ || Object.getPrototypeOf(CalenderWrapper)).call(this, props));
	
	            _this.renderFooter = function () {
	                var _this$props = _this.props,
	                    prefixCls = _this$props.prefixCls,
	                    renderExtraFooter = _this$props.renderExtraFooter;
	
	                return renderExtraFooter ? _react2['default'].createElement(
	                    'div',
	                    { className: prefixCls + '-footer-extra' },
	                    renderExtraFooter.apply(undefined, arguments)
	                ) : null;
	            };
	            _this.clearSelection = function (e) {
	                e.preventDefault();
	                e.stopPropagation();
	                _this.handleChange(null);
	            };
	            _this.handleChange = function (value) {
	                var props = _this.props;
	                if (!('value' in props)) {
	                    _this.setState({
	                        value: value,
	                        showDate: value
	                    });
	                }
	                props.onChange(value, value && value.format(props.format) || '');
	            };
	            _this.handleCalendarChange = function (value) {
	                _this.setState({ showDate: value });
	            };
	            var value = props.value || props.defaultValue;
	            if (value && !_moment2['default'].isMoment(value)) {
	                throw new Error('The value/defaultValue of DatePicker or MonthPicker must be ' + 'a moment object after `antd@2.0`, see: https://u.ant.design/date-picker-value');
	            }
	            _this.state = {
	                value: value,
	                showDate: value
	            };
	            return _this;
	        }
	
	        (0, _createClass3['default'])(CalenderWrapper, [{
	            key: 'componentWillReceiveProps',
	            value: function componentWillReceiveProps(nextProps) {
	                if ('value' in nextProps) {
	                    this.setState({
	                        value: nextProps.value,
	                        showDate: nextProps.value
	                    });
	                }
	            }
	        }, {
	            key: 'render',
	            value: function render() {
	                var _classNames;
	
	                var _state = this.state,
	                    value = _state.value,
	                    showDate = _state.showDate;
	
	                var props = (0, _omit2['default'])(this.props, ['onChange']);
	                var prefixCls = props.prefixCls,
	                    locale = props.locale;
	
	                var placeholder = 'placeholder' in props ? props.placeholder : locale.lang.placeholder;
	                var disabledTime = props.showTime ? props.disabledTime : null;
	                var calendarClassName = (0, _classnames2['default'])((_classNames = {}, (0, _defineProperty3['default'])(_classNames, prefixCls + '-time', props.showTime), (0, _defineProperty3['default'])(_classNames, prefixCls + '-month', _MonthCalendar2['default'] === TheCalendar), _classNames));
	                var pickerChangeHandler = {};
	                var calendarHandler = {};
	                if (props.showTime) {
	                    calendarHandler = {
	                        // fix https://github.com/ant-design/ant-design/issues/1902
	                        onSelect: this.handleChange
	                    };
	                } else {
	                    pickerChangeHandler = {
	                        onChange: this.handleChange
	                    };
	                }
	                (0, _warning2['default'])(!('onOK' in props), 'It should be `DatePicker[onOk]` or `MonthPicker[onOk]`, instead of `onOK`!');
	                var calendar = _react2['default'].createElement(TheCalendar, (0, _extends3['default'])({}, calendarHandler, { disabledDate: props.disabledDate, disabledTime: disabledTime, locale: locale.lang, timePicker: props.timePicker, defaultValue: props.defaultPickerValue || (0, _moment2['default'])(), dateInputPlaceholder: placeholder, prefixCls: prefixCls, className: calendarClassName, onOk: props.onOk, format: props.format, showToday: props.showToday, monthCellContentRender: props.monthCellContentRender, renderFooter: this.renderFooter, onChange: this.handleCalendarChange, value: showDate }));
	                // default width for showTime
	                var pickerStyle = {};
	                if (props.showTime) {
	                    pickerStyle.width = props.style && props.style.width || 154;
	                }
	                var clearIcon = !props.disabled && props.allowClear && value ? _react2['default'].createElement(_icon2['default'], { type: 'cross-circle', className: prefixCls + '-picker-clear', onClick: this.clearSelection }) : null;
	                var input = function input(_ref) {
	                    var inputValue = _ref.value;
	                    return _react2['default'].createElement(
	                        'div',
	                        null,
	                        _react2['default'].createElement('input', { disabled: props.disabled, readOnly: true, value: inputValue && inputValue.format(props.format) || '', placeholder: placeholder, className: props.pickerInputClass }),
	                        clearIcon,
	                        _react2['default'].createElement('span', { className: prefixCls + '-picker-icon' })
	                    );
	                };
	                var pickerValue = value;
	                var localeCode = (0, _getLocale.getLocaleCode)(this.context);
	                if (pickerValue && localeCode) {
	                    pickerValue.locale(localeCode);
	                }
	                var style = (0, _extends3['default'])({}, props.style, pickerStyle);
	                return _react2['default'].createElement(
	                    'span',
	                    { className: (0, _classnames2['default'])(props.className, props.pickerClass), style: style },
	                    _react2['default'].createElement(
	                        _Picker2['default'],
	                        (0, _extends3['default'])({}, props, pickerChangeHandler, { calendar: calendar, value: value, prefixCls: prefixCls + '-picker-container', style: props.popupStyle }),
	                        input
	                    )
	                );
	            }
	        }]);
	        return CalenderWrapper;
	    }(_react2['default'].Component), _a.contextTypes = {
	        antLocale: _propTypes2['default'].object
	    }, _a.defaultProps = {
	        prefixCls: 'ant-calendar',
	        allowClear: true,
	        showToday: true
	    }, _a;
	    var _a;
	}
	module.exports = exports['default'];

/***/ }),
/* 344 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _rcCalendar = __webpack_require__(249);
	
	var _rcCalendar2 = _interopRequireDefault(_rcCalendar);
	
	var _MonthCalendar = __webpack_require__(241);
	
	var _MonthCalendar2 = _interopRequireDefault(_MonthCalendar);
	
	var _createPicker = __webpack_require__(343);
	
	var _createPicker2 = _interopRequireDefault(_createPicker);
	
	var _wrapPicker = __webpack_require__(345);
	
	var _wrapPicker2 = _interopRequireDefault(_wrapPicker);
	
	var _RangePicker = __webpack_require__(342);
	
	var _RangePicker2 = _interopRequireDefault(_RangePicker);
	
	var _Calendar = __webpack_require__(341);
	
	var _Calendar2 = _interopRequireDefault(_Calendar);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var DatePicker = (0, _wrapPicker2['default'])((0, _createPicker2['default'])(_rcCalendar2['default']));
	var MonthPicker = (0, _wrapPicker2['default'])((0, _createPicker2['default'])(_MonthCalendar2['default']), 'YYYY-MM');
	(0, _extends3['default'])(DatePicker, {
	    RangePicker: (0, _wrapPicker2['default'])(_RangePicker2['default']),
	    Calendar: _Calendar2['default'],
	    MonthPicker: MonthPicker
	});
	exports['default'] = DatePicker;
	module.exports = exports['default'];

/***/ }),
/* 345 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	exports['default'] = wrapPicker;
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _Panel = __webpack_require__(273);
	
	var _Panel2 = _interopRequireDefault(_Panel);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _timePicker = __webpack_require__(181);
	
	var _warning = __webpack_require__(24);
	
	var _warning2 = _interopRequireDefault(_warning);
	
	var _getLocale = __webpack_require__(79);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function getColumns(_ref) {
	    var showHour = _ref.showHour,
	        showMinute = _ref.showMinute,
	        showSecond = _ref.showSecond,
	        use12Hours = _ref.use12Hours;
	
	    var column = 0;
	    if (showHour) {
	        column += 1;
	    }
	    if (showMinute) {
	        column += 1;
	    }
	    if (showSecond) {
	        column += 1;
	    }
	    if (use12Hours) {
	        column += 1;
	    }
	    return column;
	}
	function wrapPicker(Picker, defaultFormat) {
	    return _a = function (_React$Component) {
	        (0, _inherits3['default'])(PickerWrapper, _React$Component);
	
	        function PickerWrapper() {
	            (0, _classCallCheck3['default'])(this, PickerWrapper);
	
	            var _this = (0, _possibleConstructorReturn3['default'])(this, (PickerWrapper.__proto__ || Object.getPrototypeOf(PickerWrapper)).apply(this, arguments));
	
	            _this.handleOpenChange = function (open) {
	                var _this$props = _this.props,
	                    onOpenChange = _this$props.onOpenChange,
	                    toggleOpen = _this$props.toggleOpen;
	
	                onOpenChange(open);
	                if (toggleOpen) {
	                    (0, _warning2['default'])(false, '`toggleOpen` is deprecated and will be removed in the future, ' + 'please use `onOpenChange` instead, see: https://u.ant.design/date-picker-on-open-change');
	                    toggleOpen({ open: open });
	                }
	            };
	            return _this;
	        }
	
	        (0, _createClass3['default'])(PickerWrapper, [{
	            key: 'render',
	            value: function render() {
	                var _classNames2;
	
	                var props = this.props;
	                var prefixCls = props.prefixCls,
	                    inputPrefixCls = props.inputPrefixCls;
	
	                var pickerClass = (0, _classnames2['default'])((0, _defineProperty3['default'])({}, prefixCls + '-picker', true));
	                var pickerInputClass = (0, _classnames2['default'])(prefixCls + '-picker-input', inputPrefixCls, (_classNames2 = {}, (0, _defineProperty3['default'])(_classNames2, inputPrefixCls + '-lg', props.size === 'large'), (0, _defineProperty3['default'])(_classNames2, inputPrefixCls + '-sm', props.size === 'small'), (0, _defineProperty3['default'])(_classNames2, inputPrefixCls + '-disabled', props.disabled), _classNames2));
	                var locale = (0, _getLocale.getComponentLocale)(props, this.context, 'DatePicker', function () {
	                    return __webpack_require__(166);
	                });
	                var timeFormat = props.showTime && props.showTime.format || 'HH:mm:ss';
	                var rcTimePickerProps = (0, _extends3['default'])({}, (0, _timePicker.generateShowHourMinuteSecond)(timeFormat), { format: timeFormat, use12Hours: props.showTime && props.showTime.use12Hours });
	                var columns = getColumns(rcTimePickerProps);
	                var timePickerCls = prefixCls + '-time-picker-column-' + columns;
	                var timePicker = props.showTime ? _react2['default'].createElement(_Panel2['default'], (0, _extends3['default'])({}, rcTimePickerProps, props.showTime, { prefixCls: prefixCls + '-time-picker', className: timePickerCls, placeholder: locale.timePickerLocale.placeholder, transitionName: 'slide-up' })) : null;
	                return _react2['default'].createElement(Picker, (0, _extends3['default'])({}, props, { pickerClass: pickerClass, pickerInputClass: pickerInputClass, locale: locale, timePicker: timePicker, onOpenChange: this.handleOpenChange }));
	            }
	        }]);
	        return PickerWrapper;
	    }(_react2['default'].Component), _a.contextTypes = {
	        antLocale: _propTypes2['default'].object
	    }, _a.defaultProps = {
	        format: defaultFormat || 'YYYY-MM-DD',
	        transitionName: 'slide-up',
	        popupStyle: {},
	        onChange: function onChange() {},
	        onOk: function onOk() {},
	        onOpenChange: function onOpenChange() {},
	
	        locale: {},
	        prefixCls: 'ant-calendar',
	        inputPrefixCls: 'ant-input'
	    }, _a;
	    var _a;
	}
	module.exports = exports['default'];

/***/ }),
/* 346 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _button = __webpack_require__(54);
	
	var _button2 = _interopRequireDefault(_button);
	
	var _icon = __webpack_require__(16);
	
	var _icon2 = _interopRequireDefault(_icon);
	
	var _dropdown = __webpack_require__(167);
	
	var _dropdown2 = _interopRequireDefault(_dropdown);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var __rest = undefined && undefined.__rest || function (s, e) {
	    var t = {};
	    for (var p in s) {
	        if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
	    }if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	        if (e.indexOf(p[i]) < 0) t[p[i]] = s[p[i]];
	    }return t;
	};
	
	var ButtonGroup = _button2['default'].Group;
	
	var DropdownButton = function (_React$Component) {
	    (0, _inherits3['default'])(DropdownButton, _React$Component);
	
	    function DropdownButton() {
	        (0, _classCallCheck3['default'])(this, DropdownButton);
	        return (0, _possibleConstructorReturn3['default'])(this, (DropdownButton.__proto__ || Object.getPrototypeOf(DropdownButton)).apply(this, arguments));
	    }
	
	    (0, _createClass3['default'])(DropdownButton, [{
	        key: 'render',
	        value: function render() {
	            var _a = this.props,
	                type = _a.type,
	                disabled = _a.disabled,
	                onClick = _a.onClick,
	                children = _a.children,
	                prefixCls = _a.prefixCls,
	                className = _a.className,
	                overlay = _a.overlay,
	                trigger = _a.trigger,
	                align = _a.align,
	                visible = _a.visible,
	                onVisibleChange = _a.onVisibleChange,
	                placement = _a.placement,
	                getPopupContainer = _a.getPopupContainer,
	                restProps = __rest(_a, ["type", "disabled", "onClick", "children", "prefixCls", "className", "overlay", "trigger", "align", "visible", "onVisibleChange", "placement", "getPopupContainer"]);
	            var dropdownProps = {
	                align: align,
	                overlay: overlay,
	                trigger: disabled ? [] : trigger,
	                onVisibleChange: onVisibleChange,
	                placement: placement,
	                getPopupContainer: getPopupContainer
	            };
	            if ('visible' in this.props) {
	                dropdownProps.visible = visible;
	            }
	            return _react2['default'].createElement(
	                ButtonGroup,
	                (0, _extends3['default'])({}, restProps, { className: (0, _classnames2['default'])(prefixCls, className) }),
	                _react2['default'].createElement(
	                    _button2['default'],
	                    { type: type, disabled: disabled, onClick: onClick },
	                    children
	                ),
	                _react2['default'].createElement(
	                    _dropdown2['default'],
	                    dropdownProps,
	                    _react2['default'].createElement(
	                        _button2['default'],
	                        { type: type, disabled: disabled },
	                        _react2['default'].createElement(_icon2['default'], { type: 'down' })
	                    )
	                )
	            );
	        }
	    }]);
	    return DropdownButton;
	}(_react2['default'].Component);
	
	exports['default'] = DropdownButton;
	
	DropdownButton.defaultProps = {
	    placement: 'bottomRight',
	    type: 'default',
	    prefixCls: 'ant-dropdown-button'
	};
	module.exports = exports['default'];

/***/ }),
/* 347 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _createDOMForm = __webpack_require__(705);
	
	var _createDOMForm2 = _interopRequireDefault(_createDOMForm);
	
	var _PureRenderMixin = __webpack_require__(78);
	
	var _PureRenderMixin2 = _interopRequireDefault(_PureRenderMixin);
	
	var _omit = __webpack_require__(28);
	
	var _omit2 = _interopRequireDefault(_omit);
	
	var _createReactClass = __webpack_require__(14);
	
	var _createReactClass2 = _interopRequireDefault(_createReactClass);
	
	var _warning = __webpack_require__(24);
	
	var _warning2 = _interopRequireDefault(_warning);
	
	var _FormItem = __webpack_require__(348);
	
	var _FormItem2 = _interopRequireDefault(_FormItem);
	
	var _constants = __webpack_require__(168);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var Form = function (_React$Component) {
	    (0, _inherits3['default'])(Form, _React$Component);
	
	    function Form(props) {
	        (0, _classCallCheck3['default'])(this, Form);
	
	        var _this = (0, _possibleConstructorReturn3['default'])(this, (Form.__proto__ || Object.getPrototypeOf(Form)).call(this, props));
	
	        (0, _warning2['default'])(!props.form, 'It is unnecessary to pass `form` to `Form` after antd@1.7.0.');
	        return _this;
	    }
	
	    (0, _createClass3['default'])(Form, [{
	        key: 'shouldComponentUpdate',
	        value: function shouldComponentUpdate() {
	            for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
	                args[_key] = arguments[_key];
	            }
	
	            return _PureRenderMixin2['default'].shouldComponentUpdate.apply(this, args);
	        }
	    }, {
	        key: 'getChildContext',
	        value: function getChildContext() {
	            var _props = this.props,
	                layout = _props.layout,
	                vertical = _props.vertical;
	
	            return {
	                vertical: layout === 'vertical' || vertical
	            };
	        }
	    }, {
	        key: 'render',
	        value: function render() {
	            var _classNames;
	
	            var _props2 = this.props,
	                prefixCls = _props2.prefixCls,
	                hideRequiredMark = _props2.hideRequiredMark,
	                _props2$className = _props2.className,
	                className = _props2$className === undefined ? '' : _props2$className,
	                layout = _props2.layout,
	                inline = _props2.inline,
	                horizontal = _props2.horizontal,
	                vertical = _props2.vertical;
	
	            (0, _warning2['default'])(!inline && !horizontal && !vertical, '`Form[inline|horizontal|vertical]` is deprecated, please use `Form[layout]` instead.');
	            var formClassName = (0, _classnames2['default'])(prefixCls, (_classNames = {}, (0, _defineProperty3['default'])(_classNames, prefixCls + '-horizontal', !inline && !vertical && layout === 'horizontal' || horizontal), (0, _defineProperty3['default'])(_classNames, prefixCls + '-vertical', layout === 'vertical' || vertical), (0, _defineProperty3['default'])(_classNames, prefixCls + '-inline', layout === 'inline' || inline), (0, _defineProperty3['default'])(_classNames, prefixCls + '-hide-required-mark', hideRequiredMark), _classNames), className);
	            var formProps = (0, _omit2['default'])(this.props, ['prefixCls', 'className', 'layout', 'inline', 'horizontal', 'vertical', 'form', 'hideRequiredMark']);
	            return _react2['default'].createElement('form', (0, _extends3['default'])({}, formProps, { className: formClassName }));
	        }
	    }]);
	    return Form;
	}(_react2['default'].Component);
	
	exports['default'] = Form;
	
	Form.defaultProps = {
	    prefixCls: 'ant-form',
	    layout: 'horizontal',
	    hideRequiredMark: false,
	    onSubmit: function onSubmit(e) {
	        e.preventDefault();
	    }
	};
	Form.propTypes = {
	    prefixCls: _propTypes2['default'].string,
	    layout: _propTypes2['default'].oneOf(['horizontal', 'inline', 'vertical']),
	    children: _propTypes2['default'].any,
	    onSubmit: _propTypes2['default'].func,
	    hideRequiredMark: _propTypes2['default'].bool
	};
	Form.childContextTypes = {
	    vertical: _propTypes2['default'].bool
	};
	Form.Item = _FormItem2['default'];
	Form.create = function () {
	    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
	
	    var formWrapper = (0, _createDOMForm2['default'])((0, _extends3['default'])({ fieldNameProp: 'id' }, options, { fieldMetaProp: _constants.FIELD_META_PROP }));
	    /* eslint-disable react/prefer-es6-class */
	    return function (Component) {
	        return formWrapper((0, _createReactClass2['default'])({
	            propTypes: {
	                form: _propTypes2['default'].object.isRequired
	            },
	            childContextTypes: {
	                form: _propTypes2['default'].object.isRequired
	            },
	            getChildContext: function getChildContext() {
	                return {
	                    form: this.props.form
	                };
	            },
	            componentWillMount: function componentWillMount() {
	                this.__getFieldProps = this.props.form.getFieldProps;
	            },
	            deprecatedGetFieldProps: function deprecatedGetFieldProps(name, option) {
	                (0, _warning2['default'])(false, '`getFieldProps` is not recommended, please use `getFieldDecorator` instead, ' + 'see: https://u.ant.design/get-field-decorator');
	                return this.__getFieldProps(name, option);
	            },
	            render: function render() {
	                this.props.form.getFieldProps = this.deprecatedGetFieldProps;
	                var withRef = {};
	                if (options.withRef) {
	                    withRef.ref = 'formWrappedComponent';
	                } else if (this.props.wrappedComponentRef) {
	                    withRef.ref = this.props.wrappedComponentRef;
	                }
	                return _react2['default'].createElement(Component, (0, _extends3['default'])({}, this.props, withRef));
	            }
	        }));
	    };
	};
	module.exports = exports['default'];

/***/ }),
/* 348 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _reactDom = __webpack_require__(10);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _PureRenderMixin = __webpack_require__(78);
	
	var _PureRenderMixin2 = _interopRequireDefault(_PureRenderMixin);
	
	var _row = __webpack_require__(171);
	
	var _row2 = _interopRequireDefault(_row);
	
	var _col = __webpack_require__(169);
	
	var _col2 = _interopRequireDefault(_col);
	
	var _constants = __webpack_require__(168);
	
	var _warning = __webpack_require__(24);
	
	var _warning2 = _interopRequireDefault(_warning);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var FormItem = function (_React$Component) {
	    (0, _inherits3['default'])(FormItem, _React$Component);
	
	    function FormItem() {
	        (0, _classCallCheck3['default'])(this, FormItem);
	
	        // Resolve duplicated ids bug between different forms
	        // https://github.com/ant-design/ant-design/issues/7351
	        var _this = (0, _possibleConstructorReturn3['default'])(this, (FormItem.__proto__ || Object.getPrototypeOf(FormItem)).apply(this, arguments));
	
	        _this.onLabelClick = function () {
	            var id = _this.props.id || _this.getId();
	            if (!id) {
	                return;
	            }
	            var controls = document.querySelectorAll('[id="' + id + '"]');
	            if (controls.length !== 1) {
	                var control = (0, _reactDom.findDOMNode)(_this).querySelector('[id="' + id + '"]');
	                if (control && control.focus) {
	                    control.focus();
	                }
	            }
	        };
	        return _this;
	    }
	
	    (0, _createClass3['default'])(FormItem, [{
	        key: 'componentDidMount',
	        value: function componentDidMount() {
	            (0, _warning2['default'])(this.getControls(this.props.children, true).length <= 1, '`Form.Item` cannot generate `validateStatus` and `help` automatically, ' + 'while there are more than one `getFieldDecorator` in it.');
	        }
	    }, {
	        key: 'shouldComponentUpdate',
	        value: function shouldComponentUpdate() {
	            for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
	                args[_key] = arguments[_key];
	            }
	
	            return _PureRenderMixin2['default'].shouldComponentUpdate.apply(this, args);
	        }
	    }, {
	        key: 'getHelpMsg',
	        value: function getHelpMsg() {
	            var context = this.context;
	            var props = this.props;
	            if (props.help === undefined && context.form) {
	                return this.getId() ? (context.form.getFieldError(this.getId()) || []).join(', ') : '';
	            }
	            return props.help;
	        }
	    }, {
	        key: 'getControls',
	        value: function getControls(children, recursively) {
	            var controls = [];
	            var childrenArray = _react2['default'].Children.toArray(children);
	            for (var i = 0; i < childrenArray.length; i++) {
	                if (!recursively && controls.length > 0) {
	                    break;
	                }
	                var child = childrenArray[i];
	                if (child.type && (child.type === FormItem || child.type.displayName === 'FormItem')) {
	                    continue;
	                }
	                if (!child.props) {
	                    continue;
	                }
	                if (_constants.FIELD_META_PROP in child.props) {
	                    controls.push(child);
	                } else if (child.props.children) {
	                    controls = controls.concat(this.getControls(child.props.children, recursively));
	                }
	            }
	            return controls;
	        }
	    }, {
	        key: 'getOnlyControl',
	        value: function getOnlyControl() {
	            var child = this.getControls(this.props.children, false)[0];
	            return child !== undefined ? child : null;
	        }
	    }, {
	        key: 'getChildProp',
	        value: function getChildProp(prop) {
	            var child = this.getOnlyControl();
	            return child && child.props && child.props[prop];
	        }
	    }, {
	        key: 'getId',
	        value: function getId() {
	            return this.getChildProp('id');
	        }
	    }, {
	        key: 'getMeta',
	        value: function getMeta() {
	            return this.getChildProp(_constants.FIELD_META_PROP);
	        }
	    }, {
	        key: 'renderHelp',
	        value: function renderHelp() {
	            var prefixCls = this.props.prefixCls;
	            var help = this.getHelpMsg();
	            return help ? _react2['default'].createElement(
	                'div',
	                { className: prefixCls + '-explain', key: 'help' },
	                help
	            ) : null;
	        }
	    }, {
	        key: 'renderExtra',
	        value: function renderExtra() {
	            var _props = this.props,
	                prefixCls = _props.prefixCls,
	                extra = _props.extra;
	
	            return extra ? _react2['default'].createElement(
	                'div',
	                { className: prefixCls + '-extra' },
	                extra
	            ) : null;
	        }
	    }, {
	        key: 'getValidateStatus',
	        value: function getValidateStatus() {
	            var _context$form = this.context.form,
	                isFieldValidating = _context$form.isFieldValidating,
	                getFieldError = _context$form.getFieldError,
	                getFieldValue = _context$form.getFieldValue;
	
	            var fieldId = this.getId();
	            if (!fieldId) {
	                return '';
	            }
	            if (isFieldValidating(fieldId)) {
	                return 'validating';
	            }
	            if (!!getFieldError(fieldId)) {
	                return 'error';
	            }
	            var fieldValue = getFieldValue(fieldId);
	            if (fieldValue !== undefined && fieldValue !== null && fieldValue !== '') {
	                return 'success';
	            }
	            return '';
	        }
	    }, {
	        key: 'renderValidateWrapper',
	        value: function renderValidateWrapper(c1, c2, c3) {
	            var classes = '';
	            var form = this.context.form;
	            var props = this.props;
	            var validateStatus = props.validateStatus === undefined && form ? this.getValidateStatus() : props.validateStatus;
	            if (validateStatus) {
	                classes = (0, _classnames2['default'])({
	                    'has-feedback': props.hasFeedback || validateStatus === 'validating',
	                    'has-success': validateStatus === 'success',
	                    'has-warning': validateStatus === 'warning',
	                    'has-error': validateStatus === 'error',
	                    'is-validating': validateStatus === 'validating'
	                });
	            }
	            return _react2['default'].createElement(
	                'div',
	                { className: this.props.prefixCls + '-item-control ' + classes },
	                c1,
	                c2,
	                c3
	            );
	        }
	    }, {
	        key: 'renderWrapper',
	        value: function renderWrapper(children) {
	            var _props2 = this.props,
	                prefixCls = _props2.prefixCls,
	                wrapperCol = _props2.wrapperCol;
	
	            var className = (0, _classnames2['default'])(prefixCls + '-item-control-wrapper', wrapperCol && wrapperCol.className);
	            return _react2['default'].createElement(
	                _col2['default'],
	                (0, _extends3['default'])({}, wrapperCol, { className: className, key: 'wrapper' }),
	                children
	            );
	        }
	    }, {
	        key: 'isRequired',
	        value: function isRequired() {
	            var required = this.props.required;
	
	            if (required !== undefined) {
	                return required;
	            }
	            if (this.context.form) {
	                var meta = this.getMeta() || {};
	                var validate = meta.validate || [];
	                return validate.filter(function (item) {
	                    return !!item.rules;
	                }).some(function (item) {
	                    return item.rules.some(function (rule) {
	                        return rule.required;
	                    });
	                });
	            }
	            return false;
	        }
	    }, {
	        key: 'renderLabel',
	        value: function renderLabel() {
	            var _props3 = this.props,
	                prefixCls = _props3.prefixCls,
	                label = _props3.label,
	                labelCol = _props3.labelCol,
	                colon = _props3.colon,
	                id = _props3.id;
	
	            var context = this.context;
	            var required = this.isRequired();
	            var labelColClassName = (0, _classnames2['default'])(prefixCls + '-item-label', labelCol && labelCol.className);
	            var labelClassName = (0, _classnames2['default'])((0, _defineProperty3['default'])({}, prefixCls + '-item-required', required));
	            var labelChildren = label;
	            // Keep label is original where there should have no colon
	            var haveColon = colon && !context.vertical;
	            // Remove duplicated user input colon
	            if (haveColon && typeof label === 'string' && label.trim() !== '') {
	                labelChildren = label.replace(/[：|:]\s*$/, '');
	            }
	            return label ? _react2['default'].createElement(
	                _col2['default'],
	                (0, _extends3['default'])({}, labelCol, { className: labelColClassName, key: 'label' }),
	                _react2['default'].createElement(
	                    'label',
	                    { htmlFor: id || this.getId(), className: labelClassName, title: typeof label === 'string' ? label : '', onClick: this.onLabelClick },
	                    labelChildren
	                )
	            ) : null;
	        }
	    }, {
	        key: 'renderChildren',
	        value: function renderChildren() {
	            var props = this.props;
	            var children = _react2['default'].Children.map(props.children, function (child) {
	                if (child && typeof child.type === 'function' && !child.props.size) {
	                    return _react2['default'].cloneElement(child, { size: 'large' });
	                }
	                return child;
	            });
	            return [this.renderLabel(), this.renderWrapper(this.renderValidateWrapper(children, this.renderHelp(), this.renderExtra()))];
	        }
	    }, {
	        key: 'renderFormItem',
	        value: function renderFormItem(children) {
	            var _itemClassName;
	
	            var props = this.props;
	            var prefixCls = props.prefixCls;
	            var style = props.style;
	            var itemClassName = (_itemClassName = {}, (0, _defineProperty3['default'])(_itemClassName, prefixCls + '-item', true), (0, _defineProperty3['default'])(_itemClassName, prefixCls + '-item-with-help', !!this.getHelpMsg()), (0, _defineProperty3['default'])(_itemClassName, prefixCls + '-item-no-colon', !props.colon), (0, _defineProperty3['default'])(_itemClassName, '' + props.className, !!props.className), _itemClassName);
	            return _react2['default'].createElement(
	                _row2['default'],
	                { className: (0, _classnames2['default'])(itemClassName), style: style },
	                children
	            );
	        }
	    }, {
	        key: 'render',
	        value: function render() {
	            var children = this.renderChildren();
	            return this.renderFormItem(children);
	        }
	    }]);
	    return FormItem;
	}(_react2['default'].Component);
	
	exports['default'] = FormItem;
	
	FormItem.defaultProps = {
	    hasFeedback: false,
	    prefixCls: 'ant-form',
	    colon: true
	};
	FormItem.propTypes = {
	    prefixCls: _propTypes2['default'].string,
	    label: _propTypes2['default'].oneOfType([_propTypes2['default'].string, _propTypes2['default'].node]),
	    labelCol: _propTypes2['default'].object,
	    help: _propTypes2['default'].oneOfType([_propTypes2['default'].node, _propTypes2['default'].bool]),
	    validateStatus: _propTypes2['default'].oneOf(['', 'success', 'warning', 'error', 'validating']),
	    hasFeedback: _propTypes2['default'].bool,
	    wrapperCol: _propTypes2['default'].object,
	    className: _propTypes2['default'].string,
	    id: _propTypes2['default'].string,
	    children: _propTypes2['default'].node,
	    colon: _propTypes2['default'].bool
	};
	FormItem.contextTypes = {
	    form: _propTypes2['default'].object,
	    vertical: _propTypes2['default'].bool
	};
	module.exports = exports['default'];

/***/ }),
/* 349 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _Form = __webpack_require__(347);
	
	var _Form2 = _interopRequireDefault(_Form);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	exports['default'] = _Form2['default'];
	module.exports = exports['default'];

/***/ }),
/* 350 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _affix = __webpack_require__(159);
	
	Object.defineProperty(exports, 'Affix', {
	    enumerable: true,
	    get: function get() {
	        return _interopRequireDefault(_affix)['default'];
	    }
	});
	
	var _anchor = __webpack_require__(320);
	
	Object.defineProperty(exports, 'Anchor', {
	    enumerable: true,
	    get: function get() {
	        return _interopRequireDefault(_anchor)['default'];
	    }
	});
	
	var _autoComplete = __webpack_require__(322);
	
	Object.defineProperty(exports, 'AutoComplete', {
	    enumerable: true,
	    get: function get() {
	        return _interopRequireDefault(_autoComplete)['default'];
	    }
	});
	
	var _alert = __webpack_require__(317);
	
	Object.defineProperty(exports, 'Alert', {
	    enumerable: true,
	    get: function get() {
	        return _interopRequireDefault(_alert)['default'];
	    }
	});
	
	var _avatar = __webpack_require__(323);
	
	Object.defineProperty(exports, 'Avatar', {
	    enumerable: true,
	    get: function get() {
	        return _interopRequireDefault(_avatar)['default'];
	    }
	});
	
	var _backTop = __webpack_require__(324);
	
	Object.defineProperty(exports, 'BackTop', {
	    enumerable: true,
	    get: function get() {
	        return _interopRequireDefault(_backTop)['default'];
	    }
	});
	
	var _badge = __webpack_require__(326);
	
	Object.defineProperty(exports, 'Badge', {
	    enumerable: true,
	    get: function get() {
	        return _interopRequireDefault(_badge)['default'];
	    }
	});
	
	var _breadcrumb = __webpack_require__(328);
	
	Object.defineProperty(exports, 'Breadcrumb', {
	    enumerable: true,
	    get: function get() {
	        return _interopRequireDefault(_breadcrumb)['default'];
	    }
	});
	
	var _button = __webpack_require__(54);
	
	Object.defineProperty(exports, 'Button', {
	    enumerable: true,
	    get: function get() {
	        return _interopRequireDefault(_button)['default'];
	    }
	});
	
	var _calendar = __webpack_require__(332);
	
	Object.defineProperty(exports, 'Calendar', {
	    enumerable: true,
	    get: function get() {
	        return _interopRequireDefault(_calendar)['default'];
	    }
	});
	
	var _card = __webpack_require__(334);
	
	Object.defineProperty(exports, 'Card', {
	    enumerable: true,
	    get: function get() {
	        return _interopRequireDefault(_card)['default'];
	    }
	});
	
	var _collapse = __webpack_require__(340);
	
	Object.defineProperty(exports, 'Collapse', {
	    enumerable: true,
	    get: function get() {
	        return _interopRequireDefault(_collapse)['default'];
	    }
	});
	
	var _carousel = __webpack_require__(335);
	
	Object.defineProperty(exports, 'Carousel', {
	    enumerable: true,
	    get: function get() {
	        return _interopRequireDefault(_carousel)['default'];
	    }
	});
	
	var _cascader = __webpack_require__(336);
	
	Object.defineProperty(exports, 'Cascader', {
	    enumerable: true,
	    get: function get() {
	        return _interopRequireDefault(_cascader)['default'];
	    }
	});
	
	var _checkbox = __webpack_require__(55);
	
	Object.defineProperty(exports, 'Checkbox', {
	    enumerable: true,
	    get: function get() {
	        return _interopRequireDefault(_checkbox)['default'];
	    }
	});
	
	var _col = __webpack_require__(338);
	
	Object.defineProperty(exports, 'Col', {
	    enumerable: true,
	    get: function get() {
	        return _interopRequireDefault(_col)['default'];
	    }
	});
	
	var _datePicker = __webpack_require__(344);
	
	Object.defineProperty(exports, 'DatePicker', {
	    enumerable: true,
	    get: function get() {
	        return _interopRequireDefault(_datePicker)['default'];
	    }
	});
	
	var _dropdown = __webpack_require__(102);
	
	Object.defineProperty(exports, 'Dropdown', {
	    enumerable: true,
	    get: function get() {
	        return _interopRequireDefault(_dropdown)['default'];
	    }
	});
	
	var _form = __webpack_require__(349);
	
	Object.defineProperty(exports, 'Form', {
	    enumerable: true,
	    get: function get() {
	        return _interopRequireDefault(_form)['default'];
	    }
	});
	
	var _icon = __webpack_require__(16);
	
	Object.defineProperty(exports, 'Icon', {
	    enumerable: true,
	    get: function get() {
	        return _interopRequireDefault(_icon)['default'];
	    }
	});
	
	var _input = __webpack_require__(81);
	
	Object.defineProperty(exports, 'Input', {
	    enumerable: true,
	    get: function get() {
	        return _interopRequireDefault(_input)['default'];
	    }
	});
	
	var _inputNumber = __webpack_require__(351);
	
	Object.defineProperty(exports, 'InputNumber', {
	    enumerable: true,
	    get: function get() {
	        return _interopRequireDefault(_inputNumber)['default'];
	    }
	});
	
	var _layout = __webpack_require__(356);
	
	Object.defineProperty(exports, 'Layout', {
	    enumerable: true,
	    get: function get() {
	        return _interopRequireDefault(_layout)['default'];
	    }
	});
	
	var _localeProvider = __webpack_require__(358);
	
	Object.defineProperty(exports, 'LocaleProvider', {
	    enumerable: true,
	    get: function get() {
	        return _interopRequireDefault(_localeProvider)['default'];
	    }
	});
	
	var _message = __webpack_require__(361);
	
	Object.defineProperty(exports, 'message', {
	    enumerable: true,
	    get: function get() {
	        return _interopRequireDefault(_message)['default'];
	    }
	});
	
	var _menu = __webpack_require__(174);
	
	Object.defineProperty(exports, 'Menu', {
	    enumerable: true,
	    get: function get() {
	        return _interopRequireDefault(_menu)['default'];
	    }
	});
	
	var _modal = __webpack_require__(364);
	
	Object.defineProperty(exports, 'Modal', {
	    enumerable: true,
	    get: function get() {
	        return _interopRequireDefault(_modal)['default'];
	    }
	});
	
	var _notification = __webpack_require__(365);
	
	Object.defineProperty(exports, 'notification', {
	    enumerable: true,
	    get: function get() {
	        return _interopRequireDefault(_notification)['default'];
	    }
	});
	
	var _pagination = __webpack_require__(177);
	
	Object.defineProperty(exports, 'Pagination', {
	    enumerable: true,
	    get: function get() {
	        return _interopRequireDefault(_pagination)['default'];
	    }
	});
	
	var _popconfirm = __webpack_require__(368);
	
	Object.defineProperty(exports, 'Popconfirm', {
	    enumerable: true,
	    get: function get() {
	        return _interopRequireDefault(_popconfirm)['default'];
	    }
	});
	
	var _popover = __webpack_require__(369);
	
	Object.defineProperty(exports, 'Popover', {
	    enumerable: true,
	    get: function get() {
	        return _interopRequireDefault(_popover)['default'];
	    }
	});
	
	var _progress = __webpack_require__(178);
	
	Object.defineProperty(exports, 'Progress', {
	    enumerable: true,
	    get: function get() {
	        return _interopRequireDefault(_progress)['default'];
	    }
	});
	
	var _radio = __webpack_require__(82);
	
	Object.defineProperty(exports, 'Radio', {
	    enumerable: true,
	    get: function get() {
	        return _interopRequireDefault(_radio)['default'];
	    }
	});
	
	var _rate = __webpack_require__(374);
	
	Object.defineProperty(exports, 'Rate', {
	    enumerable: true,
	    get: function get() {
	        return _interopRequireDefault(_rate)['default'];
	    }
	});
	
	var _row = __webpack_require__(375);
	
	Object.defineProperty(exports, 'Row', {
	    enumerable: true,
	    get: function get() {
	        return _interopRequireDefault(_row)['default'];
	    }
	});
	
	var _select = __webpack_require__(68);
	
	Object.defineProperty(exports, 'Select', {
	    enumerable: true,
	    get: function get() {
	        return _interopRequireDefault(_select)['default'];
	    }
	});
	
	var _slider = __webpack_require__(376);
	
	Object.defineProperty(exports, 'Slider', {
	    enumerable: true,
	    get: function get() {
	        return _interopRequireDefault(_slider)['default'];
	    }
	});
	
	var _spin = __webpack_require__(180);
	
	Object.defineProperty(exports, 'Spin', {
	    enumerable: true,
	    get: function get() {
	        return _interopRequireDefault(_spin)['default'];
	    }
	});
	
	var _steps = __webpack_require__(377);
	
	Object.defineProperty(exports, 'Steps', {
	    enumerable: true,
	    get: function get() {
	        return _interopRequireDefault(_steps)['default'];
	    }
	});
	
	var _switch = __webpack_require__(378);
	
	Object.defineProperty(exports, 'Switch', {
	    enumerable: true,
	    get: function get() {
	        return _interopRequireDefault(_switch)['default'];
	    }
	});
	
	var _table = __webpack_require__(387);
	
	Object.defineProperty(exports, 'Table', {
	    enumerable: true,
	    get: function get() {
	        return _interopRequireDefault(_table)['default'];
	    }
	});
	
	var _transfer = __webpack_require__(397);
	
	Object.defineProperty(exports, 'Transfer', {
	    enumerable: true,
	    get: function get() {
	        return _interopRequireDefault(_transfer)['default'];
	    }
	});
	
	var _tree = __webpack_require__(403);
	
	Object.defineProperty(exports, 'Tree', {
	    enumerable: true,
	    get: function get() {
	        return _interopRequireDefault(_tree)['default'];
	    }
	});
	
	var _treeSelect = __webpack_require__(401);
	
	Object.defineProperty(exports, 'TreeSelect', {
	    enumerable: true,
	    get: function get() {
	        return _interopRequireDefault(_treeSelect)['default'];
	    }
	});
	
	var _tabs = __webpack_require__(389);
	
	Object.defineProperty(exports, 'Tabs', {
	    enumerable: true,
	    get: function get() {
	        return _interopRequireDefault(_tabs)['default'];
	    }
	});
	
	var _tag = __webpack_require__(391);
	
	Object.defineProperty(exports, 'Tag', {
	    enumerable: true,
	    get: function get() {
	        return _interopRequireDefault(_tag)['default'];
	    }
	});
	
	var _timePicker = __webpack_require__(181);
	
	Object.defineProperty(exports, 'TimePicker', {
	    enumerable: true,
	    get: function get() {
	        return _interopRequireDefault(_timePicker)['default'];
	    }
	});
	
	var _timeline = __webpack_require__(395);
	
	Object.defineProperty(exports, 'Timeline', {
	    enumerable: true,
	    get: function get() {
	        return _interopRequireDefault(_timeline)['default'];
	    }
	});
	
	var _tooltip = __webpack_require__(56);
	
	Object.defineProperty(exports, 'Tooltip', {
	    enumerable: true,
	    get: function get() {
	        return _interopRequireDefault(_tooltip)['default'];
	    }
	});
	
	var _mention = __webpack_require__(359);
	
	Object.defineProperty(exports, 'Mention', {
	    enumerable: true,
	    get: function get() {
	        return _interopRequireDefault(_mention)['default'];
	    }
	});
	
	var _upload = __webpack_require__(406);
	
	Object.defineProperty(exports, 'Upload', {
	    enumerable: true,
	    get: function get() {
	        return _interopRequireDefault(_upload)['default'];
	    }
	});
	
	var _version = __webpack_require__(409);
	
	Object.defineProperty(exports, 'version', {
	    enumerable: true,
	    get: function get() {
	        return _interopRequireDefault(_version)['default'];
	    }
	});
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	/* @remove-on-es-build-begin */
	// this file is not used if use https://github.com/ant-design/babel-plugin-import
	var ENV = ("development");
	if (ENV !== 'production' && ENV !== 'test' && typeof console !== 'undefined' && console.warn && typeof window !== 'undefined') {
	    console.warn('You are using a whole package of antd, ' + 'please use https://www.npmjs.com/package/babel-plugin-import to reduce app bundle size.');
	}
	/* @remove-on-es-build-end */

/***/ }),
/* 351 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _rcInputNumber = __webpack_require__(709);
	
	var _rcInputNumber2 = _interopRequireDefault(_rcInputNumber);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var __rest = undefined && undefined.__rest || function (s, e) {
	    var t = {};
	    for (var p in s) {
	        if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
	    }if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	        if (e.indexOf(p[i]) < 0) t[p[i]] = s[p[i]];
	    }return t;
	};
	
	var InputNumber = function (_React$Component) {
	    (0, _inherits3['default'])(InputNumber, _React$Component);
	
	    function InputNumber() {
	        (0, _classCallCheck3['default'])(this, InputNumber);
	        return (0, _possibleConstructorReturn3['default'])(this, (InputNumber.__proto__ || Object.getPrototypeOf(InputNumber)).apply(this, arguments));
	    }
	
	    (0, _createClass3['default'])(InputNumber, [{
	        key: 'render',
	        value: function render() {
	            var _classNames;
	
	            var _a = this.props,
	                className = _a.className,
	                size = _a.size,
	                others = __rest(_a, ["className", "size"]);
	            var inputNumberClass = (0, _classnames2['default'])((_classNames = {}, (0, _defineProperty3['default'])(_classNames, this.props.prefixCls + '-lg', size === 'large'), (0, _defineProperty3['default'])(_classNames, this.props.prefixCls + '-sm', size === 'small'), _classNames), className);
	            return _react2['default'].createElement(_rcInputNumber2['default'], (0, _extends3['default'])({ className: inputNumberClass }, others));
	        }
	    }]);
	    return InputNumber;
	}(_react2['default'].Component);
	
	exports['default'] = InputNumber;
	
	InputNumber.defaultProps = {
	    prefixCls: 'ant-input-number',
	    step: 1
	};
	module.exports = exports['default'];

/***/ }),
/* 352 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var Group = function Group(props) {
	    var _classNames;
	
	    var _props$prefixCls = props.prefixCls,
	        prefixCls = _props$prefixCls === undefined ? 'ant-input-group' : _props$prefixCls,
	        _props$className = props.className,
	        className = _props$className === undefined ? '' : _props$className;
	
	    var cls = (0, _classnames2['default'])(prefixCls, (_classNames = {}, (0, _defineProperty3['default'])(_classNames, prefixCls + '-lg', props.size === 'large'), (0, _defineProperty3['default'])(_classNames, prefixCls + '-sm', props.size === 'small'), (0, _defineProperty3['default'])(_classNames, prefixCls + '-compact', props.compact), _classNames), className);
	    return _react2['default'].createElement(
	        'span',
	        { className: cls, style: props.style },
	        props.children
	    );
	};
	exports['default'] = Group;
	module.exports = exports['default'];

/***/ }),
/* 353 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _Input = __webpack_require__(172);
	
	var _Input2 = _interopRequireDefault(_Input);
	
	var _icon = __webpack_require__(16);
	
	var _icon2 = _interopRequireDefault(_icon);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var __rest = undefined && undefined.__rest || function (s, e) {
	    var t = {};
	    for (var p in s) {
	        if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
	    }if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	        if (e.indexOf(p[i]) < 0) t[p[i]] = s[p[i]];
	    }return t;
	};
	
	var Search = function (_React$Component) {
	    (0, _inherits3['default'])(Search, _React$Component);
	
	    function Search() {
	        (0, _classCallCheck3['default'])(this, Search);
	
	        var _this = (0, _possibleConstructorReturn3['default'])(this, (Search.__proto__ || Object.getPrototypeOf(Search)).apply(this, arguments));
	
	        _this.onSearch = function () {
	            var onSearch = _this.props.onSearch;
	
	            if (onSearch) {
	                onSearch(_this.input.refs.input.value);
	            }
	            _this.input.focus();
	        };
	        return _this;
	    }
	
	    (0, _createClass3['default'])(Search, [{
	        key: 'render',
	        value: function render() {
	            var _this2 = this;
	
	            var _a = this.props,
	                className = _a.className,
	                inputPrefixCls = _a.inputPrefixCls,
	                prefixCls = _a.prefixCls,
	                suffix = _a.suffix,
	                others = __rest(_a, ["className", "inputPrefixCls", "prefixCls", "suffix"]);
	            delete others.onSearch;
	            var searchIcon = _react2['default'].createElement(_icon2['default'], { className: prefixCls + '-icon', onClick: this.onSearch, type: 'search', key: 'searchIcon' });
	            var searchSuffix = suffix ? [suffix, searchIcon] : searchIcon;
	            return _react2['default'].createElement(_Input2['default'], (0, _extends3['default'])({ onPressEnter: this.onSearch }, others, { className: (0, _classnames2['default'])(prefixCls, className), prefixCls: inputPrefixCls, suffix: searchSuffix, ref: function ref(node) {
	                    return _this2.input = node;
	                } }));
	        }
	    }]);
	    return Search;
	}(_react2['default'].Component);
	
	exports['default'] = Search;
	
	Search.defaultProps = {
	    inputPrefixCls: 'ant-input',
	    prefixCls: 'ant-input-search'
	};
	module.exports = exports['default'];

/***/ }),
/* 354 */
/***/ (function(module, exports) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	exports['default'] = calculateNodeHeight;
	// Thanks to https://github.com/andreypopp/react-textarea-autosize/
	/**
	 * calculateNodeHeight(uiTextNode, useCache = false)
	 */
	var HIDDEN_TEXTAREA_STYLE = '\n  min-height:0 !important;\n  max-height:none !important;\n  height:0 !important;\n  visibility:hidden !important;\n  overflow:hidden !important;\n  position:absolute !important;\n  z-index:-1000 !important;\n  top:0 !important;\n  right:0 !important\n';
	var SIZING_STYLE = ['letter-spacing', 'line-height', 'padding-top', 'padding-bottom', 'font-family', 'font-weight', 'font-size', 'text-rendering', 'text-transform', 'width', 'text-indent', 'padding-left', 'padding-right', 'border-width', 'box-sizing'];
	var computedStyleCache = {};
	var hiddenTextarea = void 0;
	function calculateNodeStyling(node) {
	    var useCache = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
	
	    var nodeRef = node.getAttribute('id') || node.getAttribute('data-reactid') || node.getAttribute('name');
	    if (useCache && computedStyleCache[nodeRef]) {
	        return computedStyleCache[nodeRef];
	    }
	    var style = window.getComputedStyle(node);
	    var boxSizing = style.getPropertyValue('box-sizing') || style.getPropertyValue('-moz-box-sizing') || style.getPropertyValue('-webkit-box-sizing');
	    var paddingSize = parseFloat(style.getPropertyValue('padding-bottom')) + parseFloat(style.getPropertyValue('padding-top'));
	    var borderSize = parseFloat(style.getPropertyValue('border-bottom-width')) + parseFloat(style.getPropertyValue('border-top-width'));
	    var sizingStyle = SIZING_STYLE.map(function (name) {
	        return name + ':' + style.getPropertyValue(name);
	    }).join(';');
	    var nodeInfo = {
	        sizingStyle: sizingStyle,
	        paddingSize: paddingSize,
	        borderSize: borderSize,
	        boxSizing: boxSizing
	    };
	    if (useCache && nodeRef) {
	        computedStyleCache[nodeRef] = nodeInfo;
	    }
	    return nodeInfo;
	}
	function calculateNodeHeight(uiTextNode) {
	    var useCache = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
	    var minRows = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
	    var maxRows = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
	
	    if (!hiddenTextarea) {
	        hiddenTextarea = document.createElement('textarea');
	        document.body.appendChild(hiddenTextarea);
	    }
	    // Fix wrap="off" issue
	    // https://github.com/ant-design/ant-design/issues/6577
	    if (uiTextNode.getAttribute('wrap')) {
	        hiddenTextarea.setAttribute('wrap', uiTextNode.getAttribute('wrap'));
	    } else {
	        hiddenTextarea.removeAttribute('wrap');
	    }
	    // Copy all CSS properties that have an impact on the height of the content in
	    // the textbox
	
	    var _calculateNodeStyling = calculateNodeStyling(uiTextNode, useCache),
	        paddingSize = _calculateNodeStyling.paddingSize,
	        borderSize = _calculateNodeStyling.borderSize,
	        boxSizing = _calculateNodeStyling.boxSizing,
	        sizingStyle = _calculateNodeStyling.sizingStyle;
	    // Need to have the overflow attribute to hide the scrollbar otherwise
	    // text-lines will not calculated properly as the shadow will technically be
	    // narrower for content
	
	
	    hiddenTextarea.setAttribute('style', sizingStyle + ';' + HIDDEN_TEXTAREA_STYLE);
	    hiddenTextarea.value = uiTextNode.value || uiTextNode.placeholder || '';
	    var minHeight = -Infinity;
	    var maxHeight = Infinity;
	    var height = hiddenTextarea.scrollHeight;
	    var overflowY = void 0;
	    if (boxSizing === 'border-box') {
	        // border-box: add border, since height = content + padding + border
	        height = height + borderSize;
	    } else if (boxSizing === 'content-box') {
	        // remove padding, since height = content
	        height = height - paddingSize;
	    }
	    if (minRows !== null || maxRows !== null) {
	        // measure height of a textarea with a single row
	        hiddenTextarea.value = '';
	        var singleRowHeight = hiddenTextarea.scrollHeight - paddingSize;
	        if (minRows !== null) {
	            minHeight = singleRowHeight * minRows;
	            if (boxSizing === 'border-box') {
	                minHeight = minHeight + paddingSize + borderSize;
	            }
	            height = Math.max(minHeight, height);
	        }
	        if (maxRows !== null) {
	            maxHeight = singleRowHeight * maxRows;
	            if (boxSizing === 'border-box') {
	                maxHeight = maxHeight + paddingSize + borderSize;
	            }
	            overflowY = height > maxHeight ? '' : 'hidden';
	            height = Math.min(maxHeight, height);
	        }
	    }
	    // Remove scroll bar flash when autosize without maxRows
	    if (!maxRows) {
	        overflowY = 'hidden';
	    }
	    return { height: height, minHeight: minHeight, maxHeight: maxHeight, overflowY: overflowY };
	}
	module.exports = exports['default'];

/***/ }),
/* 355 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _omit = __webpack_require__(28);
	
	var _omit2 = _interopRequireDefault(_omit);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _icon = __webpack_require__(16);
	
	var _icon2 = _interopRequireDefault(_icon);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var __rest = undefined && undefined.__rest || function (s, e) {
	    var t = {};
	    for (var p in s) {
	        if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
	    }if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	        if (e.indexOf(p[i]) < 0) t[p[i]] = s[p[i]];
	    }return t;
	};
	// matchMedia polyfill for
	// https://github.com/WickyNilliams/enquire.js/issues/82
	if (typeof window !== 'undefined') {
	    var matchMediaPolyfill = function matchMediaPolyfill(mediaQuery) {
	        return {
	            media: mediaQuery,
	            matches: false,
	            addListener: function addListener() {},
	            removeListener: function removeListener() {}
	        };
	    };
	    window.matchMedia = window.matchMedia || matchMediaPolyfill;
	}
	
	var dimensionMap = {
	    xs: '480px',
	    sm: '768px',
	    md: '992px',
	    lg: '1200px',
	    xl: '1600px'
	};
	var generateId = function () {
	    var i = 0;
	    return function () {
	        var prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
	
	        i += 1;
	        return '' + prefix + i;
	    };
	}();
	
	var Sider = function (_React$Component) {
	    (0, _inherits3['default'])(Sider, _React$Component);
	
	    function Sider(props) {
	        (0, _classCallCheck3['default'])(this, Sider);
	
	        var _this = (0, _possibleConstructorReturn3['default'])(this, (Sider.__proto__ || Object.getPrototypeOf(Sider)).call(this, props));
	
	        _this.responsiveHandler = function (mql) {
	            _this.setState({ below: mql.matches });
	            if (_this.state.collapsed !== mql.matches) {
	                _this.setCollapsed(mql.matches, 'responsive');
	            }
	        };
	        _this.setCollapsed = function (collapsed, type) {
	            if (!('collapsed' in _this.props)) {
	                _this.setState({
	                    collapsed: collapsed
	                });
	            }
	            var onCollapse = _this.props.onCollapse;
	
	            if (onCollapse) {
	                onCollapse(collapsed, type);
	            }
	        };
	        _this.toggle = function () {
	            var collapsed = !_this.state.collapsed;
	            _this.setCollapsed(collapsed, 'clickTrigger');
	        };
	        _this.belowShowChange = function () {
	            _this.setState({ belowShow: !_this.state.belowShow });
	        };
	        _this.uniqueId = generateId('ant-sider-');
	        var matchMedia = void 0;
	        if (typeof window !== 'undefined') {
	            matchMedia = window.matchMedia;
	        }
	        if (matchMedia && props.breakpoint && props.breakpoint in dimensionMap) {
	            _this.mql = matchMedia('(max-width: ' + dimensionMap[props.breakpoint] + ')');
	        }
	        var collapsed = void 0;
	        if ('collapsed' in props) {
	            collapsed = props.collapsed;
	        } else {
	            collapsed = props.defaultCollapsed;
	        }
	        _this.state = {
	            collapsed: collapsed,
	            below: false
	        };
	        return _this;
	    }
	
	    (0, _createClass3['default'])(Sider, [{
	        key: 'getChildContext',
	        value: function getChildContext() {
	            return {
	                siderCollapsed: this.state.collapsed
	            };
	        }
	    }, {
	        key: 'componentWillReceiveProps',
	        value: function componentWillReceiveProps(nextProps) {
	            if ('collapsed' in nextProps) {
	                this.setState({
	                    collapsed: nextProps.collapsed
	                });
	            }
	        }
	    }, {
	        key: 'componentDidMount',
	        value: function componentDidMount() {
	            if (this.mql) {
	                this.mql.addListener(this.responsiveHandler);
	                this.responsiveHandler(this.mql);
	            }
	            if (this.context.siderHook) {
	                this.context.siderHook.addSider(this.uniqueId);
	            }
	        }
	    }, {
	        key: 'componentWillUnmount',
	        value: function componentWillUnmount() {
	            if (this.mql) {
	                this.mql.removeListener(this.responsiveHandler);
	            }
	            if (this.context.siderHook) {
	                this.context.siderHook.removeSider(this.uniqueId);
	            }
	        }
	    }, {
	        key: 'render',
	        value: function render() {
	            var _classNames;
	
	            var _a = this.props,
	                prefixCls = _a.prefixCls,
	                className = _a.className,
	                collapsible = _a.collapsible,
	                reverseArrow = _a.reverseArrow,
	                trigger = _a.trigger,
	                style = _a.style,
	                width = _a.width,
	                collapsedWidth = _a.collapsedWidth,
	                others = __rest(_a, ["prefixCls", "className", "collapsible", "reverseArrow", "trigger", "style", "width", "collapsedWidth"]);
	            var divProps = (0, _omit2['default'])(others, ['collapsed', 'defaultCollapsed', 'onCollapse', 'breakpoint']);
	            var siderWidth = this.state.collapsed ? collapsedWidth : width;
	            // special trigger when collapsedWidth == 0
	            var zeroWidthTrigger = collapsedWidth === 0 || collapsedWidth === '0' ? _react2['default'].createElement(
	                'span',
	                { onClick: this.toggle, className: prefixCls + '-zero-width-trigger' },
	                _react2['default'].createElement(_icon2['default'], { type: 'bars' })
	            ) : null;
	            var iconObj = {
	                'expanded': reverseArrow ? _react2['default'].createElement(_icon2['default'], { type: 'right' }) : _react2['default'].createElement(_icon2['default'], { type: 'left' }),
	                'collapsed': reverseArrow ? _react2['default'].createElement(_icon2['default'], { type: 'left' }) : _react2['default'].createElement(_icon2['default'], { type: 'right' })
	            };
	            var status = this.state.collapsed ? 'collapsed' : 'expanded';
	            var defaultTrigger = iconObj[status];
	            var triggerDom = trigger !== null ? zeroWidthTrigger || _react2['default'].createElement(
	                'div',
	                { className: prefixCls + '-trigger', onClick: this.toggle, style: { width: siderWidth } },
	                trigger || defaultTrigger
	            ) : null;
	            var divStyle = (0, _extends3['default'])({}, style, { flex: '0 0 ' + siderWidth + 'px', maxWidth: siderWidth + 'px', minWidth: siderWidth + 'px', width: siderWidth + 'px' });
	            var siderCls = (0, _classnames2['default'])(className, prefixCls, (_classNames = {}, (0, _defineProperty3['default'])(_classNames, prefixCls + '-collapsed', !!this.state.collapsed), (0, _defineProperty3['default'])(_classNames, prefixCls + '-has-trigger', !!trigger), (0, _defineProperty3['default'])(_classNames, prefixCls + '-below', !!this.state.below), (0, _defineProperty3['default'])(_classNames, prefixCls + '-zero-width', siderWidth === 0 || siderWidth === '0'), _classNames));
	            return _react2['default'].createElement(
	                'div',
	                (0, _extends3['default'])({ className: siderCls }, divProps, { style: divStyle }),
	                _react2['default'].createElement(
	                    'div',
	                    { className: prefixCls + '-children' },
	                    this.props.children
	                ),
	                collapsible || this.state.below && zeroWidthTrigger ? triggerDom : null
	            );
	        }
	    }]);
	    return Sider;
	}(_react2['default'].Component);
	
	exports['default'] = Sider;
	
	Sider.__ANT_LAYOUT_SIDER = true;
	Sider.defaultProps = {
	    prefixCls: 'ant-layout-sider',
	    collapsible: false,
	    defaultCollapsed: false,
	    reverseArrow: false,
	    width: 200,
	    collapsedWidth: 64,
	    style: {}
	};
	Sider.childContextTypes = {
	    siderCollapsed: _propTypes2['default'].bool
	};
	Sider.contextTypes = {
	    siderHook: _propTypes2['default'].object
	};
	module.exports = exports['default'];

/***/ }),
/* 356 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _layout = __webpack_require__(357);
	
	var _layout2 = _interopRequireDefault(_layout);
	
	var _Sider = __webpack_require__(355);
	
	var _Sider2 = _interopRequireDefault(_Sider);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	_layout2['default'].Sider = _Sider2['default'];
	exports['default'] = _layout2['default'];
	module.exports = exports['default'];

/***/ }),
/* 357 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _toConsumableArray2 = __webpack_require__(31);
	
	var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var __rest = undefined && undefined.__rest || function (s, e) {
	    var t = {};
	    for (var p in s) {
	        if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
	    }if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	        if (e.indexOf(p[i]) < 0) t[p[i]] = s[p[i]];
	    }return t;
	};
	
	function generator(props) {
	    return function (BasicComponent) {
	        return function (_React$Component) {
	            (0, _inherits3['default'])(Adapter, _React$Component);
	
	            function Adapter() {
	                (0, _classCallCheck3['default'])(this, Adapter);
	                return (0, _possibleConstructorReturn3['default'])(this, (Adapter.__proto__ || Object.getPrototypeOf(Adapter)).apply(this, arguments));
	            }
	
	            (0, _createClass3['default'])(Adapter, [{
	                key: 'render',
	                value: function render() {
	                    var prefixCls = props.prefixCls;
	
	                    return _react2['default'].createElement(BasicComponent, (0, _extends3['default'])({ prefixCls: prefixCls }, this.props));
	                }
	            }]);
	            return Adapter;
	        }(_react2['default'].Component);
	    };
	}
	
	var Basic = function (_React$Component2) {
	    (0, _inherits3['default'])(Basic, _React$Component2);
	
	    function Basic() {
	        (0, _classCallCheck3['default'])(this, Basic);
	        return (0, _possibleConstructorReturn3['default'])(this, (Basic.__proto__ || Object.getPrototypeOf(Basic)).apply(this, arguments));
	    }
	
	    (0, _createClass3['default'])(Basic, [{
	        key: 'render',
	        value: function render() {
	            var _a = this.props,
	                prefixCls = _a.prefixCls,
	                className = _a.className,
	                children = _a.children,
	                others = __rest(_a, ["prefixCls", "className", "children"]);
	            var divCls = (0, _classnames2['default'])(className, prefixCls);
	            return _react2['default'].createElement(
	                'div',
	                (0, _extends3['default'])({ className: divCls }, others),
	                children
	            );
	        }
	    }]);
	    return Basic;
	}(_react2['default'].Component);
	
	var BasicLayout = function (_React$Component3) {
	    (0, _inherits3['default'])(BasicLayout, _React$Component3);
	
	    function BasicLayout() {
	        (0, _classCallCheck3['default'])(this, BasicLayout);
	
	        var _this3 = (0, _possibleConstructorReturn3['default'])(this, (BasicLayout.__proto__ || Object.getPrototypeOf(BasicLayout)).apply(this, arguments));
	
	        _this3.state = { siders: [] };
	        return _this3;
	    }
	
	    (0, _createClass3['default'])(BasicLayout, [{
	        key: 'getChildContext',
	        value: function getChildContext() {
	            var _this4 = this;
	
	            return {
	                siderHook: {
	                    addSider: function addSider(id) {
	                        _this4.setState({
	                            siders: [].concat((0, _toConsumableArray3['default'])(_this4.state.siders), [id])
	                        });
	                    },
	                    removeSider: function removeSider(id) {
	                        _this4.setState({
	                            siders: _this4.state.siders.filter(function (currentId) {
	                                return currentId !== id;
	                            })
	                        });
	                    }
	                }
	            };
	        }
	    }, {
	        key: 'render',
	        value: function render() {
	            var _a = this.props,
	                prefixCls = _a.prefixCls,
	                className = _a.className,
	                children = _a.children,
	                others = __rest(_a, ["prefixCls", "className", "children"]);
	            var divCls = (0, _classnames2['default'])(className, prefixCls, (0, _defineProperty3['default'])({}, prefixCls + '-has-sider', this.state.siders.length > 0));
	            return _react2['default'].createElement(
	                'div',
	                (0, _extends3['default'])({ className: divCls }, others),
	                children
	            );
	        }
	    }]);
	    return BasicLayout;
	}(_react2['default'].Component);
	
	BasicLayout.childContextTypes = {
	    siderHook: _propTypes2['default'].object
	};
	var Layout = generator({
	    prefixCls: 'ant-layout'
	})(BasicLayout);
	var Header = generator({
	    prefixCls: 'ant-layout-header'
	})(Basic);
	var Footer = generator({
	    prefixCls: 'ant-layout-footer'
	})(Basic);
	var Content = generator({
	    prefixCls: 'ant-layout-content'
	})(Basic);
	Layout.Header = Header;
	Layout.Footer = Footer;
	Layout.Content = Content;
	exports['default'] = Layout;
	module.exports = exports['default'];

/***/ }),
/* 358 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _locale = __webpack_require__(176);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var LocaleProvider = function (_React$Component) {
	    (0, _inherits3['default'])(LocaleProvider, _React$Component);
	
	    function LocaleProvider() {
	        (0, _classCallCheck3['default'])(this, LocaleProvider);
	        return (0, _possibleConstructorReturn3['default'])(this, (LocaleProvider.__proto__ || Object.getPrototypeOf(LocaleProvider)).apply(this, arguments));
	    }
	
	    (0, _createClass3['default'])(LocaleProvider, [{
	        key: 'getChildContext',
	        value: function getChildContext() {
	            return {
	                antLocale: (0, _extends3['default'])({}, this.props.locale, { exist: true })
	            };
	        }
	    }, {
	        key: 'componentWillMount',
	        value: function componentWillMount() {
	            this.componentDidUpdate();
	        }
	    }, {
	        key: 'componentDidUpdate',
	        value: function componentDidUpdate() {
	            var locale = this.props.locale;
	
	            (0, _locale.changeConfirmLocale)(locale && locale.Modal);
	        }
	    }, {
	        key: 'componentWillUnMount',
	        value: function componentWillUnMount() {
	            (0, _locale.changeConfirmLocale)();
	        }
	    }, {
	        key: 'render',
	        value: function render() {
	            return _react2['default'].Children.only(this.props.children);
	        }
	    }]);
	    return LocaleProvider;
	}(_react2['default'].Component);
	
	exports['default'] = LocaleProvider;
	
	LocaleProvider.propTypes = {
	    locale: _propTypes2['default'].object
	};
	LocaleProvider.childContextTypes = {
	    antLocale: _propTypes2['default'].object
	};
	module.exports = exports['default'];

/***/ }),
/* 359 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _rcEditorMention = __webpack_require__(700);
	
	var _rcEditorMention2 = _interopRequireDefault(_rcEditorMention);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _shallowequal = __webpack_require__(45);
	
	var _shallowequal2 = _interopRequireDefault(_shallowequal);
	
	var _icon = __webpack_require__(16);
	
	var _icon2 = _interopRequireDefault(_icon);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var Mention = function (_React$Component) {
	    (0, _inherits3['default'])(Mention, _React$Component);
	
	    function Mention(props) {
	        (0, _classCallCheck3['default'])(this, Mention);
	
	        var _this = (0, _possibleConstructorReturn3['default'])(this, (Mention.__proto__ || Object.getPrototypeOf(Mention)).call(this, props));
	
	        _this.onSearchChange = function (value, prefix) {
	            if (_this.props.onSearchChange) {
	                return _this.props.onSearchChange(value, prefix);
	            }
	            return _this.defaultSearchChange(value);
	        };
	        _this.onChange = function (editorState) {
	            if (_this.props.onChange) {
	                _this.props.onChange(editorState);
	            }
	        };
	        _this.onFocus = function (ev) {
	            _this.setState({
	                focus: true
	            });
	            if (_this.props.onFocus) {
	                _this.props.onFocus(ev);
	            }
	        };
	        _this.onBlur = function (ev) {
	            _this.setState({
	                focus: false
	            });
	            if (_this.props.onBlur) {
	                _this.props.onBlur(ev);
	            }
	        };
	        _this.focus = function () {
	            _this.mentionEle._editor.focus();
	        };
	        _this.mentionRef = function (ele) {
	            _this.mentionEle = ele;
	        };
	        _this.state = {
	            suggestions: props.suggestions,
	            focus: false
	        };
	        return _this;
	    }
	
	    (0, _createClass3['default'])(Mention, [{
	        key: 'componentWillReceiveProps',
	        value: function componentWillReceiveProps(nextProps) {
	            var suggestions = nextProps.suggestions;
	
	            if (!(0, _shallowequal2['default'])(suggestions, this.props.suggestions)) {
	                this.setState({
	                    suggestions: suggestions
	                });
	            }
	        }
	    }, {
	        key: 'defaultSearchChange',
	        value: function defaultSearchChange(value) {
	            var searchValue = value.toLowerCase();
	            var filteredSuggestions = (this.props.suggestions || []).filter(function (suggestion) {
	                if (suggestion.type && suggestion.type === _rcEditorMention.Nav) {
	                    return suggestion.props.value ? suggestion.props.value.toLowerCase().indexOf(searchValue) !== -1 : true;
	                }
	                return suggestion.toLowerCase().indexOf(searchValue) !== -1;
	            });
	            this.setState({
	                suggestions: filteredSuggestions
	            });
	        }
	    }, {
	        key: 'render',
	        value: function render() {
	            var _props = this.props,
	                _props$className = _props.className,
	                className = _props$className === undefined ? '' : _props$className,
	                prefixCls = _props.prefixCls,
	                loading = _props.loading;
	            var _state = this.state,
	                suggestions = _state.suggestions,
	                focus = _state.focus;
	
	            var cls = (0, _classnames2['default'])(className, (0, _defineProperty3['default'])({}, prefixCls + '-active', focus));
	            var notFoundContent = loading ? _react2['default'].createElement(_icon2['default'], { type: 'loading' }) : this.props.notFoundContent;
	            return _react2['default'].createElement(_rcEditorMention2['default'], (0, _extends3['default'])({}, this.props, { className: cls, ref: this.mentionRef, onSearchChange: this.onSearchChange, onChange: this.onChange, onFocus: this.onFocus, onBlur: this.onBlur, suggestions: suggestions, notFoundContent: notFoundContent }));
	        }
	    }]);
	    return Mention;
	}(_react2['default'].Component);
	
	exports['default'] = Mention;
	
	Mention.getMentions = _rcEditorMention.getMentions;
	Mention.defaultProps = {
	    prefixCls: 'ant-mention',
	    notFoundContent: '无匹配结果，轻敲空格完成输入',
	    loading: false,
	    multiLines: false
	};
	Mention.Nav = _rcEditorMention.Nav;
	Mention.toString = _rcEditorMention.toString;
	Mention.toContentState = _rcEditorMention.toEditorState;
	Mention.toEditorState = function (text) {
	    console.warn('Mention.toEditorState is deprecated. Use toContentState instead.');
	    return (0, _rcEditorMention.toEditorState)(text);
	};
	module.exports = exports['default'];

/***/ }),
/* 360 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _rcMenu = __webpack_require__(77);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _tooltip = __webpack_require__(56);
	
	var _tooltip2 = _interopRequireDefault(_tooltip);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var MenuItem = function (_React$Component) {
	    (0, _inherits3['default'])(MenuItem, _React$Component);
	
	    function MenuItem() {
	        (0, _classCallCheck3['default'])(this, MenuItem);
	        return (0, _possibleConstructorReturn3['default'])(this, (MenuItem.__proto__ || Object.getPrototypeOf(MenuItem)).apply(this, arguments));
	    }
	
	    (0, _createClass3['default'])(MenuItem, [{
	        key: 'render',
	        value: function render() {
	            var inlineCollapsed = this.context.inlineCollapsed;
	
	            var props = this.props;
	            return _react2['default'].createElement(
	                _tooltip2['default'],
	                { title: inlineCollapsed && props.level === 1 ? props.children : '', placement: 'right', overlayClassName: props.rootPrefixCls + '-inline-collapsed-tooltip' },
	                _react2['default'].createElement(_rcMenu.Item, props)
	            );
	        }
	    }]);
	    return MenuItem;
	}(_react2['default'].Component);
	
	MenuItem.contextTypes = {
	    inlineCollapsed: _propTypes2['default'].bool
	};
	MenuItem.isMenuItem = 1;
	exports['default'] = MenuItem;
	module.exports = exports['default'];

/***/ }),
/* 361 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _rcNotification = __webpack_require__(261);
	
	var _rcNotification2 = _interopRequireDefault(_rcNotification);
	
	var _icon = __webpack_require__(16);
	
	var _icon2 = _interopRequireDefault(_icon);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var defaultDuration = 3;
	var defaultTop = void 0;
	var messageInstance = void 0;
	var key = 1;
	var prefixCls = 'ant-message';
	var getContainer = void 0;
	function getMessageInstance() {
	    messageInstance = messageInstance || _rcNotification2['default'].newInstance({
	        prefixCls: prefixCls,
	        transitionName: 'move-up',
	        style: { top: defaultTop },
	        getContainer: getContainer
	    });
	    return messageInstance;
	}
	function notice(content) {
	    var duration = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : defaultDuration;
	    var type = arguments[2];
	    var onClose = arguments[3];
	
	    var iconType = {
	        info: 'info-circle',
	        success: 'check-circle',
	        error: 'cross-circle',
	        warning: 'exclamation-circle',
	        loading: 'loading'
	    }[type];
	    var instance = getMessageInstance();
	    instance.notice({
	        key: key,
	        duration: duration,
	        style: {},
	        content: _react2['default'].createElement(
	            'div',
	            { className: prefixCls + '-custom-content ' + prefixCls + '-' + type },
	            _react2['default'].createElement(_icon2['default'], { type: iconType }),
	            _react2['default'].createElement(
	                'span',
	                null,
	                content
	            )
	        ),
	        onClose: onClose
	    });
	    return function () {
	        var target = key++;
	        return function () {
	            instance.removeNotice(target);
	        };
	    }();
	}
	exports['default'] = {
	    info: function info(content, duration, onClose) {
	        return notice(content, duration, 'info', onClose);
	    },
	    success: function success(content, duration, onClose) {
	        return notice(content, duration, 'success', onClose);
	    },
	    error: function error(content, duration, onClose) {
	        return notice(content, duration, 'error', onClose);
	    },
	
	    // Departed usage, please use warning()
	    warn: function warn(content, duration, onClose) {
	        return notice(content, duration, 'warning', onClose);
	    },
	    warning: function warning(content, duration, onClose) {
	        return notice(content, duration, 'warning', onClose);
	    },
	    loading: function loading(content, duration, onClose) {
	        return notice(content, duration, 'loading', onClose);
	    },
	    config: function config(options) {
	        if (options.top !== undefined) {
	            defaultTop = options.top;
	            messageInstance = null; // delete messageInstance for new defaultTop
	        }
	        if (options.duration !== undefined) {
	            defaultDuration = options.duration;
	        }
	        if (options.prefixCls !== undefined) {
	            prefixCls = options.prefixCls;
	        }
	        if (options.getContainer !== undefined) {
	            getContainer = options.getContainer;
	        }
	    },
	    destroy: function destroy() {
	        if (messageInstance) {
	            messageInstance.destroy();
	            messageInstance = null;
	        }
	    }
	};
	module.exports = exports['default'];

/***/ }),
/* 362 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _reactDom = __webpack_require__(10);
	
	var _reactDom2 = _interopRequireDefault(_reactDom);
	
	var _button = __webpack_require__(54);
	
	var _button2 = _interopRequireDefault(_button);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var ActionButton = function (_React$Component) {
	    (0, _inherits3['default'])(ActionButton, _React$Component);
	
	    function ActionButton(props) {
	        (0, _classCallCheck3['default'])(this, ActionButton);
	
	        var _this = (0, _possibleConstructorReturn3['default'])(this, (ActionButton.__proto__ || Object.getPrototypeOf(ActionButton)).call(this, props));
	
	        _this.onClick = function () {
	            var _this$props = _this.props,
	                actionFn = _this$props.actionFn,
	                closeModal = _this$props.closeModal;
	
	            if (actionFn) {
	                var ret = void 0;
	                if (actionFn.length) {
	                    ret = actionFn(closeModal);
	                } else {
	                    ret = actionFn();
	                    if (!ret) {
	                        closeModal();
	                    }
	                }
	                if (ret && ret.then) {
	                    _this.setState({ loading: true });
	                    ret.then(function () {
	                        // It's unnecessary to set loading=false, for the Modal will be unmounted after close.
	                        // this.setState({ loading: false });
	                        closeModal.apply(undefined, arguments);
	                    }, function () {
	                        // See: https://github.com/ant-design/ant-design/issues/6183
	                        _this.setState({ loading: false });
	                    });
	                }
	            } else {
	                closeModal();
	            }
	        };
	        _this.state = {
	            loading: false
	        };
	        return _this;
	    }
	
	    (0, _createClass3['default'])(ActionButton, [{
	        key: 'componentDidMount',
	        value: function componentDidMount() {
	            if (this.props.autoFocus) {
	                var $this = _reactDom2['default'].findDOMNode(this);
	                this.timeoutId = setTimeout(function () {
	                    return $this.focus();
	                });
	            }
	        }
	    }, {
	        key: 'componentWillUnmount',
	        value: function componentWillUnmount() {
	            clearTimeout(this.timeoutId);
	        }
	    }, {
	        key: 'render',
	        value: function render() {
	            var _props = this.props,
	                type = _props.type,
	                children = _props.children;
	
	            var loading = this.state.loading;
	            return _react2['default'].createElement(
	                _button2['default'],
	                { type: type, size: 'large', onClick: this.onClick, loading: loading },
	                children
	            );
	        }
	    }]);
	    return ActionButton;
	}(_react2['default'].Component);
	
	exports['default'] = ActionButton;
	module.exports = exports['default'];

/***/ }),
/* 363 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	exports['default'] = confirm;
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _reactDom = __webpack_require__(10);
	
	var _reactDom2 = _interopRequireDefault(_reactDom);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _icon = __webpack_require__(16);
	
	var _icon2 = _interopRequireDefault(_icon);
	
	var _Modal = __webpack_require__(175);
	
	var _Modal2 = _interopRequireDefault(_Modal);
	
	var _ActionButton = __webpack_require__(362);
	
	var _ActionButton2 = _interopRequireDefault(_ActionButton);
	
	var _locale = __webpack_require__(176);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function confirm(config) {
	    var props = (0, _extends3['default'])({ iconType: 'question-circle', okType: 'primary' }, config);
	    var prefixCls = props.prefixCls || 'ant-confirm';
	    var div = document.createElement('div');
	    document.body.appendChild(div);
	    var width = props.width || 416;
	    var style = props.style || {};
	    // 默认为 false，保持旧版默认行为
	    var maskClosable = props.maskClosable === undefined ? false : props.maskClosable;
	    // 默认为 true，保持向下兼容
	    if (!('okCancel' in props)) {
	        props.okCancel = true;
	    }
	    var runtimeLocale = (0, _locale.getConfirmLocale)();
	    props.okText = props.okText || (props.okCancel ? runtimeLocale.okText : runtimeLocale.justOkText);
	    props.cancelText = props.cancelText || runtimeLocale.cancelText;
	    function close() {
	        var unmountResult = _reactDom2['default'].unmountComponentAtNode(div);
	        if (unmountResult && div.parentNode) {
	            div.parentNode.removeChild(div);
	        }
	
	        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
	            args[_key] = arguments[_key];
	        }
	
	        var triggerCancel = args && args.length && args.some(function (param) {
	            return param && param.triggerCancel;
	        });
	        if (props.onCancel && triggerCancel) {
	            props.onCancel.apply(props, args);
	        }
	    }
	    var body = _react2['default'].createElement(
	        'div',
	        { className: prefixCls + '-body' },
	        _react2['default'].createElement(_icon2['default'], { type: props.iconType }),
	        _react2['default'].createElement(
	            'span',
	            { className: prefixCls + '-title' },
	            props.title
	        ),
	        _react2['default'].createElement(
	            'div',
	            { className: prefixCls + '-content' },
	            props.content
	        )
	    );
	    var footer = null;
	    if (props.okCancel) {
	        footer = _react2['default'].createElement(
	            'div',
	            { className: prefixCls + '-btns' },
	            _react2['default'].createElement(
	                _ActionButton2['default'],
	                { actionFn: props.onCancel, closeModal: close },
	                props.cancelText
	            ),
	            _react2['default'].createElement(
	                _ActionButton2['default'],
	                { type: props.okType, actionFn: props.onOk, closeModal: close, autoFocus: true },
	                props.okText
	            )
	        );
	    } else {
	        footer = _react2['default'].createElement(
	            'div',
	            { className: prefixCls + '-btns' },
	            _react2['default'].createElement(
	                _ActionButton2['default'],
	                { type: props.okType, actionFn: props.onOk, closeModal: close, autoFocus: true },
	                props.okText
	            )
	        );
	    }
	    var classString = (0, _classnames2['default'])(prefixCls, (0, _defineProperty3['default'])({}, prefixCls + '-' + props.type, true), props.className);
	    _reactDom2['default'].render(_react2['default'].createElement(
	        _Modal2['default'],
	        { className: classString, onCancel: close.bind(this, { triggerCancel: true }), visible: true, title: '', transitionName: 'zoom', footer: '', maskTransitionName: 'fade', maskClosable: maskClosable, style: style, width: width, zIndex: props.zIndex },
	        _react2['default'].createElement(
	            'div',
	            { className: prefixCls + '-body-wrapper' },
	            body,
	            ' ',
	            footer
	        )
	    ), div);
	    return {
	        destroy: close
	    };
	}
	module.exports = exports['default'];

/***/ }),
/* 364 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	exports.ModalFuncProps = undefined;
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _Modal = __webpack_require__(175);
	
	var _Modal2 = _interopRequireDefault(_Modal);
	
	var _confirm = __webpack_require__(363);
	
	var _confirm2 = _interopRequireDefault(_confirm);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	exports.ModalFuncProps = _Modal.ModalFuncProps;
	
	_Modal2['default'].info = function (props) {
	    var config = (0, _extends3['default'])({ type: 'info', iconType: 'info-circle', okCancel: false }, props);
	    return (0, _confirm2['default'])(config);
	};
	_Modal2['default'].success = function (props) {
	    var config = (0, _extends3['default'])({ type: 'success', iconType: 'check-circle', okCancel: false }, props);
	    return (0, _confirm2['default'])(config);
	};
	_Modal2['default'].error = function (props) {
	    var config = (0, _extends3['default'])({ type: 'error', iconType: 'cross-circle', okCancel: false }, props);
	    return (0, _confirm2['default'])(config);
	};
	_Modal2['default'].warning = _Modal2['default'].warn = function (props) {
	    var config = (0, _extends3['default'])({ type: 'warning', iconType: 'exclamation-circle', okCancel: false }, props);
	    return (0, _confirm2['default'])(config);
	};
	_Modal2['default'].confirm = function (props) {
	    var config = (0, _extends3['default'])({ type: 'confirm', okCancel: true }, props);
	    return (0, _confirm2['default'])(config);
	};
	exports['default'] = _Modal2['default'];

/***/ }),
/* 365 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _rcNotification = __webpack_require__(261);
	
	var _rcNotification2 = _interopRequireDefault(_rcNotification);
	
	var _icon = __webpack_require__(16);
	
	var _icon2 = _interopRequireDefault(_icon);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var notificationInstance = {};
	var defaultDuration = 4.5;
	var defaultTop = 24;
	var defaultBottom = 24;
	var defaultPlacement = 'topRight';
	var defaultGetContainer = void 0;
	function setNotificationConfig(options) {
	    var duration = options.duration,
	        placement = options.placement,
	        bottom = options.bottom,
	        top = options.top,
	        getContainer = options.getContainer;
	
	    if (duration !== undefined) {
	        defaultDuration = duration;
	    }
	    if (placement !== undefined) {
	        defaultPlacement = placement;
	    }
	    if (bottom !== undefined) {
	        defaultBottom = bottom;
	    }
	    if (top !== undefined) {
	        defaultTop = top;
	    }
	    if (getContainer !== undefined) {
	        defaultGetContainer = getContainer;
	    }
	}
	function getPlacementStyle(placement) {
	    var style = void 0;
	    switch (placement) {
	        case 'topLeft':
	            style = {
	                left: 0,
	                top: defaultTop,
	                bottom: 'auto'
	            };
	            break;
	        case 'topRight':
	            style = {
	                right: 0,
	                top: defaultTop,
	                bottom: 'auto'
	            };
	            break;
	        case 'bottomLeft':
	            style = {
	                left: 0,
	                top: 'auto',
	                bottom: defaultBottom
	            };
	            break;
	        default:
	            style = {
	                right: 0,
	                top: 'auto',
	                bottom: defaultBottom
	            };
	            break;
	    }
	    return style;
	}
	function getNotificationInstance(prefixCls, placement) {
	    var cacheKey = prefixCls + '-' + placement;
	    if (!notificationInstance[cacheKey]) {
	        notificationInstance[cacheKey] = _rcNotification2['default'].newInstance({
	            prefixCls: prefixCls,
	            className: prefixCls + '-' + placement,
	            style: getPlacementStyle(placement),
	            getContainer: defaultGetContainer
	        });
	    }
	    return notificationInstance[cacheKey];
	}
	var typeToIcon = {
	    success: 'check-circle-o',
	    info: 'info-circle-o',
	    error: 'cross-circle-o',
	    warning: 'exclamation-circle-o'
	};
	function notice(args) {
	    var outerPrefixCls = args.prefixCls || 'ant-notification';
	    var prefixCls = outerPrefixCls + '-notice';
	    var duration = args.duration === undefined ? defaultDuration : args.duration;
	    var iconNode = null;
	    if (args.icon) {
	        iconNode = _react2['default'].createElement(
	            'span',
	            { className: prefixCls + '-icon' },
	            args.icon
	        );
	    } else if (args.type) {
	        var iconType = typeToIcon[args.type];
	        iconNode = _react2['default'].createElement(_icon2['default'], { className: prefixCls + '-icon ' + prefixCls + '-icon-' + args.type, type: iconType });
	    }
	    var autoMarginTag = !args.description && iconNode ? _react2['default'].createElement('span', { className: prefixCls + '-message-single-line-auto-margin' }) : null;
	    getNotificationInstance(outerPrefixCls, args.placement || defaultPlacement).notice({
	        content: _react2['default'].createElement(
	            'div',
	            { className: iconNode ? prefixCls + '-with-icon' : '' },
	            iconNode,
	            _react2['default'].createElement(
	                'div',
	                { className: prefixCls + '-message' },
	                autoMarginTag,
	                args.message
	            ),
	            _react2['default'].createElement(
	                'div',
	                { className: prefixCls + '-description' },
	                args.description
	            ),
	            args.btn ? _react2['default'].createElement(
	                'span',
	                { className: prefixCls + '-btn' },
	                args.btn
	            ) : null
	        ),
	        duration: duration,
	        closable: true,
	        onClose: args.onClose,
	        key: args.key,
	        style: args.style || {},
	        className: args.className
	    });
	}
	var api = {
	    open: notice,
	    close: function close(key) {
	        Object.keys(notificationInstance).forEach(function (cacheKey) {
	            return notificationInstance[cacheKey].removeNotice(key);
	        });
	    },
	
	    config: setNotificationConfig,
	    destroy: function destroy() {
	        Object.keys(notificationInstance).forEach(function (cacheKey) {
	            notificationInstance[cacheKey].destroy();
	            delete notificationInstance[cacheKey];
	        });
	    }
	};
	['success', 'info', 'warning', 'error'].forEach(function (type) {
	    api[type] = function (args) {
	        return api.open((0, _extends3['default'])({}, args, { type: type }));
	    };
	});
	api.warn = api.warning;
	exports['default'] = api;
	module.exports = exports['default'];

/***/ }),
/* 366 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _select = __webpack_require__(68);
	
	var _select2 = _interopRequireDefault(_select);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var MiniSelect = function (_React$Component) {
	    (0, _inherits3['default'])(MiniSelect, _React$Component);
	
	    function MiniSelect() {
	        (0, _classCallCheck3['default'])(this, MiniSelect);
	        return (0, _possibleConstructorReturn3['default'])(this, (MiniSelect.__proto__ || Object.getPrototypeOf(MiniSelect)).apply(this, arguments));
	    }
	
	    (0, _createClass3['default'])(MiniSelect, [{
	        key: 'render',
	        value: function render() {
	            return _react2['default'].createElement(_select2['default'], (0, _extends3['default'])({ size: 'small' }, this.props));
	        }
	    }]);
	    return MiniSelect;
	}(_react2['default'].Component);
	
	exports['default'] = MiniSelect;
	
	MiniSelect.Option = _select2['default'].Option;
	module.exports = exports['default'];

/***/ }),
/* 367 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _rcPagination = __webpack_require__(724);
	
	var _rcPagination2 = _interopRequireDefault(_rcPagination);
	
	var _zh_CN = __webpack_require__(263);
	
	var _zh_CN2 = _interopRequireDefault(_zh_CN);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _injectLocale = __webpack_require__(67);
	
	var _injectLocale2 = _interopRequireDefault(_injectLocale);
	
	var _select = __webpack_require__(68);
	
	var _select2 = _interopRequireDefault(_select);
	
	var _MiniSelect = __webpack_require__(366);
	
	var _MiniSelect2 = _interopRequireDefault(_MiniSelect);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var __rest = undefined && undefined.__rest || function (s, e) {
	    var t = {};
	    for (var p in s) {
	        if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
	    }if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	        if (e.indexOf(p[i]) < 0) t[p[i]] = s[p[i]];
	    }return t;
	};
	
	var Pagination = function (_React$Component) {
	    (0, _inherits3['default'])(Pagination, _React$Component);
	
	    function Pagination() {
	        (0, _classCallCheck3['default'])(this, Pagination);
	        return (0, _possibleConstructorReturn3['default'])(this, (Pagination.__proto__ || Object.getPrototypeOf(Pagination)).apply(this, arguments));
	    }
	
	    (0, _createClass3['default'])(Pagination, [{
	        key: 'render',
	        value: function render() {
	            var _a = this.props,
	                className = _a.className,
	                size = _a.size,
	                restProps = __rest(_a, ["className", "size"]);
	            var locale = this.getLocale();
	            var isSmall = size === 'small';
	            return _react2['default'].createElement(_rcPagination2['default'], (0, _extends3['default'])({}, restProps, { className: (0, _classnames2['default'])(className, { mini: isSmall }), selectComponentClass: isSmall ? _MiniSelect2['default'] : _select2['default'], locale: locale }));
	        }
	    }]);
	    return Pagination;
	}(_react2['default'].Component);
	
	Pagination.defaultProps = {
	    prefixCls: 'ant-pagination',
	    selectPrefixCls: 'ant-select'
	};
	var injectPaginationLocale = (0, _injectLocale2['default'])('Pagination', _zh_CN2['default']);
	exports['default'] = injectPaginationLocale(Pagination);
	module.exports = exports['default'];

/***/ }),
/* 368 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _tooltip = __webpack_require__(56);
	
	var _tooltip2 = _interopRequireDefault(_tooltip);
	
	var _icon = __webpack_require__(16);
	
	var _icon2 = _interopRequireDefault(_icon);
	
	var _button = __webpack_require__(54);
	
	var _button2 = _interopRequireDefault(_button);
	
	var _injectLocale = __webpack_require__(67);
	
	var _injectLocale2 = _interopRequireDefault(_injectLocale);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var __rest = undefined && undefined.__rest || function (s, e) {
	    var t = {};
	    for (var p in s) {
	        if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
	    }if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	        if (e.indexOf(p[i]) < 0) t[p[i]] = s[p[i]];
	    }return t;
	};
	
	var Popconfirm = function (_React$Component) {
	    (0, _inherits3['default'])(Popconfirm, _React$Component);
	
	    function Popconfirm(props) {
	        (0, _classCallCheck3['default'])(this, Popconfirm);
	
	        var _this = (0, _possibleConstructorReturn3['default'])(this, (Popconfirm.__proto__ || Object.getPrototypeOf(Popconfirm)).call(this, props));
	
	        _this.onConfirm = function (e) {
	            _this.setVisible(false);
	            var onConfirm = _this.props.onConfirm;
	
	            if (onConfirm) {
	                onConfirm.call(_this, e);
	            }
	        };
	        _this.onCancel = function (e) {
	            _this.setVisible(false);
	            var onCancel = _this.props.onCancel;
	
	            if (onCancel) {
	                onCancel.call(_this, e);
	            }
	        };
	        _this.onVisibleChange = function (visible) {
	            _this.setVisible(visible);
	        };
	        _this.state = {
	            visible: props.visible
	        };
	        return _this;
	    }
	
	    (0, _createClass3['default'])(Popconfirm, [{
	        key: 'componentWillReceiveProps',
	        value: function componentWillReceiveProps(nextProps) {
	            if ('visible' in nextProps) {
	                this.setState({ visible: nextProps.visible });
	            }
	        }
	    }, {
	        key: 'getPopupDomNode',
	        value: function getPopupDomNode() {
	            return this.refs.tooltip.getPopupDomNode();
	        }
	    }, {
	        key: 'setVisible',
	        value: function setVisible(visible) {
	            var props = this.props;
	            if (!('visible' in props)) {
	                this.setState({ visible: visible });
	            }
	            var onVisibleChange = props.onVisibleChange;
	
	            if (onVisibleChange) {
	                onVisibleChange(visible);
	            }
	        }
	    }, {
	        key: 'render',
	        value: function render() {
	            var _a = this.props,
	                prefixCls = _a.prefixCls,
	                title = _a.title,
	                placement = _a.placement,
	                okText = _a.okText,
	                okType = _a.okType,
	                cancelText = _a.cancelText,
	                restProps = __rest(_a, ["prefixCls", "title", "placement", "okText", "okType", "cancelText"]);
	            var popconfirmLocale = this.getLocale();
	            var overlay = _react2['default'].createElement(
	                'div',
	                null,
	                _react2['default'].createElement(
	                    'div',
	                    { className: prefixCls + '-inner-content' },
	                    _react2['default'].createElement(
	                        'div',
	                        { className: prefixCls + '-message' },
	                        _react2['default'].createElement(_icon2['default'], { type: 'exclamation-circle' }),
	                        _react2['default'].createElement(
	                            'div',
	                            { className: prefixCls + '-message-title' },
	                            title
	                        )
	                    ),
	                    _react2['default'].createElement(
	                        'div',
	                        { className: prefixCls + '-buttons' },
	                        _react2['default'].createElement(
	                            _button2['default'],
	                            { onClick: this.onCancel, size: 'small' },
	                            cancelText || popconfirmLocale.cancelText
	                        ),
	                        _react2['default'].createElement(
	                            _button2['default'],
	                            { onClick: this.onConfirm, type: okType, size: 'small' },
	                            okText || popconfirmLocale.okText
	                        )
	                    )
	                )
	            );
	            return _react2['default'].createElement(_tooltip2['default'], (0, _extends3['default'])({}, restProps, { prefixCls: prefixCls, placement: placement, onVisibleChange: this.onVisibleChange, visible: this.state.visible, overlay: overlay, ref: 'tooltip' }));
	        }
	    }]);
	    return Popconfirm;
	}(_react2['default'].Component);
	
	Popconfirm.defaultProps = {
	    prefixCls: 'ant-popover',
	    transitionName: 'zoom-big',
	    placement: 'top',
	    trigger: 'click',
	    okType: 'primary'
	};
	var injectPopconfirmLocale = (0, _injectLocale2['default'])('Popconfirm', {
	    cancelText: '取消',
	    okText: '确定'
	});
	exports['default'] = injectPopconfirmLocale(Popconfirm);
	module.exports = exports['default'];

/***/ }),
/* 369 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _tooltip = __webpack_require__(56);
	
	var _tooltip2 = _interopRequireDefault(_tooltip);
	
	var _warning = __webpack_require__(24);
	
	var _warning2 = _interopRequireDefault(_warning);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var Popover = function (_React$Component) {
	    (0, _inherits3['default'])(Popover, _React$Component);
	
	    function Popover() {
	        (0, _classCallCheck3['default'])(this, Popover);
	        return (0, _possibleConstructorReturn3['default'])(this, (Popover.__proto__ || Object.getPrototypeOf(Popover)).apply(this, arguments));
	    }
	
	    (0, _createClass3['default'])(Popover, [{
	        key: 'getPopupDomNode',
	        value: function getPopupDomNode() {
	            return this.refs.tooltip.getPopupDomNode();
	        }
	    }, {
	        key: 'getOverlay',
	        value: function getOverlay() {
	            var _props = this.props,
	                title = _props.title,
	                prefixCls = _props.prefixCls,
	                content = _props.content;
	
	            (0, _warning2['default'])(!('overlay' in this.props), 'Popover[overlay] is removed, please use Popover[content] instead, ' + 'see: https://u.ant.design/popover-content');
	            return _react2['default'].createElement(
	                'div',
	                null,
	                title && _react2['default'].createElement(
	                    'div',
	                    { className: prefixCls + '-title' },
	                    title
	                ),
	                _react2['default'].createElement(
	                    'div',
	                    { className: prefixCls + '-inner-content' },
	                    content
	                )
	            );
	        }
	    }, {
	        key: 'render',
	        value: function render() {
	            var props = (0, _extends3['default'])({}, this.props);
	            delete props.title;
	            return _react2['default'].createElement(_tooltip2['default'], (0, _extends3['default'])({}, props, { ref: 'tooltip', overlay: this.getOverlay() }));
	        }
	    }]);
	    return Popover;
	}(_react2['default'].Component);
	
	exports['default'] = Popover;
	
	Popover.defaultProps = {
	    prefixCls: 'ant-popover',
	    placement: 'top',
	    transitionName: 'zoom-big',
	    trigger: 'hover',
	    mouseEnterDelay: 0.1,
	    mouseLeaveDelay: 0.1,
	    overlayStyle: {}
	};
	module.exports = exports['default'];

/***/ }),
/* 370 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _icon = __webpack_require__(16);
	
	var _icon2 = _interopRequireDefault(_icon);
	
	var _rcProgress = __webpack_require__(727);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var __rest = undefined && undefined.__rest || function (s, e) {
	    var t = {};
	    for (var p in s) {
	        if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
	    }if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	        if (e.indexOf(p[i]) < 0) t[p[i]] = s[p[i]];
	    }return t;
	};
	
	var statusColorMap = {
	    normal: '#108ee9',
	    exception: '#ff5500',
	    success: '#87d068'
	};
	
	var Progress = function (_React$Component) {
	    (0, _inherits3['default'])(Progress, _React$Component);
	
	    function Progress() {
	        (0, _classCallCheck3['default'])(this, Progress);
	        return (0, _possibleConstructorReturn3['default'])(this, (Progress.__proto__ || Object.getPrototypeOf(Progress)).apply(this, arguments));
	    }
	
	    (0, _createClass3['default'])(Progress, [{
	        key: 'render',
	        value: function render() {
	            var _classNames;
	
	            var props = this.props;
	
	            var prefixCls = props.prefixCls,
	                className = props.className,
	                _props$percent = props.percent,
	                percent = _props$percent === undefined ? 0 : _props$percent,
	                status = props.status,
	                format = props.format,
	                trailColor = props.trailColor,
	                type = props.type,
	                strokeWidth = props.strokeWidth,
	                width = props.width,
	                showInfo = props.showInfo,
	                _props$gapDegree = props.gapDegree,
	                gapDegree = _props$gapDegree === undefined ? 0 : _props$gapDegree,
	                gapPosition = props.gapPosition,
	                restProps = __rest(props, ["prefixCls", "className", "percent", "status", "format", "trailColor", "type", "strokeWidth", "width", "showInfo", "gapDegree", "gapPosition"]);
	
	            var progressStatus = parseInt(percent.toString(), 10) >= 100 && !('status' in props) ? 'success' : status || 'normal';
	            var progressInfo = void 0;
	            var progress = void 0;
	            var textFormatter = format || function (percentNumber) {
	                return percentNumber + '%';
	            };
	            if (showInfo) {
	                var text = void 0;
	                var iconType = type === 'circle' || type === 'dashboard' ? '' : '-circle';
	                if (progressStatus === 'exception') {
	                    text = format ? textFormatter(percent) : _react2['default'].createElement(_icon2['default'], { type: 'cross' + iconType });
	                } else if (progressStatus === 'success') {
	                    text = format ? textFormatter(percent) : _react2['default'].createElement(_icon2['default'], { type: 'check' + iconType });
	                } else {
	                    text = textFormatter(percent);
	                }
	                progressInfo = _react2['default'].createElement(
	                    'span',
	                    { className: prefixCls + '-text' },
	                    text
	                );
	            }
	            if (type === 'line') {
	                var percentStyle = {
	                    width: percent + '%',
	                    height: strokeWidth || 10
	                };
	                progress = _react2['default'].createElement(
	                    'div',
	                    null,
	                    _react2['default'].createElement(
	                        'div',
	                        { className: prefixCls + '-outer' },
	                        _react2['default'].createElement(
	                            'div',
	                            { className: prefixCls + '-inner' },
	                            _react2['default'].createElement('div', { className: prefixCls + '-bg', style: percentStyle })
	                        )
	                    ),
	                    progressInfo
	                );
	            } else if (type === 'circle' || type === 'dashboard') {
	                var circleSize = width || 132;
	                var circleStyle = {
	                    width: circleSize,
	                    height: circleSize,
	                    fontSize: circleSize * 0.16 + 6
	                };
	                var circleWidth = strokeWidth || 6;
	                var gapPos = gapPosition || type === 'dashboard' && 'bottom' || 'top';
	                var gapDeg = gapDegree || type === 'dashboard' && 75;
	                progress = _react2['default'].createElement(
	                    'div',
	                    { className: prefixCls + '-inner', style: circleStyle },
	                    _react2['default'].createElement(_rcProgress.Circle, { percent: percent, strokeWidth: circleWidth, trailWidth: circleWidth, strokeColor: statusColorMap[progressStatus], trailColor: trailColor, prefixCls: prefixCls, gapDegree: gapDeg, gapPosition: gapPos }),
	                    progressInfo
	                );
	            }
	            var classString = (0, _classnames2['default'])(prefixCls, (_classNames = {}, (0, _defineProperty3['default'])(_classNames, prefixCls + '-' + (type === 'dashboard' && 'circle' || type), true), (0, _defineProperty3['default'])(_classNames, prefixCls + '-status-' + progressStatus, true), (0, _defineProperty3['default'])(_classNames, prefixCls + '-show-info', showInfo), _classNames), className);
	            return _react2['default'].createElement(
	                'div',
	                (0, _extends3['default'])({}, restProps, { className: classString }),
	                progress
	            );
	        }
	    }]);
	    return Progress;
	}(_react2['default'].Component);
	
	exports['default'] = Progress;
	
	Progress.defaultProps = {
	    type: 'line',
	    percent: 0,
	    showInfo: true,
	    trailColor: '#f3f3f3',
	    prefixCls: 'ant-progress'
	};
	Progress.propTypes = {
	    status: _propTypes2['default'].oneOf(['normal', 'exception', 'active', 'success']),
	    type: _propTypes2['default'].oneOf(['line', 'circle', 'dashboard']),
	    showInfo: _propTypes2['default'].bool,
	    percent: _propTypes2['default'].number,
	    width: _propTypes2['default'].number,
	    strokeWidth: _propTypes2['default'].number,
	    trailColor: _propTypes2['default'].string,
	    format: _propTypes2['default'].func,
	    gapDegree: _propTypes2['default'].number
	};
	module.exports = exports['default'];

/***/ }),
/* 371 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _shallowequal = __webpack_require__(45);
	
	var _shallowequal2 = _interopRequireDefault(_shallowequal);
	
	var _radio = __webpack_require__(104);
	
	var _radio2 = _interopRequireDefault(_radio);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function getCheckedValue(children) {
	    var value = null;
	    var matched = false;
	    _react2['default'].Children.forEach(children, function (radio) {
	        if (radio && radio.props && radio.props.checked) {
	            value = radio.props.value;
	            matched = true;
	        }
	    });
	    return matched ? { value: value } : undefined;
	}
	
	var RadioGroup = function (_React$Component) {
	    (0, _inherits3['default'])(RadioGroup, _React$Component);
	
	    function RadioGroup(props) {
	        (0, _classCallCheck3['default'])(this, RadioGroup);
	
	        var _this = (0, _possibleConstructorReturn3['default'])(this, (RadioGroup.__proto__ || Object.getPrototypeOf(RadioGroup)).call(this, props));
	
	        _this.onRadioChange = function (ev) {
	            var lastValue = _this.state.value;
	            var value = ev.target.value;
	
	            if (!('value' in _this.props)) {
	                _this.setState({
	                    value: value
	                });
	            }
	            var onChange = _this.props.onChange;
	            if (onChange && value !== lastValue) {
	                onChange(ev);
	            }
	        };
	        var value = void 0;
	        if ('value' in props) {
	            value = props.value;
	        } else if ('defaultValue' in props) {
	            value = props.defaultValue;
	        } else {
	            var checkedValue = getCheckedValue(props.children);
	            value = checkedValue && checkedValue.value;
	        }
	        _this.state = {
	            value: value
	        };
	        return _this;
	    }
	
	    (0, _createClass3['default'])(RadioGroup, [{
	        key: 'getChildContext',
	        value: function getChildContext() {
	            return {
	                radioGroup: {
	                    onChange: this.onRadioChange,
	                    value: this.state.value,
	                    disabled: this.props.disabled,
	                    name: this.props.name
	                }
	            };
	        }
	    }, {
	        key: 'componentWillReceiveProps',
	        value: function componentWillReceiveProps(nextProps) {
	            if ('value' in nextProps) {
	                this.setState({
	                    value: nextProps.value
	                });
	            } else {
	                var checkedValue = getCheckedValue(nextProps.children);
	                if (checkedValue) {
	                    this.setState({
	                        value: checkedValue.value
	                    });
	                }
	            }
	        }
	    }, {
	        key: 'shouldComponentUpdate',
	        value: function shouldComponentUpdate(nextProps, nextState) {
	            return !(0, _shallowequal2['default'])(this.props, nextProps) || !(0, _shallowequal2['default'])(this.state, nextState);
	        }
	    }, {
	        key: 'render',
	        value: function render() {
	            var _this2 = this;
	
	            var props = this.props;
	            var _props$prefixCls = props.prefixCls,
	                prefixCls = _props$prefixCls === undefined ? 'ant-radio-group' : _props$prefixCls,
	                _props$className = props.className,
	                className = _props$className === undefined ? '' : _props$className,
	                options = props.options;
	
	            var classString = (0, _classnames2['default'])(prefixCls, (0, _defineProperty3['default'])({}, prefixCls + '-' + props.size, props.size), className);
	            var children = props.children;
	            // 如果存在 options, 优先使用
	            if (options && options.length > 0) {
	                children = options.map(function (option, index) {
	                    if (typeof option === 'string') {
	                        return _react2['default'].createElement(
	                            _radio2['default'],
	                            { key: index, disabled: _this2.props.disabled, value: option, onChange: _this2.onRadioChange, checked: _this2.state.value === option },
	                            option
	                        );
	                    } else {
	                        return _react2['default'].createElement(
	                            _radio2['default'],
	                            { key: index, disabled: option.disabled || _this2.props.disabled, value: option.value, onChange: _this2.onRadioChange, checked: _this2.state.value === option.value },
	                            option.label
	                        );
	                    }
	                });
	            }
	            return _react2['default'].createElement(
	                'div',
	                { className: classString, style: props.style, onMouseEnter: props.onMouseEnter, onMouseLeave: props.onMouseLeave, id: props.id },
	                children
	            );
	        }
	    }]);
	    return RadioGroup;
	}(_react2['default'].Component);
	
	exports['default'] = RadioGroup;
	
	RadioGroup.defaultProps = {
	    disabled: false
	};
	RadioGroup.childContextTypes = {
	    radioGroup: _propTypes2['default'].any
	};
	module.exports = exports['default'];

/***/ }),
/* 372 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _radio = __webpack_require__(104);
	
	var _radio2 = _interopRequireDefault(_radio);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var RadioButton = function (_React$Component) {
	    (0, _inherits3['default'])(RadioButton, _React$Component);
	
	    function RadioButton() {
	        (0, _classCallCheck3['default'])(this, RadioButton);
	        return (0, _possibleConstructorReturn3['default'])(this, (RadioButton.__proto__ || Object.getPrototypeOf(RadioButton)).apply(this, arguments));
	    }
	
	    (0, _createClass3['default'])(RadioButton, [{
	        key: 'render',
	        value: function render() {
	            var radioProps = (0, _extends3['default'])({}, this.props);
	            if (this.context.radioGroup) {
	                radioProps.onChange = this.context.radioGroup.onChange;
	                radioProps.checked = this.props.value === this.context.radioGroup.value;
	                radioProps.disabled = this.props.disabled || this.context.radioGroup.disabled;
	            }
	            return _react2['default'].createElement(_radio2['default'], radioProps);
	        }
	    }]);
	    return RadioButton;
	}(_react2['default'].Component);
	
	exports['default'] = RadioButton;
	
	RadioButton.defaultProps = {
	    prefixCls: 'ant-radio-button'
	};
	RadioButton.contextTypes = {
	    radioGroup: _propTypes2['default'].any
	};
	module.exports = exports['default'];

/***/ }),
/* 373 */
[1078, 1006],
/* 374 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _rcRate = __webpack_require__(730);
	
	var _rcRate2 = _interopRequireDefault(_rcRate);
	
	var _icon = __webpack_require__(16);
	
	var _icon2 = _interopRequireDefault(_icon);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var Rate = function (_React$Component) {
	    (0, _inherits3['default'])(Rate, _React$Component);
	
	    function Rate() {
	        (0, _classCallCheck3['default'])(this, Rate);
	        return (0, _possibleConstructorReturn3['default'])(this, (Rate.__proto__ || Object.getPrototypeOf(Rate)).apply(this, arguments));
	    }
	
	    (0, _createClass3['default'])(Rate, [{
	        key: 'render',
	        value: function render() {
	            return _react2['default'].createElement(_rcRate2['default'], this.props);
	        }
	    }]);
	    return Rate;
	}(_react2['default'].Component);
	
	exports['default'] = Rate;
	
	Rate.propTypes = {
	    prefixCls: _propTypes2['default'].string,
	    character: _propTypes2['default'].node
	};
	Rate.defaultProps = {
	    prefixCls: 'ant-rate',
	    character: _react2['default'].createElement(_icon2['default'], { type: 'star' })
	};
	module.exports = exports['default'];

/***/ }),
/* 375 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _grid = __webpack_require__(170);
	
	exports['default'] = _grid.Row;
	module.exports = exports['default'];

/***/ }),
/* 376 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _extends3 = __webpack_require__(2);
	
	var _extends4 = _interopRequireDefault(_extends3);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _Slider = __webpack_require__(738);
	
	var _Slider2 = _interopRequireDefault(_Slider);
	
	var _Range = __webpack_require__(737);
	
	var _Range2 = _interopRequireDefault(_Range);
	
	var _Handle = __webpack_require__(268);
	
	var _Handle2 = _interopRequireDefault(_Handle);
	
	var _tooltip = __webpack_require__(56);
	
	var _tooltip2 = _interopRequireDefault(_tooltip);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var __rest = undefined && undefined.__rest || function (s, e) {
	    var t = {};
	    for (var p in s) {
	        if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
	    }if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	        if (e.indexOf(p[i]) < 0) t[p[i]] = s[p[i]];
	    }return t;
	};
	
	var Slider = function (_React$Component) {
	    (0, _inherits3['default'])(Slider, _React$Component);
	
	    function Slider(props) {
	        (0, _classCallCheck3['default'])(this, Slider);
	
	        var _this = (0, _possibleConstructorReturn3['default'])(this, (Slider.__proto__ || Object.getPrototypeOf(Slider)).call(this, props));
	
	        _this.toggleTooltipVisible = function (index, visible) {
	            _this.setState(function (_ref) {
	                var visibles = _ref.visibles;
	                return {
	                    visibles: (0, _extends4['default'])({}, visibles, (0, _defineProperty3['default'])({}, index, visible))
	                };
	            });
	        };
	        _this.handleWithTooltip = function (_a) {
	            var value = _a.value,
	                dragging = _a.dragging,
	                index = _a.index,
	                restProps = __rest(_a, ["value", "dragging", "index"]);
	
	            var _this$props = _this.props,
	                tooltipPrefixCls = _this$props.tooltipPrefixCls,
	                tipFormatter = _this$props.tipFormatter;
	            var visibles = _this.state.visibles;
	
	            return _react2['default'].createElement(
	                _tooltip2['default'],
	                { prefixCls: tooltipPrefixCls, title: tipFormatter ? tipFormatter(value) : '', visible: tipFormatter && (visibles[index] || dragging), placement: 'top', transitionName: 'zoom-down', key: index },
	                _react2['default'].createElement(_Handle2['default'], (0, _extends4['default'])({}, restProps, { value: value, onMouseEnter: function onMouseEnter() {
	                        return _this.toggleTooltipVisible(index, true);
	                    }, onMouseLeave: function onMouseLeave() {
	                        return _this.toggleTooltipVisible(index, false);
	                    } }))
	            );
	        };
	        _this.state = {
	            visibles: {}
	        };
	        return _this;
	    }
	
	    (0, _createClass3['default'])(Slider, [{
	        key: 'render',
	        value: function render() {
	            var _a = this.props,
	                range = _a.range,
	                restProps = __rest(_a, ["range"]);
	            if (range) {
	                return _react2['default'].createElement(_Range2['default'], (0, _extends4['default'])({}, restProps, { handle: this.handleWithTooltip }));
	            }
	            return _react2['default'].createElement(_Slider2['default'], (0, _extends4['default'])({}, restProps, { handle: this.handleWithTooltip }));
	        }
	    }]);
	    return Slider;
	}(_react2['default'].Component);
	
	exports['default'] = Slider;
	
	Slider.defaultProps = {
	    prefixCls: 'ant-slider',
	    tooltipPrefixCls: 'ant-tooltip',
	    tipFormatter: function tipFormatter(value) {
	        return value.toString();
	    }
	};
	module.exports = exports['default'];

/***/ }),
/* 377 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _rcSteps = __webpack_require__(743);
	
	var _rcSteps2 = _interopRequireDefault(_rcSteps);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var Steps = function (_React$Component) {
	    (0, _inherits3['default'])(Steps, _React$Component);
	
	    function Steps() {
	        (0, _classCallCheck3['default'])(this, Steps);
	        return (0, _possibleConstructorReturn3['default'])(this, (Steps.__proto__ || Object.getPrototypeOf(Steps)).apply(this, arguments));
	    }
	
	    (0, _createClass3['default'])(Steps, [{
	        key: 'render',
	        value: function render() {
	            return _react2['default'].createElement(_rcSteps2['default'], this.props);
	        }
	    }]);
	    return Steps;
	}(_react2['default'].Component);
	
	exports['default'] = Steps;
	
	Steps.Step = _rcSteps2['default'].Step;
	Steps.defaultProps = {
	    prefixCls: 'ant-steps',
	    iconPrefix: 'ant',
	    current: 0
	};
	Steps.propTypes = {
	    prefixCls: _propTypes2['default'].string,
	    iconPrefix: _propTypes2['default'].string,
	    current: _propTypes2['default'].number
	};
	module.exports = exports['default'];

/***/ }),
/* 378 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _rcSwitch = __webpack_require__(745);
	
	var _rcSwitch2 = _interopRequireDefault(_rcSwitch);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var Switch = function (_React$Component) {
	    (0, _inherits3['default'])(Switch, _React$Component);
	
	    function Switch() {
	        (0, _classCallCheck3['default'])(this, Switch);
	        return (0, _possibleConstructorReturn3['default'])(this, (Switch.__proto__ || Object.getPrototypeOf(Switch)).apply(this, arguments));
	    }
	
	    (0, _createClass3['default'])(Switch, [{
	        key: 'render',
	        value: function render() {
	            var _props = this.props,
	                prefixCls = _props.prefixCls,
	                size = _props.size,
	                _props$className = _props.className,
	                className = _props$className === undefined ? '' : _props$className;
	
	            var classes = (0, _classnames2['default'])(className, (0, _defineProperty3['default'])({}, prefixCls + '-small', size === 'small'));
	            return _react2['default'].createElement(_rcSwitch2['default'], (0, _extends3['default'])({}, this.props, { className: classes }));
	        }
	    }]);
	    return Switch;
	}(_react2['default'].Component);
	
	exports['default'] = Switch;
	
	Switch.defaultProps = {
	    prefixCls: 'ant-switch'
	};
	Switch.propTypes = {
	    prefixCls: _propTypes2['default'].string,
	    // HACK: https://github.com/ant-design/ant-design/issues/5368
	    // size=default and size=large are the same
	    size: _propTypes2['default'].oneOf(['small', 'default', 'large']),
	    className: _propTypes2['default'].string
	};
	module.exports = exports['default'];

/***/ }),
/* 379 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var Column = function (_React$Component) {
	  (0, _inherits3['default'])(Column, _React$Component);
	
	  function Column() {
	    (0, _classCallCheck3['default'])(this, Column);
	    return (0, _possibleConstructorReturn3['default'])(this, (Column.__proto__ || Object.getPrototypeOf(Column)).apply(this, arguments));
	  }
	
	  return Column;
	}(_react2['default'].Component);
	
	exports['default'] = Column;
	module.exports = exports['default'];

/***/ }),
/* 380 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var ColumnGroup = function (_React$Component) {
	  (0, _inherits3['default'])(ColumnGroup, _React$Component);
	
	  function ColumnGroup() {
	    (0, _classCallCheck3['default'])(this, ColumnGroup);
	    return (0, _possibleConstructorReturn3['default'])(this, (ColumnGroup.__proto__ || Object.getPrototypeOf(ColumnGroup)).apply(this, arguments));
	  }
	
	  return ColumnGroup;
	}(_react2['default'].Component);
	
	exports['default'] = ColumnGroup;
	
	ColumnGroup.__ANT_TABLE_COLUMN_GROUP = true;
	module.exports = exports['default'];

/***/ }),
/* 381 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	exports['default'] = function (props) {
	    return _react2['default'].createElement(
	        'div',
	        { className: props.className, onClick: props.onClick },
	        props.children
	    );
	};
	
	module.exports = exports['default'];

/***/ }),
/* 382 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _checkbox = __webpack_require__(55);
	
	var _checkbox2 = _interopRequireDefault(_checkbox);
	
	var _radio = __webpack_require__(82);
	
	var _radio2 = _interopRequireDefault(_radio);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var SelectionBox = function (_React$Component) {
	    (0, _inherits3['default'])(SelectionBox, _React$Component);
	
	    function SelectionBox(props) {
	        (0, _classCallCheck3['default'])(this, SelectionBox);
	
	        var _this = (0, _possibleConstructorReturn3['default'])(this, (SelectionBox.__proto__ || Object.getPrototypeOf(SelectionBox)).call(this, props));
	
	        _this.state = {
	            checked: _this.getCheckState(props)
	        };
	        return _this;
	    }
	
	    (0, _createClass3['default'])(SelectionBox, [{
	        key: 'componentDidMount',
	        value: function componentDidMount() {
	            this.subscribe();
	        }
	    }, {
	        key: 'componentWillUnmount',
	        value: function componentWillUnmount() {
	            if (this.unsubscribe) {
	                this.unsubscribe();
	            }
	        }
	    }, {
	        key: 'subscribe',
	        value: function subscribe() {
	            var _this2 = this;
	
	            var store = this.props.store;
	
	            this.unsubscribe = store.subscribe(function () {
	                var checked = _this2.getCheckState(_this2.props);
	                _this2.setState({ checked: checked });
	            });
	        }
	    }, {
	        key: 'getCheckState',
	        value: function getCheckState(props) {
	            var store = props.store,
	                defaultSelection = props.defaultSelection,
	                rowIndex = props.rowIndex;
	
	            var checked = false;
	            if (store.getState().selectionDirty) {
	                checked = store.getState().selectedRowKeys.indexOf(rowIndex) >= 0;
	            } else {
	                checked = store.getState().selectedRowKeys.indexOf(rowIndex) >= 0 || defaultSelection.indexOf(rowIndex) >= 0;
	            }
	            return checked;
	        }
	    }, {
	        key: 'render',
	        value: function render() {
	            var _props = this.props,
	                type = _props.type,
	                rowIndex = _props.rowIndex,
	                disabled = _props.disabled,
	                onChange = _props.onChange;
	            var checked = this.state.checked;
	
	            if (type === 'radio') {
	                return _react2['default'].createElement(_radio2['default'], { disabled: disabled, onChange: onChange, value: rowIndex, checked: checked });
	            }
	            return _react2['default'].createElement(_checkbox2['default'], { checked: checked, disabled: disabled, onChange: onChange });
	        }
	    }]);
	    return SelectionBox;
	}(_react2['default'].Component);
	
	exports['default'] = SelectionBox;
	module.exports = exports['default'];

/***/ }),
/* 383 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _checkbox = __webpack_require__(55);
	
	var _checkbox2 = _interopRequireDefault(_checkbox);
	
	var _dropdown = __webpack_require__(102);
	
	var _dropdown2 = _interopRequireDefault(_dropdown);
	
	var _menu = __webpack_require__(174);
	
	var _menu2 = _interopRequireDefault(_menu);
	
	var _icon = __webpack_require__(16);
	
	var _icon2 = _interopRequireDefault(_icon);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var SelectionCheckboxAll = function (_React$Component) {
	    (0, _inherits3['default'])(SelectionCheckboxAll, _React$Component);
	
	    function SelectionCheckboxAll(props) {
	        (0, _classCallCheck3['default'])(this, SelectionCheckboxAll);
	
	        var _this = (0, _possibleConstructorReturn3['default'])(this, (SelectionCheckboxAll.__proto__ || Object.getPrototypeOf(SelectionCheckboxAll)).call(this, props));
	
	        _this.handleSelectAllChagne = function (e) {
	            var checked = e.target.checked;
	            _this.props.onSelect(checked ? 'all' : 'removeAll', 0, null);
	        };
	        _this.defaultSelections = props.hideDefaultSelections ? [] : [{
	            key: 'all',
	            text: props.locale.selectAll,
	            onSelect: function onSelect() {}
	        }, {
	            key: 'invert',
	            text: props.locale.selectInvert,
	            onSelect: function onSelect() {}
	        }];
	        _this.state = {
	            checked: _this.getCheckState(props),
	            indeterminate: _this.getIndeterminateState(props)
	        };
	        return _this;
	    }
	
	    (0, _createClass3['default'])(SelectionCheckboxAll, [{
	        key: 'componentDidMount',
	        value: function componentDidMount() {
	            this.subscribe();
	        }
	    }, {
	        key: 'componentWillReceiveProps',
	        value: function componentWillReceiveProps(nextProps) {
	            this.setCheckState(nextProps);
	        }
	    }, {
	        key: 'componentWillUnmount',
	        value: function componentWillUnmount() {
	            if (this.unsubscribe) {
	                this.unsubscribe();
	            }
	        }
	    }, {
	        key: 'subscribe',
	        value: function subscribe() {
	            var _this2 = this;
	
	            var store = this.props.store;
	
	            this.unsubscribe = store.subscribe(function () {
	                _this2.setCheckState(_this2.props);
	            });
	        }
	    }, {
	        key: 'checkSelection',
	        value: function checkSelection(data, type, byDefaultChecked) {
	            var _props = this.props,
	                store = _props.store,
	                getCheckboxPropsByItem = _props.getCheckboxPropsByItem,
	                getRecordKey = _props.getRecordKey;
	            // type should be 'every' | 'some'
	
	            if (type === 'every' || type === 'some') {
	                return byDefaultChecked ? data[type](function (item, i) {
	                    return getCheckboxPropsByItem(item, i).defaultChecked;
	                }) : data[type](function (item, i) {
	                    return store.getState().selectedRowKeys.indexOf(getRecordKey(item, i)) >= 0;
	                });
	            }
	            return false;
	        }
	    }, {
	        key: 'setCheckState',
	        value: function setCheckState(props) {
	            var checked = this.getCheckState(props);
	            var indeterminate = this.getIndeterminateState(props);
	            if (checked !== this.state.checked) {
	                this.setState({ checked: checked });
	            }
	            if (indeterminate !== this.state.indeterminate) {
	                this.setState({ indeterminate: indeterminate });
	            }
	        }
	    }, {
	        key: 'getCheckState',
	        value: function getCheckState(props) {
	            var store = props.store,
	                data = props.data;
	
	            var checked = void 0;
	            if (!data.length) {
	                checked = false;
	            } else {
	                checked = store.getState().selectionDirty ? this.checkSelection(data, 'every', false) : this.checkSelection(data, 'every', false) || this.checkSelection(data, 'every', true);
	            }
	            return checked;
	        }
	    }, {
	        key: 'getIndeterminateState',
	        value: function getIndeterminateState(props) {
	            var store = props.store,
	                data = props.data;
	
	            var indeterminate = void 0;
	            if (!data.length) {
	                indeterminate = false;
	            } else {
	                indeterminate = store.getState().selectionDirty ? this.checkSelection(data, 'some', false) && !this.checkSelection(data, 'every', false) : this.checkSelection(data, 'some', false) && !this.checkSelection(data, 'every', false) || this.checkSelection(data, 'some', true) && !this.checkSelection(data, 'every', true);
	            }
	            return indeterminate;
	        }
	    }, {
	        key: 'renderMenus',
	        value: function renderMenus(selections) {
	            var _this3 = this;
	
	            return selections.map(function (selection, index) {
	                return _react2['default'].createElement(
	                    _menu2['default'].Item,
	                    { key: selection.key || index },
	                    _react2['default'].createElement(
	                        'div',
	                        { onClick: function onClick() {
	                                _this3.props.onSelect(selection.key, index, selection.onSelect);
	                            } },
	                        selection.text
	                    )
	                );
	            });
	        }
	    }, {
	        key: 'render',
	        value: function render() {
	            var _props2 = this.props,
	                disabled = _props2.disabled,
	                prefixCls = _props2.prefixCls,
	                selections = _props2.selections,
	                getPopupContainer = _props2.getPopupContainer;
	            var _state = this.state,
	                checked = _state.checked,
	                indeterminate = _state.indeterminate;
	
	            var selectionPrefixCls = prefixCls + '-selection';
	            var customSelections = null;
	            if (selections) {
	                var newSelections = Array.isArray(selections) ? this.defaultSelections.concat(selections) : this.defaultSelections;
	                var menu = _react2['default'].createElement(
	                    _menu2['default'],
	                    { className: selectionPrefixCls + '-menu', selectedKeys: [] },
	                    this.renderMenus(newSelections)
	                );
	                customSelections = newSelections.length > 0 ? _react2['default'].createElement(
	                    _dropdown2['default'],
	                    { overlay: menu, getPopupContainer: getPopupContainer },
	                    _react2['default'].createElement(
	                        'div',
	                        { className: selectionPrefixCls + '-down' },
	                        _react2['default'].createElement(_icon2['default'], { type: 'down' })
	                    )
	                ) : null;
	            }
	            return _react2['default'].createElement(
	                'div',
	                { className: selectionPrefixCls },
	                _react2['default'].createElement(_checkbox2['default'], { className: (0, _classnames2['default'])((0, _defineProperty3['default'])({}, selectionPrefixCls + '-select-all-custom', customSelections)), checked: checked, indeterminate: indeterminate, disabled: disabled, onChange: this.handleSelectAllChagne }),
	                customSelections
	            );
	        }
	    }]);
	    return SelectionCheckboxAll;
	}(_react2['default'].Component);
	
	exports['default'] = SelectionCheckboxAll;
	module.exports = exports['default'];

/***/ }),
/* 384 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _typeof2 = __webpack_require__(21);
	
	var _typeof3 = _interopRequireDefault(_typeof2);
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _extends4 = __webpack_require__(2);
	
	var _extends5 = _interopRequireDefault(_extends4);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _reactDom = __webpack_require__(10);
	
	var _rcTable = __webpack_require__(755);
	
	var _rcTable2 = _interopRequireDefault(_rcTable);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _pagination = __webpack_require__(177);
	
	var _pagination2 = _interopRequireDefault(_pagination);
	
	var _icon = __webpack_require__(16);
	
	var _icon2 = _interopRequireDefault(_icon);
	
	var _spin = __webpack_require__(180);
	
	var _spin2 = _interopRequireDefault(_spin);
	
	var _warning = __webpack_require__(24);
	
	var _warning2 = _interopRequireDefault(_warning);
	
	var _filterDropdown = __webpack_require__(386);
	
	var _filterDropdown2 = _interopRequireDefault(_filterDropdown);
	
	var _createStore = __webpack_require__(385);
	
	var _createStore2 = _interopRequireDefault(_createStore);
	
	var _SelectionBox = __webpack_require__(382);
	
	var _SelectionBox2 = _interopRequireDefault(_SelectionBox);
	
	var _SelectionCheckboxAll = __webpack_require__(383);
	
	var _SelectionCheckboxAll2 = _interopRequireDefault(_SelectionCheckboxAll);
	
	var _Column = __webpack_require__(379);
	
	var _Column2 = _interopRequireDefault(_Column);
	
	var _ColumnGroup = __webpack_require__(380);
	
	var _ColumnGroup2 = _interopRequireDefault(_ColumnGroup);
	
	var _util = __webpack_require__(388);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var __rest = undefined && undefined.__rest || function (s, e) {
	    var t = {};
	    for (var p in s) {
	        if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
	    }if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	        if (e.indexOf(p[i]) < 0) t[p[i]] = s[p[i]];
	    }return t;
	};
	
	function noop() {}
	function stopPropagation(e) {
	    e.stopPropagation();
	    if (e.nativeEvent.stopImmediatePropagation) {
	        e.nativeEvent.stopImmediatePropagation();
	    }
	}
	var defaultLocale = {
	    filterTitle: '筛选',
	    filterConfirm: '确定',
	    filterReset: '重置',
	    emptyText: _react2['default'].createElement(
	        'span',
	        null,
	        _react2['default'].createElement(_icon2['default'], { type: 'frown-o' }),
	        '\u6682\u65E0\u6570\u636E'
	    ),
	    selectAll: '全选当页',
	    selectInvert: '反选当页'
	};
	var defaultPagination = {
	    onChange: noop,
	    onShowSizeChange: noop
	};
	/**
	 * Avoid creating new object, so that parent component's shouldComponentUpdate
	 * can works appropriately。
	 */
	var emptyObject = {};
	
	var Table = function (_React$Component) {
	    (0, _inherits3['default'])(Table, _React$Component);
	
	    function Table(props) {
	        (0, _classCallCheck3['default'])(this, Table);
	
	        var _this = (0, _possibleConstructorReturn3['default'])(this, (Table.__proto__ || Object.getPrototypeOf(Table)).call(this, props));
	
	        _this.getCheckboxPropsByItem = function (item, index) {
	            var _this$props$rowSelect = _this.props.rowSelection,
	                rowSelection = _this$props$rowSelect === undefined ? {} : _this$props$rowSelect;
	
	            if (!rowSelection.getCheckboxProps) {
	                return {};
	            }
	            var key = _this.getRecordKey(item, index);
	            // Cache checkboxProps
	            if (!_this.CheckboxPropsCache[key]) {
	                _this.CheckboxPropsCache[key] = rowSelection.getCheckboxProps(item);
	            }
	            return _this.CheckboxPropsCache[key];
	        };
	        _this.handleFilter = function (column, nextFilters) {
	            var props = _this.props;
	            var pagination = (0, _extends5['default'])({}, _this.state.pagination);
	            var filters = (0, _extends5['default'])({}, _this.state.filters, (0, _defineProperty3['default'])({}, _this.getColumnKey(column), nextFilters));
	            // Remove filters not in current columns
	            var currentColumnKeys = [];
	            (0, _util.treeMap)(_this.columns, function (c) {
	                if (!c.children) {
	                    currentColumnKeys.push(_this.getColumnKey(c));
	                }
	            });
	            Object.keys(filters).forEach(function (columnKey) {
	                if (currentColumnKeys.indexOf(columnKey) < 0) {
	                    delete filters[columnKey];
	                }
	            });
	            if (props.pagination) {
	                // Reset current prop
	                pagination.current = 1;
	                pagination.onChange(pagination.current);
	            }
	            var newState = {
	                pagination: pagination,
	                filters: {}
	            };
	            var filtersToSetState = (0, _extends5['default'])({}, filters);
	            // Remove filters which is controlled
	            _this.getFilteredValueColumns().forEach(function (col) {
	                var columnKey = _this.getColumnKey(col);
	                if (columnKey) {
	                    delete filtersToSetState[columnKey];
	                }
	            });
	            if (Object.keys(filtersToSetState).length > 0) {
	                newState.filters = filtersToSetState;
	            }
	            // Controlled current prop will not respond user interaction
	            if ((0, _typeof3['default'])(props.pagination) === 'object' && 'current' in props.pagination) {
	                newState.pagination = (0, _extends5['default'])({}, pagination, { current: _this.state.pagination.current });
	            }
	            _this.setState(newState, function () {
	                _this.store.setState({
	                    selectionDirty: false
	                });
	                var onChange = _this.props.onChange;
	                if (onChange) {
	                    onChange.apply(null, _this.prepareParamsArguments((0, _extends5['default'])({}, _this.state, { selectionDirty: false, filters: filters,
	                        pagination: pagination })));
	                }
	            });
	        };
	        _this.handleSelect = function (record, rowIndex, e) {
	            var checked = e.target.checked;
	            var defaultSelection = _this.store.getState().selectionDirty ? [] : _this.getDefaultSelection();
	            var selectedRowKeys = _this.store.getState().selectedRowKeys.concat(defaultSelection);
	            var key = _this.getRecordKey(record, rowIndex);
	            if (checked) {
	                selectedRowKeys.push(_this.getRecordKey(record, rowIndex));
	            } else {
	                selectedRowKeys = selectedRowKeys.filter(function (i) {
	                    return key !== i;
	                });
	            }
	            _this.store.setState({
	                selectionDirty: true
	            });
	            _this.setSelectedRowKeys(selectedRowKeys, {
	                selectWay: 'onSelect',
	                record: record,
	                checked: checked
	            });
	        };
	        _this.handleRadioSelect = function (record, rowIndex, e) {
	            var checked = e.target.checked;
	            var defaultSelection = _this.store.getState().selectionDirty ? [] : _this.getDefaultSelection();
	            var selectedRowKeys = _this.store.getState().selectedRowKeys.concat(defaultSelection);
	            var key = _this.getRecordKey(record, rowIndex);
	            selectedRowKeys = [key];
	            _this.store.setState({
	                selectionDirty: true
	            });
	            _this.setSelectedRowKeys(selectedRowKeys, {
	                selectWay: 'onSelect',
	                record: record,
	                checked: checked
	            });
	        };
	        _this.handleSelectRow = function (selectionKey, index, onSelectFunc) {
	            var data = _this.getFlatCurrentPageData();
	            var defaultSelection = _this.store.getState().selectionDirty ? [] : _this.getDefaultSelection();
	            var selectedRowKeys = _this.store.getState().selectedRowKeys.concat(defaultSelection);
	            var changeableRowKeys = data.filter(function (item, i) {
	                return !_this.getCheckboxPropsByItem(item, i).disabled;
	            }).map(function (item, i) {
	                return _this.getRecordKey(item, i);
	            });
	            var changeRowKeys = [];
	            var selectWay = '';
	            var checked = void 0;
	            // handle default selection
	            switch (selectionKey) {
	                case 'all':
	                    changeableRowKeys.forEach(function (key) {
	                        if (selectedRowKeys.indexOf(key) < 0) {
	                            selectedRowKeys.push(key);
	                            changeRowKeys.push(key);
	                        }
	                    });
	                    selectWay = 'onSelectAll';
	                    checked = true;
	                    break;
	                case 'removeAll':
	                    changeableRowKeys.forEach(function (key) {
	                        if (selectedRowKeys.indexOf(key) >= 0) {
	                            selectedRowKeys.splice(selectedRowKeys.indexOf(key), 1);
	                            changeRowKeys.push(key);
	                        }
	                    });
	                    selectWay = 'onSelectAll';
	                    checked = false;
	                    break;
	                case 'invert':
	                    changeableRowKeys.forEach(function (key) {
	                        if (selectedRowKeys.indexOf(key) < 0) {
	                            selectedRowKeys.push(key);
	                        } else {
	                            selectedRowKeys.splice(selectedRowKeys.indexOf(key), 1);
	                        }
	                        changeRowKeys.push(key);
	                        selectWay = 'onSelectInvert';
	                    });
	                    break;
	                default:
	                    break;
	            }
	            _this.store.setState({
	                selectionDirty: true
	            });
	            // when select custom selection, callback selections[n].onSelect
	            var rowSelection = _this.props.rowSelection;
	
	            var customSelectionStartIndex = 2;
	            if (rowSelection && rowSelection.hideDefaultSelections) {
	                customSelectionStartIndex = 0;
	            }
	            if (index >= customSelectionStartIndex && typeof onSelectFunc === 'function') {
	                return onSelectFunc(changeableRowKeys);
	            }
	            _this.setSelectedRowKeys(selectedRowKeys, {
	                selectWay: selectWay,
	                checked: checked,
	                changeRowKeys: changeRowKeys
	            });
	        };
	        _this.handlePageChange = function (current) {
	            for (var _len = arguments.length, otherArguments = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
	                otherArguments[_key - 1] = arguments[_key];
	            }
	
	            var props = _this.props;
	            var pagination = (0, _extends5['default'])({}, _this.state.pagination);
	            if (current) {
	                pagination.current = current;
	            } else {
	                pagination.current = pagination.current || 1;
	            }
	            pagination.onChange.apply(pagination, [pagination.current].concat(otherArguments));
	            var newState = {
	                pagination: pagination
	            };
	            // Controlled current prop will not respond user interaction
	            if (props.pagination && (0, _typeof3['default'])(props.pagination) === 'object' && 'current' in props.pagination) {
	                newState.pagination = (0, _extends5['default'])({}, pagination, { current: _this.state.pagination.current });
	            }
	            _this.setState(newState);
	            _this.store.setState({
	                selectionDirty: false
	            });
	            var onChange = _this.props.onChange;
	            if (onChange) {
	                onChange.apply(null, _this.prepareParamsArguments((0, _extends5['default'])({}, _this.state, { selectionDirty: false, pagination: pagination })));
	            }
	        };
	        _this.renderSelectionBox = function (type) {
	            return function (_, record, index) {
	                var rowIndex = _this.getRecordKey(record, index); // 从 1 开始
	                var props = _this.getCheckboxPropsByItem(record, index);
	                var handleChange = function handleChange(e) {
	                    type === 'radio' ? _this.handleRadioSelect(record, rowIndex, e) : _this.handleSelect(record, rowIndex, e);
	                };
	                return _react2['default'].createElement(
	                    'span',
	                    { onClick: stopPropagation },
	                    _react2['default'].createElement(_SelectionBox2['default'], { type: type, store: _this.store, rowIndex: rowIndex, disabled: props.disabled, onChange: handleChange, defaultSelection: _this.getDefaultSelection() })
	                );
	            };
	        };
	        _this.getRecordKey = function (record, index) {
	            var rowKey = _this.props.rowKey;
	            var recordKey = typeof rowKey === 'function' ? rowKey(record, index) : record[rowKey];
	            (0, _warning2['default'])(recordKey !== undefined, 'Each record in dataSource of table should have a unique `key` prop, or set `rowKey` to an unique primary key,' + 'see https://u.ant.design/table-row-key');
	            return recordKey === undefined ? index : recordKey;
	        };
	        _this.getPopupContainer = function () {
	            return (0, _reactDom.findDOMNode)(_this);
	        };
	        _this.handleShowSizeChange = function (current, pageSize) {
	            var pagination = _this.state.pagination;
	            pagination.onShowSizeChange(current, pageSize);
	            var nextPagination = (0, _extends5['default'])({}, pagination, { pageSize: pageSize,
	                current: current });
	            _this.setState({ pagination: nextPagination });
	            var onChange = _this.props.onChange;
	            if (onChange) {
	                onChange.apply(null, _this.prepareParamsArguments((0, _extends5['default'])({}, _this.state, { pagination: nextPagination })));
	            }
	        };
	        (0, _warning2['default'])(!('columnsPageRange' in props || 'columnsPageSize' in props), '`columnsPageRange` and `columnsPageSize` are removed, please use ' + 'fixed columns instead, see: https://u.ant.design/fixed-columns.');
	        _this.columns = props.columns || (0, _util.normalizeColumns)(props.children);
	        _this.state = (0, _extends5['default'])({}, _this.getSortStateFromColumns(), {
	            // 减少状态
	            filters: _this.getFiltersFromColumns(), pagination: _this.getDefaultPagination(props) });
	        _this.CheckboxPropsCache = {};
	        _this.store = (0, _createStore2['default'])({
	            selectedRowKeys: (props.rowSelection || {}).selectedRowKeys || [],
	            selectionDirty: false
	        });
	        return _this;
	    }
	
	    (0, _createClass3['default'])(Table, [{
	        key: 'getDefaultSelection',
	        value: function getDefaultSelection() {
	            var _this2 = this;
	
	            var _props$rowSelection = this.props.rowSelection,
	                rowSelection = _props$rowSelection === undefined ? {} : _props$rowSelection;
	
	            if (!rowSelection.getCheckboxProps) {
	                return [];
	            }
	            return this.getFlatData().filter(function (item, rowIndex) {
	                return _this2.getCheckboxPropsByItem(item, rowIndex).defaultChecked;
	            }).map(function (record, rowIndex) {
	                return _this2.getRecordKey(record, rowIndex);
	            });
	        }
	    }, {
	        key: 'getDefaultPagination',
	        value: function getDefaultPagination(props) {
	            var pagination = props.pagination || {};
	            return this.hasPagination(props) ? (0, _extends5['default'])({}, defaultPagination, pagination, { current: pagination.defaultCurrent || pagination.current || 1, pageSize: pagination.defaultPageSize || pagination.pageSize || 10 }) : {};
	        }
	    }, {
	        key: 'getLocale',
	        value: function getLocale() {
	            var locale = {};
	            if (this.context.antLocale && this.context.antLocale.Table) {
	                locale = this.context.antLocale.Table;
	            }
	            return (0, _extends5['default'])({}, defaultLocale, locale, this.props.locale);
	        }
	    }, {
	        key: 'componentWillReceiveProps',
	        value: function componentWillReceiveProps(nextProps) {
	            this.columns = nextProps.columns || (0, _util.normalizeColumns)(nextProps.children);
	            if ('pagination' in nextProps || 'pagination' in this.props) {
	                this.setState(function (previousState) {
	                    var newPagination = (0, _extends5['default'])({}, defaultPagination, previousState.pagination, nextProps.pagination);
	                    newPagination.current = newPagination.current || 1;
	                    newPagination.pageSize = newPagination.pageSize || 10;
	                    return { pagination: nextProps.pagination !== false ? newPagination : emptyObject };
	                });
	            }
	            if (nextProps.rowSelection && 'selectedRowKeys' in nextProps.rowSelection) {
	                this.store.setState({
	                    selectedRowKeys: nextProps.rowSelection.selectedRowKeys || []
	                });
	                var rowSelection = this.props.rowSelection;
	
	                if (rowSelection && nextProps.rowSelection.getCheckboxProps !== rowSelection.getCheckboxProps) {
	                    this.CheckboxPropsCache = {};
	                }
	            }
	            if ('dataSource' in nextProps && nextProps.dataSource !== this.props.dataSource) {
	                this.store.setState({
	                    selectionDirty: false
	                });
	                this.CheckboxPropsCache = {};
	            }
	            if (this.getSortOrderColumns(this.columns).length > 0) {
	                var sortState = this.getSortStateFromColumns(this.columns);
	                if (sortState.sortColumn !== this.state.sortColumn || sortState.sortOrder !== this.state.sortOrder) {
	                    this.setState(sortState);
	                }
	            }
	            var filteredValueColumns = this.getFilteredValueColumns(this.columns);
	            if (filteredValueColumns.length > 0) {
	                var filtersFromColumns = this.getFiltersFromColumns(this.columns);
	                var newFilters = (0, _extends5['default'])({}, this.state.filters);
	                Object.keys(filtersFromColumns).forEach(function (key) {
	                    newFilters[key] = filtersFromColumns[key];
	                });
	                if (this.isFiltersChanged(newFilters)) {
	                    this.setState({ filters: newFilters });
	                }
	            }
	        }
	    }, {
	        key: 'setSelectedRowKeys',
	        value: function setSelectedRowKeys(selectedRowKeys, _ref) {
	            var _this3 = this;
	
	            var selectWay = _ref.selectWay,
	                record = _ref.record,
	                checked = _ref.checked,
	                changeRowKeys = _ref.changeRowKeys;
	            var _props$rowSelection2 = this.props.rowSelection,
	                rowSelection = _props$rowSelection2 === undefined ? {} : _props$rowSelection2;
	
	            if (rowSelection && !('selectedRowKeys' in rowSelection)) {
	                this.store.setState({ selectedRowKeys: selectedRowKeys });
	            }
	            var data = this.getFlatData();
	            if (!rowSelection.onChange && !rowSelection[selectWay]) {
	                return;
	            }
	            var selectedRows = data.filter(function (row, i) {
	                return selectedRowKeys.indexOf(_this3.getRecordKey(row, i)) >= 0;
	            });
	            if (rowSelection.onChange) {
	                rowSelection.onChange(selectedRowKeys, selectedRows);
	            }
	            if (selectWay === 'onSelect' && rowSelection.onSelect) {
	                rowSelection.onSelect(record, checked, selectedRows);
	            } else if (selectWay === 'onSelectAll' && rowSelection.onSelectAll) {
	                var changeRows = data.filter(function (row, i) {
	                    return changeRowKeys.indexOf(_this3.getRecordKey(row, i)) >= 0;
	                });
	                rowSelection.onSelectAll(checked, selectedRows, changeRows);
	            } else if (selectWay === 'onSelectInvert' && rowSelection.onSelectInvert) {
	                rowSelection.onSelectInvert(selectedRowKeys);
	            }
	        }
	    }, {
	        key: 'hasPagination',
	        value: function hasPagination(props) {
	            return (props || this.props).pagination !== false;
	        }
	    }, {
	        key: 'isFiltersChanged',
	        value: function isFiltersChanged(filters) {
	            var _this4 = this;
	
	            var filtersChanged = false;
	            if (Object.keys(filters).length !== Object.keys(this.state.filters).length) {
	                filtersChanged = true;
	            } else {
	                Object.keys(filters).forEach(function (columnKey) {
	                    if (filters[columnKey] !== _this4.state.filters[columnKey]) {
	                        filtersChanged = true;
	                    }
	                });
	            }
	            return filtersChanged;
	        }
	    }, {
	        key: 'getSortOrderColumns',
	        value: function getSortOrderColumns(columns) {
	            return (0, _util.flatFilter)(columns || this.columns || [], function (column) {
	                return 'sortOrder' in column;
	            });
	        }
	    }, {
	        key: 'getFilteredValueColumns',
	        value: function getFilteredValueColumns(columns) {
	            return (0, _util.flatFilter)(columns || this.columns || [], function (column) {
	                return typeof column.filteredValue !== 'undefined';
	            });
	        }
	    }, {
	        key: 'getFiltersFromColumns',
	        value: function getFiltersFromColumns(columns) {
	            var _this5 = this;
	
	            var filters = {};
	            this.getFilteredValueColumns(columns).forEach(function (col) {
	                filters[_this5.getColumnKey(col)] = col.filteredValue;
	            });
	            return filters;
	        }
	    }, {
	        key: 'getSortStateFromColumns',
	        value: function getSortStateFromColumns(columns) {
	            // return fisrt column which sortOrder is not falsy
	            var sortedColumn = this.getSortOrderColumns(columns).filter(function (col) {
	                return col.sortOrder;
	            })[0];
	            if (sortedColumn) {
	                return {
	                    sortColumn: sortedColumn,
	                    sortOrder: sortedColumn.sortOrder
	                };
	            }
	            return {
	                sortColumn: null,
	                sortOrder: null
	            };
	        }
	    }, {
	        key: 'getSorterFn',
	        value: function getSorterFn() {
	            var _state = this.state,
	                sortOrder = _state.sortOrder,
	                sortColumn = _state.sortColumn;
	
	            if (!sortOrder || !sortColumn || typeof sortColumn.sorter !== 'function') {
	                return;
	            }
	            return function (a, b) {
	                var result = sortColumn.sorter(a, b);
	                if (result !== 0) {
	                    return sortOrder === 'descend' ? -result : result;
	                }
	                return 0;
	            };
	        }
	    }, {
	        key: 'toggleSortOrder',
	        value: function toggleSortOrder(order, column) {
	            var _state2 = this.state,
	                sortColumn = _state2.sortColumn,
	                sortOrder = _state2.sortOrder;
	            // 只同时允许一列进行排序，否则会导致排序顺序的逻辑问题
	
	            var isSortColumn = this.isSortColumn(column);
	            if (!isSortColumn) {
	                sortOrder = order;
	                sortColumn = column;
	            } else {
	                if (sortOrder === order) {
	                    sortOrder = '';
	                    sortColumn = null;
	                } else {
	                    sortOrder = order;
	                }
	            }
	            var newState = {
	                sortOrder: sortOrder,
	                sortColumn: sortColumn
	            };
	            // Controlled
	            if (this.getSortOrderColumns().length === 0) {
	                this.setState(newState);
	            }
	            var onChange = this.props.onChange;
	            if (onChange) {
	                onChange.apply(null, this.prepareParamsArguments((0, _extends5['default'])({}, this.state, newState)));
	            }
	        }
	    }, {
	        key: 'renderRowSelection',
	        value: function renderRowSelection() {
	            var _this6 = this;
	
	            var _props = this.props,
	                prefixCls = _props.prefixCls,
	                rowSelection = _props.rowSelection;
	
	            var columns = this.columns.concat();
	            if (rowSelection) {
	                var data = this.getFlatCurrentPageData().filter(function (item, index) {
	                    if (rowSelection.getCheckboxProps) {
	                        return !_this6.getCheckboxPropsByItem(item, index).disabled;
	                    }
	                    return true;
	                });
	                var selectionColumnClass = (0, _classnames2['default'])(prefixCls + '-selection-column', (0, _defineProperty3['default'])({}, prefixCls + '-selection-column-custom', rowSelection.selections));
	                var selectionColumn = {
	                    key: 'selection-column',
	                    render: this.renderSelectionBox(rowSelection.type),
	                    className: selectionColumnClass
	                };
	                if (rowSelection.type !== 'radio') {
	                    var checkboxAllDisabled = data.every(function (item, index) {
	                        return _this6.getCheckboxPropsByItem(item, index).disabled;
	                    });
	                    selectionColumn.title = _react2['default'].createElement(_SelectionCheckboxAll2['default'], { store: this.store, locale: this.getLocale(), data: data, getCheckboxPropsByItem: this.getCheckboxPropsByItem, getRecordKey: this.getRecordKey, disabled: checkboxAllDisabled, prefixCls: prefixCls, onSelect: this.handleSelectRow, selections: rowSelection.selections, hideDefaultSelections: rowSelection.hideDefaultSelections, getPopupContainer: this.getPopupContainer });
	                }
	                if (columns.some(function (column) {
	                    return column.fixed === 'left' || column.fixed === true;
	                })) {
	                    selectionColumn.fixed = 'left';
	                }
	                if (columns[0] && columns[0].key === 'selection-column') {
	                    columns[0] = selectionColumn;
	                } else {
	                    columns.unshift(selectionColumn);
	                }
	            }
	            return columns;
	        }
	    }, {
	        key: 'getColumnKey',
	        value: function getColumnKey(column, index) {
	            return column.key || column.dataIndex || index;
	        }
	    }, {
	        key: 'getMaxCurrent',
	        value: function getMaxCurrent(total) {
	            var _state$pagination = this.state.pagination,
	                current = _state$pagination.current,
	                pageSize = _state$pagination.pageSize;
	
	            if ((current - 1) * pageSize >= total) {
	                return Math.floor((total - 1) / pageSize) + 1;
	            }
	            return current;
	        }
	    }, {
	        key: 'isSortColumn',
	        value: function isSortColumn(column) {
	            var sortColumn = this.state.sortColumn;
	
	            if (!column || !sortColumn) {
	                return false;
	            }
	            return this.getColumnKey(sortColumn) === this.getColumnKey(column);
	        }
	    }, {
	        key: 'renderColumnsDropdown',
	        value: function renderColumnsDropdown(columns) {
	            var _this7 = this;
	
	            var _props2 = this.props,
	                prefixCls = _props2.prefixCls,
	                dropdownPrefixCls = _props2.dropdownPrefixCls;
	            var sortOrder = this.state.sortOrder;
	
	            var locale = this.getLocale();
	            return (0, _util.treeMap)(columns, function (originColumn, i) {
	                var column = (0, _extends5['default'])({}, originColumn);
	                var key = _this7.getColumnKey(column, i);
	                var filterDropdown = void 0;
	                var sortButton = void 0;
	                if (column.filters && column.filters.length > 0 || column.filterDropdown) {
	                    var colFilters = _this7.state.filters[key] || [];
	                    filterDropdown = _react2['default'].createElement(_filterDropdown2['default'], { locale: locale, column: column, selectedKeys: colFilters, confirmFilter: _this7.handleFilter, prefixCls: prefixCls + '-filter', dropdownPrefixCls: dropdownPrefixCls || 'ant-dropdown', getPopupContainer: _this7.getPopupContainer });
	                }
	                if (column.sorter) {
	                    var isSortColumn = _this7.isSortColumn(column);
	                    if (isSortColumn) {
	                        column.className = column.className || '';
	                        if (sortOrder) {
	                            column.className += ' ' + prefixCls + '-column-sort';
	                        }
	                    }
	                    var isAscend = isSortColumn && sortOrder === 'ascend';
	                    var isDescend = isSortColumn && sortOrder === 'descend';
	                    sortButton = _react2['default'].createElement(
	                        'div',
	                        { className: prefixCls + '-column-sorter' },
	                        _react2['default'].createElement(
	                            'span',
	                            { className: prefixCls + '-column-sorter-up ' + (isAscend ? 'on' : 'off'), title: '\u2191', onClick: function onClick() {
	                                    return _this7.toggleSortOrder('ascend', column);
	                                } },
	                            _react2['default'].createElement(_icon2['default'], { type: 'caret-up' })
	                        ),
	                        _react2['default'].createElement(
	                            'span',
	                            { className: prefixCls + '-column-sorter-down ' + (isDescend ? 'on' : 'off'), title: '\u2193', onClick: function onClick() {
	                                    return _this7.toggleSortOrder('descend', column);
	                                } },
	                            _react2['default'].createElement(_icon2['default'], { type: 'caret-down' })
	                        )
	                    );
	                }
	                column.title = _react2['default'].createElement(
	                    'span',
	                    null,
	                    column.title,
	                    sortButton,
	                    filterDropdown
	                );
	                return column;
	            });
	        }
	    }, {
	        key: 'renderPagination',
	        value: function renderPagination() {
	            // 强制不需要分页
	            if (!this.hasPagination()) {
	                return null;
	            }
	            var size = 'default';
	            var pagination = this.state.pagination;
	
	            if (pagination.size) {
	                size = pagination.size;
	            } else if (this.props.size === 'middle' || this.props.size === 'small') {
	                size = 'small';
	            }
	            var total = pagination.total || this.getLocalData().length;
	            return total > 0 ? _react2['default'].createElement(_pagination2['default'], (0, _extends5['default'])({ key: 'pagination' }, pagination, { className: (0, _classnames2['default'])(pagination.className, this.props.prefixCls + '-pagination'), onChange: this.handlePageChange, total: total, size: size, current: this.getMaxCurrent(total), onShowSizeChange: this.handleShowSizeChange })) : null;
	        }
	        // Get pagination, filters, sorter
	
	    }, {
	        key: 'prepareParamsArguments',
	        value: function prepareParamsArguments(state) {
	            var pagination = (0, _extends5['default'])({}, state.pagination);
	            // remove useless handle function in Table.onChange
	            delete pagination.onChange;
	            delete pagination.onShowSizeChange;
	            var filters = state.filters;
	            var sorter = {};
	            if (state.sortColumn && state.sortOrder) {
	                sorter.column = state.sortColumn;
	                sorter.order = state.sortOrder;
	                sorter.field = state.sortColumn.dataIndex;
	                sorter.columnKey = this.getColumnKey(state.sortColumn);
	            }
	            return [pagination, filters, sorter];
	        }
	    }, {
	        key: 'findColumn',
	        value: function findColumn(myKey) {
	            var _this8 = this;
	
	            var column = void 0;
	            (0, _util.treeMap)(this.columns, function (c) {
	                if (_this8.getColumnKey(c) === myKey) {
	                    column = c;
	                }
	            });
	            return column;
	        }
	    }, {
	        key: 'getCurrentPageData',
	        value: function getCurrentPageData() {
	            var data = this.getLocalData();
	            var current = void 0;
	            var pageSize = void 0;
	            var state = this.state;
	            // 如果没有分页的话，默认全部展示
	            if (!this.hasPagination()) {
	                pageSize = Number.MAX_VALUE;
	                current = 1;
	            } else {
	                pageSize = state.pagination.pageSize;
	                current = this.getMaxCurrent(state.pagination.total || data.length);
	            }
	            // 分页
	            // ---
	            // 当数据量少于等于每页数量时，直接设置数据
	            // 否则进行读取分页数据
	            if (data.length > pageSize || pageSize === Number.MAX_VALUE) {
	                data = data.filter(function (_, i) {
	                    return i >= (current - 1) * pageSize && i < current * pageSize;
	                });
	            }
	            return data;
	        }
	    }, {
	        key: 'getFlatData',
	        value: function getFlatData() {
	            return (0, _util.flatArray)(this.getLocalData());
	        }
	    }, {
	        key: 'getFlatCurrentPageData',
	        value: function getFlatCurrentPageData() {
	            return (0, _util.flatArray)(this.getCurrentPageData());
	        }
	    }, {
	        key: 'recursiveSort',
	        value: function recursiveSort(data, sorterFn) {
	            var _this9 = this;
	
	            var _props$childrenColumn = this.props.childrenColumnName,
	                childrenColumnName = _props$childrenColumn === undefined ? 'children' : _props$childrenColumn;
	
	            return data.sort(sorterFn).map(function (item) {
	                return item[childrenColumnName] ? (0, _extends5['default'])({}, item, (0, _defineProperty3['default'])({}, childrenColumnName, _this9.recursiveSort(item[childrenColumnName], sorterFn))) : item;
	            });
	        }
	    }, {
	        key: 'getLocalData',
	        value: function getLocalData() {
	            var _this10 = this;
	
	            var state = this.state;
	            var dataSource = this.props.dataSource;
	
	            var data = dataSource || [];
	            // 优化本地排序
	            data = data.slice(0);
	            var sorterFn = this.getSorterFn();
	            if (sorterFn) {
	                data = this.recursiveSort(data, sorterFn);
	            }
	            // 筛选
	            if (state.filters) {
	                Object.keys(state.filters).forEach(function (columnKey) {
	                    var col = _this10.findColumn(columnKey);
	                    if (!col) {
	                        return;
	                    }
	                    var values = state.filters[columnKey] || [];
	                    if (values.length === 0) {
	                        return;
	                    }
	                    var onFilter = col.onFilter;
	                    data = onFilter ? data.filter(function (record) {
	                        return values.some(function (v) {
	                            return onFilter(v, record);
	                        });
	                    }) : data;
	                });
	            }
	            return data;
	        }
	    }, {
	        key: 'render',
	        value: function render() {
	            var _classNames2,
	                _this11 = this;
	
	            var _a = this.props,
	                style = _a.style,
	                className = _a.className,
	                prefixCls = _a.prefixCls,
	                showHeader = _a.showHeader,
	                restProps = __rest(_a, ["style", "className", "prefixCls", "showHeader"]);
	            var data = this.getCurrentPageData();
	            var columns = this.renderRowSelection();
	            var expandIconAsCell = this.props.expandedRowRender && this.props.expandIconAsCell !== false;
	            var locale = this.getLocale();
	            var classString = (0, _classnames2['default'])((_classNames2 = {}, (0, _defineProperty3['default'])(_classNames2, prefixCls + '-' + this.props.size, true), (0, _defineProperty3['default'])(_classNames2, prefixCls + '-bordered', this.props.bordered), (0, _defineProperty3['default'])(_classNames2, prefixCls + '-empty', !data.length), (0, _defineProperty3['default'])(_classNames2, prefixCls + '-without-column-header', !showHeader), _classNames2));
	            columns = this.renderColumnsDropdown(columns);
	            columns = columns.map(function (column, i) {
	                var newColumn = (0, _extends5['default'])({}, column);
	                newColumn.key = _this11.getColumnKey(newColumn, i);
	                return newColumn;
	            });
	            var expandIconColumnIndex = columns[0] && columns[0].key === 'selection-column' ? 1 : 0;
	            if ('expandIconColumnIndex' in restProps) {
	                expandIconColumnIndex = restProps.expandIconColumnIndex;
	            }
	            var table = _react2['default'].createElement(_rcTable2['default'], (0, _extends5['default'])({ key: 'table' }, restProps, { prefixCls: prefixCls, data: data, columns: columns, showHeader: showHeader, className: classString, expandIconColumnIndex: expandIconColumnIndex, expandIconAsCell: expandIconAsCell, emptyText: function emptyText() {
	                    return locale.emptyText;
	                } }));
	            // if there is no pagination or no data,
	            // the height of spin should decrease by half of pagination
	            var paginationPatchClass = this.hasPagination() && data && data.length !== 0 ? prefixCls + '-with-pagination' : prefixCls + '-without-pagination';
	            var loading = this.props.loading;
	            if (typeof loading === 'boolean') {
	                loading = {
	                    spinning: loading
	                };
	            }
	            return _react2['default'].createElement(
	                'div',
	                { className: (0, _classnames2['default'])(prefixCls + '-wrapper', className), style: style },
	                _react2['default'].createElement(
	                    _spin2['default'],
	                    (0, _extends5['default'])({}, loading, { className: loading ? paginationPatchClass + ' ' + prefixCls + '-spin-holder' : '' }),
	                    table,
	                    this.renderPagination()
	                )
	            );
	        }
	    }]);
	    return Table;
	}(_react2['default'].Component);
	
	exports['default'] = Table;
	
	Table.Column = _Column2['default'];
	Table.ColumnGroup = _ColumnGroup2['default'];
	Table.propTypes = {
	    dataSource: _propTypes2['default'].array,
	    columns: _propTypes2['default'].array,
	    prefixCls: _propTypes2['default'].string,
	    useFixedHeader: _propTypes2['default'].bool,
	    rowSelection: _propTypes2['default'].object,
	    className: _propTypes2['default'].string,
	    size: _propTypes2['default'].string,
	    loading: _propTypes2['default'].oneOfType([_propTypes2['default'].bool, _propTypes2['default'].object]),
	    bordered: _propTypes2['default'].bool,
	    onChange: _propTypes2['default'].func,
	    locale: _propTypes2['default'].object,
	    dropdownPrefixCls: _propTypes2['default'].string
	};
	Table.defaultProps = {
	    dataSource: [],
	    prefixCls: 'ant-table',
	    useFixedHeader: false,
	    rowSelection: null,
	    className: '',
	    size: 'large',
	    loading: false,
	    bordered: false,
	    indentSize: 20,
	    locale: {},
	    rowKey: 'key',
	    showHeader: true
	};
	Table.contextTypes = {
	    antLocale: _propTypes2['default'].object
	};
	module.exports = exports['default'];

/***/ }),
/* 385 */
/***/ (function(module, exports, __webpack_require__) {

	"use strict";
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	exports["default"] = createStore;
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
	
	function createStore(initialState) {
	    var state = initialState;
	    var listeners = [];
	    function setState(partial) {
	        state = (0, _extends3["default"])({}, state, partial);
	        for (var i = 0; i < listeners.length; i++) {
	            listeners[i]();
	        }
	    }
	    function getState() {
	        return state;
	    }
	    function subscribe(listener) {
	        listeners.push(listener);
	        return function unsubscribe() {
	            var index = listeners.indexOf(listener);
	            listeners.splice(index, 1);
	        };
	    }
	    return {
	        setState: setState,
	        getState: getState,
	        subscribe: subscribe
	    };
	}
	module.exports = exports["default"];

/***/ }),
/* 386 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _reactDom = __webpack_require__(10);
	
	var _reactDom2 = _interopRequireDefault(_reactDom);
	
	var _rcMenu = __webpack_require__(77);
	
	var _rcMenu2 = _interopRequireDefault(_rcMenu);
	
	var _domClosest = __webpack_require__(476);
	
	var _domClosest2 = _interopRequireDefault(_domClosest);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _dropdown = __webpack_require__(102);
	
	var _dropdown2 = _interopRequireDefault(_dropdown);
	
	var _icon = __webpack_require__(16);
	
	var _icon2 = _interopRequireDefault(_icon);
	
	var _checkbox = __webpack_require__(55);
	
	var _checkbox2 = _interopRequireDefault(_checkbox);
	
	var _radio = __webpack_require__(82);
	
	var _radio2 = _interopRequireDefault(_radio);
	
	var _FilterDropdownMenuWrapper = __webpack_require__(381);
	
	var _FilterDropdownMenuWrapper2 = _interopRequireDefault(_FilterDropdownMenuWrapper);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var FilterMenu = function (_React$Component) {
	    (0, _inherits3['default'])(FilterMenu, _React$Component);
	
	    function FilterMenu(props) {
	        (0, _classCallCheck3['default'])(this, FilterMenu);
	
	        var _this = (0, _possibleConstructorReturn3['default'])(this, (FilterMenu.__proto__ || Object.getPrototypeOf(FilterMenu)).call(this, props));
	
	        _this.setNeverShown = function (column) {
	            var rootNode = _reactDom2['default'].findDOMNode(_this);
	            var filterBelongToScrollBody = !!(0, _domClosest2['default'])(rootNode, '.ant-table-scroll');
	            if (filterBelongToScrollBody) {
	                // When fixed column have filters, there will be two dropdown menus
	                // Filter dropdown menu inside scroll body should never be shown
	                // To fix https://github.com/ant-design/ant-design/issues/5010 and
	                // https://github.com/ant-design/ant-design/issues/7909
	                _this.neverShown = !!column.fixed;
	            }
	        };
	        _this.setSelectedKeys = function (_ref) {
	            var selectedKeys = _ref.selectedKeys;
	
	            _this.setState({ selectedKeys: selectedKeys });
	        };
	        _this.handleClearFilters = function () {
	            _this.setState({
	                selectedKeys: []
	            }, _this.handleConfirm);
	        };
	        _this.handleConfirm = function () {
	            _this.setVisible(false);
	            _this.confirmFilter();
	        };
	        _this.onVisibleChange = function (visible) {
	            _this.setVisible(visible);
	            if (!visible) {
	                _this.confirmFilter();
	            }
	        };
	        _this.handleMenuItemClick = function (info) {
	            if (info.keyPath.length <= 1) {
	                return;
	            }
	            var keyPathOfSelectedItem = _this.state.keyPathOfSelectedItem;
	            if (_this.state.selectedKeys.indexOf(info.key) >= 0) {
	                // deselect SubMenu child
	                delete keyPathOfSelectedItem[info.key];
	            } else {
	                // select SubMenu child
	                keyPathOfSelectedItem[info.key] = info.keyPath;
	            }
	            _this.setState({ keyPathOfSelectedItem: keyPathOfSelectedItem });
	        };
	        _this.renderFilterIcon = function () {
	            var _this$props = _this.props,
	                column = _this$props.column,
	                locale = _this$props.locale,
	                prefixCls = _this$props.prefixCls;
	
	            var filterIcon = column.filterIcon;
	            var dropdownSelectedClass = _this.props.selectedKeys.length > 0 ? prefixCls + '-selected' : '';
	            return filterIcon ? _react2['default'].cloneElement(filterIcon, {
	                title: locale.filterTitle,
	                className: (0, _classnames2['default'])(filterIcon.className, (0, _defineProperty3['default'])({}, prefixCls + '-icon', true))
	            }) : _react2['default'].createElement(_icon2['default'], { title: locale.filterTitle, type: 'filter', className: dropdownSelectedClass });
	        };
	        var visible = 'filterDropdownVisible' in props.column ? props.column.filterDropdownVisible : false;
	        _this.state = {
	            selectedKeys: props.selectedKeys,
	            keyPathOfSelectedItem: {},
	            visible: visible
	        };
	        return _this;
	    }
	
	    (0, _createClass3['default'])(FilterMenu, [{
	        key: 'componentDidMount',
	        value: function componentDidMount() {
	            var column = this.props.column;
	
	            this.setNeverShown(column);
	        }
	    }, {
	        key: 'componentWillReceiveProps',
	        value: function componentWillReceiveProps(nextProps) {
	            var column = nextProps.column;
	
	            this.setNeverShown(column);
	            var newState = {};
	            if ('selectedKeys' in nextProps) {
	                newState.selectedKeys = nextProps.selectedKeys;
	            }
	            if ('filterDropdownVisible' in column) {
	                newState.visible = column.filterDropdownVisible;
	            }
	            if (Object.keys(newState).length > 0) {
	                this.setState(newState);
	            }
	        }
	    }, {
	        key: 'setVisible',
	        value: function setVisible(visible) {
	            var column = this.props.column;
	
	            if (!('filterDropdownVisible' in column)) {
	                this.setState({ visible: visible });
	            }
	            if (column.onFilterDropdownVisibleChange) {
	                column.onFilterDropdownVisibleChange(visible);
	            }
	        }
	    }, {
	        key: 'confirmFilter',
	        value: function confirmFilter() {
	            if (this.state.selectedKeys !== this.props.selectedKeys) {
	                this.props.confirmFilter(this.props.column, this.state.selectedKeys);
	            }
	        }
	    }, {
	        key: 'renderMenuItem',
	        value: function renderMenuItem(item) {
	            var column = this.props.column;
	
	            var multiple = 'filterMultiple' in column ? column.filterMultiple : true;
	            var input = multiple ? _react2['default'].createElement(_checkbox2['default'], { checked: this.state.selectedKeys.indexOf(item.value.toString()) >= 0 }) : _react2['default'].createElement(_radio2['default'], { checked: this.state.selectedKeys.indexOf(item.value.toString()) >= 0 });
	            return _react2['default'].createElement(
	                _rcMenu.Item,
	                { key: item.value },
	                input,
	                _react2['default'].createElement(
	                    'span',
	                    null,
	                    item.text
	                )
	            );
	        }
	    }, {
	        key: 'hasSubMenu',
	        value: function hasSubMenu() {
	            var _props$column$filters = this.props.column.filters,
	                filters = _props$column$filters === undefined ? [] : _props$column$filters;
	
	            return filters.some(function (item) {
	                return !!(item.children && item.children.length > 0);
	            });
	        }
	    }, {
	        key: 'renderMenus',
	        value: function renderMenus(items) {
	            var _this2 = this;
	
	            return items.map(function (item) {
	                if (item.children && item.children.length > 0) {
	                    var keyPathOfSelectedItem = _this2.state.keyPathOfSelectedItem;
	
	                    var containSelected = Object.keys(keyPathOfSelectedItem).some(function (key) {
	                        return keyPathOfSelectedItem[key].indexOf(item.value) >= 0;
	                    });
	                    var subMenuCls = containSelected ? _this2.props.dropdownPrefixCls + '-submenu-contain-selected' : '';
	                    return _react2['default'].createElement(
	                        _rcMenu.SubMenu,
	                        { title: item.text, className: subMenuCls, key: item.value.toString() },
	                        _this2.renderMenus(item.children)
	                    );
	                }
	                return _this2.renderMenuItem(item);
	            });
	        }
	    }, {
	        key: 'render',
	        value: function render() {
	            var _props = this.props,
	                column = _props.column,
	                locale = _props.locale,
	                prefixCls = _props.prefixCls,
	                dropdownPrefixCls = _props.dropdownPrefixCls,
	                getPopupContainer = _props.getPopupContainer;
	            // default multiple selection in filter dropdown
	
	            var multiple = 'filterMultiple' in column ? column.filterMultiple : true;
	            var dropdownMenuClass = (0, _classnames2['default'])((0, _defineProperty3['default'])({}, dropdownPrefixCls + '-menu-without-submenu', !this.hasSubMenu()));
	            var menus = column.filterDropdown ? _react2['default'].createElement(
	                _FilterDropdownMenuWrapper2['default'],
	                null,
	                column.filterDropdown
	            ) : _react2['default'].createElement(
	                _FilterDropdownMenuWrapper2['default'],
	                { className: prefixCls + '-dropdown' },
	                _react2['default'].createElement(
	                    _rcMenu2['default'],
	                    { multiple: multiple, onClick: this.handleMenuItemClick, prefixCls: dropdownPrefixCls + '-menu', className: dropdownMenuClass, onSelect: this.setSelectedKeys, onDeselect: this.setSelectedKeys, selectedKeys: this.state.selectedKeys },
	                    this.renderMenus(column.filters)
	                ),
	                _react2['default'].createElement(
	                    'div',
	                    { className: prefixCls + '-dropdown-btns' },
	                    _react2['default'].createElement(
	                        'a',
	                        { className: prefixCls + '-dropdown-link confirm', onClick: this.handleConfirm },
	                        locale.filterConfirm
	                    ),
	                    _react2['default'].createElement(
	                        'a',
	                        { className: prefixCls + '-dropdown-link clear', onClick: this.handleClearFilters },
	                        locale.filterReset
	                    )
	                )
	            );
	            return _react2['default'].createElement(
	                _dropdown2['default'],
	                { trigger: ['click'], overlay: menus, visible: this.neverShown ? false : this.state.visible, onVisibleChange: this.onVisibleChange, getPopupContainer: getPopupContainer },
	                this.renderFilterIcon()
	            );
	        }
	    }]);
	    return FilterMenu;
	}(_react2['default'].Component);
	
	exports['default'] = FilterMenu;
	
	FilterMenu.defaultProps = {
	    handleFilter: function handleFilter() {},
	
	    column: {}
	};
	module.exports = exports['default'];

/***/ }),
/* 387 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _Table = __webpack_require__(384);
	
	var _Table2 = _interopRequireDefault(_Table);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	exports['default'] = _Table2['default'];
	module.exports = exports['default'];

/***/ }),
/* 388 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _toConsumableArray2 = __webpack_require__(31);
	
	var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	exports.flatArray = flatArray;
	exports.treeMap = treeMap;
	exports.flatFilter = flatFilter;
	exports.normalizeColumns = normalizeColumns;
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function flatArray() {
	    var data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
	    var childrenName = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'children';
	
	    var result = [];
	    var loop = function loop(array) {
	        array.forEach(function (item) {
	            if (item[childrenName]) {
	                var newItem = (0, _extends3['default'])({}, item);
	                delete newItem[childrenName];
	                result.push(newItem);
	                if (item[childrenName].length > 0) {
	                    loop(item[childrenName]);
	                }
	            } else {
	                result.push(item);
	            }
	        });
	    };
	    loop(data);
	    return result;
	}
	function treeMap(tree, mapper) {
	    var childrenName = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'children';
	
	    return tree.map(function (node, index) {
	        var extra = {};
	        if (node[childrenName]) {
	            extra[childrenName] = treeMap(node[childrenName], mapper, childrenName);
	        }
	        return (0, _extends3['default'])({}, mapper(node, index), extra);
	    });
	}
	function flatFilter(tree, callback) {
	    return tree.reduce(function (acc, node) {
	        if (callback(node)) {
	            acc.push(node);
	        }
	        if (node.children) {
	            var children = flatFilter(node.children, callback);
	            acc.push.apply(acc, (0, _toConsumableArray3['default'])(children));
	        }
	        return acc;
	    }, []);
	}
	function normalizeColumns(elements) {
	    var columns = [];
	    _react2['default'].Children.forEach(elements, function (element) {
	        if (!_react2['default'].isValidElement(element)) {
	            return;
	        }
	        var column = (0, _extends3['default'])({}, element.props);
	        if (element.key) {
	            column.key = element.key;
	        }
	        if (element.type && element.type.__ANT_TABLE_COLUMN_GROUP) {
	            column.children = normalizeColumns(column.children);
	        }
	        columns.push(column);
	    });
	    return columns;
	}

/***/ }),
/* 389 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _typeof2 = __webpack_require__(21);
	
	var _typeof3 = _interopRequireDefault(_typeof2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _reactDom = __webpack_require__(10);
	
	var _rcTabs = __webpack_require__(764);
	
	var _rcTabs2 = _interopRequireDefault(_rcTabs);
	
	var _ScrollableInkTabBar = __webpack_require__(760);
	
	var _ScrollableInkTabBar2 = _interopRequireDefault(_ScrollableInkTabBar);
	
	var _TabContent = __webpack_require__(271);
	
	var _TabContent2 = _interopRequireDefault(_TabContent);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _icon = __webpack_require__(16);
	
	var _icon2 = _interopRequireDefault(_icon);
	
	var _warning = __webpack_require__(24);
	
	var _warning2 = _interopRequireDefault(_warning);
	
	var _isFlexSupported = __webpack_require__(315);
	
	var _isFlexSupported2 = _interopRequireDefault(_isFlexSupported);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var Tabs = function (_React$Component) {
	    (0, _inherits3['default'])(Tabs, _React$Component);
	
	    function Tabs() {
	        (0, _classCallCheck3['default'])(this, Tabs);
	
	        var _this = (0, _possibleConstructorReturn3['default'])(this, (Tabs.__proto__ || Object.getPrototypeOf(Tabs)).apply(this, arguments));
	
	        _this.createNewTab = function (targetKey) {
	            var onEdit = _this.props.onEdit;
	            if (onEdit) {
	                onEdit(targetKey, 'add');
	            }
	        };
	        _this.removeTab = function (targetKey, e) {
	            e.stopPropagation();
	            if (!targetKey) {
	                return;
	            }
	            var onEdit = _this.props.onEdit;
	            if (onEdit) {
	                onEdit(targetKey, 'remove');
	            }
	        };
	        _this.handleChange = function (activeKey) {
	            var onChange = _this.props.onChange;
	            if (onChange) {
	                onChange(activeKey);
	            }
	        };
	        return _this;
	    }
	
	    (0, _createClass3['default'])(Tabs, [{
	        key: 'componentDidMount',
	        value: function componentDidMount() {
	            var NO_FLEX = ' no-flex';
	            var tabNode = (0, _reactDom.findDOMNode)(this);
	            if (tabNode && !(0, _isFlexSupported2['default'])() && tabNode.className.indexOf(NO_FLEX) === -1) {
	                tabNode.className += NO_FLEX;
	            }
	        }
	    }, {
	        key: 'render',
	        value: function render() {
	            var _classNames,
	                _this2 = this;
	
	            var _props = this.props,
	                prefixCls = _props.prefixCls,
	                _props$className = _props.className,
	                className = _props$className === undefined ? '' : _props$className,
	                size = _props.size,
	                _props$type = _props.type,
	                type = _props$type === undefined ? 'line' : _props$type,
	                tabPosition = _props.tabPosition,
	                children = _props.children,
	                tabBarExtraContent = _props.tabBarExtraContent,
	                tabBarStyle = _props.tabBarStyle,
	                hideAdd = _props.hideAdd,
	                onTabClick = _props.onTabClick,
	                onPrevClick = _props.onPrevClick,
	                onNextClick = _props.onNextClick,
	                _props$animated = _props.animated,
	                animated = _props$animated === undefined ? true : _props$animated;
	
	            var _ref = (typeof animated === 'undefined' ? 'undefined' : (0, _typeof3['default'])(animated)) === 'object' ? {
	                inkBarAnimated: animated.inkBar, tabPaneAnimated: animated.tabPane
	            } : {
	                inkBarAnimated: animated, tabPaneAnimated: animated
	            },
	                inkBarAnimated = _ref.inkBarAnimated,
	                tabPaneAnimated = _ref.tabPaneAnimated;
	            // card tabs should not have animation
	
	
	            if (type !== 'line') {
	                tabPaneAnimated = 'animated' in this.props ? tabPaneAnimated : false;
	            }
	            (0, _warning2['default'])(!(type.indexOf('card') >= 0 && size === 'small'), 'Tabs[type=card|editable-card] doesn\'t have small size, it\'s by designed.');
	            var cls = (0, _classnames2['default'])(className, (_classNames = {}, (0, _defineProperty3['default'])(_classNames, prefixCls + '-mini', size === 'small' || size === 'mini'), (0, _defineProperty3['default'])(_classNames, prefixCls + '-vertical', tabPosition === 'left' || tabPosition === 'right'), (0, _defineProperty3['default'])(_classNames, prefixCls + '-card', type.indexOf('card') >= 0), (0, _defineProperty3['default'])(_classNames, prefixCls + '-' + type, true), (0, _defineProperty3['default'])(_classNames, prefixCls + '-no-animation', !tabPaneAnimated), _classNames));
	            // only card type tabs can be added and closed
	            var childrenWithClose = void 0;
	            if (type === 'editable-card') {
	                childrenWithClose = [];
	                _react2['default'].Children.forEach(children, function (child, index) {
	                    var closable = child.props.closable;
	                    closable = typeof closable === 'undefined' ? true : closable;
	                    var closeIcon = closable ? _react2['default'].createElement(_icon2['default'], { type: 'close', onClick: function onClick(e) {
	                            return _this2.removeTab(child.key, e);
	                        } }) : null;
	                    childrenWithClose.push((0, _react.cloneElement)(child, {
	                        tab: _react2['default'].createElement(
	                            'div',
	                            { className: closable ? undefined : prefixCls + '-tab-unclosable' },
	                            child.props.tab,
	                            closeIcon
	                        ),
	                        key: child.key || index
	                    }));
	                });
	                // Add new tab handler
	                if (!hideAdd) {
	                    tabBarExtraContent = _react2['default'].createElement(
	                        'span',
	                        null,
	                        _react2['default'].createElement(_icon2['default'], { type: 'plus', className: prefixCls + '-new-tab', onClick: this.createNewTab }),
	                        tabBarExtraContent
	                    );
	                }
	            }
	            tabBarExtraContent = tabBarExtraContent ? _react2['default'].createElement(
	                'div',
	                { className: prefixCls + '-extra-content' },
	                tabBarExtraContent
	            ) : null;
	            var renderTabBar = function renderTabBar() {
	                return _react2['default'].createElement(_ScrollableInkTabBar2['default'], { inkBarAnimated: inkBarAnimated, extraContent: tabBarExtraContent, onTabClick: onTabClick, onPrevClick: onPrevClick, onNextClick: onNextClick, style: tabBarStyle });
	            };
	            return _react2['default'].createElement(
	                _rcTabs2['default'],
	                (0, _extends3['default'])({}, this.props, { className: cls, tabBarPosition: tabPosition, renderTabBar: renderTabBar, renderTabContent: function renderTabContent() {
	                        return _react2['default'].createElement(_TabContent2['default'], { animated: tabPaneAnimated, animatedWithMargin: true });
	                    }, onChange: this.handleChange }),
	                childrenWithClose || children
	            );
	        }
	    }]);
	    return Tabs;
	}(_react2['default'].Component);
	
	exports['default'] = Tabs;
	
	Tabs.TabPane = _rcTabs.TabPane;
	Tabs.defaultProps = {
	    prefixCls: 'ant-tabs',
	    hideAdd: false
	};
	module.exports = exports['default'];

/***/ }),
/* 390 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var __rest = undefined && undefined.__rest || function (s, e) {
	    var t = {};
	    for (var p in s) {
	        if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
	    }if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	        if (e.indexOf(p[i]) < 0) t[p[i]] = s[p[i]];
	    }return t;
	};
	
	var CheckableTag = function (_React$Component) {
	    (0, _inherits3['default'])(CheckableTag, _React$Component);
	
	    function CheckableTag() {
	        (0, _classCallCheck3['default'])(this, CheckableTag);
	
	        var _this = (0, _possibleConstructorReturn3['default'])(this, (CheckableTag.__proto__ || Object.getPrototypeOf(CheckableTag)).apply(this, arguments));
	
	        _this.handleClick = function () {
	            var _this$props = _this.props,
	                checked = _this$props.checked,
	                onChange = _this$props.onChange;
	
	            if (onChange) {
	                onChange(!checked);
	            }
	        };
	        return _this;
	    }
	
	    (0, _createClass3['default'])(CheckableTag, [{
	        key: 'render',
	        value: function render() {
	            var _classNames;
	
	            var _a = this.props,
	                _a$prefixCls = _a.prefixCls,
	                prefixCls = _a$prefixCls === undefined ? 'ant-tag' : _a$prefixCls,
	                className = _a.className,
	                checked = _a.checked,
	                restProps = __rest(_a, ["prefixCls", "className", "checked"]);
	            var cls = (0, _classnames2['default'])(prefixCls, (_classNames = {}, (0, _defineProperty3['default'])(_classNames, prefixCls + '-checkable', true), (0, _defineProperty3['default'])(_classNames, prefixCls + '-checkable-checked', checked), _classNames), className);
	            delete restProps.onChange; // TypeScript cannot check delete now.
	            return _react2['default'].createElement('div', (0, _extends3['default'])({}, restProps, { className: cls, onClick: this.handleClick }));
	        }
	    }]);
	    return CheckableTag;
	}(_react2['default'].Component);
	
	exports['default'] = CheckableTag;
	module.exports = exports['default'];

/***/ }),
/* 391 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _reactDom = __webpack_require__(10);
	
	var _reactDom2 = _interopRequireDefault(_reactDom);
	
	var _rcAnimate = __webpack_require__(22);
	
	var _rcAnimate2 = _interopRequireDefault(_rcAnimate);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _omit = __webpack_require__(28);
	
	var _omit2 = _interopRequireDefault(_omit);
	
	var _icon = __webpack_require__(16);
	
	var _icon2 = _interopRequireDefault(_icon);
	
	var _CheckableTag = __webpack_require__(390);
	
	var _CheckableTag2 = _interopRequireDefault(_CheckableTag);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var __rest = undefined && undefined.__rest || function (s, e) {
	    var t = {};
	    for (var p in s) {
	        if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
	    }if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	        if (e.indexOf(p[i]) < 0) t[p[i]] = s[p[i]];
	    }return t;
	};
	
	var Tag = function (_React$Component) {
	    (0, _inherits3['default'])(Tag, _React$Component);
	
	    function Tag(props) {
	        (0, _classCallCheck3['default'])(this, Tag);
	
	        var _this = (0, _possibleConstructorReturn3['default'])(this, (Tag.__proto__ || Object.getPrototypeOf(Tag)).call(this, props));
	
	        _this.close = function (e) {
	            var onClose = _this.props.onClose;
	            if (onClose) {
	                onClose(e);
	            }
	            if (e.defaultPrevented) {
	                return;
	            }
	            var dom = _reactDom2['default'].findDOMNode(_this);
	            dom.style.width = dom.getBoundingClientRect().width + 'px';
	            // It's Magic Code, don't know why
	            dom.style.width = dom.getBoundingClientRect().width + 'px';
	            _this.setState({
	                closing: true
	            });
	        };
	        _this.animationEnd = function (_, existed) {
	            if (!existed && !_this.state.closed) {
	                _this.setState({
	                    closed: true,
	                    closing: false
	                });
	                var afterClose = _this.props.afterClose;
	                if (afterClose) {
	                    afterClose();
	                }
	            }
	        };
	        _this.state = {
	            closing: false,
	            closed: false
	        };
	        return _this;
	    }
	
	    (0, _createClass3['default'])(Tag, [{
	        key: 'isPresetColor',
	        value: function isPresetColor(color) {
	            if (!color) {
	                return false;
	            }
	            return (/^(pink|red|yellow|orange|cyan|green|blue|purple)(-inverse)?$/.test(color)
	            );
	        }
	    }, {
	        key: 'render',
	        value: function render() {
	            var _classNames;
	
	            var _a = this.props,
	                prefixCls = _a.prefixCls,
	                closable = _a.closable,
	                color = _a.color,
	                className = _a.className,
	                children = _a.children,
	                style = _a.style,
	                otherProps = __rest(_a, ["prefixCls", "closable", "color", "className", "children", "style"]);
	            var closeIcon = closable ? _react2['default'].createElement(_icon2['default'], { type: 'cross', onClick: this.close }) : '';
	            var isPresetColor = this.isPresetColor(color);
	            var classString = (0, _classnames2['default'])(prefixCls, (_classNames = {}, (0, _defineProperty3['default'])(_classNames, prefixCls + '-' + color, isPresetColor), (0, _defineProperty3['default'])(_classNames, prefixCls + '-has-color', color && !isPresetColor), (0, _defineProperty3['default'])(_classNames, prefixCls + '-close', this.state.closing), _classNames), className);
	            // fix https://fb.me/react-unknown-prop
	            var divProps = (0, _omit2['default'])(otherProps, ['onClose', 'afterClose']);
	            var tagStyle = (0, _extends3['default'])({ backgroundColor: color && !isPresetColor ? color : null }, style);
	            var tag = this.state.closed ? null : _react2['default'].createElement(
	                'div',
	                (0, _extends3['default'])({ 'data-show': !this.state.closing }, divProps, { className: classString, style: tagStyle }),
	                _react2['default'].createElement(
	                    'span',
	                    { className: prefixCls + '-text' },
	                    children
	                ),
	                closeIcon
	            );
	            return _react2['default'].createElement(
	                _rcAnimate2['default'],
	                { component: '', showProp: 'data-show', transitionName: prefixCls + '-zoom', transitionAppear: true, onEnd: this.animationEnd },
	                tag
	            );
	        }
	    }]);
	    return Tag;
	}(_react2['default'].Component);
	
	exports['default'] = Tag;
	
	Tag.CheckableTag = _CheckableTag2['default'];
	Tag.defaultProps = {
	    prefixCls: 'ant-tag',
	    closable: false
	};
	module.exports = exports['default'];

/***/ }),
/* 392 */,
/* 393 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _TimelineItem = __webpack_require__(394);
	
	var _TimelineItem2 = _interopRequireDefault(_TimelineItem);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var __rest = undefined && undefined.__rest || function (s, e) {
	    var t = {};
	    for (var p in s) {
	        if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
	    }if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	        if (e.indexOf(p[i]) < 0) t[p[i]] = s[p[i]];
	    }return t;
	};
	
	var Timeline = function (_React$Component) {
	    (0, _inherits3['default'])(Timeline, _React$Component);
	
	    function Timeline() {
	        (0, _classCallCheck3['default'])(this, Timeline);
	        return (0, _possibleConstructorReturn3['default'])(this, (Timeline.__proto__ || Object.getPrototypeOf(Timeline)).apply(this, arguments));
	    }
	
	    (0, _createClass3['default'])(Timeline, [{
	        key: 'render',
	        value: function render() {
	            var _a = this.props,
	                prefixCls = _a.prefixCls,
	                children = _a.children,
	                pending = _a.pending,
	                className = _a.className,
	                restProps = __rest(_a, ["prefixCls", "children", "pending", "className"]);
	            var pendingNode = typeof pending === 'boolean' ? null : pending;
	            var classString = (0, _classnames2['default'])(prefixCls, (0, _defineProperty3['default'])({}, prefixCls + '-pending', !!pending), className);
	            // Remove falsy items
	            var falsylessItems = _react.Children.toArray(children).filter(function (item) {
	                return !!item;
	            });
	            var items = _react.Children.map(falsylessItems, function (ele, idx) {
	                return _react2['default'].cloneElement(ele, {
	                    last: idx === _react.Children.count(falsylessItems) - 1
	                });
	            });
	            var pendingItem = !!pending ? _react2['default'].createElement(
	                _TimelineItem2['default'],
	                { pending: !!pending },
	                pendingNode
	            ) : null;
	            return _react2['default'].createElement(
	                'ul',
	                (0, _extends3['default'])({}, restProps, { className: classString }),
	                items,
	                pendingItem
	            );
	        }
	    }]);
	    return Timeline;
	}(_react2['default'].Component);
	
	exports['default'] = Timeline;
	
	Timeline.Item = _TimelineItem2['default'];
	Timeline.defaultProps = {
	    prefixCls: 'ant-timeline'
	};
	module.exports = exports['default'];

/***/ }),
/* 394 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var __rest = undefined && undefined.__rest || function (s, e) {
	    var t = {};
	    for (var p in s) {
	        if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
	    }if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	        if (e.indexOf(p[i]) < 0) t[p[i]] = s[p[i]];
	    }return t;
	};
	
	var TimelineItem = function (_React$Component) {
	    (0, _inherits3['default'])(TimelineItem, _React$Component);
	
	    function TimelineItem() {
	        (0, _classCallCheck3['default'])(this, TimelineItem);
	        return (0, _possibleConstructorReturn3['default'])(this, (TimelineItem.__proto__ || Object.getPrototypeOf(TimelineItem)).apply(this, arguments));
	    }
	
	    (0, _createClass3['default'])(TimelineItem, [{
	        key: 'render',
	        value: function render() {
	            var _classNames, _classNames2;
	
	            var _a = this.props,
	                prefixCls = _a.prefixCls,
	                className = _a.className,
	                _a$color = _a.color,
	                color = _a$color === undefined ? '' : _a$color,
	                last = _a.last,
	                children = _a.children,
	                pending = _a.pending,
	                dot = _a.dot,
	                restProps = __rest(_a, ["prefixCls", "className", "color", "last", "children", "pending", "dot"]);
	            var itemClassName = (0, _classnames2['default'])((_classNames = {}, (0, _defineProperty3['default'])(_classNames, prefixCls + '-item', true), (0, _defineProperty3['default'])(_classNames, prefixCls + '-item-last', last), (0, _defineProperty3['default'])(_classNames, prefixCls + '-item-pending', pending), _classNames), className);
	            var dotClassName = (0, _classnames2['default'])((_classNames2 = {}, (0, _defineProperty3['default'])(_classNames2, prefixCls + '-item-head', true), (0, _defineProperty3['default'])(_classNames2, prefixCls + '-item-head-custom', dot), (0, _defineProperty3['default'])(_classNames2, prefixCls + '-item-head-' + color, true), _classNames2));
	            return _react2['default'].createElement(
	                'li',
	                (0, _extends3['default'])({}, restProps, { className: itemClassName }),
	                _react2['default'].createElement('div', { className: prefixCls + '-item-tail' }),
	                _react2['default'].createElement(
	                    'div',
	                    { className: dotClassName, style: { borderColor: /blue|red|green/.test(color) ? null : color } },
	                    dot
	                ),
	                _react2['default'].createElement(
	                    'div',
	                    { className: prefixCls + '-item-content' },
	                    children
	                )
	            );
	        }
	    }]);
	    return TimelineItem;
	}(_react2['default'].Component);
	
	exports['default'] = TimelineItem;
	
	TimelineItem.defaultProps = {
	    prefixCls: 'ant-timeline',
	    color: 'blue',
	    last: false,
	    pending: false
	};
	module.exports = exports['default'];

/***/ }),
/* 395 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _Timeline = __webpack_require__(393);
	
	var _Timeline2 = _interopRequireDefault(_Timeline);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	exports['default'] = _Timeline2['default'];
	module.exports = exports['default'];

/***/ }),
/* 396 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	exports.getOverflowOptions = getOverflowOptions;
	exports['default'] = getPlacements;
	
	var _placements = __webpack_require__(274);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var autoAdjustOverflowEnabled = {
	    adjustX: 1,
	    adjustY: 1
	};
	var autoAdjustOverflowDisabled = {
	    adjustX: 0,
	    adjustY: 0
	};
	var targetOffset = [0, 0];
	function getOverflowOptions(autoAdjustOverflow) {
	    if (typeof autoAdjustOverflow === 'boolean') {
	        return autoAdjustOverflow ? autoAdjustOverflowEnabled : autoAdjustOverflowDisabled;
	    }
	    return (0, _extends3['default'])({}, autoAdjustOverflowDisabled, autoAdjustOverflow);
	}
	function getPlacements() {
	    var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
	    var _config$arrowWidth = config.arrowWidth,
	        arrowWidth = _config$arrowWidth === undefined ? 5 : _config$arrowWidth,
	        _config$horizontalArr = config.horizontalArrowShift,
	        horizontalArrowShift = _config$horizontalArr === undefined ? 16 : _config$horizontalArr,
	        _config$verticalArrow = config.verticalArrowShift,
	        verticalArrowShift = _config$verticalArrow === undefined ? 12 : _config$verticalArrow,
	        _config$autoAdjustOve = config.autoAdjustOverflow,
	        autoAdjustOverflow = _config$autoAdjustOve === undefined ? true : _config$autoAdjustOve;
	
	    var placementMap = {
	        left: {
	            points: ['cr', 'cl'],
	            offset: [-4, 0]
	        },
	        right: {
	            points: ['cl', 'cr'],
	            offset: [4, 0]
	        },
	        top: {
	            points: ['bc', 'tc'],
	            offset: [0, -4]
	        },
	        bottom: {
	            points: ['tc', 'bc'],
	            offset: [0, 4]
	        },
	        topLeft: {
	            points: ['bl', 'tc'],
	            offset: [-(horizontalArrowShift + arrowWidth), -4]
	        },
	        leftTop: {
	            points: ['tr', 'cl'],
	            offset: [-4, -(verticalArrowShift + arrowWidth)]
	        },
	        topRight: {
	            points: ['br', 'tc'],
	            offset: [horizontalArrowShift + arrowWidth, -4]
	        },
	        rightTop: {
	            points: ['tl', 'cr'],
	            offset: [4, -(verticalArrowShift + arrowWidth)]
	        },
	        bottomRight: {
	            points: ['tr', 'bc'],
	            offset: [horizontalArrowShift + arrowWidth, 4]
	        },
	        rightBottom: {
	            points: ['bl', 'cr'],
	            offset: [4, verticalArrowShift + arrowWidth]
	        },
	        bottomLeft: {
	            points: ['tl', 'bc'],
	            offset: [-(horizontalArrowShift + arrowWidth), 4]
	        },
	        leftBottom: {
	            points: ['br', 'cl'],
	            offset: [-4, verticalArrowShift + arrowWidth]
	        }
	    };
	    Object.keys(placementMap).forEach(function (key) {
	        placementMap[key] = config.arrowPointAtCenter ? (0, _extends3['default'])({}, placementMap[key], { overflow: getOverflowOptions(autoAdjustOverflow), targetOffset: targetOffset }) : (0, _extends3['default'])({}, _placements.placements[key], { overflow: getOverflowOptions(autoAdjustOverflow) });
	    });
	    return placementMap;
	}

/***/ }),
/* 397 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _toConsumableArray2 = __webpack_require__(31);
	
	var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _list = __webpack_require__(399);
	
	var _list2 = _interopRequireDefault(_list);
	
	var _operation = __webpack_require__(400);
	
	var _operation2 = _interopRequireDefault(_operation);
	
	var _search = __webpack_require__(183);
	
	var _search2 = _interopRequireDefault(_search);
	
	var _injectLocale = __webpack_require__(67);
	
	var _injectLocale2 = _interopRequireDefault(_injectLocale);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function noop() {}
	
	var Transfer = function (_React$Component) {
	    (0, _inherits3['default'])(Transfer, _React$Component);
	
	    function Transfer(props) {
	        (0, _classCallCheck3['default'])(this, Transfer);
	
	        var _this = (0, _possibleConstructorReturn3['default'])(this, (Transfer.__proto__ || Object.getPrototypeOf(Transfer)).call(this, props));
	
	        _this.moveTo = function (direction) {
	            var _this$props = _this.props,
	                _this$props$targetKey = _this$props.targetKeys,
	                targetKeys = _this$props$targetKey === undefined ? [] : _this$props$targetKey,
	                _this$props$dataSourc = _this$props.dataSource,
	                dataSource = _this$props$dataSourc === undefined ? [] : _this$props$dataSourc,
	                onChange = _this$props.onChange;
	            var _this$state = _this.state,
	                sourceSelectedKeys = _this$state.sourceSelectedKeys,
	                targetSelectedKeys = _this$state.targetSelectedKeys;
	
	            var moveKeys = direction === 'right' ? sourceSelectedKeys : targetSelectedKeys;
	            // filter the disabled options
	            var newMoveKeys = moveKeys.filter(function (key) {
	                return !dataSource.some(function (data) {
	                    return !!(key === data.key && data.disabled);
	                });
	            });
	            // move items to target box
	            var newTargetKeys = direction === 'right' ? newMoveKeys.concat(targetKeys) : targetKeys.filter(function (targetKey) {
	                return newMoveKeys.indexOf(targetKey) === -1;
	            });
	            // empty checked keys
	            var oppositeDirection = direction === 'right' ? 'left' : 'right';
	            _this.setState((0, _defineProperty3['default'])({}, _this.getSelectedKeysName(oppositeDirection), []));
	            _this.handleSelectChange(oppositeDirection, []);
	            if (onChange) {
	                onChange(newTargetKeys, direction, newMoveKeys);
	            }
	        };
	        _this.moveToLeft = function () {
	            return _this.moveTo('left');
	        };
	        _this.moveToRight = function () {
	            return _this.moveTo('right');
	        };
	        _this.handleSelectAll = function (direction, filteredDataSource, checkAll) {
	            var originalSelectedKeys = _this.state[_this.getSelectedKeysName(direction)] || [];
	            var currentKeys = filteredDataSource.map(function (item) {
	                return item.key;
	            });
	            // Only operate current keys from original selected keys
	            var newKeys1 = originalSelectedKeys.filter(function (key) {
	                return currentKeys.indexOf(key) === -1;
	            });
	            var newKeys2 = [].concat((0, _toConsumableArray3['default'])(originalSelectedKeys));
	            currentKeys.forEach(function (key) {
	                if (newKeys2.indexOf(key) === -1) {
	                    newKeys2.push(key);
	                }
	            });
	            var holder = checkAll ? newKeys1 : newKeys2;
	            _this.handleSelectChange(direction, holder);
	            if (!_this.props.selectedKeys) {
	                _this.setState((0, _defineProperty3['default'])({}, _this.getSelectedKeysName(direction), holder));
	            }
	        };
	        _this.handleLeftSelectAll = function (filteredDataSource, checkAll) {
	            return _this.handleSelectAll('left', filteredDataSource, checkAll);
	        };
	        _this.handleRightSelectAll = function (filteredDataSource, checkAll) {
	            return _this.handleSelectAll('right', filteredDataSource, checkAll);
	        };
	        _this.handleFilter = function (direction, e) {
	            _this.setState((0, _defineProperty3['default'])({}, direction + 'Filter', e.target.value));
	            if (_this.props.onSearchChange) {
	                _this.props.onSearchChange(direction, e);
	            }
	        };
	        _this.handleLeftFilter = function (e) {
	            return _this.handleFilter('left', e);
	        };
	        _this.handleRightFilter = function (e) {
	            return _this.handleFilter('right', e);
	        };
	        _this.handleClear = function (direction) {
	            _this.setState((0, _defineProperty3['default'])({}, direction + 'Filter', ''));
	        };
	        _this.handleLeftClear = function () {
	            return _this.handleClear('left');
	        };
	        _this.handleRightClear = function () {
	            return _this.handleClear('right');
	        };
	        _this.handleSelect = function (direction, selectedItem, checked) {
	            var _this$state2 = _this.state,
	                sourceSelectedKeys = _this$state2.sourceSelectedKeys,
	                targetSelectedKeys = _this$state2.targetSelectedKeys;
	
	            var holder = direction === 'left' ? [].concat((0, _toConsumableArray3['default'])(sourceSelectedKeys)) : [].concat((0, _toConsumableArray3['default'])(targetSelectedKeys));
	            var index = holder.indexOf(selectedItem.key);
	            if (index > -1) {
	                holder.splice(index, 1);
	            }
	            if (checked) {
	                holder.push(selectedItem.key);
	            }
	            _this.handleSelectChange(direction, holder);
	            if (!_this.props.selectedKeys) {
	                _this.setState((0, _defineProperty3['default'])({}, _this.getSelectedKeysName(direction), holder));
	            }
	        };
	        _this.handleLeftSelect = function (selectedItem, checked) {
	            return _this.handleSelect('left', selectedItem, checked);
	        };
	        _this.handleRightSelect = function (selectedItem, checked) {
	            return _this.handleSelect('right', selectedItem, checked);
	        };
	        _this.handleScroll = function (direction, e) {
	            var onScroll = _this.props.onScroll;
	
	            if (onScroll) {
	                onScroll(direction, e);
	            }
	        };
	        _this.handleLeftScroll = function (e) {
	            return _this.handleScroll('left', e);
	        };
	        _this.handleRightScroll = function (e) {
	            return _this.handleScroll('right', e);
	        };
	        var _props$selectedKeys = props.selectedKeys,
	            selectedKeys = _props$selectedKeys === undefined ? [] : _props$selectedKeys,
	            _props$targetKeys = props.targetKeys,
	            targetKeys = _props$targetKeys === undefined ? [] : _props$targetKeys;
	
	        _this.state = {
	            leftFilter: '',
	            rightFilter: '',
	            sourceSelectedKeys: selectedKeys.filter(function (key) {
	                return targetKeys.indexOf(key) === -1;
	            }),
	            targetSelectedKeys: selectedKeys.filter(function (key) {
	                return targetKeys.indexOf(key) > -1;
	            })
	        };
	        return _this;
	    }
	
	    (0, _createClass3['default'])(Transfer, [{
	        key: 'componentWillReceiveProps',
	        value: function componentWillReceiveProps(nextProps) {
	            var _state = this.state,
	                sourceSelectedKeys = _state.sourceSelectedKeys,
	                targetSelectedKeys = _state.targetSelectedKeys;
	
	            if (nextProps.targetKeys !== this.props.targetKeys || nextProps.dataSource !== this.props.dataSource) {
	                // clear cached splited dataSource
	                this.splitedDataSource = null;
	                if (!nextProps.selectedKeys) {
	                    // clear key nolonger existed
	                    // clear checkedKeys according to targetKeys
	                    var dataSource = nextProps.dataSource,
	                        _nextProps$targetKeys = nextProps.targetKeys,
	                        targetKeys = _nextProps$targetKeys === undefined ? [] : _nextProps$targetKeys;
	
	                    var newSourceSelectedKeys = [];
	                    var newTargetSelectedKeys = [];
	                    dataSource.forEach(function (_ref) {
	                        var key = _ref.key;
	
	                        if (sourceSelectedKeys.includes(key) && !targetKeys.includes(key)) {
	                            newSourceSelectedKeys.push(key);
	                        }
	                        if (targetSelectedKeys.includes(key) && targetKeys.includes(key)) {
	                            newTargetSelectedKeys.push(key);
	                        }
	                    });
	                    this.setState({
	                        sourceSelectedKeys: newSourceSelectedKeys,
	                        targetSelectedKeys: newTargetSelectedKeys
	                    });
	                }
	            }
	            if (nextProps.selectedKeys) {
	                var _targetKeys = nextProps.targetKeys || [];
	                this.setState({
	                    sourceSelectedKeys: nextProps.selectedKeys.filter(function (key) {
	                        return !_targetKeys.includes(key);
	                    }),
	                    targetSelectedKeys: nextProps.selectedKeys.filter(function (key) {
	                        return _targetKeys.includes(key);
	                    })
	                });
	            }
	        }
	    }, {
	        key: 'splitDataSource',
	        value: function splitDataSource(props) {
	            if (this.splitedDataSource) {
	                return this.splitedDataSource;
	            }
	            var dataSource = props.dataSource,
	                rowKey = props.rowKey,
	                _props$targetKeys2 = props.targetKeys,
	                targetKeys = _props$targetKeys2 === undefined ? [] : _props$targetKeys2;
	
	            var leftDataSource = [];
	            var rightDataSource = new Array(targetKeys.length);
	            dataSource.forEach(function (record) {
	                if (rowKey) {
	                    record.key = rowKey(record);
	                }
	                // rightDataSource should be ordered by targetKeys
	                // leftDataSource should be ordered by dataSource
	                var indexOfKey = targetKeys.indexOf(record.key);
	                if (indexOfKey !== -1) {
	                    rightDataSource[indexOfKey] = record;
	                } else {
	                    leftDataSource.push(record);
	                }
	            });
	            this.splitedDataSource = {
	                leftDataSource: leftDataSource,
	                rightDataSource: rightDataSource
	            };
	            return this.splitedDataSource;
	        }
	    }, {
	        key: 'handleSelectChange',
	        value: function handleSelectChange(direction, holder) {
	            var _state2 = this.state,
	                sourceSelectedKeys = _state2.sourceSelectedKeys,
	                targetSelectedKeys = _state2.targetSelectedKeys;
	
	            var onSelectChange = this.props.onSelectChange;
	            if (!onSelectChange) {
	                return;
	            }
	            if (direction === 'left') {
	                onSelectChange(holder, targetSelectedKeys);
	            } else {
	                onSelectChange(sourceSelectedKeys, holder);
	            }
	        }
	    }, {
	        key: 'getTitles',
	        value: function getTitles() {
	            var props = this.props;
	
	            if (props.titles) {
	                return props.titles;
	            }
	            var transferLocale = this.getLocale();
	            return transferLocale.titles;
	        }
	    }, {
	        key: 'getSelectedKeysName',
	        value: function getSelectedKeysName(direction) {
	            return direction === 'left' ? 'sourceSelectedKeys' : 'targetSelectedKeys';
	        }
	    }, {
	        key: 'render',
	        value: function render() {
	            var locale = this.getLocale();
	            var _props = this.props,
	                _props$prefixCls = _props.prefixCls,
	                prefixCls = _props$prefixCls === undefined ? 'ant-transfer' : _props$prefixCls,
	                className = _props.className,
	                _props$operations = _props.operations,
	                operations = _props$operations === undefined ? [] : _props$operations,
	                showSearch = _props.showSearch,
	                _props$notFoundConten = _props.notFoundContent,
	                notFoundContent = _props$notFoundConten === undefined ? locale.notFoundContent : _props$notFoundConten,
	                _props$searchPlacehol = _props.searchPlaceholder,
	                searchPlaceholder = _props$searchPlacehol === undefined ? locale.searchPlaceholder : _props$searchPlacehol,
	                body = _props.body,
	                footer = _props.footer,
	                listStyle = _props.listStyle,
	                filterOption = _props.filterOption,
	                render = _props.render,
	                lazy = _props.lazy;
	            var _state3 = this.state,
	                leftFilter = _state3.leftFilter,
	                rightFilter = _state3.rightFilter,
	                sourceSelectedKeys = _state3.sourceSelectedKeys,
	                targetSelectedKeys = _state3.targetSelectedKeys;
	
	            var _splitDataSource = this.splitDataSource(this.props),
	                leftDataSource = _splitDataSource.leftDataSource,
	                rightDataSource = _splitDataSource.rightDataSource;
	
	            var leftActive = targetSelectedKeys.length > 0;
	            var rightActive = sourceSelectedKeys.length > 0;
	            var cls = (0, _classnames2['default'])(className, prefixCls);
	            var titles = this.getTitles();
	            return _react2['default'].createElement(
	                'div',
	                { className: cls },
	                _react2['default'].createElement(_list2['default'], { prefixCls: prefixCls + '-list', titleText: titles[0], dataSource: leftDataSource, filter: leftFilter, filterOption: filterOption, style: listStyle, checkedKeys: sourceSelectedKeys, handleFilter: this.handleLeftFilter, handleClear: this.handleLeftClear, handleSelect: this.handleLeftSelect, handleSelectAll: this.handleLeftSelectAll, render: render, showSearch: showSearch, searchPlaceholder: searchPlaceholder, notFoundContent: notFoundContent, itemUnit: locale.itemUnit, itemsUnit: locale.itemsUnit, body: body, footer: footer, lazy: lazy, onScroll: this.handleLeftScroll }),
	                _react2['default'].createElement(_operation2['default'], { className: prefixCls + '-operation', rightActive: rightActive, rightArrowText: operations[0], moveToRight: this.moveToRight, leftActive: leftActive, leftArrowText: operations[1], moveToLeft: this.moveToLeft }),
	                _react2['default'].createElement(_list2['default'], { prefixCls: prefixCls + '-list', titleText: titles[1], dataSource: rightDataSource, filter: rightFilter, filterOption: filterOption, style: listStyle, checkedKeys: targetSelectedKeys, handleFilter: this.handleRightFilter, handleClear: this.handleRightClear, handleSelect: this.handleRightSelect, handleSelectAll: this.handleRightSelectAll, render: render, showSearch: showSearch, searchPlaceholder: searchPlaceholder, notFoundContent: notFoundContent, itemUnit: locale.itemUnit, itemsUnit: locale.itemsUnit, body: body, footer: footer, lazy: lazy, onScroll: this.handleRightScroll })
	            );
	        }
	    }]);
	    return Transfer;
	}(_react2['default'].Component);
	// For high-level customized Transfer @dqaria
	
	
	Transfer.List = _list2['default'];
	Transfer.Operation = _operation2['default'];
	Transfer.Search = _search2['default'];
	Transfer.defaultProps = {
	    dataSource: [],
	    render: noop,
	    showSearch: false
	};
	Transfer.propTypes = {
	    prefixCls: _propTypes2['default'].string,
	    dataSource: _propTypes2['default'].array,
	    render: _propTypes2['default'].func,
	    targetKeys: _propTypes2['default'].array,
	    onChange: _propTypes2['default'].func,
	    height: _propTypes2['default'].number,
	    listStyle: _propTypes2['default'].object,
	    className: _propTypes2['default'].string,
	    titles: _propTypes2['default'].array,
	    operations: _propTypes2['default'].array,
	    showSearch: _propTypes2['default'].bool,
	    filterOption: _propTypes2['default'].func,
	    searchPlaceholder: _propTypes2['default'].string,
	    notFoundContent: _propTypes2['default'].node,
	    body: _propTypes2['default'].func,
	    footer: _propTypes2['default'].func,
	    rowKey: _propTypes2['default'].func,
	    lazy: _propTypes2['default'].oneOfType([_propTypes2['default'].object, _propTypes2['default'].bool])
	};
	var injectTransferLocale = (0, _injectLocale2['default'])('Transfer', {
	    titles: ['', ''],
	    searchPlaceholder: 'Search',
	    notFoundContent: 'Not Found'
	});
	exports['default'] = injectTransferLocale(Transfer);
	module.exports = exports['default'];

/***/ }),
/* 398 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _PureRenderMixin = __webpack_require__(78);
	
	var _PureRenderMixin2 = _interopRequireDefault(_PureRenderMixin);
	
	var _reactLazyLoad = __webpack_require__(791);
	
	var _reactLazyLoad2 = _interopRequireDefault(_reactLazyLoad);
	
	var _checkbox = __webpack_require__(55);
	
	var _checkbox2 = _interopRequireDefault(_checkbox);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var Item = function (_React$Component) {
	    (0, _inherits3['default'])(Item, _React$Component);
	
	    function Item() {
	        (0, _classCallCheck3['default'])(this, Item);
	        return (0, _possibleConstructorReturn3['default'])(this, (Item.__proto__ || Object.getPrototypeOf(Item)).apply(this, arguments));
	    }
	
	    (0, _createClass3['default'])(Item, [{
	        key: 'shouldComponentUpdate',
	        value: function shouldComponentUpdate() {
	            for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
	                args[_key] = arguments[_key];
	            }
	
	            return _PureRenderMixin2['default'].shouldComponentUpdate.apply(this, args);
	        }
	    }, {
	        key: 'render',
	        value: function render() {
	            var _classNames;
	
	            var _props = this.props,
	                renderedText = _props.renderedText,
	                renderedEl = _props.renderedEl,
	                item = _props.item,
	                lazy = _props.lazy,
	                checked = _props.checked,
	                prefixCls = _props.prefixCls,
	                onClick = _props.onClick;
	
	            var className = (0, _classnames2['default'])((_classNames = {}, (0, _defineProperty3['default'])(_classNames, prefixCls + '-content-item', true), (0, _defineProperty3['default'])(_classNames, prefixCls + '-content-item-disabled', item.disabled), _classNames));
	            var listItem = _react2['default'].createElement(
	                'li',
	                { className: className, title: renderedText, onClick: item.disabled ? undefined : function () {
	                        return onClick(item);
	                    } },
	                _react2['default'].createElement(_checkbox2['default'], { checked: checked, disabled: item.disabled }),
	                _react2['default'].createElement(
	                    'span',
	                    null,
	                    renderedEl
	                )
	            );
	            var children = null;
	            if (lazy) {
	                var lazyProps = (0, _extends3['default'])({ height: 32, offset: 500, throttle: 0, debounce: false }, lazy);
	                children = _react2['default'].createElement(
	                    _reactLazyLoad2['default'],
	                    lazyProps,
	                    listItem
	                );
	            } else {
	                children = listItem;
	            }
	            return children;
	        }
	    }]);
	    return Item;
	}(_react2['default'].Component);
	
	exports['default'] = Item;
	module.exports = exports['default'];

/***/ }),
/* 399 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _reactDom = __webpack_require__(10);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _rcAnimate = __webpack_require__(22);
	
	var _rcAnimate2 = _interopRequireDefault(_rcAnimate);
	
	var _PureRenderMixin = __webpack_require__(78);
	
	var _PureRenderMixin2 = _interopRequireDefault(_PureRenderMixin);
	
	var _checkbox = __webpack_require__(55);
	
	var _checkbox2 = _interopRequireDefault(_checkbox);
	
	var _search = __webpack_require__(183);
	
	var _search2 = _interopRequireDefault(_search);
	
	var _item = __webpack_require__(398);
	
	var _item2 = _interopRequireDefault(_item);
	
	var _triggerEvent = __webpack_require__(316);
	
	var _triggerEvent2 = _interopRequireDefault(_triggerEvent);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function noop() {}
	function isRenderResultPlainObject(result) {
	    return result && !_react2['default'].isValidElement(result) && Object.prototype.toString.call(result) === '[object Object]';
	}
	
	var TransferList = function (_React$Component) {
	    (0, _inherits3['default'])(TransferList, _React$Component);
	
	    function TransferList(props) {
	        (0, _classCallCheck3['default'])(this, TransferList);
	
	        var _this = (0, _possibleConstructorReturn3['default'])(this, (TransferList.__proto__ || Object.getPrototypeOf(TransferList)).call(this, props));
	
	        _this.handleSelect = function (selectedItem) {
	            var checkedKeys = _this.props.checkedKeys;
	
	            var result = checkedKeys.some(function (key) {
	                return key === selectedItem.key;
	            });
	            _this.props.handleSelect(selectedItem, !result);
	        };
	        _this.handleFilter = function (e) {
	            _this.props.handleFilter(e);
	            if (!e.target.value) {
	                return;
	            }
	            // Manually trigger scroll event for lazy search bug
	            // https://github.com/ant-design/ant-design/issues/5631
	            _this.triggerScrollTimer = setTimeout(function () {
	                var listNode = (0, _reactDom.findDOMNode)(_this).querySelectorAll('.ant-transfer-list-content')[0];
	                if (listNode) {
	                    (0, _triggerEvent2['default'])(listNode, 'scroll');
	                }
	            }, 0);
	        };
	        _this.handleClear = function () {
	            _this.props.handleClear();
	        };
	        _this.matchFilter = function (text, item) {
	            var _this$props = _this.props,
	                filter = _this$props.filter,
	                filterOption = _this$props.filterOption;
	
	            if (filterOption) {
	                return filterOption(filter, item);
	            }
	            return text.indexOf(filter) >= 0;
	        };
	        _this.renderItem = function (item) {
	            var _this$props$render = _this.props.render,
	                render = _this$props$render === undefined ? noop : _this$props$render;
	
	            var renderResult = render(item);
	            var isRenderResultPlain = isRenderResultPlainObject(renderResult);
	            return {
	                renderedText: isRenderResultPlain ? renderResult.value : renderResult,
	                renderedEl: isRenderResultPlain ? renderResult.label : renderResult
	            };
	        };
	        _this.state = {
	            mounted: false
	        };
	        return _this;
	    }
	
	    (0, _createClass3['default'])(TransferList, [{
	        key: 'componentDidMount',
	        value: function componentDidMount() {
	            var _this2 = this;
	
	            this.timer = setTimeout(function () {
	                _this2.setState({
	                    mounted: true
	                });
	            }, 0);
	        }
	    }, {
	        key: 'componentWillUnmount',
	        value: function componentWillUnmount() {
	            clearTimeout(this.timer);
	            clearTimeout(this.triggerScrollTimer);
	        }
	    }, {
	        key: 'shouldComponentUpdate',
	        value: function shouldComponentUpdate() {
	            for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
	                args[_key] = arguments[_key];
	            }
	
	            return _PureRenderMixin2['default'].shouldComponentUpdate.apply(this, args);
	        }
	    }, {
	        key: 'getCheckStatus',
	        value: function getCheckStatus(filteredDataSource) {
	            var checkedKeys = this.props.checkedKeys;
	
	            if (checkedKeys.length === 0) {
	                return 'none';
	            } else if (filteredDataSource.every(function (item) {
	                return checkedKeys.indexOf(item.key) >= 0;
	            })) {
	                return 'all';
	            }
	            return 'part';
	        }
	    }, {
	        key: 'render',
	        value: function render() {
	            var _this3 = this;
	
	            var _props = this.props,
	                prefixCls = _props.prefixCls,
	                dataSource = _props.dataSource,
	                titleText = _props.titleText,
	                checkedKeys = _props.checkedKeys,
	                lazy = _props.lazy,
	                _props$body = _props.body,
	                body = _props$body === undefined ? noop : _props$body,
	                _props$footer = _props.footer,
	                footer = _props$footer === undefined ? noop : _props$footer,
	                showSearch = _props.showSearch,
	                style = _props.style,
	                filter = _props.filter,
	                searchPlaceholder = _props.searchPlaceholder,
	                notFoundContent = _props.notFoundContent,
	                itemUnit = _props.itemUnit,
	                itemsUnit = _props.itemsUnit,
	                onScroll = _props.onScroll;
	            // Custom Layout
	
	            var footerDom = footer((0, _extends3['default'])({}, this.props));
	            var bodyDom = body((0, _extends3['default'])({}, this.props));
	            var listCls = (0, _classnames2['default'])(prefixCls, (0, _defineProperty3['default'])({}, prefixCls + '-with-footer', !!footerDom));
	            var filteredDataSource = [];
	            var totalDataSource = [];
	            var showItems = dataSource.map(function (item) {
	                var _renderItem = _this3.renderItem(item),
	                    renderedText = _renderItem.renderedText,
	                    renderedEl = _renderItem.renderedEl;
	
	                if (filter && filter.trim() && !_this3.matchFilter(renderedText, item)) {
	                    return null;
	                }
	                // all show items
	                totalDataSource.push(item);
	                if (!item.disabled) {
	                    // response to checkAll items
	                    filteredDataSource.push(item);
	                }
	                var checked = checkedKeys.indexOf(item.key) >= 0;
	                return _react2['default'].createElement(_item2['default'], { key: item.key, item: item, lazy: lazy, renderedText: renderedText, renderedEl: renderedEl, checked: checked, prefixCls: prefixCls, onClick: _this3.handleSelect });
	            });
	            var unit = dataSource.length > 1 ? itemsUnit : itemUnit;
	            var search = showSearch ? _react2['default'].createElement(
	                'div',
	                { className: prefixCls + '-body-search-wrapper' },
	                _react2['default'].createElement(_search2['default'], { prefixCls: prefixCls + '-search', onChange: this.handleFilter, handleClear: this.handleClear, placeholder: searchPlaceholder, value: filter })
	            ) : null;
	            var listBody = bodyDom || _react2['default'].createElement(
	                'div',
	                { className: showSearch ? prefixCls + '-body ' + prefixCls + '-body-with-search' : prefixCls + '-body' },
	                search,
	                _react2['default'].createElement(
	                    _rcAnimate2['default'],
	                    { component: 'ul', componentProps: { onScroll: onScroll }, className: prefixCls + '-content', transitionName: this.state.mounted ? prefixCls + '-content-item-highlight' : '', transitionLeave: false },
	                    showItems
	                ),
	                _react2['default'].createElement(
	                    'div',
	                    { className: prefixCls + '-body-not-found' },
	                    notFoundContent
	                )
	            );
	            var listFooter = footerDom ? _react2['default'].createElement(
	                'div',
	                { className: prefixCls + '-footer' },
	                footerDom
	            ) : null;
	            var checkStatus = this.getCheckStatus(filteredDataSource);
	            var checkedAll = checkStatus === 'all';
	            var checkAllCheckbox = _react2['default'].createElement(_checkbox2['default'], { ref: 'checkbox', checked: checkedAll, indeterminate: checkStatus === 'part', onChange: function onChange() {
	                    return _this3.props.handleSelectAll(filteredDataSource, checkedAll);
	                } });
	            return _react2['default'].createElement(
	                'div',
	                { className: listCls, style: style },
	                _react2['default'].createElement(
	                    'div',
	                    { className: prefixCls + '-header' },
	                    checkAllCheckbox,
	                    _react2['default'].createElement(
	                        'span',
	                        { className: prefixCls + '-header-selected' },
	                        _react2['default'].createElement(
	                            'span',
	                            null,
	                            (checkedKeys.length > 0 ? checkedKeys.length + '/' : '') + totalDataSource.length,
	                            ' ',
	                            unit
	                        ),
	                        _react2['default'].createElement(
	                            'span',
	                            { className: prefixCls + '-header-title' },
	                            titleText
	                        )
	                    )
	                ),
	                listBody,
	                listFooter
	            );
	        }
	    }]);
	    return TransferList;
	}(_react2['default'].Component);
	
	exports['default'] = TransferList;
	
	TransferList.defaultProps = {
	    dataSource: [],
	    titleText: '',
	    showSearch: false,
	    render: noop,
	    lazy: {}
	};
	module.exports = exports['default'];

/***/ }),
/* 400 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _button = __webpack_require__(54);
	
	var _button2 = _interopRequireDefault(_button);
	
	var _icon = __webpack_require__(16);
	
	var _icon2 = _interopRequireDefault(_icon);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function noop() {}
	
	var TransferOperation = function (_React$Component) {
	    (0, _inherits3['default'])(TransferOperation, _React$Component);
	
	    function TransferOperation() {
	        (0, _classCallCheck3['default'])(this, TransferOperation);
	        return (0, _possibleConstructorReturn3['default'])(this, (TransferOperation.__proto__ || Object.getPrototypeOf(TransferOperation)).apply(this, arguments));
	    }
	
	    (0, _createClass3['default'])(TransferOperation, [{
	        key: 'render',
	        value: function render() {
	            var _props = this.props,
	                moveToLeft = _props.moveToLeft,
	                moveToRight = _props.moveToRight,
	                leftArrowText = _props.leftArrowText,
	                rightArrowText = _props.rightArrowText,
	                leftActive = _props.leftActive,
	                rightActive = _props.rightActive,
	                className = _props.className;
	
	            var moveToLeftButton = _react2['default'].createElement(
	                _button2['default'],
	                { type: 'primary', size: 'small', disabled: !leftActive, onClick: moveToLeft },
	                _react2['default'].createElement(
	                    'span',
	                    null,
	                    _react2['default'].createElement(_icon2['default'], { type: 'left' }),
	                    leftArrowText
	                )
	            );
	            var moveToRightButton = _react2['default'].createElement(
	                _button2['default'],
	                { type: 'primary', size: 'small', disabled: !rightActive, onClick: moveToRight },
	                _react2['default'].createElement(
	                    'span',
	                    null,
	                    rightArrowText,
	                    _react2['default'].createElement(_icon2['default'], { type: 'right' })
	                )
	            );
	            return _react2['default'].createElement(
	                'div',
	                { className: className },
	                moveToLeftButton,
	                moveToRightButton
	            );
	        }
	    }]);
	    return TransferOperation;
	}(_react2['default'].Component);
	
	exports['default'] = TransferOperation;
	
	TransferOperation.defaultProps = {
	    leftArrowText: '',
	    rightArrowText: '',
	    moveToLeft: noop,
	    moveToRight: noop
	};
	module.exports = exports['default'];

/***/ }),
/* 401 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	exports.TreeSelectProps = undefined;
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _rcTreeSelect = __webpack_require__(777);
	
	var _rcTreeSelect2 = _interopRequireDefault(_rcTreeSelect);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _interface = __webpack_require__(402);
	
	var _injectLocale = __webpack_require__(67);
	
	var _injectLocale2 = _interopRequireDefault(_injectLocale);
	
	var _warning = __webpack_require__(24);
	
	var _warning2 = _interopRequireDefault(_warning);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var __rest = undefined && undefined.__rest || function (s, e) {
	    var t = {};
	    for (var p in s) {
	        if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
	    }if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
	        if (e.indexOf(p[i]) < 0) t[p[i]] = s[p[i]];
	    }return t;
	};
	exports.TreeSelectProps = _interface.TreeSelectProps;
	
	var TreeSelect = function (_React$Component) {
	    (0, _inherits3['default'])(TreeSelect, _React$Component);
	
	    function TreeSelect(props) {
	        (0, _classCallCheck3['default'])(this, TreeSelect);
	
	        var _this = (0, _possibleConstructorReturn3['default'])(this, (TreeSelect.__proto__ || Object.getPrototypeOf(TreeSelect)).call(this, props));
	
	        (0, _warning2['default'])(props.multiple !== false || !props.treeCheckable, '`multiple` will alway be `true` when `treeCheckable` is true');
	        return _this;
	    }
	
	    (0, _createClass3['default'])(TreeSelect, [{
	        key: 'render',
	        value: function render() {
	            var _classNames;
	
	            var locale = this.getLocale();
	            var _a = this.props,
	                prefixCls = _a.prefixCls,
	                className = _a.className,
	                size = _a.size,
	                _a$notFoundContent = _a.notFoundContent,
	                notFoundContent = _a$notFoundContent === undefined ? locale.notFoundContent : _a$notFoundContent,
	                dropdownStyle = _a.dropdownStyle,
	                restProps = __rest(_a, ["prefixCls", "className", "size", "notFoundContent", "dropdownStyle"]);
	            var cls = (0, _classnames2['default'])((_classNames = {}, (0, _defineProperty3['default'])(_classNames, prefixCls + '-lg', size === 'large'), (0, _defineProperty3['default'])(_classNames, prefixCls + '-sm', size === 'small'), _classNames), className);
	            var checkable = restProps.treeCheckable;
	            if (checkable) {
	                checkable = _react2['default'].createElement('span', { className: prefixCls + '-tree-checkbox-inner' });
	            }
	            return _react2['default'].createElement(_rcTreeSelect2['default'], (0, _extends3['default'])({}, restProps, { prefixCls: prefixCls, className: cls, dropdownStyle: (0, _extends3['default'])({ maxHeight: '100vh', overflow: 'auto' }, dropdownStyle), treeCheckable: checkable, notFoundContent: notFoundContent }));
	        }
	    }]);
	    return TreeSelect;
	}(_react2['default'].Component);
	
	TreeSelect.TreeNode = _rcTreeSelect.TreeNode;
	TreeSelect.SHOW_ALL = _rcTreeSelect.SHOW_ALL;
	TreeSelect.SHOW_PARENT = _rcTreeSelect.SHOW_PARENT;
	TreeSelect.SHOW_CHILD = _rcTreeSelect.SHOW_CHILD;
	TreeSelect.defaultProps = {
	    prefixCls: 'ant-select',
	    transitionName: 'slide-up',
	    choiceTransitionName: 'zoom',
	    showSearch: false,
	    dropdownClassName: 'ant-select-tree-dropdown'
	};
	// Use Select's locale
	var injectSelectLocale = (0, _injectLocale2['default'])('Select', {});
	exports['default'] = injectSelectLocale(TreeSelect);

/***/ }),
/* 402 */
/***/ (function(module, exports) {

	"use strict";

/***/ }),
/* 403 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	exports.AntTreeNode = undefined;
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _rcTree = __webpack_require__(278);
	
	var _rcTree2 = _interopRequireDefault(_rcTree);
	
	var _openAnimation = __webpack_require__(101);
	
	var _openAnimation2 = _interopRequireDefault(_openAnimation);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var AntTreeNode = exports.AntTreeNode = function (_React$Component) {
	    (0, _inherits3['default'])(AntTreeNode, _React$Component);
	
	    function AntTreeNode() {
	        (0, _classCallCheck3['default'])(this, AntTreeNode);
	        return (0, _possibleConstructorReturn3['default'])(this, (AntTreeNode.__proto__ || Object.getPrototypeOf(AntTreeNode)).apply(this, arguments));
	    }
	
	    (0, _createClass3['default'])(AntTreeNode, [{
	        key: 'render',
	        value: function render() {
	            return _react2['default'].createElement(AntTreeNode, this.props);
	        }
	    }]);
	    return AntTreeNode;
	}(_react2['default'].Component);
	
	var Tree = function (_React$Component2) {
	    (0, _inherits3['default'])(Tree, _React$Component2);
	
	    function Tree() {
	        (0, _classCallCheck3['default'])(this, Tree);
	        return (0, _possibleConstructorReturn3['default'])(this, (Tree.__proto__ || Object.getPrototypeOf(Tree)).apply(this, arguments));
	    }
	
	    (0, _createClass3['default'])(Tree, [{
	        key: 'render',
	        value: function render() {
	            var props = this.props;
	            var prefixCls = props.prefixCls,
	                className = props.className;
	
	            var checkable = props.checkable;
	            return _react2['default'].createElement(
	                _rcTree2['default'],
	                (0, _extends3['default'])({}, props, { className: className, checkable: checkable ? _react2['default'].createElement('span', { className: prefixCls + '-checkbox-inner' }) : checkable }),
	                this.props.children
	            );
	        }
	    }]);
	    return Tree;
	}(_react2['default'].Component);
	
	exports['default'] = Tree;
	
	Tree.TreeNode = _rcTree.TreeNode;
	Tree.defaultProps = {
	    prefixCls: 'ant-tree',
	    checkable: false,
	    showIcon: false,
	    openAnimation: _openAnimation2['default']
	};

/***/ }),
/* 404 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _Upload = __webpack_require__(184);
	
	var _Upload2 = _interopRequireDefault(_Upload);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var Dragger = function (_React$Component) {
	    (0, _inherits3['default'])(Dragger, _React$Component);
	
	    function Dragger() {
	        (0, _classCallCheck3['default'])(this, Dragger);
	        return (0, _possibleConstructorReturn3['default'])(this, (Dragger.__proto__ || Object.getPrototypeOf(Dragger)).apply(this, arguments));
	    }
	
	    (0, _createClass3['default'])(Dragger, [{
	        key: 'render',
	        value: function render() {
	            var props = this.props;
	
	            return _react2['default'].createElement(_Upload2['default'], (0, _extends3['default'])({}, props, { type: 'drag', style: (0, _extends3['default'])({}, props.style, { height: props.height }) }));
	        }
	    }]);
	    return Dragger;
	}(_react2['default'].Component);
	
	exports['default'] = Dragger;
	module.exports = exports['default'];

/***/ }),
/* 405 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _rcAnimate = __webpack_require__(22);
	
	var _rcAnimate2 = _interopRequireDefault(_rcAnimate);
	
	var _icon = __webpack_require__(16);
	
	var _icon2 = _interopRequireDefault(_icon);
	
	var _tooltip = __webpack_require__(56);
	
	var _tooltip2 = _interopRequireDefault(_tooltip);
	
	var _progress = __webpack_require__(178);
	
	var _progress2 = _interopRequireDefault(_progress);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	// https://developer.mozilla.org/en-US/docs/Web/API/FileReader/readAsDataURL
	var previewFile = function previewFile(file, callback) {
	    var reader = new FileReader();
	    reader.onloadend = function () {
	        return callback(reader.result);
	    };
	    reader.readAsDataURL(file);
	};
	
	var UploadList = function (_React$Component) {
	    (0, _inherits3['default'])(UploadList, _React$Component);
	
	    function UploadList() {
	        (0, _classCallCheck3['default'])(this, UploadList);
	
	        var _this = (0, _possibleConstructorReturn3['default'])(this, (UploadList.__proto__ || Object.getPrototypeOf(UploadList)).apply(this, arguments));
	
	        _this.handleClose = function (file) {
	            var onRemove = _this.props.onRemove;
	
	            if (onRemove) {
	                onRemove(file);
	            }
	        };
	        _this.handlePreview = function (file, e) {
	            var onPreview = _this.props.onPreview;
	
	            if (!onPreview) {
	                return;
	            }
	            e.preventDefault();
	            return onPreview(file);
	        };
	        return _this;
	    }
	
	    (0, _createClass3['default'])(UploadList, [{
	        key: 'componentDidUpdate',
	        value: function componentDidUpdate() {
	            var _this2 = this;
	
	            if (this.props.listType !== 'picture' && this.props.listType !== 'picture-card') {
	                return;
	            }
	            (this.props.items || []).forEach(function (file) {
	                if (typeof document === 'undefined' || typeof window === 'undefined' || !window.FileReader || !window.File || !(file.originFileObj instanceof File) || file.thumbUrl !== undefined) {
	                    return;
	                }
	                /*eslint-disable */
	                file.thumbUrl = '';
	                /*eslint-enable */
	                previewFile(file.originFileObj, function (previewDataUrl) {
	                    /*eslint-disable */
	                    file.thumbUrl = previewDataUrl;
	                    /*eslint-enable */
	                    _this2.forceUpdate();
	                });
	            });
	        }
	    }, {
	        key: 'render',
	        value: function render() {
	            var _this3 = this,
	                _classNames2;
	
	            var _props = this.props,
	                prefixCls = _props.prefixCls,
	                _props$items = _props.items,
	                items = _props$items === undefined ? [] : _props$items,
	                listType = _props.listType,
	                showPreviewIcon = _props.showPreviewIcon,
	                showRemoveIcon = _props.showRemoveIcon,
	                locale = _props.locale;
	
	            var list = items.map(function (file) {
	                var _classNames;
	
	                var progress = void 0;
	                var icon = _react2['default'].createElement(_icon2['default'], { type: file.status === 'uploading' ? 'loading' : 'paper-clip' });
	                if (listType === 'picture' || listType === 'picture-card') {
	                    if (file.status === 'uploading' || !file.thumbUrl && !file.url) {
	                        if (listType === 'picture-card') {
	                            icon = _react2['default'].createElement(
	                                'div',
	                                { className: prefixCls + '-list-item-uploading-text' },
	                                locale.uploading
	                            );
	                        } else {
	                            icon = _react2['default'].createElement(_icon2['default'], { className: prefixCls + '-list-item-thumbnail', type: 'picture' });
	                        }
	                    } else {
	                        icon = _react2['default'].createElement(
	                            'a',
	                            { className: prefixCls + '-list-item-thumbnail', onClick: function onClick(e) {
	                                    return _this3.handlePreview(file, e);
	                                }, href: file.url || file.thumbUrl, target: '_blank', rel: 'noopener noreferrer' },
	                            _react2['default'].createElement('img', { src: file.thumbUrl || file.url, alt: file.name })
	                        );
	                    }
	                }
	                if (file.status === 'uploading') {
	                    // show loading icon if upload progress listener is disabled
	                    var loadingProgress = 'percent' in file ? _react2['default'].createElement(_progress2['default'], (0, _extends3['default'])({ type: 'line' }, _this3.props.progressAttr, { percent: file.percent })) : null;
	                    progress = _react2['default'].createElement(
	                        'div',
	                        { className: prefixCls + '-list-item-progress', key: 'progress' },
	                        loadingProgress
	                    );
	                }
	                var infoUploadingClass = (0, _classnames2['default'])((_classNames = {}, (0, _defineProperty3['default'])(_classNames, prefixCls + '-list-item', true), (0, _defineProperty3['default'])(_classNames, prefixCls + '-list-item-' + file.status, true), _classNames));
	                var preview = file.url ? _react2['default'].createElement(
	                    'a',
	                    { href: file.url, target: '_blank', rel: 'noopener noreferrer', className: prefixCls + '-list-item-name', onClick: function onClick(e) {
	                            return _this3.handlePreview(file, e);
	                        }, title: file.name },
	                    file.name
	                ) : _react2['default'].createElement(
	                    'span',
	                    { className: prefixCls + '-list-item-name', onClick: function onClick(e) {
	                            return _this3.handlePreview(file, e);
	                        }, title: file.name },
	                    file.name
	                );
	                var style = file.url || file.thumbUrl ? undefined : {
	                    pointerEvents: 'none',
	                    opacity: 0.5
	                };
	                var previewIcon = showPreviewIcon ? _react2['default'].createElement(
	                    'a',
	                    { href: file.url || file.thumbUrl, target: '_blank', rel: 'noopener noreferrer', style: style, onClick: function onClick(e) {
	                            return _this3.handlePreview(file, e);
	                        }, title: locale.previewFile },
	                    _react2['default'].createElement(_icon2['default'], { type: 'eye-o' })
	                ) : null;
	                var removeIcon = showRemoveIcon ? _react2['default'].createElement(_icon2['default'], { type: 'delete', title: locale.removeFile, onClick: function onClick() {
	                        return _this3.handleClose(file);
	                    } }) : null;
	                var removeIconCross = showRemoveIcon ? _react2['default'].createElement(_icon2['default'], { type: 'cross', title: locale.removeFile, onClick: function onClick() {
	                        return _this3.handleClose(file);
	                    } }) : null;
	                var actions = listType === 'picture-card' && file.status !== 'uploading' ? _react2['default'].createElement(
	                    'span',
	                    { className: prefixCls + '-list-item-actions' },
	                    previewIcon,
	                    removeIcon
	                ) : removeIconCross;
	                var message = void 0;
	                if (file.response && typeof file.response === 'string') {
	                    message = file.response;
	                } else {
	                    message = file.error && file.error.statusText || locale.uploadError;
	                }
	                var iconAndPreview = file.status === 'error' ? _react2['default'].createElement(
	                    _tooltip2['default'],
	                    { title: message },
	                    icon,
	                    preview
	                ) : _react2['default'].createElement(
	                    'span',
	                    null,
	                    icon,
	                    preview
	                );
	                return _react2['default'].createElement(
	                    'div',
	                    { className: infoUploadingClass, key: file.uid },
	                    _react2['default'].createElement(
	                        'div',
	                        { className: prefixCls + '-list-item-info' },
	                        iconAndPreview
	                    ),
	                    actions,
	                    _react2['default'].createElement(
	                        _rcAnimate2['default'],
	                        { transitionName: 'fade', component: '' },
	                        progress
	                    )
	                );
	            });
	            var listClassNames = (0, _classnames2['default'])((_classNames2 = {}, (0, _defineProperty3['default'])(_classNames2, prefixCls + '-list', true), (0, _defineProperty3['default'])(_classNames2, prefixCls + '-list-' + listType, true), _classNames2));
	            var animationDirection = listType === 'picture-card' ? 'animate-inline' : 'animate';
	            return _react2['default'].createElement(
	                _rcAnimate2['default'],
	                { transitionName: prefixCls + '-' + animationDirection, component: 'div', className: listClassNames },
	                list
	            );
	        }
	    }]);
	    return UploadList;
	}(_react2['default'].Component);
	
	exports['default'] = UploadList;
	
	UploadList.defaultProps = {
	    listType: 'text',
	    progressAttr: {
	        strokeWidth: 2,
	        showInfo: false
	    },
	    prefixCls: 'ant-upload',
	    showRemoveIcon: true,
	    showPreviewIcon: true
	};
	module.exports = exports['default'];

/***/ }),
/* 406 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _Upload = __webpack_require__(184);
	
	var _Upload2 = _interopRequireDefault(_Upload);
	
	var _Dragger = __webpack_require__(404);
	
	var _Dragger2 = _interopRequireDefault(_Dragger);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	_Upload2['default'].Dragger = _Dragger2['default'];
	exports['default'] = _Upload2['default'];
	module.exports = exports['default'];

/***/ }),
/* 407 */
402,
/* 408 */
/***/ (function(module, exports) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	exports.T = T;
	exports.fileToObject = fileToObject;
	exports.genPercentAdd = genPercentAdd;
	exports.getFileItem = getFileItem;
	exports.removeFileItem = removeFileItem;
	function T() {
	    return true;
	}
	// Fix IE file.status problem
	// via coping a new Object
	function fileToObject(file) {
	    return {
	        lastModified: file.lastModified,
	        lastModifiedDate: file.lastModifiedDate,
	        name: file.filename || file.name,
	        size: file.size,
	        type: file.type,
	        uid: file.uid,
	        response: file.response,
	        error: file.error,
	        percent: 0,
	        originFileObj: file,
	        status: null
	    };
	}
	/**
	 * 生成Progress percent: 0.1 -> 0.98
	 *   - for ie
	 */
	function genPercentAdd() {
	    var k = 0.1;
	    var i = 0.01;
	    var end = 0.98;
	    return function (s) {
	        var start = s;
	        if (start >= end) {
	            return start;
	        }
	        start += k;
	        k = k - i;
	        if (k < 0.001) {
	            k = 0.001;
	        }
	        return start * 100;
	    };
	}
	function getFileItem(file, fileList) {
	    var matchKey = file.uid !== undefined ? 'uid' : 'name';
	    return fileList.filter(function (item) {
	        return item[matchKey] === file[matchKey];
	    })[0];
	}
	function removeFileItem(file, fileList) {
	    var matchKey = file.uid !== undefined ? 'uid' : 'name';
	    var removed = fileList.filter(function (item) {
	        return item[matchKey] !== file[matchKey];
	    });
	    if (removed.length === fileList.length) {
	        return null;
	    }
	    return removed;
	}

/***/ }),
/* 409 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _package = __webpack_require__(574);
	
	exports['default'] = _package.version;
	module.exports = exports['default'];

/***/ }),
/* 410 */
/***/ (function(module, exports, __webpack_require__) {

	module.exports = { "default": __webpack_require__(422), __esModule: true };

/***/ }),
/* 411 */
/***/ (function(module, exports, __webpack_require__) {

	module.exports = { "default": __webpack_require__(423), __esModule: true };

/***/ }),
/* 412 */
/***/ (function(module, exports, __webpack_require__) {

	module.exports = { "default": __webpack_require__(424), __esModule: true };

/***/ }),
/* 413 */
/***/ (function(module, exports, __webpack_require__) {

	module.exports = { "default": __webpack_require__(425), __esModule: true };

/***/ }),
/* 414 */
/***/ (function(module, exports, __webpack_require__) {

	module.exports = { "default": __webpack_require__(426), __esModule: true };

/***/ }),
/* 415 */
/***/ (function(module, exports, __webpack_require__) {

	module.exports = { "default": __webpack_require__(428), __esModule: true };

/***/ }),
/* 416 */
/***/ (function(module, exports, __webpack_require__) {

	module.exports = { "default": __webpack_require__(429), __esModule: true };

/***/ }),
/* 417 */
/***/ (function(module, exports, __webpack_require__) {

	module.exports = { "default": __webpack_require__(430), __esModule: true };

/***/ }),
/* 418 */
/***/ (function(module, exports, __webpack_require__) {

	module.exports = { "default": __webpack_require__(431), __esModule: true };

/***/ }),
/* 419 */
/***/ (function(module, exports, __webpack_require__) {

	module.exports = { "default": __webpack_require__(432), __esModule: true };

/***/ }),
/* 420 */
/***/ (function(module, exports, __webpack_require__) {

	"use strict";
	
	exports.__esModule = true;
	
	var _getPrototypeOf = __webpack_require__(416);
	
	var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);
	
	var _getOwnPropertyDescriptor = __webpack_require__(415);
	
	var _getOwnPropertyDescriptor2 = _interopRequireDefault(_getOwnPropertyDescriptor);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
	
	exports.default = function get(object, property, receiver) {
	  if (object === null) object = Function.prototype;
	  var desc = (0, _getOwnPropertyDescriptor2.default)(object, property);
	
	  if (desc === undefined) {
	    var parent = (0, _getPrototypeOf2.default)(object);
	
	    if (parent === null) {
	      return undefined;
	    } else {
	      return get(parent, property, receiver);
	    }
	  } else if ("value" in desc) {
	    return desc.value;
	  } else {
	    var getter = desc.get;
	
	    if (getter === undefined) {
	      return undefined;
	    }
	
	    return getter.call(receiver);
	  }
	};

/***/ }),
/* 421 */
/***/ (function(module, exports) {

	var canUseDOM = !!(
	  typeof window !== 'undefined' &&
	  window.document &&
	  window.document.createElement
	);
	
	module.exports = canUseDOM;

/***/ }),
/* 422 */
/***/ (function(module, exports, __webpack_require__) {

	__webpack_require__(87);
	__webpack_require__(454);
	module.exports = __webpack_require__(25).Array.from;


/***/ }),
/* 423 */
/***/ (function(module, exports, __webpack_require__) {

	__webpack_require__(121);
	__webpack_require__(87);
	module.exports = __webpack_require__(452);


/***/ }),
/* 424 */
/***/ (function(module, exports, __webpack_require__) {

	__webpack_require__(121);
	__webpack_require__(87);
	module.exports = __webpack_require__(453);


/***/ }),
/* 425 */
/***/ (function(module, exports, __webpack_require__) {

	__webpack_require__(456);
	module.exports = __webpack_require__(25).Object.assign;


/***/ }),
/* 426 */
/***/ (function(module, exports, __webpack_require__) {

	__webpack_require__(457);
	var $Object = __webpack_require__(25).Object;
	module.exports = function create(P, D) {
	  return $Object.create(P, D);
	};


/***/ }),
/* 427 */
/***/ (function(module, exports, __webpack_require__) {

	__webpack_require__(458);
	var $Object = __webpack_require__(25).Object;
	module.exports = function defineProperty(it, key, desc) {
	  return $Object.defineProperty(it, key, desc);
	};


/***/ }),
/* 428 */
/***/ (function(module, exports, __webpack_require__) {

	__webpack_require__(459);
	var $Object = __webpack_require__(25).Object;
	module.exports = function getOwnPropertyDescriptor(it, key) {
	  return $Object.getOwnPropertyDescriptor(it, key);
	};


/***/ }),
/* 429 */
/***/ (function(module, exports, __webpack_require__) {

	__webpack_require__(460);
	module.exports = __webpack_require__(25).Object.getPrototypeOf;


/***/ }),
/* 430 */
/***/ (function(module, exports, __webpack_require__) {

	__webpack_require__(461);
	module.exports = __webpack_require__(25).Object.setPrototypeOf;


/***/ }),
/* 431 */
/***/ (function(module, exports, __webpack_require__) {

	__webpack_require__(463);
	__webpack_require__(462);
	__webpack_require__(464);
	__webpack_require__(465);
	module.exports = __webpack_require__(25).Symbol;


/***/ }),
/* 432 */
/***/ (function(module, exports, __webpack_require__) {

	__webpack_require__(87);
	__webpack_require__(121);
	module.exports = __webpack_require__(120).f('iterator');


/***/ }),
/* 433 */
/***/ (function(module, exports) {

	module.exports = function (it) {
	  if (typeof it != 'function') throw TypeError(it + ' is not a function!');
	  return it;
	};


/***/ }),
/* 434 */
/***/ (function(module, exports) {

	module.exports = function () { /* empty */ };


/***/ }),
/* 435 */
/***/ (function(module, exports, __webpack_require__) {

	// false -> Array#indexOf
	// true  -> Array#includes
	var toIObject = __webpack_require__(49);
	var toLength = __webpack_require__(198);
	var toAbsoluteIndex = __webpack_require__(451);
	module.exports = function (IS_INCLUDES) {
	  return function ($this, el, fromIndex) {
	    var O = toIObject($this);
	    var length = toLength(O.length);
	    var index = toAbsoluteIndex(fromIndex, length);
	    var value;
	    // Array#includes uses SameValueZero equality algorithm
	    // eslint-disable-next-line no-self-compare
	    if (IS_INCLUDES && el != el) while (length > index) {
	      value = O[index++];
	      // eslint-disable-next-line no-self-compare
	      if (value != value) return true;
	    // Array#indexOf 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;
	  };
	};


/***/ }),
/* 436 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	var $defineProperty = __webpack_require__(40);
	var createDesc = __webpack_require__(69);
	
	module.exports = function (object, index, value) {
	  if (index in object) $defineProperty.f(object, index, createDesc(0, value));
	  else object[index] = value;
	};


/***/ }),
/* 437 */
/***/ (function(module, exports, __webpack_require__) {

	// all enumerable object keys, includes symbols
	var getKeys = __webpack_require__(83);
	var gOPS = __webpack_require__(113);
	var pIE = __webpack_require__(84);
	module.exports = function (it) {
	  var result = getKeys(it);
	  var getSymbols = gOPS.f;
	  if (getSymbols) {
	    var symbols = getSymbols(it);
	    var isEnum = pIE.f;
	    var i = 0;
	    var key;
	    while (symbols.length > i) if (isEnum.call(it, key = symbols[i++])) result.push(key);
	  } return result;
	};


/***/ }),
/* 438 */
/***/ (function(module, exports, __webpack_require__) {

	var document = __webpack_require__(39).document;
	module.exports = document && document.documentElement;


/***/ }),
/* 439 */
/***/ (function(module, exports, __webpack_require__) {

	// check on default Array iterator
	var Iterators = __webpack_require__(60);
	var ITERATOR = __webpack_require__(32)('iterator');
	var ArrayProto = Array.prototype;
	
	module.exports = function (it) {
	  return it !== undefined && (Iterators.Array === it || ArrayProto[ITERATOR] === it);
	};


/***/ }),
/* 440 */
/***/ (function(module, exports, __webpack_require__) {

	// 7.2.2 IsArray(argument)
	var cof = __webpack_require__(106);
	module.exports = Array.isArray || function isArray(arg) {
	  return cof(arg) == 'Array';
	};


/***/ }),
/* 441 */
/***/ (function(module, exports, __webpack_require__) {

	// call something on iterator step with safe closing on error
	var anObject = __webpack_require__(46);
	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;
	  }
	};


/***/ }),
/* 442 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	var create = __webpack_require__(111);
	var descriptor = __webpack_require__(69);
	var setToStringTag = __webpack_require__(114);
	var IteratorPrototype = {};
	
	// 25.1.2.1.1 %IteratorPrototype%[@@iterator]()
	__webpack_require__(58)(IteratorPrototype, __webpack_require__(32)('iterator'), function () { return this; });
	
	module.exports = function (Constructor, NAME, next) {
	  Constructor.prototype = create(IteratorPrototype, { next: descriptor(1, next) });
	  setToStringTag(Constructor, NAME + ' Iterator');
	};


/***/ }),
/* 443 */
/***/ (function(module, exports, __webpack_require__) {

	var ITERATOR = __webpack_require__(32)('iterator');
	var SAFE_CLOSING = false;
	
	try {
	  var riter = [7][ITERATOR]();
	  riter['return'] = function () { SAFE_CLOSING = true; };
	  // eslint-disable-next-line no-throw-literal
	  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];
	    var iter = arr[ITERATOR]();
	    iter.next = function () { return { done: safe = true }; };
	    arr[ITERATOR] = function () { return iter; };
	    exec(arr);
	  } catch (e) { /* empty */ }
	  return safe;
	};


/***/ }),
/* 444 */
/***/ (function(module, exports) {

	module.exports = function (done, value) {
	  return { value: value, done: !!done };
	};


/***/ }),
/* 445 */
/***/ (function(module, exports, __webpack_require__) {

	var META = __webpack_require__(86)('meta');
	var isObject = __webpack_require__(59);
	var has = __webpack_require__(48);
	var setDesc = __webpack_require__(40).f;
	var id = 0;
	var isExtensible = Object.isExtensible || function () {
	  return true;
	};
	var FREEZE = !__webpack_require__(57)(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
	};


/***/ }),
/* 446 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	// 19.1.2.1 Object.assign(target, source, ...)
	var getKeys = __webpack_require__(83);
	var gOPS = __webpack_require__(113);
	var pIE = __webpack_require__(84);
	var toObject = __webpack_require__(85);
	var IObject = __webpack_require__(191);
	var $assign = Object.assign;
	
	// should work with symbols and should have deterministic property order (V8 bug)
	module.exports = !$assign || __webpack_require__(57)(function () {
	  var A = {};
	  var B = {};
	  // eslint-disable-next-line no-undef
	  var S = Symbol();
	  var 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);
	  var aLen = arguments.length;
	  var index = 1;
	  var getSymbols = gOPS.f;
	  var isEnum = pIE.f;
	  while (aLen > index) {
	    var S = IObject(arguments[index++]);
	    var keys = getSymbols ? getKeys(S).concat(getSymbols(S)) : getKeys(S);
	    var length = keys.length;
	    var j = 0;
	    var key;
	    while (length > j) if (isEnum.call(S, key = keys[j++])) T[key] = S[key];
	  } return T;
	} : $assign;


/***/ }),
/* 447 */
/***/ (function(module, exports, __webpack_require__) {

	var dP = __webpack_require__(40);
	var anObject = __webpack_require__(46);
	var getKeys = __webpack_require__(83);
	
	module.exports = __webpack_require__(47) ? Object.defineProperties : function defineProperties(O, Properties) {
	  anObject(O);
	  var keys = getKeys(Properties);
	  var length = keys.length;
	  var i = 0;
	  var P;
	  while (length > i) dP.f(O, P = keys[i++], Properties[P]);
	  return O;
	};


/***/ }),
/* 448 */
/***/ (function(module, exports, __webpack_require__) {

	// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window
	var toIObject = __webpack_require__(49);
	var gOPN = __webpack_require__(193).f;
	var 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));
	};


/***/ }),
/* 449 */
/***/ (function(module, exports, __webpack_require__) {

	// Works with __proto__ only. Old v8 can't work with null proto objects.
	/* eslint-disable no-proto */
	var isObject = __webpack_require__(59);
	var anObject = __webpack_require__(46);
	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 = __webpack_require__(107)(Function.call, __webpack_require__(112).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
	};


/***/ }),
/* 450 */
/***/ (function(module, exports, __webpack_require__) {

	var toInteger = __webpack_require__(117);
	var defined = __webpack_require__(108);
	// true  -> String#at
	// false -> String#codePointAt
	module.exports = function (TO_STRING) {
	  return function (that, pos) {
	    var s = String(defined(that));
	    var i = toInteger(pos);
	    var l = s.length;
	    var 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;
	  };
	};


/***/ }),
/* 451 */
/***/ (function(module, exports, __webpack_require__) {

	var toInteger = __webpack_require__(117);
	var max = Math.max;
	var min = Math.min;
	module.exports = function (index, length) {
	  index = toInteger(index);
	  return index < 0 ? max(index + length, 0) : min(index, length);
	};


/***/ }),
/* 452 */
/***/ (function(module, exports, __webpack_require__) {

	var anObject = __webpack_require__(46);
	var get = __webpack_require__(199);
	module.exports = __webpack_require__(25).getIterator = function (it) {
	  var iterFn = get(it);
	  if (typeof iterFn != 'function') throw TypeError(it + ' is not iterable!');
	  return anObject(iterFn.call(it));
	};


/***/ }),
/* 453 */
/***/ (function(module, exports, __webpack_require__) {

	var classof = __webpack_require__(188);
	var ITERATOR = __webpack_require__(32)('iterator');
	var Iterators = __webpack_require__(60);
	module.exports = __webpack_require__(25).isIterable = function (it) {
	  var O = Object(it);
	  return O[ITERATOR] !== undefined
	    || '@@iterator' in O
	    // eslint-disable-next-line no-prototype-builtins
	    || Iterators.hasOwnProperty(classof(O));
	};


/***/ }),
/* 454 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	var ctx = __webpack_require__(107);
	var $export = __webpack_require__(38);
	var toObject = __webpack_require__(85);
	var call = __webpack_require__(441);
	var isArrayIter = __webpack_require__(439);
	var toLength = __webpack_require__(198);
	var createProperty = __webpack_require__(436);
	var getIterFn = __webpack_require__(199);
	
	$export($export.S + $export.F * !__webpack_require__(443)(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);
	    var C = typeof this == 'function' ? this : Array;
	    var aLen = arguments.length;
	    var mapfn = aLen > 1 ? arguments[1] : undefined;
	    var mapping = mapfn !== undefined;
	    var index = 0;
	    var iterFn = getIterFn(O);
	    var 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;
	  }
	});


/***/ }),
/* 455 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	var addToUnscopables = __webpack_require__(434);
	var step = __webpack_require__(444);
	var Iterators = __webpack_require__(60);
	var toIObject = __webpack_require__(49);
	
	// 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 = __webpack_require__(192)(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;
	  var kind = this._k;
	  var 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');


/***/ }),
/* 456 */
/***/ (function(module, exports, __webpack_require__) {

	// 19.1.3.1 Object.assign(target, source)
	var $export = __webpack_require__(38);
	
	$export($export.S + $export.F, 'Object', { assign: __webpack_require__(446) });


/***/ }),
/* 457 */
/***/ (function(module, exports, __webpack_require__) {

	var $export = __webpack_require__(38);
	// 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])
	$export($export.S, 'Object', { create: __webpack_require__(111) });


/***/ }),
/* 458 */
/***/ (function(module, exports, __webpack_require__) {

	var $export = __webpack_require__(38);
	// 19.1.2.4 / 15.2.3.6 Object.defineProperty(O, P, Attributes)
	$export($export.S + $export.F * !__webpack_require__(47), 'Object', { defineProperty: __webpack_require__(40).f });


/***/ }),
/* 459 */
/***/ (function(module, exports, __webpack_require__) {

	// 19.1.2.6 Object.getOwnPropertyDescriptor(O, P)
	var toIObject = __webpack_require__(49);
	var $getOwnPropertyDescriptor = __webpack_require__(112).f;
	
	__webpack_require__(196)('getOwnPropertyDescriptor', function () {
	  return function getOwnPropertyDescriptor(it, key) {
	    return $getOwnPropertyDescriptor(toIObject(it), key);
	  };
	});


/***/ }),
/* 460 */
/***/ (function(module, exports, __webpack_require__) {

	// 19.1.2.9 Object.getPrototypeOf(O)
	var toObject = __webpack_require__(85);
	var $getPrototypeOf = __webpack_require__(194);
	
	__webpack_require__(196)('getPrototypeOf', function () {
	  return function getPrototypeOf(it) {
	    return $getPrototypeOf(toObject(it));
	  };
	});


/***/ }),
/* 461 */
/***/ (function(module, exports, __webpack_require__) {

	// 19.1.3.19 Object.setPrototypeOf(O, proto)
	var $export = __webpack_require__(38);
	$export($export.S, 'Object', { setPrototypeOf: __webpack_require__(449).set });


/***/ }),
/* 462 */
/***/ (function(module, exports) {



/***/ }),
/* 463 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	// ECMAScript 6 symbols shim
	var global = __webpack_require__(39);
	var has = __webpack_require__(48);
	var DESCRIPTORS = __webpack_require__(47);
	var $export = __webpack_require__(38);
	var redefine = __webpack_require__(197);
	var META = __webpack_require__(445).KEY;
	var $fails = __webpack_require__(57);
	var shared = __webpack_require__(116);
	var setToStringTag = __webpack_require__(114);
	var uid = __webpack_require__(86);
	var wks = __webpack_require__(32);
	var wksExt = __webpack_require__(120);
	var wksDefine = __webpack_require__(119);
	var enumKeys = __webpack_require__(437);
	var isArray = __webpack_require__(440);
	var anObject = __webpack_require__(46);
	var isObject = __webpack_require__(59);
	var toIObject = __webpack_require__(49);
	var toPrimitive = __webpack_require__(118);
	var createDesc = __webpack_require__(69);
	var _create = __webpack_require__(111);
	var gOPNExt = __webpack_require__(448);
	var $GOPD = __webpack_require__(112);
	var $DP = __webpack_require__(40);
	var $keys = __webpack_require__(83);
	var gOPD = $GOPD.f;
	var dP = $DP.f;
	var gOPN = gOPNExt.f;
	var $Symbol = global.Symbol;
	var $JSON = global.JSON;
	var _stringify = $JSON && $JSON.stringify;
	var PROTOTYPE = 'prototype';
	var HIDDEN = wks('_hidden');
	var TO_PRIMITIVE = wks('toPrimitive');
	var isEnum = {}.propertyIsEnumerable;
	var SymbolRegistry = shared('symbol-registry');
	var AllSymbols = shared('symbols');
	var OPSymbols = shared('op-symbols');
	var ObjectProto = Object[PROTOTYPE];
	var USE_NATIVE = typeof $Symbol == 'function';
	var 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));
	  var i = 0;
	  var l = keys.length;
	  var 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));
	  var result = [];
	  var i = 0;
	  var 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;
	  var names = gOPN(IS_OP ? OPSymbols : toIObject(it));
	  var result = [];
	  var i = 0;
	  var 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;
	  __webpack_require__(193).f = gOPNExt.f = $getOwnPropertyNames;
	  __webpack_require__(84).f = $propertyIsEnumerable;
	  __webpack_require__(113).f = $getOwnPropertySymbols;
	
	  if (DESCRIPTORS && !__webpack_require__(110)) {
	    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 es6Symbols = (
	  // 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(','), j = 0; es6Symbols.length > j;)wks(es6Symbols[j++]);
	
	for (var wellKnownSymbols = $keys(wks.store), k = 0; wellKnownSymbols.length > k;) wksDefine(wellKnownSymbols[k++]);
	
	$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(sym) {
	    if (!isSymbol(sym)) throw TypeError(sym + ' is not a symbol!');
	    for (var key in SymbolRegistry) if (SymbolRegistry[key] === sym) return key;
	  },
	  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) {
	    var args = [it];
	    var i = 1;
	    var replacer, $replacer;
	    while (arguments.length > i) args.push(arguments[i++]);
	    $replacer = replacer = args[1];
	    if (!isObject(replacer) && it === undefined || isSymbol(it)) return; // IE8 returns string on undefined
	    if (!isArray(replacer)) replacer = function (key, value) {
	      if (typeof $replacer == 'function') 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] || __webpack_require__(58)($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);


/***/ }),
/* 464 */
/***/ (function(module, exports, __webpack_require__) {

	__webpack_require__(119)('asyncIterator');


/***/ }),
/* 465 */
/***/ (function(module, exports, __webpack_require__) {

	__webpack_require__(119)('observable');


/***/ }),
/* 466 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 */
	
	'use strict';
	
	var _assign = __webpack_require__(18);
	
	var emptyObject = __webpack_require__(559);
	var _invariant = __webpack_require__(12);
	
	if (true) {
	  var warning = __webpack_require__(135);
	}
	
	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;
	}
	
	var ReactPropTypeLocationNames;
	if (true) {
	  ReactPropTypeLocationNames = {
	    prop: 'prop',
	    context: 'context',
	    childContext: 'child context'
	  };
	} else {
	  ReactPropTypeLocationNames = {};
	}
	
	function factory(ReactComponent, isValidElement, ReactNoopUpdateQueue) {
	  /**
	   * 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}
	     * @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',
	
	    /**
	     * Replacement for (deprecated) `componentWillMount`.
	     *
	     * @optional
	     */
	    UNSAFE_componentWillMount: 'DEFINE_MANY',
	
	    /**
	     * Replacement for (deprecated) `componentWillReceiveProps`.
	     *
	     * @optional
	     */
	    UNSAFE_componentWillReceiveProps: 'DEFINE_MANY',
	
	    /**
	     * Replacement for (deprecated) `componentWillUpdate`.
	     *
	     * @optional
	     */
	    UNSAFE_componentWillUpdate: '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'
	  };
	
	  /**
	   * Similar to ReactClassInterface but for static methods.
	   */
	  var ReactClassStaticInterface = {
	    /**
	     * This method is invoked after a component is instantiated and when it
	     * receives new props. Return an object to update state in response to
	     * prop changes. Return null to indicate no change to state.
	     *
	     * If an object is returned, its keys will be merged into the existing state.
	     *
	     * @return {object || null}
	     * @optional
	     */
	    getDerivedStateFromProps: 'DEFINE_MANY_MERGED'
	  };
	
	  /**
	   * 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 (true) {
	        validateTypeDef(Constructor, childContextTypes, 'childContext');
	      }
	      Constructor.childContextTypes = _assign(
	        {},
	        Constructor.childContextTypes,
	        childContextTypes
	      );
	    },
	    contextTypes: function(Constructor, contextTypes) {
	      if (true) {
	        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 (true) {
	        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__
	        if (true) {
	          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
	          );
	        }
	      }
	    }
	  }
	
	  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)) {
	      _invariant(
	        specPolicy === 'OVERRIDE_BASE',
	        'ReactClassInterface: You are attempting to override ' +
	          '`%s` from your class specification. Ensure that your method names ' +
	          'do not overlap with React methods.',
	        name
	      );
	    }
	
	    // Disallow defining methods more than once unless explicitly allowed.
	    if (isAlreadyDefined) {
	      _invariant(
	        specPolicy === 'DEFINE_MANY' || specPolicy === 'DEFINE_MANY_MERGED',
	        'ReactClassInterface: You are attempting to define ' +
	          '`%s` on your component more than once. This conflict may be due ' +
	          'to a mixin.',
	        name
	      );
	    }
	  }
	
	  /**
	   * Mixin helper which handles policy validation and reserved
	   * specification keys when building React classes.
	   */
	  function mixSpecIntoComponent(Constructor, spec) {
	    if (!spec) {
	      if (true) {
	        var typeofSpec = typeof spec;
	        var isMixinValid = typeofSpec === 'object' && spec !== null;
	
	        if (true) {
	          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
	          );
	        }
	      }
	
	      return;
	    }
	
	    _invariant(
	      typeof spec !== 'function',
	      "ReactClass: You're attempting to " +
	        'use a component class or function as a mixin. Instead, just use a ' +
	        'regular object.'
	    );
	    _invariant(
	      !isValidElement(spec),
	      "ReactClass: You're attempting to " +
	        'use a component as a mixin. Instead, just use a regular object.'
	    );
	
	    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.
	            _invariant(
	              isReactClassMethod &&
	                (specPolicy === 'DEFINE_MANY_MERGED' ||
	                  specPolicy === 'DEFINE_MANY'),
	              'ReactClass: Unexpected spec policy %s for key %s ' +
	                'when mixing in component specs.',
	              specPolicy,
	              name
	            );
	
	            // 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 (true) {
	              // 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;
	      _invariant(
	        !isReserved,
	        '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
	      );
	
	      var isAlreadyDefined = name in Constructor;
	      if (isAlreadyDefined) {
	        var specPolicy = ReactClassStaticInterface.hasOwnProperty(name)
	          ? ReactClassStaticInterface[name]
	          : null;
	
	        _invariant(
	          specPolicy === 'DEFINE_MANY_MERGED',
	          'ReactClass: You are attempting to define ' +
	            '`%s` on your component more than once. This conflict may be ' +
	            'due to a mixin.',
	          name
	        );
	
	        Constructor[name] = createMergedResultFunction(Constructor[name], property);
	
	        return;
	      }
	
	      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) {
	    _invariant(
	      one && two && typeof one === 'object' && typeof two === 'object',
	      'mergeIntoWithNoDuplicateKeys(): Cannot merge non-objects.'
	    );
	
	    for (var key in two) {
	      if (two.hasOwnProperty(key)) {
	        _invariant(
	          one[key] === undefined,
	          '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
	        );
	        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 (true) {
	      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) {
	          if (true) {
	            warning(
	              false,
	              'bind(): React component methods may only be bound to the ' +
	                'component instance. See %s',
	              componentName
	            );
	          }
	        } else if (!args.length) {
	          if (true) {
	            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
	            );
	          }
	          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);
	    }
	  }
	
	  var IsMountedPreMixin = {
	    componentDidMount: function() {
	      this.__isMounted = true;
	    }
	  };
	
	  var IsMountedPostMixin = {
	    componentWillUnmount: function() {
	      this.__isMounted = false;
	    }
	  };
	
	  /**
	   * 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, callback);
	    },
	
	    /**
	     * Checks whether or not this composite component is mounted.
	     * @return {boolean} True if mounted, false otherwise.
	     * @protected
	     * @final
	     */
	    isMounted: function() {
	      if (true) {
	        warning(
	          this.__didWarnIsMounted,
	          '%s: isMounted is deprecated. Instead, make sure to clean up ' +
	            'subscriptions and pending requests in componentWillUnmount to ' +
	            'prevent memory leaks.',
	          (this.constructor && this.constructor.displayName) ||
	            this.name ||
	            'Component'
	        );
	        this.__didWarnIsMounted = true;
	      }
	      return !!this.__isMounted;
	    }
	  };
	
	  var ReactClassComponent = function() {};
	  _assign(
	    ReactClassComponent.prototype,
	    ReactComponent.prototype,
	    ReactClassMixin
	  );
	
	  /**
	   * 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
	   */
	  function createClass(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 (true) {
	        warning(
	          this instanceof Constructor,
	          'Something is calling a React component directly. Use a factory or ' +
	            'JSX instead. See: https://fb.me/react-legacyfactory'
	        );
	      }
	
	      // 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 (true) {
	        // 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;
	        }
	      }
	      _invariant(
	        typeof initialState === 'object' && !Array.isArray(initialState),
	        '%s.getInitialState(): must return an object or null',
	        Constructor.displayName || 'ReactCompositeComponent'
	      );
	
	      this.state = initialState;
	    });
	    Constructor.prototype = new ReactClassComponent();
	    Constructor.prototype.constructor = Constructor;
	    Constructor.prototype.__reactAutoBindPairs = [];
	
	    injectedMixins.forEach(mixSpecIntoComponent.bind(null, Constructor));
	
	    mixSpecIntoComponent(Constructor, IsMountedPreMixin);
	    mixSpecIntoComponent(Constructor, spec);
	    mixSpecIntoComponent(Constructor, IsMountedPostMixin);
	
	    // Initialize the defaultProps property after all mixins have been merged.
	    if (Constructor.getDefaultProps) {
	      Constructor.defaultProps = Constructor.getDefaultProps();
	    }
	
	    if (true) {
	      // 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 = {};
	      }
	    }
	
	    _invariant(
	      Constructor.prototype.render,
	      'createClass(...): Class specification must implement a `render` method.'
	    );
	
	    if (true) {
	      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'
	      );
	      warning(
	        !Constructor.prototype.componentWillRecieveProps,
	        '%s has a method called ' +
	          'componentWillRecieveProps(). Did you mean componentWillReceiveProps()?',
	        spec.displayName || 'A component'
	      );
	      warning(
	        !Constructor.prototype.UNSAFE_componentWillRecieveProps,
	        '%s has a method called UNSAFE_componentWillRecieveProps(). ' +
	          'Did you mean UNSAFE_componentWillReceiveProps()?',
	        spec.displayName || 'A component'
	      );
	    }
	
	    // 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;
	  }
	
	  return createClass;
	}
	
	module.exports = factory;


/***/ }),
/* 467 */
/***/ (function(module, exports) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	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;
	
	  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) {
	    if (EVENT_NAME_MAP.hasOwnProperty(baseEventName)) {
	      var baseEvents = EVENT_NAME_MAP[baseEventName];
	      for (var styleName in baseEvents) {
	        if (styleName in style) {
	          endEvents.push(baseEvents[styleName]);
	          break;
	        }
	      }
	    }
	  }
	}
	
	if (typeof window !== 'undefined' && typeof document !== 'undefined') {
	  detectEvents();
	}
	
	function addEventListener(node, eventName, eventListener) {
	  node.addEventListener(eventName, eventListener, false);
	}
	
	function removeEventListener(node, eventName, eventListener) {
	  node.removeEventListener(eventName, eventListener, false);
	}
	
	var TransitionEvents = {
	  addEndEventListener: function addEndEventListener(node, eventListener) {
	    if (endEvents.length === 0) {
	      window.setTimeout(eventListener, 0);
	      return;
	    }
	    endEvents.forEach(function (endEvent) {
	      addEventListener(node, endEvent, eventListener);
	    });
	  },
	
	
	  endEvents: endEvents,
	
	  removeEndEventListener: function removeEndEventListener(node, eventListener) {
	    if (endEvents.length === 0) {
	      return;
	    }
	    endEvents.forEach(function (endEvent) {
	      removeEventListener(node, endEvent, eventListener);
	    });
	  }
	};
	
	exports['default'] = TransitionEvents;
	module.exports = exports['default'];

/***/ }),
/* 468 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _utils = __webpack_require__(61);
	
	var _utils2 = _interopRequireDefault(_utils);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function adjustForViewport(elFuturePos, elRegion, visibleRect, overflow) {
	  var pos = _utils2['default'].clone(elFuturePos);
	  var size = {
	    width: elRegion.width,
	    height: elRegion.height
	  };
	
	  if (overflow.adjustX && pos.left < visibleRect.left) {
	    pos.left = visibleRect.left;
	  }
	
	  // Left edge inside and right edge outside viewport, try to resize it.
	  if (overflow.resizeWidth && pos.left >= visibleRect.left && pos.left + size.width > visibleRect.right) {
	    size.width -= pos.left + size.width - visibleRect.right;
	  }
	
	  // Right edge outside viewport, try to move it.
	  if (overflow.adjustX && pos.left + size.width > visibleRect.right) {
	    // 保证左边界和可视区域左边界对齐
	    pos.left = Math.max(visibleRect.right - size.width, visibleRect.left);
	  }
	
	  // Top edge outside viewport, try to move it.
	  if (overflow.adjustY && pos.top < visibleRect.top) {
	    pos.top = visibleRect.top;
	  }
	
	  // Top edge inside and bottom edge outside viewport, try to resize it.
	  if (overflow.resizeHeight && pos.top >= visibleRect.top && pos.top + size.height > visibleRect.bottom) {
	    size.height -= pos.top + size.height - visibleRect.bottom;
	  }
	
	  // Bottom edge outside viewport, try to move it.
	  if (overflow.adjustY && pos.top + size.height > visibleRect.bottom) {
	    // 保证上边界和可视区域上边界对齐
	    pos.top = Math.max(visibleRect.bottom - size.height, visibleRect.top);
	  }
	
	  return _utils2['default'].mix(pos, size);
	}
	
	exports['default'] = adjustForViewport;
	module.exports = exports['default'];

/***/ }),
/* 469 */
/***/ (function(module, exports) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	/**
	 * 获取 node 上的 align 对齐点 相对于页面的坐标
	 */
	
	function getAlignOffset(region, align) {
	  var V = align.charAt(0);
	  var H = align.charAt(1);
	  var w = region.width;
	  var h = region.height;
	
	  var x = region.left;
	  var y = region.top;
	
	  if (V === 'c') {
	    y += h / 2;
	  } else if (V === 'b') {
	    y += h;
	  }
	
	  if (H === 'c') {
	    x += w / 2;
	  } else if (H === 'r') {
	    x += w;
	  }
	
	  return {
	    left: x,
	    top: y
	  };
	}
	
	exports['default'] = getAlignOffset;
	module.exports = exports['default'];

/***/ }),
/* 470 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _getAlignOffset = __webpack_require__(469);
	
	var _getAlignOffset2 = _interopRequireDefault(_getAlignOffset);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function getElFuturePos(elRegion, refNodeRegion, points, offset, targetOffset) {
	  var p1 = (0, _getAlignOffset2['default'])(refNodeRegion, points[1]);
	  var p2 = (0, _getAlignOffset2['default'])(elRegion, points[0]);
	  var diff = [p2.left - p1.left, p2.top - p1.top];
	
	  return {
	    left: elRegion.left - diff[0] + offset[0] - targetOffset[0],
	    top: elRegion.top - diff[1] + offset[1] - targetOffset[1]
	  };
	}
	
	exports['default'] = getElFuturePos;
	module.exports = exports['default'];

/***/ }),
/* 471 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _utils = __webpack_require__(61);
	
	var _utils2 = _interopRequireDefault(_utils);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function getRegion(node) {
	  var offset = void 0;
	  var w = void 0;
	  var h = void 0;
	  if (!_utils2['default'].isWindow(node) && node.nodeType !== 9) {
	    offset = _utils2['default'].offset(node);
	    w = _utils2['default'].outerWidth(node);
	    h = _utils2['default'].outerHeight(node);
	  } else {
	    var win = _utils2['default'].getWindow(node);
	    offset = {
	      left: _utils2['default'].getWindowScrollLeft(win),
	      top: _utils2['default'].getWindowScrollTop(win)
	    };
	    w = _utils2['default'].viewportWidth(win);
	    h = _utils2['default'].viewportHeight(win);
	  }
	  offset.width = w;
	  offset.height = h;
	  return offset;
	}
	
	exports['default'] = getRegion;
	module.exports = exports['default'];

/***/ }),
/* 472 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _utils = __webpack_require__(61);
	
	var _utils2 = _interopRequireDefault(_utils);
	
	var _getOffsetParent = __webpack_require__(200);
	
	var _getOffsetParent2 = _interopRequireDefault(_getOffsetParent);
	
	var _isAncestorFixed = __webpack_require__(474);
	
	var _isAncestorFixed2 = _interopRequireDefault(_isAncestorFixed);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	/**
	 * 获得元素的显示部分的区域
	 */
	function getVisibleRectForElement(element) {
	  var visibleRect = {
	    left: 0,
	    right: Infinity,
	    top: 0,
	    bottom: Infinity
	  };
	  var el = (0, _getOffsetParent2['default'])(element);
	  var doc = _utils2['default'].getDocument(element);
	  var win = doc.defaultView || doc.parentWindow;
	  var body = doc.body;
	  var documentElement = doc.documentElement;
	
	  // Determine the size of the visible rect by climbing the dom accounting for
	  // all scrollable containers.
	  while (el) {
	    // clientWidth is zero for inline block elements in ie.
	    if ((navigator.userAgent.indexOf('MSIE') === -1 || el.clientWidth !== 0) &&
	    // body may have overflow set on it, yet we still get the entire
	    // viewport. In some browsers, el.offsetParent may be
	    // document.documentElement, so check for that too.
	    el !== body && el !== documentElement && _utils2['default'].css(el, 'overflow') !== 'visible') {
	      var pos = _utils2['default'].offset(el);
	      // add border
	      pos.left += el.clientLeft;
	      pos.top += el.clientTop;
	      visibleRect.top = Math.max(visibleRect.top, pos.top);
	      visibleRect.right = Math.min(visibleRect.right,
	      // consider area without scrollBar
	      pos.left + el.clientWidth);
	      visibleRect.bottom = Math.min(visibleRect.bottom, pos.top + el.clientHeight);
	      visibleRect.left = Math.max(visibleRect.left, pos.left);
	    } else if (el === body || el === documentElement) {
	      break;
	    }
	    el = (0, _getOffsetParent2['default'])(el);
	  }
	
	  // Set element position to fixed
	  // make sure absolute element itself don't affect it's visible area
	  // https://github.com/ant-design/ant-design/issues/7601
	  var originalPosition = null;
	  if (!_utils2['default'].isWindow(element) && element.nodeType !== 9) {
	    originalPosition = element.style.position;
	    var position = _utils2['default'].css(element, 'position');
	    if (position === 'absolute') {
	      element.style.position = 'fixed';
	    }
	  }
	
	  var scrollX = _utils2['default'].getWindowScrollLeft(win);
	  var scrollY = _utils2['default'].getWindowScrollTop(win);
	  var viewportWidth = _utils2['default'].viewportWidth(win);
	  var viewportHeight = _utils2['default'].viewportHeight(win);
	  var documentWidth = documentElement.scrollWidth;
	  var documentHeight = documentElement.scrollHeight;
	
	  // Reset element position after calculate the visible area
	  if (element.style) {
	    element.style.position = originalPosition;
	  }
	
	  if ((0, _isAncestorFixed2['default'])(element)) {
	    // Clip by viewport's size.
	    visibleRect.left = Math.max(visibleRect.left, scrollX);
	    visibleRect.top = Math.max(visibleRect.top, scrollY);
	    visibleRect.right = Math.min(visibleRect.right, scrollX + viewportWidth);
	    visibleRect.bottom = Math.min(visibleRect.bottom, scrollY + viewportHeight);
	  } else {
	    // Clip by document's size.
	    var maxVisibleWidth = Math.max(documentWidth, scrollX + viewportWidth);
	    visibleRect.right = Math.min(visibleRect.right, maxVisibleWidth);
	
	    var maxVisibleHeight = Math.max(documentHeight, scrollY + viewportHeight);
	    visibleRect.bottom = Math.min(visibleRect.bottom, maxVisibleHeight);
	  }
	
	  return visibleRect.top >= 0 && visibleRect.left >= 0 && visibleRect.bottom > visibleRect.top && visibleRect.right > visibleRect.left ? visibleRect : null;
	}
	
	exports['default'] = getVisibleRectForElement;
	module.exports = exports['default'];

/***/ }),
/* 473 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _utils = __webpack_require__(61);
	
	var _utils2 = _interopRequireDefault(_utils);
	
	var _getOffsetParent = __webpack_require__(200);
	
	var _getOffsetParent2 = _interopRequireDefault(_getOffsetParent);
	
	var _getVisibleRectForElement = __webpack_require__(472);
	
	var _getVisibleRectForElement2 = _interopRequireDefault(_getVisibleRectForElement);
	
	var _adjustForViewport = __webpack_require__(468);
	
	var _adjustForViewport2 = _interopRequireDefault(_adjustForViewport);
	
	var _getRegion = __webpack_require__(471);
	
	var _getRegion2 = _interopRequireDefault(_getRegion);
	
	var _getElFuturePos = __webpack_require__(470);
	
	var _getElFuturePos2 = _interopRequireDefault(_getElFuturePos);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	// http://yiminghe.iteye.com/blog/1124720
	
	/**
	 * align dom node flexibly
	 * @author yiminghe@gmail.com
	 */
	
	function isFailX(elFuturePos, elRegion, visibleRect) {
	  return elFuturePos.left < visibleRect.left || elFuturePos.left + elRegion.width > visibleRect.right;
	}
	
	function isFailY(elFuturePos, elRegion, visibleRect) {
	  return elFuturePos.top < visibleRect.top || elFuturePos.top + elRegion.height > visibleRect.bottom;
	}
	
	function isCompleteFailX(elFuturePos, elRegion, visibleRect) {
	  return elFuturePos.left > visibleRect.right || elFuturePos.left + elRegion.width < visibleRect.left;
	}
	
	function isCompleteFailY(elFuturePos, elRegion, visibleRect) {
	  return elFuturePos.top > visibleRect.bottom || elFuturePos.top + elRegion.height < visibleRect.top;
	}
	
	function isOutOfVisibleRect(target) {
	  var visibleRect = (0, _getVisibleRectForElement2['default'])(target);
	  var targetRegion = (0, _getRegion2['default'])(target);
	
	  return !visibleRect || targetRegion.left + targetRegion.width <= visibleRect.left || targetRegion.top + targetRegion.height <= visibleRect.top || targetRegion.left >= visibleRect.right || targetRegion.top >= visibleRect.bottom;
	}
	
	function flip(points, reg, map) {
	  var ret = [];
	  _utils2['default'].each(points, function (p) {
	    ret.push(p.replace(reg, function (m) {
	      return map[m];
	    }));
	  });
	  return ret;
	}
	
	function flipOffset(offset, index) {
	  offset[index] = -offset[index];
	  return offset;
	}
	
	function convertOffset(str, offsetLen) {
	  var n = void 0;
	  if (/%$/.test(str)) {
	    n = parseInt(str.substring(0, str.length - 1), 10) / 100 * offsetLen;
	  } else {
	    n = parseInt(str, 10);
	  }
	  return n || 0;
	}
	
	function normalizeOffset(offset, el) {
	  offset[0] = convertOffset(offset[0], el.width);
	  offset[1] = convertOffset(offset[1], el.height);
	}
	
	function domAlign(el, refNode, align) {
	  var points = align.points;
	  var offset = align.offset || [0, 0];
	  var targetOffset = align.targetOffset || [0, 0];
	  var overflow = align.overflow;
	  var target = align.target || refNode;
	  var source = align.source || el;
	  offset = [].concat(offset);
	  targetOffset = [].concat(targetOffset);
	  overflow = overflow || {};
	  var newOverflowCfg = {};
	  var fail = 0;
	  // 当前节点可以被放置的显示区域
	  var visibleRect = (0, _getVisibleRectForElement2['default'])(source);
	  // 当前节点所占的区域, left/top/width/height
	  var elRegion = (0, _getRegion2['default'])(source);
	  // 参照节点所占的区域, left/top/width/height
	  var refNodeRegion = (0, _getRegion2['default'])(target);
	  // 将 offset 转换成数值，支持百分比
	  normalizeOffset(offset, elRegion);
	  normalizeOffset(targetOffset, refNodeRegion);
	  // 当前节点将要被放置的位置
	  var elFuturePos = (0, _getElFuturePos2['default'])(elRegion, refNodeRegion, points, offset, targetOffset);
	  // 当前节点将要所处的区域
	  var newElRegion = _utils2['default'].merge(elRegion, elFuturePos);
	
	  var isTargetNotOutOfVisible = !isOutOfVisibleRect(target);
	
	  // 如果可视区域不能完全放置当前节点时允许调整
	  if (visibleRect && (overflow.adjustX || overflow.adjustY) && isTargetNotOutOfVisible) {
	    if (overflow.adjustX) {
	      // 如果横向不能放下
	      if (isFailX(elFuturePos, elRegion, visibleRect)) {
	        // 对齐位置反下
	        var newPoints = flip(points, /[lr]/ig, {
	          l: 'r',
	          r: 'l'
	        });
	        // 偏移量也反下
	        var newOffset = flipOffset(offset, 0);
	        var newTargetOffset = flipOffset(targetOffset, 0);
	        var newElFuturePos = (0, _getElFuturePos2['default'])(elRegion, refNodeRegion, newPoints, newOffset, newTargetOffset);
	
	        if (!isCompleteFailX(newElFuturePos, elRegion, visibleRect)) {
	          fail = 1;
	          points = newPoints;
	          offset = newOffset;
	          targetOffset = newTargetOffset;
	        }
	      }
	    }
	
	    if (overflow.adjustY) {
	      // 如果纵向不能放下
	      if (isFailY(elFuturePos, elRegion, visibleRect)) {
	        // 对齐位置反下
	        var _newPoints = flip(points, /[tb]/ig, {
	          t: 'b',
	          b: 't'
	        });
	        // 偏移量也反下
	        var _newOffset = flipOffset(offset, 1);
	        var _newTargetOffset = flipOffset(targetOffset, 1);
	        var _newElFuturePos = (0, _getElFuturePos2['default'])(elRegion, refNodeRegion, _newPoints, _newOffset, _newTargetOffset);
	
	        if (!isCompleteFailY(_newElFuturePos, elRegion, visibleRect)) {
	          fail = 1;
	          points = _newPoints;
	          offset = _newOffset;
	          targetOffset = _newTargetOffset;
	        }
	      }
	    }
	
	    // 如果失败，重新计算当前节点将要被放置的位置
	    if (fail) {
	      elFuturePos = (0, _getElFuturePos2['default'])(elRegion, refNodeRegion, points, offset, targetOffset);
	      _utils2['default'].mix(newElRegion, elFuturePos);
	    }
	    var isStillFailX = isFailX(elFuturePos, elRegion, visibleRect);
	    var isStillFailY = isFailY(elFuturePos, elRegion, visibleRect);
	    // 检查反下后的位置是否可以放下了，如果仍然放不下：
	    // 1. 复原修改过的定位参数
	    if (isStillFailX || isStillFailY) {
	      points = align.points;
	      offset = align.offset || [0, 0];
	      targetOffset = align.targetOffset || [0, 0];
	    }
	    // 2. 只有指定了可以调整当前方向才调整
	    newOverflowCfg.adjustX = overflow.adjustX && isStillFailX;
	    newOverflowCfg.adjustY = overflow.adjustY && isStillFailY;
	
	    // 确实要调整，甚至可能会调整高度宽度
	    if (newOverflowCfg.adjustX || newOverflowCfg.adjustY) {
	      newElRegion = (0, _adjustForViewport2['default'])(elFuturePos, elRegion, visibleRect, newOverflowCfg);
	    }
	  }
	
	  // need judge to in case set fixed with in css on height auto element
	  if (newElRegion.width !== elRegion.width) {
	    _utils2['default'].css(source, 'width', _utils2['default'].width(source) + newElRegion.width - elRegion.width);
	  }
	
	  if (newElRegion.height !== elRegion.height) {
	    _utils2['default'].css(source, 'height', _utils2['default'].height(source) + newElRegion.height - elRegion.height);
	  }
	
	  // https://github.com/kissyteam/kissy/issues/190
	  // 相对于屏幕位置没变，而 left/top 变了
	  // 例如 <div 'relative'><el absolute></div>
	  _utils2['default'].offset(source, {
	    left: newElRegion.left,
	    top: newElRegion.top
	  }, {
	    useCssRight: align.useCssRight,
	    useCssBottom: align.useCssBottom,
	    useCssTransform: align.useCssTransform
	  });
	
	  return {
	    points: points,
	    offset: offset,
	    targetOffset: targetOffset,
	    overflow: newOverflowCfg
	  };
	}
	
	domAlign.__getOffsetParent = _getOffsetParent2['default'];
	
	domAlign.__getVisibleRectForElement = _getVisibleRectForElement2['default'];
	
	exports['default'] = domAlign;
	/**
	 *  2012-04-26 yiminghe@gmail.com
	 *   - 优化智能对齐算法
	 *   - 慎用 resizeXX
	 *
	 *  2011-07-13 yiminghe@gmail.com note:
	 *   - 增加智能对齐，以及大小调整选项
	 **/
	
	module.exports = exports['default'];

/***/ }),
/* 474 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports['default'] = isAncestorFixed;
	
	var _utils = __webpack_require__(61);
	
	var _utils2 = _interopRequireDefault(_utils);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function isAncestorFixed(element) {
	  if (_utils2['default'].isWindow(element) || element.nodeType === 9) {
	    return false;
	  }
	
	  var doc = _utils2['default'].getDocument(element);
	  var body = doc.body;
	  var parent = null;
	  for (parent = element.parentNode; parent && parent !== body; parent = parent.parentNode) {
	    var positionStyle = _utils2['default'].css(parent, 'position');
	    if (positionStyle === 'fixed') {
	      return true;
	    }
	  }
	  return false;
	}
	module.exports = exports['default'];

/***/ }),
/* 475 */
/***/ (function(module, exports) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.getTransformName = getTransformName;
	exports.setTransitionProperty = setTransitionProperty;
	exports.getTransitionProperty = getTransitionProperty;
	exports.getTransformXY = getTransformXY;
	exports.setTransformXY = setTransformXY;
	var vendorPrefix = void 0;
	
	var jsCssMap = {
	  Webkit: '-webkit-',
	  Moz: '-moz-',
	  // IE did it wrong again ...
	  ms: '-ms-',
	  O: '-o-'
	};
	
	function getVendorPrefix() {
	  if (vendorPrefix !== undefined) {
	    return vendorPrefix;
	  }
	  vendorPrefix = '';
	  var style = document.createElement('p').style;
	  var testProp = 'Transform';
	  for (var key in jsCssMap) {
	    if (key + testProp in style) {
	      vendorPrefix = key;
	    }
	  }
	  return vendorPrefix;
	}
	
	function getTransitionName() {
	  return getVendorPrefix() ? getVendorPrefix() + 'TransitionProperty' : 'transitionProperty';
	}
	
	function getTransformName() {
	  return getVendorPrefix() ? getVendorPrefix() + 'Transform' : 'transform';
	}
	
	function setTransitionProperty(node, value) {
	  var name = getTransitionName();
	  if (name) {
	    node.style[name] = value;
	    if (name !== 'transitionProperty') {
	      node.style.transitionProperty = value;
	    }
	  }
	}
	
	function setTransform(node, value) {
	  var name = getTransformName();
	  if (name) {
	    node.style[name] = value;
	    if (name !== 'transform') {
	      node.style.transform = value;
	    }
	  }
	}
	
	function getTransitionProperty(node) {
	  return node.style.transitionProperty || node.style[getTransitionName()];
	}
	
	function getTransformXY(node) {
	  var style = window.getComputedStyle(node, null);
	  var transform = style.getPropertyValue('transform') || style.getPropertyValue(getTransformName());
	  if (transform && transform !== 'none') {
	    var matrix = transform.replace(/[^0-9\-.,]/g, '').split(',');
	    return { x: parseFloat(matrix[12] || matrix[4], 0), y: parseFloat(matrix[13] || matrix[5], 0) };
	  }
	  return {
	    x: 0,
	    y: 0
	  };
	}
	
	var matrix2d = /matrix\((.*)\)/;
	var matrix3d = /matrix3d\((.*)\)/;
	
	function setTransformXY(node, xy) {
	  var style = window.getComputedStyle(node, null);
	  var transform = style.getPropertyValue('transform') || style.getPropertyValue(getTransformName());
	  if (transform && transform !== 'none') {
	    var arr = void 0;
	    var match2d = transform.match(matrix2d);
	    if (match2d) {
	      match2d = match2d[1];
	      arr = match2d.split(',').map(function (item) {
	        return parseFloat(item, 10);
	      });
	      arr[4] = xy.x;
	      arr[5] = xy.y;
	      setTransform(node, 'matrix(' + arr.join(',') + ')');
	    } else {
	      var match3d = transform.match(matrix3d)[1];
	      arr = match3d.split(',').map(function (item) {
	        return parseFloat(item, 10);
	      });
	      arr[12] = xy.x;
	      arr[13] = xy.y;
	      setTransform(node, 'matrix3d(' + arr.join(',') + ')');
	    }
	  } else {
	    setTransform(node, 'translateX(' + xy.x + 'px) translateY(' + xy.y + 'px) translateZ(0)');
	  }
	}

/***/ }),
/* 476 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Module dependencies
	 */
	
	var matches = __webpack_require__(477);
	
	/**
	 * @param element {Element}
	 * @param selector {String}
	 * @param context {Element}
	 * @return {Element}
	 */
	module.exports = function (element, selector, context) {
	  context = context || document;
	  // guard against orphans
	  element = { parentNode: element };
	
	  while ((element = element.parentNode) && element !== context) {
	    if (matches(element, selector)) {
	      return element;
	    }
	  }
	};


/***/ }),
/* 477 */
/***/ (function(module, exports) {

	'use strict';
	
	/**
	 * Determine if a DOM element matches a CSS selector
	 *
	 * @param {Element} elem
	 * @param {String} selector
	 * @return {Boolean}
	 * @api public
	 */
	
	function matches(elem, selector) {
	  // Vendor-specific implementations of `Element.prototype.matches()`.
	  var proto = window.Element.prototype;
	  var nativeMatches = proto.matches ||
	      proto.mozMatchesSelector ||
	      proto.msMatchesSelector ||
	      proto.oMatchesSelector ||
	      proto.webkitMatchesSelector;
	
	  if (!elem || elem.nodeType !== 1) {
	    return false;
	  }
	
	  var parentElem = elem.parentNode;
	
	  // use native 'matches'
	  if (nativeMatches) {
	    return nativeMatches.call(elem, selector);
	  }
	
	  // native support for `matches` is missing and a fallback is required
	  var nodes = parentElem.querySelectorAll(selector);
	  var len = nodes.length;
	
	  for (var i = 0; i < len; i++) {
	    if (nodes[i] === elem) {
	      return true;
	    }
	  }
	
	  return false;
	}
	
	/**
	 * Expose `matches`
	 */
	
	module.exports = matches;


/***/ }),
/* 478 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	var util = __webpack_require__(479);
	
	function scrollIntoView(elem, container, config) {
	  config = config || {};
	  // document 归一化到 window
	  if (container.nodeType === 9) {
	    container = util.getWindow(container);
	  }
	
	  var allowHorizontalScroll = config.allowHorizontalScroll;
	  var onlyScrollIfNeeded = config.onlyScrollIfNeeded;
	  var alignWithTop = config.alignWithTop;
	  var alignWithLeft = config.alignWithLeft;
	  var offsetTop = config.offsetTop || 0;
	  var offsetLeft = config.offsetLeft || 0;
	  var offsetBottom = config.offsetBottom || 0;
	  var offsetRight = config.offsetRight || 0;
	
	  allowHorizontalScroll = allowHorizontalScroll === undefined ? true : allowHorizontalScroll;
	
	  var isWin = util.isWindow(container);
	  var elemOffset = util.offset(elem);
	  var eh = util.outerHeight(elem);
	  var ew = util.outerWidth(elem);
	  var containerOffset = undefined;
	  var ch = undefined;
	  var cw = undefined;
	  var containerScroll = undefined;
	  var diffTop = undefined;
	  var diffBottom = undefined;
	  var win = undefined;
	  var winScroll = undefined;
	  var ww = undefined;
	  var wh = undefined;
	
	  if (isWin) {
	    win = container;
	    wh = util.height(win);
	    ww = util.width(win);
	    winScroll = {
	      left: util.scrollLeft(win),
	      top: util.scrollTop(win)
	    };
	    // elem 相对 container 可视视窗的距离
	    diffTop = {
	      left: elemOffset.left - winScroll.left - offsetLeft,
	      top: elemOffset.top - winScroll.top - offsetTop
	    };
	    diffBottom = {
	      left: elemOffset.left + ew - (winScroll.left + ww) + offsetRight,
	      top: elemOffset.top + eh - (winScroll.top + wh) + offsetBottom
	    };
	    containerScroll = winScroll;
	  } else {
	    containerOffset = util.offset(container);
	    ch = container.clientHeight;
	    cw = container.clientWidth;
	    containerScroll = {
	      left: container.scrollLeft,
	      top: container.scrollTop
	    };
	    // elem 相对 container 可视视窗的距离
	    // 注意边框, offset 是边框到根节点
	    diffTop = {
	      left: elemOffset.left - (containerOffset.left + (parseFloat(util.css(container, 'borderLeftWidth')) || 0)) - offsetLeft,
	      top: elemOffset.top - (containerOffset.top + (parseFloat(util.css(container, 'borderTopWidth')) || 0)) - offsetTop
	    };
	    diffBottom = {
	      left: elemOffset.left + ew - (containerOffset.left + cw + (parseFloat(util.css(container, 'borderRightWidth')) || 0)) + offsetRight,
	      top: elemOffset.top + eh - (containerOffset.top + ch + (parseFloat(util.css(container, 'borderBottomWidth')) || 0)) + offsetBottom
	    };
	  }
	
	  if (diffTop.top < 0 || diffBottom.top > 0) {
	    // 强制向上
	    if (alignWithTop === true) {
	      util.scrollTop(container, containerScroll.top + diffTop.top);
	    } else if (alignWithTop === false) {
	      util.scrollTop(container, containerScroll.top + diffBottom.top);
	    } else {
	      // 自动调整
	      if (diffTop.top < 0) {
	        util.scrollTop(container, containerScroll.top + diffTop.top);
	      } else {
	        util.scrollTop(container, containerScroll.top + diffBottom.top);
	      }
	    }
	  } else {
	    if (!onlyScrollIfNeeded) {
	      alignWithTop = alignWithTop === undefined ? true : !!alignWithTop;
	      if (alignWithTop) {
	        util.scrollTop(container, containerScroll.top + diffTop.top);
	      } else {
	        util.scrollTop(container, containerScroll.top + diffBottom.top);
	      }
	    }
	  }
	
	  if (allowHorizontalScroll) {
	    if (diffTop.left < 0 || diffBottom.left > 0) {
	      // 强制向上
	      if (alignWithLeft === true) {
	        util.scrollLeft(container, containerScroll.left + diffTop.left);
	      } else if (alignWithLeft === false) {
	        util.scrollLeft(container, containerScroll.left + diffBottom.left);
	      } else {
	        // 自动调整
	        if (diffTop.left < 0) {
	          util.scrollLeft(container, containerScroll.left + diffTop.left);
	        } else {
	          util.scrollLeft(container, containerScroll.left + diffBottom.left);
	        }
	      }
	    } else {
	      if (!onlyScrollIfNeeded) {
	        alignWithLeft = alignWithLeft === undefined ? true : !!alignWithLeft;
	        if (alignWithLeft) {
	          util.scrollLeft(container, containerScroll.left + diffTop.left);
	        } else {
	          util.scrollLeft(container, containerScroll.left + diffBottom.left);
	        }
	      }
	    }
	  }
	}
	
	module.exports = scrollIntoView;

/***/ }),
/* 479 */
/***/ (function(module, exports) {

	'use strict';
	
	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 _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 RE_NUM = /[\-+]?(?:\d*\.|)\d+(?:[eE][\-+]?\d+|)/.source;
	
	function getClientPosition(elem) {
	  var box = undefined;
	  var x = undefined;
	  var y = undefined;
	  var doc = elem.ownerDocument;
	  var body = doc.body;
	  var docElem = doc && doc.documentElement;
	  // 根据 GBS 最新数据，A-Grade Browsers 都已支持 getBoundingClientRect 方法，不用再考虑传统的实现方式
	  box = elem.getBoundingClientRect();
	
	  // 注：jQuery 还考虑减去 docElem.clientLeft/clientTop
	  // 但测试发现，这样反而会导致当 html 和 body 有边距/边框样式时，获取的值不正确
	  // 此外，ie6 会忽略 html 的 margin 值，幸运地是没有谁会去设置 html 的 margin
	
	  x = box.left;
	  y = box.top;
	
	  // In IE, most of the time, 2 extra pixels are added to the top and left
	  // due to the implicit 2-pixel inset border.  In IE6/7 quirks mode and
	  // IE6 standards mode, this border can be overridden by setting the
	  // document element's border to zero -- thus, we cannot rely on the
	  // offset always being 2 pixels.
	
	  // In quirks mode, the offset can be determined by querying the body's
	  // clientLeft/clientTop, but in standards mode, it is found by querying
	  // the document element's clientLeft/clientTop.  Since we already called
	  // getClientBoundingRect we have already forced a reflow, so it is not
	  // too expensive just to query them all.
	
	  // ie 下应该减去窗口的边框吧，毕竟默认 absolute 都是相对窗口定位的
	  // 窗口边框标准是设 documentElement ,quirks 时设置 body
	  // 最好禁止在 body 和 html 上边框 ，但 ie < 9 html 默认有 2px ，减去
	  // 但是非 ie 不可能设置窗口边框，body html 也不是窗口 ,ie 可以通过 html,body 设置
	  // 标准 ie 下 docElem.clientTop 就是 border-top
	  // ie7 html 即窗口边框改变不了。永远为 2
	  // 但标准 firefox/chrome/ie9 下 docElem.clientTop 是窗口边框，即使设了 border-top 也为 0
	
	  x -= docElem.clientLeft || body.clientLeft || 0;
	  y -= docElem.clientTop || body.clientTop || 0;
	
	  return {
	    left: x,
	    top: y
	  };
	}
	
	function getScroll(w, top) {
	  var ret = w['page' + (top ? 'Y' : 'X') + 'Offset'];
	  var method = 'scroll' + (top ? 'Top' : 'Left');
	  if (typeof ret !== 'number') {
	    var d = w.document;
	    // ie6,7,8 standard mode
	    ret = d.documentElement[method];
	    if (typeof ret !== 'number') {
	      // quirks mode
	      ret = d.body[method];
	    }
	  }
	  return ret;
	}
	
	function getScrollLeft(w) {
	  return getScroll(w);
	}
	
	function getScrollTop(w) {
	  return getScroll(w, true);
	}
	
	function getOffset(el) {
	  var pos = getClientPosition(el);
	  var doc = el.ownerDocument;
	  var w = doc.defaultView || doc.parentWindow;
	  pos.left += getScrollLeft(w);
	  pos.top += getScrollTop(w);
	  return pos;
	}
	function _getComputedStyle(elem, name, computedStyle_) {
	  var val = '';
	  var d = elem.ownerDocument;
	  var computedStyle = computedStyle_ || d.defaultView.getComputedStyle(elem, null);
	
	  // https://github.com/kissyteam/kissy/issues/61
	  if (computedStyle) {
	    val = computedStyle.getPropertyValue(name) || computedStyle[name];
	  }
	
	  return val;
	}
	
	var _RE_NUM_NO_PX = new RegExp('^(' + RE_NUM + ')(?!px)[a-z%]+$', 'i');
	var RE_POS = /^(top|right|bottom|left)$/;
	var CURRENT_STYLE = 'currentStyle';
	var RUNTIME_STYLE = 'runtimeStyle';
	var LEFT = 'left';
	var PX = 'px';
	
	function _getComputedStyleIE(elem, name) {
	  // currentStyle maybe null
	  // http://msdn.microsoft.com/en-us/library/ms535231.aspx
	  var ret = elem[CURRENT_STYLE] && elem[CURRENT_STYLE][name];
	
	  // 当 width/height 设置为百分比时，通过 pixelLeft 方式转换的 width/height 值
	  // 一开始就处理了! CUSTOM_STYLE.height,CUSTOM_STYLE.width ,cssHook 解决@2011-08-19
	  // 在 ie 下不对，需要直接用 offset 方式
	  // borderWidth 等值也有问题，但考虑到 borderWidth 设为百分比的概率很小，这里就不考虑了
	
	  // From the awesome hack by Dean Edwards
	  // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
	  // If we're not dealing with a regular pixel number
	  // but a number that has a weird ending, we need to convert it to pixels
	  // exclude left right for relativity
	  if (_RE_NUM_NO_PX.test(ret) && !RE_POS.test(name)) {
	    // Remember the original values
	    var style = elem.style;
	    var left = style[LEFT];
	    var rsLeft = elem[RUNTIME_STYLE][LEFT];
	
	    // prevent flashing of content
	    elem[RUNTIME_STYLE][LEFT] = elem[CURRENT_STYLE][LEFT];
	
	    // Put in the new values to get a computed value out
	    style[LEFT] = name === 'fontSize' ? '1em' : ret || 0;
	    ret = style.pixelLeft + PX;
	
	    // Revert the changed values
	    style[LEFT] = left;
	
	    elem[RUNTIME_STYLE][LEFT] = rsLeft;
	  }
	  return ret === '' ? 'auto' : ret;
	}
	
	var getComputedStyleX = undefined;
	if (typeof window !== 'undefined') {
	  getComputedStyleX = window.getComputedStyle ? _getComputedStyle : _getComputedStyleIE;
	}
	
	function each(arr, fn) {
	  for (var i = 0; i < arr.length; i++) {
	    fn(arr[i]);
	  }
	}
	
	function isBorderBoxFn(elem) {
	  return getComputedStyleX(elem, 'boxSizing') === 'border-box';
	}
	
	var BOX_MODELS = ['margin', 'border', 'padding'];
	var CONTENT_INDEX = -1;
	var PADDING_INDEX = 2;
	var BORDER_INDEX = 1;
	var MARGIN_INDEX = 0;
	
	function swap(elem, options, callback) {
	  var old = {};
	  var style = elem.style;
	  var name = undefined;
	
	  // Remember the old values, and insert the new ones
	  for (name in options) {
	    if (options.hasOwnProperty(name)) {
	      old[name] = style[name];
	      style[name] = options[name];
	    }
	  }
	
	  callback.call(elem);
	
	  // Revert the old values
	  for (name in options) {
	    if (options.hasOwnProperty(name)) {
	      style[name] = old[name];
	    }
	  }
	}
	
	function getPBMWidth(elem, props, which) {
	  var value = 0;
	  var prop = undefined;
	  var j = undefined;
	  var i = undefined;
	  for (j = 0; j < props.length; j++) {
	    prop = props[j];
	    if (prop) {
	      for (i = 0; i < which.length; i++) {
	        var cssProp = undefined;
	        if (prop === 'border') {
	          cssProp = prop + which[i] + 'Width';
	        } else {
	          cssProp = prop + which[i];
	        }
	        value += parseFloat(getComputedStyleX(elem, cssProp)) || 0;
	      }
	    }
	  }
	  return value;
	}
	
	/**
	 * A crude way of determining if an object is a window
	 * @member util
	 */
	function isWindow(obj) {
	  // must use == for ie8
	  /* eslint eqeqeq:0 */
	  return obj != null && obj == obj.window;
	}
	
	var domUtils = {};
	
	each(['Width', 'Height'], function (name) {
	  domUtils['doc' + name] = function (refWin) {
	    var d = refWin.document;
	    return Math.max(
	    // firefox chrome documentElement.scrollHeight< body.scrollHeight
	    // ie standard mode : documentElement.scrollHeight> body.scrollHeight
	    d.documentElement['scroll' + name],
	    // quirks : documentElement.scrollHeight 最大等于可视窗口多一点？
	    d.body['scroll' + name], domUtils['viewport' + name](d));
	  };
	
	  domUtils['viewport' + name] = function (win) {
	    // pc browser includes scrollbar in window.innerWidth
	    var prop = 'client' + name;
	    var doc = win.document;
	    var body = doc.body;
	    var documentElement = doc.documentElement;
	    var documentElementProp = documentElement[prop];
	    // 标准模式取 documentElement
	    // backcompat 取 body
	    return doc.compatMode === 'CSS1Compat' && documentElementProp || body && body[prop] || documentElementProp;
	  };
	});
	
	/*
	 得到元素的大小信息
	 @param elem
	 @param name
	 @param {String} [extra]  'padding' : (css width) + padding
	 'border' : (css width) + padding + border
	 'margin' : (css width) + padding + border + margin
	 */
	function getWH(elem, name, extra) {
	  if (isWindow(elem)) {
	    return name === 'width' ? domUtils.viewportWidth(elem) : domUtils.viewportHeight(elem);
	  } else if (elem.nodeType === 9) {
	    return name === 'width' ? domUtils.docWidth(elem) : domUtils.docHeight(elem);
	  }
	  var which = name === 'width' ? ['Left', 'Right'] : ['Top', 'Bottom'];
	  var borderBoxValue = name === 'width' ? elem.offsetWidth : elem.offsetHeight;
	  var computedStyle = getComputedStyleX(elem);
	  var isBorderBox = isBorderBoxFn(elem, computedStyle);
	  var cssBoxValue = 0;
	  if (borderBoxValue == null || borderBoxValue <= 0) {
	    borderBoxValue = undefined;
	    // Fall back to computed then un computed css if necessary
	    cssBoxValue = getComputedStyleX(elem, name);
	    if (cssBoxValue == null || Number(cssBoxValue) < 0) {
	      cssBoxValue = elem.style[name] || 0;
	    }
	    // Normalize '', auto, and prepare for extra
	    cssBoxValue = parseFloat(cssBoxValue) || 0;
	  }
	  if (extra === undefined) {
	    extra = isBorderBox ? BORDER_INDEX : CONTENT_INDEX;
	  }
	  var borderBoxValueOrIsBorderBox = borderBoxValue !== undefined || isBorderBox;
	  var val = borderBoxValue || cssBoxValue;
	  if (extra === CONTENT_INDEX) {
	    if (borderBoxValueOrIsBorderBox) {
	      return val - getPBMWidth(elem, ['border', 'padding'], which, computedStyle);
	    }
	    return cssBoxValue;
	  }
	  if (borderBoxValueOrIsBorderBox) {
	    var padding = extra === PADDING_INDEX ? -getPBMWidth(elem, ['border'], which, computedStyle) : getPBMWidth(elem, ['margin'], which, computedStyle);
	    return val + (extra === BORDER_INDEX ? 0 : padding);
	  }
	  return cssBoxValue + getPBMWidth(elem, BOX_MODELS.slice(extra), which, computedStyle);
	}
	
	var cssShow = {
	  position: 'absolute',
	  visibility: 'hidden',
	  display: 'block'
	};
	
	// fix #119 : https://github.com/kissyteam/kissy/issues/119
	function getWHIgnoreDisplay(elem) {
	  var val = undefined;
	  var args = arguments;
	  // in case elem is window
	  // elem.offsetWidth === undefined
	  if (elem.offsetWidth !== 0) {
	    val = getWH.apply(undefined, args);
	  } else {
	    swap(elem, cssShow, function () {
	      val = getWH.apply(undefined, args);
	    });
	  }
	  return val;
	}
	
	function css(el, name, v) {
	  var value = v;
	  if ((typeof name === 'undefined' ? 'undefined' : _typeof(name)) === 'object') {
	    for (var i in name) {
	      if (name.hasOwnProperty(i)) {
	        css(el, i, name[i]);
	      }
	    }
	    return undefined;
	  }
	  if (typeof value !== 'undefined') {
	    if (typeof value === 'number') {
	      value += 'px';
	    }
	    el.style[name] = value;
	    return undefined;
	  }
	  return getComputedStyleX(el, name);
	}
	
	each(['width', 'height'], function (name) {
	  var first = name.charAt(0).toUpperCase() + name.slice(1);
	  domUtils['outer' + first] = function (el, includeMargin) {
	    return el && getWHIgnoreDisplay(el, name, includeMargin ? MARGIN_INDEX : BORDER_INDEX);
	  };
	  var which = name === 'width' ? ['Left', 'Right'] : ['Top', 'Bottom'];
	
	  domUtils[name] = function (elem, val) {
	    if (val !== undefined) {
	      if (elem) {
	        var computedStyle = getComputedStyleX(elem);
	        var isBorderBox = isBorderBoxFn(elem);
	        if (isBorderBox) {
	          val += getPBMWidth(elem, ['padding', 'border'], which, computedStyle);
	        }
	        return css(elem, name, val);
	      }
	      return undefined;
	    }
	    return elem && getWHIgnoreDisplay(elem, name, CONTENT_INDEX);
	  };
	});
	
	// 设置 elem 相对 elem.ownerDocument 的坐标
	function setOffset(elem, offset) {
	  // set position first, in-case top/left are set even on static elem
	  if (css(elem, 'position') === 'static') {
	    elem.style.position = 'relative';
	  }
	
	  var old = getOffset(elem);
	  var ret = {};
	  var current = undefined;
	  var key = undefined;
	
	  for (key in offset) {
	    if (offset.hasOwnProperty(key)) {
	      current = parseFloat(css(elem, key)) || 0;
	      ret[key] = current + offset[key] - old[key];
	    }
	  }
	  css(elem, ret);
	}
	
	module.exports = _extends({
	  getWindow: function getWindow(node) {
	    var doc = node.ownerDocument || node;
	    return doc.defaultView || doc.parentWindow;
	  },
	  offset: function offset(el, value) {
	    if (typeof value !== 'undefined') {
	      setOffset(el, value);
	    } else {
	      return getOffset(el);
	    }
	  },
	
	  isWindow: isWindow,
	  each: each,
	  css: css,
	  clone: function clone(obj) {
	    var ret = {};
	    for (var i in obj) {
	      if (obj.hasOwnProperty(i)) {
	        ret[i] = obj[i];
	      }
	    }
	    var overflow = obj.overflow;
	    if (overflow) {
	      for (var i in obj) {
	        if (obj.hasOwnProperty(i)) {
	          ret.overflow[i] = obj.overflow[i];
	        }
	      }
	    }
	    return ret;
	  },
	  scrollLeft: function scrollLeft(w, v) {
	    if (isWindow(w)) {
	      if (v === undefined) {
	        return getScrollLeft(w);
	      }
	      window.scrollTo(v, getScrollTop(w));
	    } else {
	      if (v === undefined) {
	        return w.scrollLeft;
	      }
	      w.scrollLeft = v;
	    }
	  },
	  scrollTop: function scrollTop(w, v) {
	    if (isWindow(w)) {
	      if (v === undefined) {
	        return getScrollTop(w);
	      }
	      window.scrollTo(getScrollLeft(w), v);
	    } else {
	      if (v === undefined) {
	        return w.scrollTop;
	      }
	      w.scrollTop = v;
	    }
	  },
	
	  viewportWidth: 0,
	  viewportHeight: 0
	}, domUtils);

/***/ }),
/* 480 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule AtomicBlockUtils
	 * @format
	 * 
	 */
	
	'use strict';
	
	var _assign = __webpack_require__(18);
	
	var _extends = _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 BlockMapBuilder = __webpack_require__(70);
	var CharacterMetadata = __webpack_require__(27);
	var ContentBlock = __webpack_require__(50);
	var ContentBlockNode = __webpack_require__(30);
	var DraftFeatureFlags = __webpack_require__(42);
	var DraftModifier = __webpack_require__(26);
	var EditorState = __webpack_require__(15);
	var Immutable = __webpack_require__(11);
	var SelectionState = __webpack_require__(62);
	
	var generateRandomKey = __webpack_require__(37);
	var moveBlockInContentState = __webpack_require__(540);
	
	var experimentalTreeDataSupport = DraftFeatureFlags.draft_tree_data_support;
	var ContentBlockRecord = experimentalTreeDataSupport ? ContentBlockNode : ContentBlock;
	
	var List = Immutable.List,
	    Repeat = Immutable.Repeat;
	
	
	var AtomicBlockUtils = {
	  insertAtomicBlock: function insertAtomicBlock(editorState, entityKey, character) {
	    var contentState = editorState.getCurrentContent();
	    var selectionState = editorState.getSelection();
	
	    var afterRemoval = DraftModifier.removeRange(contentState, selectionState, 'backward');
	
	    var targetSelection = afterRemoval.getSelectionAfter();
	    var afterSplit = DraftModifier.splitBlock(afterRemoval, targetSelection);
	    var insertionTarget = afterSplit.getSelectionAfter();
	
	    var asAtomicBlock = DraftModifier.setBlockType(afterSplit, insertionTarget, 'atomic');
	
	    var charData = CharacterMetadata.create({ entity: entityKey });
	
	    var atomicBlockConfig = {
	      key: generateRandomKey(),
	      type: 'atomic',
	      text: character,
	      characterList: List(Repeat(charData, character.length))
	    };
	
	    var atomicDividerBlockConfig = {
	      key: generateRandomKey(),
	      type: 'unstyled'
	    };
	
	    if (experimentalTreeDataSupport) {
	      atomicBlockConfig = _extends({}, atomicBlockConfig, {
	        nextSibling: atomicDividerBlockConfig.key
	      });
	      atomicDividerBlockConfig = _extends({}, atomicDividerBlockConfig, {
	        prevSibling: atomicBlockConfig.key
	      });
	    }
	
	    var fragmentArray = [new ContentBlockRecord(atomicBlockConfig), new ContentBlockRecord(atomicDividerBlockConfig)];
	
	    var fragment = BlockMapBuilder.createFromArray(fragmentArray);
	
	    var withAtomicBlock = DraftModifier.replaceWithFragment(asAtomicBlock, insertionTarget, fragment);
	
	    var newContent = withAtomicBlock.merge({
	      selectionBefore: selectionState,
	      selectionAfter: withAtomicBlock.getSelectionAfter().set('hasFocus', true)
	    });
	
	    return EditorState.push(editorState, newContent, 'insert-fragment');
	  },
	
	  moveAtomicBlock: function moveAtomicBlock(editorState, atomicBlock, targetRange, insertionMode) {
	    var contentState = editorState.getCurrentContent();
	    var selectionState = editorState.getSelection();
	
	    var withMovedAtomicBlock = void 0;
	
	    if (insertionMode === 'before' || insertionMode === 'after') {
	      var targetBlock = contentState.getBlockForKey(insertionMode === 'before' ? targetRange.getStartKey() : targetRange.getEndKey());
	
	      withMovedAtomicBlock = moveBlockInContentState(contentState, atomicBlock, targetBlock, insertionMode);
	    } else {
	      var afterRemoval = DraftModifier.removeRange(contentState, targetRange, 'backward');
	
	      var selectionAfterRemoval = afterRemoval.getSelectionAfter();
	      var _targetBlock = afterRemoval.getBlockForKey(selectionAfterRemoval.getFocusKey());
	
	      if (selectionAfterRemoval.getStartOffset() === 0) {
	        withMovedAtomicBlock = moveBlockInContentState(afterRemoval, atomicBlock, _targetBlock, 'before');
	      } else if (selectionAfterRemoval.getEndOffset() === _targetBlock.getLength()) {
	        withMovedAtomicBlock = moveBlockInContentState(afterRemoval, atomicBlock, _targetBlock, 'after');
	      } else {
	        var afterSplit = DraftModifier.splitBlock(afterRemoval, selectionAfterRemoval);
	
	        var selectionAfterSplit = afterSplit.getSelectionAfter();
	        var _targetBlock2 = afterSplit.getBlockForKey(selectionAfterSplit.getFocusKey());
	
	        withMovedAtomicBlock = moveBlockInContentState(afterSplit, atomicBlock, _targetBlock2, 'before');
	      }
	    }
	
	    var newContent = withMovedAtomicBlock.merge({
	      selectionBefore: selectionState,
	      selectionAfter: withMovedAtomicBlock.getSelectionAfter().set('hasFocus', true)
	    });
	
	    return EditorState.push(editorState, newContent, 'move-block');
	  }
	};
	
	module.exports = AtomicBlockUtils;

/***/ }),
/* 481 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule CompositeDraftDecorator
	 * @format
	 * 
	 */
	
	'use strict';
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	var Immutable = __webpack_require__(11);
	
	var List = Immutable.List;
	
	
	var DELIMITER = '.';
	
	/**
	 * A CompositeDraftDecorator traverses through a list of DraftDecorator
	 * instances to identify sections of a ContentBlock that should be rendered
	 * in a "decorated" manner. For example, hashtags, mentions, and links may
	 * be intended to stand out visually, be rendered as anchors, etc.
	 *
	 * The list of decorators supplied to the constructor will be used in the
	 * order they are provided. This allows the caller to specify a priority for
	 * string matching, in case of match collisions among decorators.
	 *
	 * For instance, I may have a link with a `#` in its text. Though this section
	 * of text may match our hashtag decorator, it should not be treated as a
	 * hashtag. I should therefore list my link DraftDecorator
	 * before my hashtag DraftDecorator when constructing this composite
	 * decorator instance.
	 *
	 * Thus, when a collision like this is encountered, the earlier match is
	 * preserved and the new match is discarded.
	 */
	
	var CompositeDraftDecorator = function () {
	  function CompositeDraftDecorator(decorators) {
	    _classCallCheck(this, CompositeDraftDecorator);
	
	    // Copy the decorator array, since we use this array order to determine
	    // precedence of decoration matching. If the array is mutated externally,
	    // we don't want to be affected here.
	    this._decorators = decorators.slice();
	  }
	
	  CompositeDraftDecorator.prototype.getDecorations = function getDecorations(block, contentState) {
	    var decorations = Array(block.getText().length).fill(null);
	
	    this._decorators.forEach(function ( /*object*/decorator, /*number*/ii) {
	      var counter = 0;
	      var strategy = decorator.strategy;
	      var callback = function callback( /*number*/start, /*number*/end) {
	        // Find out if any of our matching range is already occupied
	        // by another decorator. If so, discard the match. Otherwise, store
	        // the component key for rendering.
	        if (canOccupySlice(decorations, start, end)) {
	          occupySlice(decorations, start, end, ii + DELIMITER + counter);
	          counter++;
	        }
	      };
	      strategy(block, callback, contentState);
	    });
	
	    return List(decorations);
	  };
	
	  CompositeDraftDecorator.prototype.getComponentForKey = function getComponentForKey(key) {
	    var componentKey = parseInt(key.split(DELIMITER)[0], 10);
	    return this._decorators[componentKey].component;
	  };
	
	  CompositeDraftDecorator.prototype.getPropsForKey = function getPropsForKey(key) {
	    var componentKey = parseInt(key.split(DELIMITER)[0], 10);
	    return this._decorators[componentKey].props;
	  };
	
	  return CompositeDraftDecorator;
	}();
	
	/**
	 * Determine whether we can occupy the specified slice of the decorations
	 * array.
	 */
	
	
	function canOccupySlice(decorations, start, end) {
	  for (var ii = start; ii < end; ii++) {
	    if (decorations[ii] != null) {
	      return false;
	    }
	  }
	  return true;
	}
	
	/**
	 * Splice the specified component into our decoration array at the desired
	 * range.
	 */
	function occupySlice(targetArr, start, end, componentKey) {
	  for (var ii = start; ii < end; ii++) {
	    targetArr[ii] = componentKey;
	  }
	}
	
	module.exports = CompositeDraftDecorator;

/***/ }),
/* 482 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule ContentStateInlineStyle
	 * @format
	 * 
	 */
	
	'use strict';
	
	var CharacterMetadata = __webpack_require__(27);
	
	var _require = __webpack_require__(11),
	    Map = _require.Map;
	
	var ContentStateInlineStyle = {
	  add: function add(contentState, selectionState, inlineStyle) {
	    return modifyInlineStyle(contentState, selectionState, inlineStyle, true);
	  },
	
	  remove: function remove(contentState, selectionState, inlineStyle) {
	    return modifyInlineStyle(contentState, selectionState, inlineStyle, false);
	  }
	};
	
	function modifyInlineStyle(contentState, selectionState, inlineStyle, addOrRemove) {
	  var blockMap = contentState.getBlockMap();
	  var startKey = selectionState.getStartKey();
	  var startOffset = selectionState.getStartOffset();
	  var endKey = selectionState.getEndKey();
	  var endOffset = selectionState.getEndOffset();
	
	  var newBlocks = blockMap.skipUntil(function (_, k) {
	    return k === startKey;
	  }).takeUntil(function (_, k) {
	    return k === endKey;
	  }).concat(Map([[endKey, blockMap.get(endKey)]])).map(function (block, blockKey) {
	    var sliceStart;
	    var sliceEnd;
	
	    if (startKey === endKey) {
	      sliceStart = startOffset;
	      sliceEnd = endOffset;
	    } else {
	      sliceStart = blockKey === startKey ? startOffset : 0;
	      sliceEnd = blockKey === endKey ? endOffset : block.getLength();
	    }
	
	    var chars = block.getCharacterList();
	    var current;
	    while (sliceStart < sliceEnd) {
	      current = chars.get(sliceStart);
	      chars = chars.set(sliceStart, addOrRemove ? CharacterMetadata.applyStyle(current, inlineStyle) : CharacterMetadata.removeStyle(current, inlineStyle));
	      sliceStart++;
	    }
	
	    return block.set('characterList', chars);
	  });
	
	  return contentState.merge({
	    blockMap: blockMap.merge(newBlocks),
	    selectionBefore: selectionState,
	    selectionAfter: selectionState
	  });
	}
	
	module.exports = ContentStateInlineStyle;

/***/ }),
/* 483 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule DraftEditor.react
	 * @format
	 * 
	 * @preventMunge
	 */
	
	'use strict';
	
	var _assign = __webpack_require__(18);
	
	var _extends = _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; };
	
	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 DefaultDraftBlockRenderMap = __webpack_require__(124);
	var DefaultDraftInlineStyle = __webpack_require__(202);
	var DraftEditorCompositionHandler = __webpack_require__(484);
	var DraftEditorContents = __webpack_require__(486);
	var DraftEditorDragHandler = __webpack_require__(487);
	var DraftEditorEditHandler = __webpack_require__(488);
	var DraftEditorPlaceholder = __webpack_require__(490);
	var EditorState = __webpack_require__(15);
	var React = __webpack_require__(1);
	var ReactDOM = __webpack_require__(10);
	var Scroll = __webpack_require__(225);
	var Style = __webpack_require__(131);
	var UserAgent = __webpack_require__(36);
	
	var cx = __webpack_require__(63);
	var emptyFunction = __webpack_require__(75);
	var generateRandomKey = __webpack_require__(37);
	var getDefaultKeyBinding = __webpack_require__(209);
	var getScrollPosition = __webpack_require__(134);
	var invariant = __webpack_require__(12);
	var nullthrows = __webpack_require__(33);
	
	var isIE = UserAgent.isBrowser('IE');
	
	// IE does not support the `input` event on contentEditable, so we can't
	// observe spellcheck behavior.
	var allowSpellCheck = !isIE;
	
	// Define a set of handler objects to correspond to each possible `mode`
	// of editor behavior.
	var handlerMap = {
	  edit: DraftEditorEditHandler,
	  composite: DraftEditorCompositionHandler,
	  drag: DraftEditorDragHandler,
	  cut: null,
	  render: null
	};
	
	/**
	 * `DraftEditor` is the root editor component. It composes a `contentEditable`
	 * div, and provides a wide variety of useful function props for managing the
	 * state of the editor. See `DraftEditorProps` for details.
	 */
	var DraftEditor = function (_React$Component) {
	  _inherits(DraftEditor, _React$Component);
	
	  function DraftEditor(props) {
	    _classCallCheck(this, DraftEditor);
	
	    var _this = _possibleConstructorReturn(this, _React$Component.call(this, props));
	
	    _this.focus = function (scrollPosition) {
	      var editorState = _this.props.editorState;
	
	      var alreadyHasFocus = editorState.getSelection().getHasFocus();
	      var editorNode = ReactDOM.findDOMNode(_this.editor);
	
	      if (!editorNode) {
	        // once in a while people call 'focus' in a setTimeout, and the node has
	        // been deleted, so it can be null in that case.
	        return;
	      }
	
	      var scrollParent = Style.getScrollParent(editorNode);
	
	      var _ref = scrollPosition || getScrollPosition(scrollParent),
	          x = _ref.x,
	          y = _ref.y;
	
	      !(editorNode instanceof HTMLElement) ?  true ? invariant(false, 'editorNode is not an HTMLElement') : invariant(false) : void 0;
	      editorNode.focus();
	
	      // Restore scroll position
	      if (scrollParent === window) {
	        window.scrollTo(x, y);
	      } else {
	        Scroll.setTop(scrollParent, y);
	      }
	
	      // On Chrome and Safari, calling focus on contenteditable focuses the
	      // cursor at the first character. This is something you don't expect when
	      // you're clicking on an input element but not directly on a character.
	      // Put the cursor back where it was before the blur.
	      if (!alreadyHasFocus) {
	        _this.update(EditorState.forceSelection(editorState, editorState.getSelection()));
	      }
	    };
	
	    _this.blur = function () {
	      var editorNode = ReactDOM.findDOMNode(_this.editor);
	      !(editorNode instanceof HTMLElement) ?  true ? invariant(false, 'editorNode is not an HTMLElement') : invariant(false) : void 0;
	      editorNode.blur();
	    };
	
	    _this.setMode = function (mode) {
	      _this._handler = handlerMap[mode];
	    };
	
	    _this.exitCurrentMode = function () {
	      _this.setMode('edit');
	    };
	
	    _this.restoreEditorDOM = function (scrollPosition) {
	      _this.setState({ contentsKey: _this.state.contentsKey + 1 }, function () {
	        _this.focus(scrollPosition);
	      });
	    };
	
	    _this.setClipboard = function (clipboard) {
	      _this._clipboard = clipboard;
	    };
	
	    _this.getClipboard = function () {
	      return _this._clipboard;
	    };
	
	    _this.update = function (editorState) {
	      _this._latestEditorState = editorState;
	      _this.props.onChange(editorState);
	    };
	
	    _this.onDragEnter = function () {
	      _this._dragCount++;
	    };
	
	    _this.onDragLeave = function () {
	      _this._dragCount--;
	      if (_this._dragCount === 0) {
	        _this.exitCurrentMode();
	      }
	    };
	
	    _this._blockSelectEvents = false;
	    _this._clipboard = null;
	    _this._handler = null;
	    _this._dragCount = 0;
	    _this._editorKey = props.editorKey || generateRandomKey();
	    _this._placeholderAccessibilityID = 'placeholder-' + _this._editorKey;
	    _this._latestEditorState = props.editorState;
	    _this._latestCommittedEditorState = props.editorState;
	
	    _this._onBeforeInput = _this._buildHandler('onBeforeInput');
	    _this._onBlur = _this._buildHandler('onBlur');
	    _this._onCharacterData = _this._buildHandler('onCharacterData');
	    _this._onCompositionEnd = _this._buildHandler('onCompositionEnd');
	    _this._onCompositionStart = _this._buildHandler('onCompositionStart');
	    _this._onCopy = _this._buildHandler('onCopy');
	    _this._onCut = _this._buildHandler('onCut');
	    _this._onDragEnd = _this._buildHandler('onDragEnd');
	    _this._onDragOver = _this._buildHandler('onDragOver');
	    _this._onDragStart = _this._buildHandler('onDragStart');
	    _this._onDrop = _this._buildHandler('onDrop');
	    _this._onInput = _this._buildHandler('onInput');
	    _this._onFocus = _this._buildHandler('onFocus');
	    _this._onKeyDown = _this._buildHandler('onKeyDown');
	    _this._onKeyPress = _this._buildHandler('onKeyPress');
	    _this._onKeyUp = _this._buildHandler('onKeyUp');
	    _this._onMouseDown = _this._buildHandler('onMouseDown');
	    _this._onMouseUp = _this._buildHandler('onMouseUp');
	    _this._onPaste = _this._buildHandler('onPaste');
	    _this._onSelect = _this._buildHandler('onSelect');
	
	    _this.getEditorKey = function () {
	      return _this._editorKey;
	    };
	
	    // See `restoreEditorDOM()`.
	    _this.state = { contentsKey: 0 };
	    return _this;
	  }
	
	  /**
	   * Build a method that will pass the event to the specified handler method.
	   * This allows us to look up the correct handler function for the current
	   * editor mode, if any has been specified.
	   */
	
	
	  /**
	   * Define proxies that can route events to the current handler.
	   */
	
	
	  DraftEditor.prototype._buildHandler = function _buildHandler(eventName) {
	    var _this2 = this;
	
	    return function (e) {
	      if (!_this2.props.readOnly) {
	        var method = _this2._handler && _this2._handler[eventName];
	        method && method(_this2, e);
	      }
	    };
	  };
	
	  DraftEditor.prototype._showPlaceholder = function _showPlaceholder() {
	    return !!this.props.placeholder && !this.props.editorState.isInCompositionMode() && !this.props.editorState.getCurrentContent().hasText();
	  };
	
	  DraftEditor.prototype._renderPlaceholder = function _renderPlaceholder() {
	    if (this._showPlaceholder()) {
	      var placeHolderProps = {
	        text: nullthrows(this.props.placeholder),
	        editorState: this.props.editorState,
	        textAlignment: this.props.textAlignment,
	        accessibilityID: this._placeholderAccessibilityID
	      };
	
	      return React.createElement(DraftEditorPlaceholder, placeHolderProps);
	    }
	    return null;
	  };
	
	  DraftEditor.prototype.render = function render() {
	    var _this3 = this;
	
	    var _props = this.props,
	        blockRenderMap = _props.blockRenderMap,
	        blockRendererFn = _props.blockRendererFn,
	        blockStyleFn = _props.blockStyleFn,
	        customStyleFn = _props.customStyleFn,
	        customStyleMap = _props.customStyleMap,
	        editorState = _props.editorState,
	        readOnly = _props.readOnly,
	        textAlignment = _props.textAlignment,
	        textDirectionality = _props.textDirectionality;
	
	
	    var rootClass = cx({
	      'DraftEditor/root': true,
	      'DraftEditor/alignLeft': textAlignment === 'left',
	      'DraftEditor/alignRight': textAlignment === 'right',
	      'DraftEditor/alignCenter': textAlignment === 'center'
	    });
	
	    var contentStyle = {
	      outline: 'none',
	      // fix parent-draggable Safari bug. #1326
	      userSelect: 'text',
	      WebkitUserSelect: 'text',
	      whiteSpace: 'pre-wrap',
	      wordWrap: 'break-word'
	    };
	
	    // The aria-expanded and aria-haspopup properties should only be rendered
	    // for a combobox.
	    var ariaRole = this.props.role || 'textbox';
	    var ariaExpanded = ariaRole === 'combobox' ? !!this.props.ariaExpanded : null;
	
	    var editorContentsProps = {
	      blockRenderMap: blockRenderMap,
	      blockRendererFn: blockRendererFn,
	      blockStyleFn: blockStyleFn,
	      customStyleMap: _extends({}, DefaultDraftInlineStyle, customStyleMap),
	      customStyleFn: customStyleFn,
	      editorKey: this._editorKey,
	      editorState: editorState,
	      key: 'contents' + this.state.contentsKey,
	      textDirectionality: textDirectionality
	    };
	
	    return React.createElement(
	      'div',
	      { className: rootClass },
	      this._renderPlaceholder(),
	      React.createElement(
	        'div',
	        {
	          className: cx('DraftEditor/editorContainer'),
	          ref: function ref(_ref3) {
	            return _this3.editorContainer = _ref3;
	          } },
	        React.createElement(
	          'div',
	          {
	            'aria-activedescendant': readOnly ? null : this.props.ariaActiveDescendantID,
	            'aria-autocomplete': readOnly ? null : this.props.ariaAutoComplete,
	            'aria-controls': readOnly ? null : this.props.ariaControls,
	            'aria-describedby': this.props.ariaDescribedBy || this._placeholderAccessibilityID,
	            'aria-expanded': readOnly ? null : ariaExpanded,
	            'aria-label': this.props.ariaLabel,
	            'aria-labelledby': this.props.ariaLabelledBy,
	            'aria-multiline': this.props.ariaMultiline,
	            autoCapitalize: this.props.autoCapitalize,
	            autoComplete: this.props.autoComplete,
	            autoCorrect: this.props.autoCorrect,
	            className: cx({
	              // Chrome's built-in translation feature mutates the DOM in ways
	              // that Draft doesn't expect (ex: adding <font> tags inside
	              // DraftEditorLeaf spans) and causes problems. We add notranslate
	              // here which makes its autotranslation skip over this subtree.
	              notranslate: !readOnly,
	              'public/DraftEditor/content': true
	            }),
	            contentEditable: !readOnly,
	            'data-testid': this.props.webDriverTestID,
	            onBeforeInput: this._onBeforeInput,
	            onBlur: this._onBlur,
	            onCompositionEnd: this._onCompositionEnd,
	            onCompositionStart: this._onCompositionStart,
	            onCopy: this._onCopy,
	            onCut: this._onCut,
	            onDragEnd: this._onDragEnd,
	            onDragEnter: this.onDragEnter,
	            onDragLeave: this.onDragLeave,
	            onDragOver: this._onDragOver,
	            onDragStart: this._onDragStart,
	            onDrop: this._onDrop,
	            onFocus: this._onFocus,
	            onInput: this._onInput,
	            onKeyDown: this._onKeyDown,
	            onKeyPress: this._onKeyPress,
	            onKeyUp: this._onKeyUp,
	            onMouseUp: this._onMouseUp,
	            onPaste: this._onPaste,
	            onSelect: this._onSelect,
	            ref: function ref(_ref2) {
	              return _this3.editor = _ref2;
	            },
	            role: readOnly ? null : ariaRole,
	            spellCheck: allowSpellCheck && this.props.spellCheck,
	            style: contentStyle,
	            suppressContentEditableWarning: true,
	            tabIndex: this.props.tabIndex },
	          React.createElement(DraftEditorContents, editorContentsProps)
	        )
	      )
	    );
	  };
	
	  DraftEditor.prototype.componentDidMount = function componentDidMount() {
	    this.setMode('edit');
	
	    /**
	     * IE has a hardcoded "feature" that attempts to convert link text into
	     * anchors in contentEditable DOM. This breaks the editor's expectations of
	     * the DOM, and control is lost. Disable it to make IE behave.
	     * See: http://blogs.msdn.com/b/ieinternals/archive/2010/09/15/
	     * ie9-beta-minor-change-list.aspx
	     */
	    if (isIE) {
	      document.execCommand('AutoUrlDetect', false, false);
	    }
	  };
	
	  /**
	   * Prevent selection events from affecting the current editor state. This
	   * is mostly intended to defend against IE, which fires off `selectionchange`
	   * events regardless of whether the selection is set via the browser or
	   * programmatically. We only care about selection events that occur because
	   * of browser interaction, not re-renders and forced selections.
	   */
	
	
	  DraftEditor.prototype.componentWillUpdate = function componentWillUpdate(nextProps) {
	    this._blockSelectEvents = true;
	    this._latestEditorState = nextProps.editorState;
	  };
	
	  DraftEditor.prototype.componentDidUpdate = function componentDidUpdate() {
	    this._blockSelectEvents = false;
	    this._latestCommittedEditorState = this.props.editorState;
	  };
	
	  /**
	   * Used via `this.focus()`.
	   *
	   * Force focus back onto the editor node.
	   *
	   * We attempt to preserve scroll position when focusing. You can also pass
	   * a specified scroll position (for cases like `cut` behavior where it should
	   * be restored to a known position).
	   */
	
	
	  /**
	   * Used via `this.setMode(...)`.
	   *
	   * Set the behavior mode for the editor component. This switches the current
	   * handler module to ensure that DOM events are managed appropriately for
	   * the active mode.
	   */
	
	
	  /**
	   * Used via `this.restoreEditorDOM()`.
	   *
	   * Force a complete re-render of the DraftEditorContents based on the current
	   * EditorState. This is useful when we know we are going to lose control of
	   * the DOM state (cut command, IME) and we want to make sure that
	   * reconciliation occurs on a version of the DOM that is synchronized with
	   * our EditorState.
	   */
	
	
	  /**
	   * Used via `this.setClipboard(...)`.
	   *
	   * Set the clipboard state for a cut/copy event.
	   */
	
	
	  /**
	   * Used via `this.getClipboard()`.
	   *
	   * Retrieve the clipboard state for a cut/copy event.
	   */
	
	
	  /**
	   * Used via `this.update(...)`.
	   *
	   * Propagate a new `EditorState` object to higher-level components. This is
	   * the method by which event handlers inform the `DraftEditor` component of
	   * state changes. A component that composes a `DraftEditor` **must** provide
	   * an `onChange` prop to receive state updates passed along from this
	   * function.
	   */
	
	
	  /**
	   * Used in conjunction with `onDragLeave()`, by counting the number of times
	   * a dragged element enters and leaves the editor (or any of its children),
	   * to determine when the dragged element absolutely leaves the editor.
	   */
	
	
	  /**
	   * See `onDragEnter()`.
	   */
	
	
	  return DraftEditor;
	}(React.Component);
	
	DraftEditor.defaultProps = {
	  blockRenderMap: DefaultDraftBlockRenderMap,
	  blockRendererFn: emptyFunction.thatReturnsNull,
	  blockStyleFn: emptyFunction.thatReturns(''),
	  keyBindingFn: getDefaultKeyBinding,
	  readOnly: false,
	  spellCheck: false,
	  stripPastedStyles: false
	};
	
	
	module.exports = DraftEditor;

/***/ }),
/* 484 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule DraftEditorCompositionHandler
	 * @format
	 * 
	 */
	
	'use strict';
	
	var DraftFeatureFlags = __webpack_require__(42);
	var DraftModifier = __webpack_require__(26);
	var EditorState = __webpack_require__(15);
	var Keys = __webpack_require__(130);
	
	var getEntityKeyForSelection = __webpack_require__(127);
	var isEventHandled = __webpack_require__(73);
	var isSelectionAtLeafStart = __webpack_require__(219);
	
	/**
	 * Millisecond delay to allow `compositionstart` to fire again upon
	 * `compositionend`.
	 *
	 * This is used for Korean input to ensure that typing can continue without
	 * the editor trying to render too quickly. More specifically, Safari 7.1+
	 * triggers `compositionstart` a little slower than Chrome/FF, which
	 * leads to composed characters being resolved and re-render occurring
	 * sooner than we want.
	 */
	var RESOLVE_DELAY = 20;
	
	/**
	 * A handful of variables used to track the current composition and its
	 * resolution status. These exist at the module level because it is not
	 * possible to have compositions occurring in multiple editors simultaneously,
	 * and it simplifies state management with respect to the DraftEditor component.
	 */
	var resolved = false;
	var stillComposing = false;
	var textInputData = '';
	
	var DraftEditorCompositionHandler = {
	  onBeforeInput: function onBeforeInput(editor, e) {
	    textInputData = (textInputData || '') + e.data;
	  },
	
	  /**
	   * A `compositionstart` event has fired while we're still in composition
	   * mode. Continue the current composition session to prevent a re-render.
	   */
	  onCompositionStart: function onCompositionStart(editor) {
	    stillComposing = true;
	  },
	
	  /**
	   * Attempt to end the current composition session.
	   *
	   * Defer handling because browser will still insert the chars into active
	   * element after `compositionend`. If a `compositionstart` event fires
	   * before `resolveComposition` executes, our composition session will
	   * continue.
	   *
	   * The `resolved` flag is useful because certain IME interfaces fire the
	   * `compositionend` event multiple times, thus queueing up multiple attempts
	   * at handling the composition. Since handling the same composition event
	   * twice could break the DOM, we only use the first event. Example: Arabic
	   * Google Input Tools on Windows 8.1 fires `compositionend` three times.
	   */
	  onCompositionEnd: function onCompositionEnd(editor) {
	    resolved = false;
	    stillComposing = false;
	    setTimeout(function () {
	      if (!resolved) {
	        DraftEditorCompositionHandler.resolveComposition(editor);
	      }
	    }, RESOLVE_DELAY);
	  },
	
	  /**
	   * In Safari, keydown events may fire when committing compositions. If
	   * the arrow keys are used to commit, prevent default so that the cursor
	   * doesn't move, otherwise it will jump back noticeably on re-render.
	   */
	  onKeyDown: function onKeyDown(editor, e) {
	    if (!stillComposing) {
	      // If a keydown event is received after compositionend but before the
	      // 20ms timer expires (ex: type option-E then backspace, or type A then
	      // backspace in 2-Set Korean), we should immediately resolve the
	      // composition and reinterpret the key press in edit mode.
	      DraftEditorCompositionHandler.resolveComposition(editor);
	      editor._onKeyDown(e);
	      return;
	    }
	    if (e.which === Keys.RIGHT || e.which === Keys.LEFT) {
	      e.preventDefault();
	    }
	  },
	
	  /**
	   * Keypress events may fire when committing compositions. In Firefox,
	   * pressing RETURN commits the composition and inserts extra newline
	   * characters that we do not want. `preventDefault` allows the composition
	   * to be committed while preventing the extra characters.
	   */
	  onKeyPress: function onKeyPress(editor, e) {
	    if (e.which === Keys.RETURN) {
	      e.preventDefault();
	    }
	  },
	
	  /**
	   * Attempt to insert composed characters into the document.
	   *
	   * If we are still in a composition session, do nothing. Otherwise, insert
	   * the characters into the document and terminate the composition session.
	   *
	   * If no characters were composed -- for instance, the user
	   * deleted all composed characters and committed nothing new --
	   * force a re-render. We also re-render when the composition occurs
	   * at the beginning of a leaf, to ensure that if the browser has
	   * created a new text node for the composition, we will discard it.
	   *
	   * Resetting innerHTML will move focus to the beginning of the editor,
	   * so we update to force it back to the correct place.
	   */
	  resolveComposition: function resolveComposition(editor) {
	    if (stillComposing) {
	      return;
	    }
	
	    resolved = true;
	    var composedChars = textInputData;
	    textInputData = '';
	
	    var editorState = EditorState.set(editor._latestEditorState, {
	      inCompositionMode: false
	    });
	
	    var currentStyle = editorState.getCurrentInlineStyle();
	    var entityKey = getEntityKeyForSelection(editorState.getCurrentContent(), editorState.getSelection());
	
	    var mustReset = !composedChars || isSelectionAtLeafStart(editorState) || currentStyle.size > 0 || entityKey !== null;
	
	    if (mustReset) {
	      editor.restoreEditorDOM();
	    }
	
	    editor.exitCurrentMode();
	
	    if (composedChars) {
	      if (DraftFeatureFlags.draft_handlebeforeinput_composed_text && editor.props.handleBeforeInput && isEventHandled(editor.props.handleBeforeInput(composedChars, editorState))) {
	        return;
	      }
	      // If characters have been composed, re-rendering with the update
	      // is sufficient to reset the editor.
	      var contentState = DraftModifier.replaceText(editorState.getCurrentContent(), editorState.getSelection(), composedChars, currentStyle, entityKey);
	      editor.update(EditorState.push(editorState, contentState, 'insert-characters'));
	      return;
	    }
	
	    if (mustReset) {
	      editor.update(EditorState.set(editorState, {
	        nativelyRenderedContent: null,
	        forceSelection: true
	      }));
	    }
	  }
	};
	
	module.exports = DraftEditorCompositionHandler;

/***/ }),
/* 485 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule DraftEditorContents-core.react
	 * @format
	 * 
	 */
	
	'use strict';
	
	var _assign = __webpack_require__(18);
	
	var _extends = _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; };
	
	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 DraftEditorBlock = __webpack_require__(203);
	var DraftOffsetKey = __webpack_require__(71);
	var EditorState = __webpack_require__(15);
	var React = __webpack_require__(1);
	
	var cx = __webpack_require__(63);
	var joinClasses = __webpack_require__(569);
	var nullthrows = __webpack_require__(33);
	
	/**
	 * Provide default styling for list items. This way, lists will be styled with
	 * proper counters and indentation even if the caller does not specify
	 * their own styling at all. If more than five levels of nesting are needed,
	 * the necessary CSS classes can be provided via `blockStyleFn` configuration.
	 */
	var getListItemClasses = function getListItemClasses(type, depth, shouldResetCount, direction) {
	  return cx({
	    'public/DraftStyleDefault/unorderedListItem': type === 'unordered-list-item',
	    'public/DraftStyleDefault/orderedListItem': type === 'ordered-list-item',
	    'public/DraftStyleDefault/reset': shouldResetCount,
	    'public/DraftStyleDefault/depth0': depth === 0,
	    'public/DraftStyleDefault/depth1': depth === 1,
	    'public/DraftStyleDefault/depth2': depth === 2,
	    'public/DraftStyleDefault/depth3': depth === 3,
	    'public/DraftStyleDefault/depth4': depth === 4,
	    'public/DraftStyleDefault/listLTR': direction === 'LTR',
	    'public/DraftStyleDefault/listRTL': direction === 'RTL'
	  });
	};
	
	/**
	 * `DraftEditorContents` is the container component for all block components
	 * rendered for a `DraftEditor`. It is optimized to aggressively avoid
	 * re-rendering blocks whenever possible.
	 *
	 * This component is separate from `DraftEditor` because certain props
	 * (for instance, ARIA props) must be allowed to update without affecting
	 * the contents of the editor.
	 */
	
	var DraftEditorContents = function (_React$Component) {
	  _inherits(DraftEditorContents, _React$Component);
	
	  function DraftEditorContents() {
	    _classCallCheck(this, DraftEditorContents);
	
	    return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	  }
	
	  DraftEditorContents.prototype.shouldComponentUpdate = function shouldComponentUpdate(nextProps) {
	    var prevEditorState = this.props.editorState;
	    var nextEditorState = nextProps.editorState;
	
	    var prevDirectionMap = prevEditorState.getDirectionMap();
	    var nextDirectionMap = nextEditorState.getDirectionMap();
	
	    // Text direction has changed for one or more blocks. We must re-render.
	    if (prevDirectionMap !== nextDirectionMap) {
	      return true;
	    }
	
	    var didHaveFocus = prevEditorState.getSelection().getHasFocus();
	    var nowHasFocus = nextEditorState.getSelection().getHasFocus();
	
	    if (didHaveFocus !== nowHasFocus) {
	      return true;
	    }
	
	    var nextNativeContent = nextEditorState.getNativelyRenderedContent();
	
	    var wasComposing = prevEditorState.isInCompositionMode();
	    var nowComposing = nextEditorState.isInCompositionMode();
	
	    // If the state is unchanged or we're currently rendering a natively
	    // rendered state, there's nothing new to be done.
	    if (prevEditorState === nextEditorState || nextNativeContent !== null && nextEditorState.getCurrentContent() === nextNativeContent || wasComposing && nowComposing) {
	      return false;
	    }
	
	    var prevContent = prevEditorState.getCurrentContent();
	    var nextContent = nextEditorState.getCurrentContent();
	    var prevDecorator = prevEditorState.getDecorator();
	    var nextDecorator = nextEditorState.getDecorator();
	    return wasComposing !== nowComposing || prevContent !== nextContent || prevDecorator !== nextDecorator || nextEditorState.mustForceSelection();
	  };
	
	  DraftEditorContents.prototype.render = function render() {
	    var _props = this.props,
	        blockRenderMap = _props.blockRenderMap,
	        blockRendererFn = _props.blockRendererFn,
	        blockStyleFn = _props.blockStyleFn,
	        customStyleMap = _props.customStyleMap,
	        customStyleFn = _props.customStyleFn,
	        editorState = _props.editorState,
	        editorKey = _props.editorKey,
	        textDirectionality = _props.textDirectionality;
	
	
	    var content = editorState.getCurrentContent();
	    var selection = editorState.getSelection();
	    var forceSelection = editorState.mustForceSelection();
	    var decorator = editorState.getDecorator();
	    var directionMap = nullthrows(editorState.getDirectionMap());
	
	    var blocksAsArray = content.getBlocksAsArray();
	    var processedBlocks = [];
	
	    var currentDepth = null;
	    var lastWrapperTemplate = null;
	
	    for (var ii = 0; ii < blocksAsArray.length; ii++) {
	      var _block = blocksAsArray[ii];
	      var key = _block.getKey();
	      var blockType = _block.getType();
	
	      var customRenderer = blockRendererFn(_block);
	      var CustomComponent = void 0,
	          customProps = void 0,
	          customEditable = void 0;
	      if (customRenderer) {
	        CustomComponent = customRenderer.component;
	        customProps = customRenderer.props;
	        customEditable = customRenderer.editable;
	      }
	
	      var direction = textDirectionality ? textDirectionality : directionMap.get(key);
	      var offsetKey = DraftOffsetKey.encode(key, 0, 0);
	      var componentProps = {
	        contentState: content,
	        block: _block,
	        blockProps: customProps,
	        blockStyleFn: blockStyleFn,
	        customStyleMap: customStyleMap,
	        customStyleFn: customStyleFn,
	        decorator: decorator,
	        direction: direction,
	        forceSelection: forceSelection,
	        key: key,
	        offsetKey: offsetKey,
	        selection: selection,
	        tree: editorState.getBlockTree(key)
	      };
	
	      var configForType = blockRenderMap.get(blockType) || blockRenderMap.get('unstyled');
	      var wrapperTemplate = configForType.wrapper;
	
	      var Element = configForType.element || blockRenderMap.get('unstyled').element;
	
	      var depth = _block.getDepth();
	      var className = '';
	      if (blockStyleFn) {
	        className = blockStyleFn(_block);
	      }
	
	      // List items are special snowflakes, since we handle nesting and
	      // counters manually.
	      if (Element === 'li') {
	        var shouldResetCount = lastWrapperTemplate !== wrapperTemplate || currentDepth === null || depth > currentDepth;
	        className = joinClasses(className, getListItemClasses(blockType, depth, shouldResetCount, direction));
	      }
	
	      var Component = CustomComponent || DraftEditorBlock;
	      var childProps = {
	        className: className,
	        'data-block': true,
	        'data-editor': editorKey,
	        'data-offset-key': offsetKey,
	        key: key
	      };
	      if (customEditable !== undefined) {
	        childProps = _extends({}, childProps, {
	          contentEditable: customEditable,
	          suppressContentEditableWarning: true
	        });
	      }
	
	      var child = React.createElement(Element, childProps, React.createElement(Component, componentProps));
	
	      processedBlocks.push({
	        block: child,
	        wrapperTemplate: wrapperTemplate,
	        key: key,
	        offsetKey: offsetKey
	      });
	
	      if (wrapperTemplate) {
	        currentDepth = _block.getDepth();
	      } else {
	        currentDepth = null;
	      }
	      lastWrapperTemplate = wrapperTemplate;
	    }
	
	    // Group contiguous runs of blocks that have the same wrapperTemplate
	    var outputBlocks = [];
	    for (var _ii = 0; _ii < processedBlocks.length;) {
	      var info = processedBlocks[_ii];
	      if (info.wrapperTemplate) {
	        var blocks = [];
	        do {
	          blocks.push(processedBlocks[_ii].block);
	          _ii++;
	        } while (_ii < processedBlocks.length && processedBlocks[_ii].wrapperTemplate === info.wrapperTemplate);
	        var wrapperElement = React.cloneElement(info.wrapperTemplate, {
	          key: info.key + '-wrap',
	          'data-offset-key': info.offsetKey
	        }, blocks);
	        outputBlocks.push(wrapperElement);
	      } else {
	        outputBlocks.push(info.block);
	        _ii++;
	      }
	    }
	
	    return React.createElement(
	      'div',
	      { 'data-contents': 'true' },
	      outputBlocks
	    );
	  };
	
	  return DraftEditorContents;
	}(React.Component);
	
	module.exports = DraftEditorContents;

/***/ }),
/* 486 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule DraftEditorContents.react
	 * @format
	 * 
	 */
	
	'use strict';
	
	var DraftEditorContents = __webpack_require__(485);
	
	module.exports = DraftEditorContents;

/***/ }),
/* 487 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule DraftEditorDragHandler
	 * @format
	 * 
	 */
	
	'use strict';
	
	var DataTransfer = __webpack_require__(224);
	var DraftModifier = __webpack_require__(26);
	var EditorState = __webpack_require__(15);
	
	var findAncestorOffsetKey = __webpack_require__(126);
	var getTextContentFromFiles = __webpack_require__(216);
	var getUpdatedSelectionState = __webpack_require__(217);
	var isEventHandled = __webpack_require__(73);
	var nullthrows = __webpack_require__(33);
	
	/**
	 * Get a SelectionState for the supplied mouse event.
	 */
	function getSelectionForEvent(event, editorState) {
	  var node = null;
	  var offset = null;
	
	  if (typeof document.caretRangeFromPoint === 'function') {
	    var dropRange = document.caretRangeFromPoint(event.x, event.y);
	    node = dropRange.startContainer;
	    offset = dropRange.startOffset;
	  } else if (event.rangeParent) {
	    node = event.rangeParent;
	    offset = event.rangeOffset;
	  } else {
	    return null;
	  }
	
	  node = nullthrows(node);
	  offset = nullthrows(offset);
	  var offsetKey = nullthrows(findAncestorOffsetKey(node));
	
	  return getUpdatedSelectionState(editorState, offsetKey, offset, offsetKey, offset);
	}
	
	var DraftEditorDragHandler = {
	  /**
	   * Drag originating from input terminated.
	   */
	  onDragEnd: function onDragEnd(editor) {
	    editor.exitCurrentMode();
	  },
	
	  /**
	   * Handle data being dropped.
	   */
	  onDrop: function onDrop(editor, e) {
	    var data = new DataTransfer(e.nativeEvent.dataTransfer);
	
	    var editorState = editor._latestEditorState;
	    var dropSelection = getSelectionForEvent(e.nativeEvent, editorState);
	
	    e.preventDefault();
	    editor.exitCurrentMode();
	
	    if (dropSelection == null) {
	      return;
	    }
	
	    var files = data.getFiles();
	    if (files.length > 0) {
	      if (editor.props.handleDroppedFiles && isEventHandled(editor.props.handleDroppedFiles(dropSelection, files))) {
	        return;
	      }
	
	      getTextContentFromFiles(files, function (fileText) {
	        fileText && editor.update(insertTextAtSelection(editorState, dropSelection, fileText));
	      });
	      return;
	    }
	
	    var dragType = editor._internalDrag ? 'internal' : 'external';
	    if (editor.props.handleDrop && isEventHandled(editor.props.handleDrop(dropSelection, data, dragType))) {
	      return;
	    }
	
	    if (editor._internalDrag) {
	      editor.update(moveText(editorState, dropSelection));
	      return;
	    }
	
	    editor.update(insertTextAtSelection(editorState, dropSelection, data.getText()));
	  }
	};
	
	function moveText(editorState, targetSelection) {
	  var newContentState = DraftModifier.moveText(editorState.getCurrentContent(), editorState.getSelection(), targetSelection);
	  return EditorState.push(editorState, newContentState, 'insert-fragment');
	}
	
	/**
	 * Insert text at a specified selection.
	 */
	function insertTextAtSelection(editorState, selection, text) {
	  var newContentState = DraftModifier.insertText(editorState.getCurrentContent(), selection, text, editorState.getCurrentInlineStyle());
	  return EditorState.push(editorState, newContentState, 'insert-fragment');
	}
	
	module.exports = DraftEditorDragHandler;

/***/ }),
/* 488 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule DraftEditorEditHandler
	 * @format
	 * 
	 */
	
	'use strict';
	
	var onBeforeInput = __webpack_require__(507);
	var onBlur = __webpack_require__(508);
	var onCompositionStart = __webpack_require__(509);
	var onCopy = __webpack_require__(510);
	var onCut = __webpack_require__(511);
	var onDragOver = __webpack_require__(512);
	var onDragStart = __webpack_require__(513);
	var onFocus = __webpack_require__(514);
	var onInput = __webpack_require__(515);
	var onKeyDown = __webpack_require__(516);
	var onPaste = __webpack_require__(517);
	var onSelect = __webpack_require__(518);
	
	var DraftEditorEditHandler = {
	  onBeforeInput: onBeforeInput,
	  onBlur: onBlur,
	  onCompositionStart: onCompositionStart,
	  onCopy: onCopy,
	  onCut: onCut,
	  onDragOver: onDragOver,
	  onDragStart: onDragStart,
	  onFocus: onFocus,
	  onInput: onInput,
	  onKeyDown: onKeyDown,
	  onPaste: onPaste,
	  onSelect: onSelect
	};
	
	module.exports = DraftEditorEditHandler;

/***/ }),
/* 489 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule DraftEditorLeaf.react
	 * @format
	 * 
	 */
	
	'use strict';
	
	var _assign = __webpack_require__(18);
	
	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 DraftEditorTextNode = __webpack_require__(491);
	var React = __webpack_require__(1);
	var ReactDOM = __webpack_require__(10);
	
	var invariant = __webpack_require__(12);
	var setDraftEditorSelection = __webpack_require__(542);
	
	/**
	 * All leaf nodes in the editor are spans with single text nodes. Leaf
	 * elements are styled based on the merging of an optional custom style map
	 * and a default style map.
	 *
	 * `DraftEditorLeaf` also provides a wrapper for calling into the imperative
	 * DOM Selection API. In this way, top-level components can declaratively
	 * maintain the selection state.
	 */
	var DraftEditorLeaf = function (_React$Component) {
	  _inherits(DraftEditorLeaf, _React$Component);
	
	  function DraftEditorLeaf() {
	    _classCallCheck(this, DraftEditorLeaf);
	
	    return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	  }
	
	  DraftEditorLeaf.prototype._setSelection = function _setSelection() {
	    var selection = this.props.selection;
	
	    // If selection state is irrelevant to the parent block, no-op.
	
	    if (selection == null || !selection.getHasFocus()) {
	      return;
	    }
	
	    var _props = this.props,
	        block = _props.block,
	        start = _props.start,
	        text = _props.text;
	
	    var blockKey = block.getKey();
	    var end = start + text.length;
	    if (!selection.hasEdgeWithin(blockKey, start, end)) {
	      return;
	    }
	
	    // Determine the appropriate target node for selection. If the child
	    // is not a text node, it is a <br /> spacer. In this case, use the
	    // <span> itself as the selection target.
	    var node = ReactDOM.findDOMNode(this);
	    !node ?  true ? invariant(false, 'Missing node') : invariant(false) : void 0;
	    var child = node.firstChild;
	    !child ?  true ? invariant(false, 'Missing child') : invariant(false) : void 0;
	    var targetNode = void 0;
	
	    if (child.nodeType === Node.TEXT_NODE) {
	      targetNode = child;
	    } else if (child.tagName === 'BR') {
	      targetNode = node;
	    } else {
	      targetNode = child.firstChild;
	      !targetNode ?  true ? invariant(false, 'Missing targetNode') : invariant(false) : void 0;
	    }
	
	    setDraftEditorSelection(selection, targetNode, blockKey, start, end);
	  };
	  /**
	   * By making individual leaf instances aware of their context within
	   * the text of the editor, we can set our selection range more
	   * easily than we could in the non-React world.
	   *
	   * Note that this depends on our maintaining tight control over the
	   * DOM structure of the DraftEditor component. If leaves had multiple
	   * text nodes, this would be harder.
	   */
	
	  DraftEditorLeaf.prototype.shouldComponentUpdate = function shouldComponentUpdate(nextProps) {
	    var leafNode = ReactDOM.findDOMNode(this.leaf);
	    !leafNode ?  true ? invariant(false, 'Missing leafNode') : invariant(false) : void 0;
	    return leafNode.textContent !== nextProps.text || nextProps.styleSet !== this.props.styleSet || nextProps.forceSelection;
	  };
	
	  DraftEditorLeaf.prototype.componentDidUpdate = function componentDidUpdate() {
	    this._setSelection();
	  };
	
	  DraftEditorLeaf.prototype.componentDidMount = function componentDidMount() {
	    this._setSelection();
	  };
	
	  DraftEditorLeaf.prototype.render = function render() {
	    var _this2 = this;
	
	    var block = this.props.block;
	    var text = this.props.text;
	
	    // If the leaf is at the end of its block and ends in a soft newline, append
	    // an extra line feed character. Browsers collapse trailing newline
	    // characters, which leaves the cursor in the wrong place after a
	    // shift+enter. The extra character repairs this.
	
	    if (text.endsWith('\n') && this.props.isLast) {
	      text += '\n';
	    }
	
	    var _props2 = this.props,
	        customStyleMap = _props2.customStyleMap,
	        customStyleFn = _props2.customStyleFn,
	        offsetKey = _props2.offsetKey,
	        styleSet = _props2.styleSet;
	
	    var styleObj = styleSet.reduce(function (map, styleName) {
	      var mergedStyles = {};
	      var style = customStyleMap[styleName];
	
	      if (style !== undefined && map.textDecoration !== style.textDecoration) {
	        // .trim() is necessary for IE9/10/11 and Edge
	        mergedStyles.textDecoration = [map.textDecoration, style.textDecoration].join(' ').trim();
	      }
	
	      return _assign(map, style, mergedStyles);
	    }, {});
	
	    if (customStyleFn) {
	      var newStyles = customStyleFn(styleSet, block);
	      styleObj = _assign(styleObj, newStyles);
	    }
	
	    return React.createElement(
	      'span',
	      {
	        'data-offset-key': offsetKey,
	        ref: function ref(_ref) {
	          return _this2.leaf = _ref;
	        },
	        style: styleObj },
	      React.createElement(
	        DraftEditorTextNode,
	        null,
	        text
	      )
	    );
	  };
	
	  return DraftEditorLeaf;
	}(React.Component);
	
	module.exports = DraftEditorLeaf;

/***/ }),
/* 490 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule DraftEditorPlaceholder.react
	 * @format
	 * 
	 */
	
	'use strict';
	
	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 React = __webpack_require__(1);
	
	var cx = __webpack_require__(63);
	
	/**
	 * This component is responsible for rendering placeholder text for the
	 * `DraftEditor` component.
	 *
	 * Override placeholder style via CSS.
	 */
	var DraftEditorPlaceholder = function (_React$Component) {
	  _inherits(DraftEditorPlaceholder, _React$Component);
	
	  function DraftEditorPlaceholder() {
	    _classCallCheck(this, DraftEditorPlaceholder);
	
	    return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	  }
	
	  DraftEditorPlaceholder.prototype.shouldComponentUpdate = function shouldComponentUpdate(nextProps) {
	    return this.props.text !== nextProps.text || this.props.editorState.getSelection().getHasFocus() !== nextProps.editorState.getSelection().getHasFocus();
	  };
	
	  DraftEditorPlaceholder.prototype.render = function render() {
	    var hasFocus = this.props.editorState.getSelection().getHasFocus();
	
	    var className = cx({
	      'public/DraftEditorPlaceholder/root': true,
	      'public/DraftEditorPlaceholder/hasFocus': hasFocus
	    });
	
	    var contentStyle = {
	      whiteSpace: 'pre-wrap'
	    };
	
	    return React.createElement(
	      'div',
	      { className: className },
	      React.createElement(
	        'div',
	        {
	          className: cx('public/DraftEditorPlaceholder/inner'),
	          id: this.props.accessibilityID,
	          style: contentStyle },
	        this.props.text
	      )
	    );
	  };
	
	  return DraftEditorPlaceholder;
	}(React.Component);
	
	module.exports = DraftEditorPlaceholder;

/***/ }),
/* 491 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule DraftEditorTextNode.react
	 * @format
	 * 
	 */
	
	'use strict';
	
	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 React = __webpack_require__(1);
	var ReactDOM = __webpack_require__(10);
	var UserAgent = __webpack_require__(36);
	
	var invariant = __webpack_require__(12);
	
	// In IE, spans with <br> tags render as two newlines. By rendering a span
	// with only a newline character, we can be sure to render a single line.
	var useNewlineChar = UserAgent.isBrowser('IE <= 11');
	
	/**
	 * Check whether the node should be considered a newline.
	 */
	function isNewline(node) {
	  return useNewlineChar ? node.textContent === '\n' : node.tagName === 'BR';
	}
	
	/**
	 * Placeholder elements for empty text content.
	 *
	 * What is this `data-text` attribute, anyway? It turns out that we need to
	 * put an attribute on the lowest-level text node in order to preserve correct
	 * spellcheck handling. If the <span> is naked, Chrome and Safari may do
	 * bizarre things to do the DOM -- split text nodes, create extra spans, etc.
	 * If the <span> has an attribute, this appears not to happen.
	 * See http://jsfiddle.net/9khdavod/ for the failure case, and
	 * http://jsfiddle.net/7pg143f7/ for the fixed case.
	 */
	var NEWLINE_A = useNewlineChar ? React.createElement(
	  'span',
	  { key: 'A', 'data-text': 'true' },
	  '\n'
	) : React.createElement('br', { key: 'A', 'data-text': 'true' });
	
	var NEWLINE_B = useNewlineChar ? React.createElement(
	  'span',
	  { key: 'B', 'data-text': 'true' },
	  '\n'
	) : React.createElement('br', { key: 'B', 'data-text': 'true' });
	
	/**
	 * The lowest-level component in a `DraftEditor`, the text node component
	 * replaces the default React text node implementation. This allows us to
	 * perform custom handling of newline behavior and avoid re-rendering text
	 * nodes with DOM state that already matches the expectations of our immutable
	 * editor state.
	 */
	var DraftEditorTextNode = function (_React$Component) {
	  _inherits(DraftEditorTextNode, _React$Component);
	
	  function DraftEditorTextNode(props) {
	    _classCallCheck(this, DraftEditorTextNode);
	
	    // By flipping this flag, we also keep flipping keys which forces
	    // React to remount this node every time it rerenders.
	    var _this = _possibleConstructorReturn(this, _React$Component.call(this, props));
	
	    _this._forceFlag = false;
	    return _this;
	  }
	
	  DraftEditorTextNode.prototype.shouldComponentUpdate = function shouldComponentUpdate(nextProps) {
	    var node = ReactDOM.findDOMNode(this);
	    var shouldBeNewline = nextProps.children === '';
	    !(node instanceof Element) ?  true ? invariant(false, 'node is not an Element') : invariant(false) : void 0;
	    if (shouldBeNewline) {
	      return !isNewline(node);
	    }
	    return node.textContent !== nextProps.children;
	  };
	
	  DraftEditorTextNode.prototype.componentDidMount = function componentDidMount() {
	    this._forceFlag = !this._forceFlag;
	  };
	
	  DraftEditorTextNode.prototype.componentDidUpdate = function componentDidUpdate() {
	    this._forceFlag = !this._forceFlag;
	  };
	
	  DraftEditorTextNode.prototype.render = function render() {
	    if (this.props.children === '') {
	      return this._forceFlag ? NEWLINE_A : NEWLINE_B;
	    }
	    return React.createElement(
	      'span',
	      { key: this._forceFlag ? 'A' : 'B', 'data-text': 'true' },
	      this.props.children
	    );
	  };
	
	  return DraftEditorTextNode;
	}(React.Component);
	
	module.exports = DraftEditorTextNode;

/***/ }),
/* 492 */
/***/ (function(module, exports) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule DraftEntitySegments
	 * @format
	 * 
	 */
	
	'use strict';
	
	/**
	 * Identify the range to delete from a segmented entity.
	 *
	 * Rules:
	 *
	 *  Example: 'John F. Kennedy'
	 *
	 *   - Deletion from within any non-whitespace (i.e. ['John', 'F.', 'Kennedy'])
	 *     will return the range of that text.
	 *
	 *       'John F. Kennedy' -> 'John F.'
	 *                  ^
	 *
	 *   - Forward deletion of whitespace will remove the following section:
	 *
	 *       'John F. Kennedy' -> 'John Kennedy'
	 *            ^
	 *
	 *   - Backward deletion of whitespace will remove the previous section:
	 *
	 *       'John F. Kennedy' -> 'F. Kennedy'
	 *            ^
	 */
	var DraftEntitySegments = {
	  getRemovalRange: function getRemovalRange(selectionStart, selectionEnd, text, entityStart, direction) {
	    var segments = text.split(' ');
	    segments = segments.map(function ( /*string*/segment, /*number*/ii) {
	      if (direction === 'forward') {
	        if (ii > 0) {
	          return ' ' + segment;
	        }
	      } else if (ii < segments.length - 1) {
	        return segment + ' ';
	      }
	      return segment;
	    });
	
	    var segmentStart = entityStart;
	    var segmentEnd;
	    var segment;
	    var removalStart = null;
	    var removalEnd = null;
	
	    for (var jj = 0; jj < segments.length; jj++) {
	      segment = segments[jj];
	      segmentEnd = segmentStart + segment.length;
	
	      // Our selection overlaps this segment.
	      if (selectionStart < segmentEnd && segmentStart < selectionEnd) {
	        if (removalStart !== null) {
	          removalEnd = segmentEnd;
	        } else {
	          removalStart = segmentStart;
	          removalEnd = segmentEnd;
	        }
	      } else if (removalStart !== null) {
	        break;
	      }
	
	      segmentStart = segmentEnd;
	    }
	
	    var entityEnd = entityStart + text.length;
	    var atStart = removalStart === entityStart;
	    var atEnd = removalEnd === entityEnd;
	
	    if (!atStart && atEnd || atStart && !atEnd) {
	      if (direction === 'forward') {
	        if (removalEnd !== entityEnd) {
	          removalEnd++;
	        }
	      } else if (removalStart !== entityStart) {
	        removalStart--;
	      }
	    }
	
	    return {
	      start: removalStart,
	      end: removalEnd
	    };
	  }
	};
	
	module.exports = DraftEntitySegments;

/***/ }),
/* 493 */
/***/ (function(module, exports) {

	/**
	 * Copyright 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule DraftFeatureFlags-core
	 * @format
	 * 
	 */
	
	'use strict';
	
	var DraftFeatureFlags = {
	  draft_killswitch_allow_nontextnodes: false,
	  draft_segmented_entities_behavior: false,
	  draft_handlebeforeinput_composed_text: false,
	  draft_tree_data_support: false
	};
	
	module.exports = DraftFeatureFlags;

/***/ }),
/* 494 */
/***/ (function(module, exports) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule DraftJsDebugLogging
	 */
	
	'use strict';
	
	module.exports = {
	  logSelectionStateFailure: function logSelectionStateFailure() {
	    return null;
	  }
	};

/***/ }),
/* 495 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule DraftPasteProcessor
	 * @format
	 * 
	 */
	
	'use strict';
	
	var _assign = __webpack_require__(18);
	
	var _extends = _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 CharacterMetadata = __webpack_require__(27);
	var ContentBlock = __webpack_require__(50);
	var ContentBlockNode = __webpack_require__(30);
	var DraftFeatureFlags = __webpack_require__(42);
	var Immutable = __webpack_require__(11);
	
	var convertFromHTMLtoContentBlocks = __webpack_require__(208);
	var generateRandomKey = __webpack_require__(37);
	var getSafeBodyFromHTML = __webpack_require__(214);
	var sanitizeDraftText = __webpack_require__(129);
	
	var List = Immutable.List,
	    Repeat = Immutable.Repeat;
	
	
	var experimentalTreeDataSupport = DraftFeatureFlags.draft_tree_data_support;
	var ContentBlockRecord = experimentalTreeDataSupport ? ContentBlockNode : ContentBlock;
	
	var DraftPasteProcessor = {
	  processHTML: function processHTML(html, blockRenderMap) {
	    return convertFromHTMLtoContentBlocks(html, getSafeBodyFromHTML, blockRenderMap);
	  },
	  processText: function processText(textBlocks, character, type) {
	    return textBlocks.reduce(function (acc, textLine, index) {
	      textLine = sanitizeDraftText(textLine);
	      var key = generateRandomKey();
	
	      var blockNodeConfig = {
	        key: key,
	        type: type,
	        text: textLine,
	        characterList: List(Repeat(character, textLine.length))
	      };
	
	      // next block updates previous block
	      if (experimentalTreeDataSupport && index !== 0) {
	        var prevSiblingIndex = index - 1;
	        // update previous block
	        var previousBlock = acc[prevSiblingIndex] = acc[prevSiblingIndex].merge({
	          nextSibling: key
	        });
	        blockNodeConfig = _extends({}, blockNodeConfig, {
	          prevSibling: previousBlock.getKey()
	        });
	      }
	
	      acc.push(new ContentBlockRecord(blockNodeConfig));
	
	      return acc;
	    }, []);
	  }
	};
	
	module.exports = DraftPasteProcessor;

/***/ }),
/* 496 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	var _assign = __webpack_require__(18);
	
	var _extends = _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; };
	
	/**
	 * 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.
	 *
	 * @providesModule DraftTreeAdapter
	 * @format
	 * 
	 *
	 * This is unstable and not part of the public API and should not be used by
	 * production systems. This file may be update/removed without notice.
	 */
	
	var invariant = __webpack_require__(12);
	
	var traverseInDepthOrder = function traverseInDepthOrder(blocks, fn) {
	  var stack = [].concat(blocks).reverse();
	  while (stack.length) {
	    var _block = stack.pop();
	
	    fn(_block);
	
	    var children = _block.children;
	
	    !Array.isArray(children) ?  true ? invariant(false, 'Invalid tree raw block') : invariant(false) : void 0;
	
	    stack = stack.concat([].concat(children.reverse()));
	  }
	};
	
	var isListBlock = function isListBlock(block) {
	  if (!(block && block.type)) {
	    return false;
	  }
	  var type = block.type;
	
	  return type === 'unordered-list-item' || type === 'ordered-list-item';
	};
	
	var addDepthToChildren = function addDepthToChildren(block) {
	  if (Array.isArray(block.children)) {
	    block.children = block.children.map(function (child) {
	      return child.type === block.type ? _extends({}, child, { depth: (block.depth || 0) + 1 }) : child;
	    });
	  }
	};
	
	/**
	 * This adapter is intended to be be used as an adapter to draft tree data
	 *
	 * draft state <=====> draft tree state
	 */
	var DraftTreeAdapter = {
	  /**
	   * Converts from a tree raw state back to  draft raw state
	   */
	  fromRawTreeStateToRawState: function fromRawTreeStateToRawState(draftTreeState) {
	    var blocks = draftTreeState.blocks;
	
	    var transformedBlocks = [];
	
	    !Array.isArray(blocks) ?  true ? invariant(false, 'Invalid raw state') : invariant(false) : void 0;
	
	    if (!Array.isArray(blocks) || !blocks.length) {
	      return draftTreeState;
	    }
	
	    traverseInDepthOrder(blocks, function (block) {
	      var newBlock = _extends({}, block);
	
	      if (isListBlock(block)) {
	        newBlock.depth = newBlock.depth || 0;
	        addDepthToChildren(block);
	      }
	
	      delete newBlock.children;
	
	      transformedBlocks.push(newBlock);
	    });
	
	    draftTreeState.blocks = transformedBlocks;
	
	    return _extends({}, draftTreeState, {
	      blocks: transformedBlocks
	    });
	  },
	
	
	  /**
	   * Converts from draft raw state to tree draft state
	   */
	  fromRawStateToRawTreeState: function fromRawStateToRawTreeState(draftState) {
	    var lastListDepthCacheRef = {};
	    var transformedBlocks = [];
	
	    draftState.blocks.forEach(function (block) {
	      var isList = isListBlock(block);
	      var depth = block.depth || 0;
	      var treeBlock = _extends({}, block, {
	        children: []
	      });
	
	      if (!isList) {
	        // reset the cache path
	        lastListDepthCacheRef = {};
	        transformedBlocks.push(treeBlock);
	        return;
	      }
	
	      // update our depth cache reference path
	      lastListDepthCacheRef[depth] = treeBlock;
	
	      // if we are greater than zero we must have seen a parent already
	      if (depth > 0) {
	        var parent = lastListDepthCacheRef[depth - 1];
	
	        !parent ?  true ? invariant(false, 'Invalid depth for RawDraftContentBlock') : invariant(false) : void 0;
	
	        // push nested list blocks
	        parent.children.push(treeBlock);
	        return;
	      }
	
	      // push root list blocks
	      transformedBlocks.push(treeBlock);
	    });
	
	    return _extends({}, draftState, {
	      blocks: transformedBlocks
	    });
	  }
	};
	
	module.exports = DraftTreeAdapter;

/***/ }),
/* 497 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule EditorBidiService
	 * @format
	 * 
	 */
	
	'use strict';
	
	var Immutable = __webpack_require__(11);
	var UnicodeBidiService = __webpack_require__(554);
	
	var nullthrows = __webpack_require__(33);
	
	var OrderedMap = Immutable.OrderedMap;
	
	
	var bidiService;
	
	var EditorBidiService = {
	  getDirectionMap: function getDirectionMap(content, prevBidiMap) {
	    if (!bidiService) {
	      bidiService = new UnicodeBidiService();
	    } else {
	      bidiService.reset();
	    }
	
	    var blockMap = content.getBlockMap();
	    var nextBidi = blockMap.valueSeq().map(function (block) {
	      return nullthrows(bidiService).getDirection(block.getText());
	    });
	    var bidiMap = OrderedMap(blockMap.keySeq().zip(nextBidi));
	
	    if (prevBidiMap != null && Immutable.is(prevBidiMap, bidiMap)) {
	      return prevBidiMap;
	    }
	
	    return bidiMap;
	  }
	};
	
	module.exports = EditorBidiService;

/***/ }),
/* 498 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule SecondaryClipboard
	 * @format
	 * 
	 */
	
	'use strict';
	
	var DraftModifier = __webpack_require__(26);
	var EditorState = __webpack_require__(15);
	
	var getContentStateFragment = __webpack_require__(90);
	var nullthrows = __webpack_require__(33);
	
	var clipboard = null;
	
	/**
	 * Some systems offer a "secondary" clipboard to allow quick internal cut
	 * and paste behavior. For instance, Ctrl+K (cut) and Ctrl+Y (paste).
	 */
	var SecondaryClipboard = {
	  cut: function cut(editorState) {
	    var content = editorState.getCurrentContent();
	    var selection = editorState.getSelection();
	    var targetRange = null;
	
	    if (selection.isCollapsed()) {
	      var anchorKey = selection.getAnchorKey();
	      var blockEnd = content.getBlockForKey(anchorKey).getLength();
	
	      if (blockEnd === selection.getAnchorOffset()) {
	        return editorState;
	      }
	
	      targetRange = selection.set('focusOffset', blockEnd);
	    } else {
	      targetRange = selection;
	    }
	
	    targetRange = nullthrows(targetRange);
	    clipboard = getContentStateFragment(content, targetRange);
	
	    var afterRemoval = DraftModifier.removeRange(content, targetRange, 'forward');
	
	    if (afterRemoval === content) {
	      return editorState;
	    }
	
	    return EditorState.push(editorState, afterRemoval, 'remove-range');
	  },
	
	  paste: function paste(editorState) {
	    if (!clipboard) {
	      return editorState;
	    }
	
	    var newContent = DraftModifier.replaceWithFragment(editorState.getCurrentContent(), editorState.getSelection(), clipboard);
	
	    return EditorState.push(editorState, newContent, 'insert-fragment');
	  }
	};
	
	module.exports = SecondaryClipboard;

/***/ }),
/* 499 */
/***/ (function(module, exports) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule adjustBlockDepthForContentState
	 * @format
	 * 
	 */
	
	'use strict';
	
	function adjustBlockDepthForContentState(contentState, selectionState, adjustment, maxDepth) {
	  var startKey = selectionState.getStartKey();
	  var endKey = selectionState.getEndKey();
	  var blockMap = contentState.getBlockMap();
	  var blocks = blockMap.toSeq().skipUntil(function (_, k) {
	    return k === startKey;
	  }).takeUntil(function (_, k) {
	    return k === endKey;
	  }).concat([[endKey, blockMap.get(endKey)]]).map(function (block) {
	    var depth = block.getDepth() + adjustment;
	    depth = Math.max(0, Math.min(depth, maxDepth));
	    return block.set('depth', depth);
	  });
	
	  blockMap = blockMap.merge(blocks);
	
	  return contentState.merge({
	    blockMap: blockMap,
	    selectionBefore: selectionState,
	    selectionAfter: selectionState
	  });
	}
	
	module.exports = adjustBlockDepthForContentState;

/***/ }),
/* 500 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule applyEntityToContentBlock
	 * @format
	 * 
	 */
	
	'use strict';
	
	var CharacterMetadata = __webpack_require__(27);
	
	function applyEntityToContentBlock(contentBlock, start, end, entityKey) {
	  var characterList = contentBlock.getCharacterList();
	  while (start < end) {
	    characterList = characterList.set(start, CharacterMetadata.applyEntity(characterList.get(start), entityKey));
	    start++;
	  }
	  return contentBlock.set('characterList', characterList);
	}
	
	module.exports = applyEntityToContentBlock;

/***/ }),
/* 501 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule applyEntityToContentState
	 * @format
	 * 
	 */
	
	'use strict';
	
	var Immutable = __webpack_require__(11);
	
	var applyEntityToContentBlock = __webpack_require__(500);
	
	function applyEntityToContentState(contentState, selectionState, entityKey) {
	  var blockMap = contentState.getBlockMap();
	  var startKey = selectionState.getStartKey();
	  var startOffset = selectionState.getStartOffset();
	  var endKey = selectionState.getEndKey();
	  var endOffset = selectionState.getEndOffset();
	
	  var newBlocks = blockMap.skipUntil(function (_, k) {
	    return k === startKey;
	  }).takeUntil(function (_, k) {
	    return k === endKey;
	  }).toOrderedMap().merge(Immutable.OrderedMap([[endKey, blockMap.get(endKey)]])).map(function (block, blockKey) {
	    var sliceStart = blockKey === startKey ? startOffset : 0;
	    var sliceEnd = blockKey === endKey ? endOffset : block.getLength();
	    return applyEntityToContentBlock(block, sliceStart, sliceEnd, entityKey);
	  });
	
	  return contentState.merge({
	    blockMap: blockMap.merge(newBlocks),
	    selectionBefore: selectionState,
	    selectionAfter: selectionState
	  });
	}
	
	module.exports = applyEntityToContentState;

/***/ }),
/* 502 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule convertFromDraftStateToRaw
	 * @format
	 * 
	 */
	
	'use strict';
	
	var _assign = __webpack_require__(18);
	
	var _extends = _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 ContentBlock = __webpack_require__(50);
	var ContentBlockNode = __webpack_require__(30);
	var DraftStringKey = __webpack_require__(206);
	
	var encodeEntityRanges = __webpack_require__(519);
	var encodeInlineStyleRanges = __webpack_require__(520);
	var invariant = __webpack_require__(12);
	
	var createRawBlock = function createRawBlock(block, entityStorageMap) {
	  return {
	    key: block.getKey(),
	    text: block.getText(),
	    type: block.getType(),
	    depth: block.getDepth(),
	    inlineStyleRanges: encodeInlineStyleRanges(block),
	    entityRanges: encodeEntityRanges(block, entityStorageMap),
	    data: block.getData().toObject()
	  };
	};
	
	var insertRawBlock = function insertRawBlock(block, entityMap, rawBlocks, blockCacheRef) {
	  if (block instanceof ContentBlock) {
	    rawBlocks.push(createRawBlock(block, entityMap));
	    return;
	  }
	
	  !(block instanceof ContentBlockNode) ?  true ? invariant(false, 'block is not a BlockNode') : invariant(false) : void 0;
	
	  var parentKey = block.getParentKey();
	  var rawBlock = blockCacheRef[block.getKey()] = _extends({}, createRawBlock(block, entityMap), {
	    children: []
	  });
	
	  if (parentKey) {
	    blockCacheRef[parentKey].children.push(rawBlock);
	    return;
	  }
	
	  rawBlocks.push(rawBlock);
	};
	
	var encodeRawBlocks = function encodeRawBlocks(contentState, rawState) {
	  var entityMap = rawState.entityMap;
	
	
	  var rawBlocks = [];
	
	  var blockCacheRef = {};
	  var entityCacheRef = {};
	  var entityStorageKey = 0;
	
	  contentState.getBlockMap().forEach(function (block) {
	    block.findEntityRanges(function (character) {
	      return character.getEntity() !== null;
	    }, function (start) {
	      var entityKey = block.getEntityAt(start);
	      // Stringify to maintain order of otherwise numeric keys.
	      var stringifiedEntityKey = DraftStringKey.stringify(entityKey);
	      // This makes this function resilient to two entities
	      // erroneously having the same key
	      if (entityCacheRef[stringifiedEntityKey]) {
	        return;
	      }
	      entityCacheRef[stringifiedEntityKey] = entityKey;
	      // we need the `any` casting here since this is a temporary state
	      // where we will later on flip the entity map and populate it with
	      // real entity, at this stage we just need to map back the entity
	      // key used by the BlockNode
	      entityMap[stringifiedEntityKey] = '' + entityStorageKey;
	      entityStorageKey++;
	    });
	
	    insertRawBlock(block, entityMap, rawBlocks, blockCacheRef);
	  });
	
	  return {
	    blocks: rawBlocks,
	    entityMap: entityMap
	  };
	};
	
	// Flip storage map so that our storage keys map to global
	// DraftEntity keys.
	var encodeRawEntityMap = function encodeRawEntityMap(contentState, rawState) {
	  var blocks = rawState.blocks,
	      entityMap = rawState.entityMap;
	
	
	  var rawEntityMap = {};
	
	  Object.keys(entityMap).forEach(function (key, index) {
	    var entity = contentState.getEntity(DraftStringKey.unstringify(key));
	    rawEntityMap[index] = {
	      type: entity.getType(),
	      mutability: entity.getMutability(),
	      data: entity.getData()
	    };
	  });
	
	  return {
	    blocks: blocks,
	    entityMap: rawEntityMap
	  };
	};
	
	var convertFromDraftStateToRaw = function convertFromDraftStateToRaw(contentState) {
	  var rawDraftContentState = {
	    entityMap: {},
	    blocks: []
	  };
	
	  // add blocks
	  rawDraftContentState = encodeRawBlocks(contentState, rawDraftContentState);
	
	  // add entities
	  rawDraftContentState = encodeRawEntityMap(contentState, rawDraftContentState);
	
	  return rawDraftContentState;
	};
	
	module.exports = convertFromDraftStateToRaw;

/***/ }),
/* 503 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule convertFromRawToDraftState
	 * @format
	 * 
	 */
	
	'use strict';
	
	var _assign = __webpack_require__(18);
	
	var _extends = _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 ContentBlock = __webpack_require__(50);
	var ContentBlockNode = __webpack_require__(30);
	var ContentState = __webpack_require__(123);
	var DraftEntity = __webpack_require__(89);
	var DraftFeatureFlags = __webpack_require__(42);
	var DraftTreeAdapter = __webpack_require__(496);
	var Immutable = __webpack_require__(11);
	var SelectionState = __webpack_require__(62);
	
	var createCharacterList = __webpack_require__(504);
	var decodeEntityRanges = __webpack_require__(505);
	var decodeInlineStyleRanges = __webpack_require__(506);
	var generateRandomKey = __webpack_require__(37);
	var invariant = __webpack_require__(12);
	
	var experimentalTreeDataSupport = DraftFeatureFlags.draft_tree_data_support;
	
	var List = Immutable.List,
	    Map = Immutable.Map,
	    OrderedMap = Immutable.OrderedMap;
	
	
	var decodeBlockNodeConfig = function decodeBlockNodeConfig(block, entityMap) {
	  var key = block.key,
	      type = block.type,
	      data = block.data,
	      text = block.text,
	      depth = block.depth;
	
	
	  var blockNodeConfig = {
	    text: text,
	    depth: depth || 0,
	    type: type || 'unstyled',
	    key: key || generateRandomKey(),
	    data: Map(data),
	    characterList: decodeCharacterList(block, entityMap)
	  };
	
	  return blockNodeConfig;
	};
	
	var decodeCharacterList = function decodeCharacterList(block, entityMap) {
	  var text = block.text,
	      rawEntityRanges = block.entityRanges,
	      rawInlineStyleRanges = block.inlineStyleRanges;
	
	
	  var entityRanges = rawEntityRanges || [];
	  var inlineStyleRanges = rawInlineStyleRanges || [];
	
	  // Translate entity range keys to the DraftEntity map.
	  return createCharacterList(decodeInlineStyleRanges(text, inlineStyleRanges), decodeEntityRanges(text, entityRanges.filter(function (range) {
	    return entityMap.hasOwnProperty(range.key);
	  }).map(function (range) {
	    return _extends({}, range, { key: entityMap[range.key] });
	  })));
	};
	
	var addKeyIfMissing = function addKeyIfMissing(block) {
	  return _extends({}, block, {
	    key: block.key || generateRandomKey()
	  });
	};
	
	/**
	 * Node stack is responsible to ensure we traverse the tree only once
	 * in depth order, while also providing parent refs to inner nodes to
	 * construct their links.
	 */
	var updateNodeStack = function updateNodeStack(stack, nodes, parentRef) {
	  var nodesWithParentRef = nodes.map(function (block) {
	    return _extends({}, block, {
	      parentRef: parentRef
	    });
	  });
	
	  // since we pop nodes from the stack we need to insert them in reverse
	  return stack.concat(nodesWithParentRef.reverse());
	};
	
	/**
	 * This will build a tree draft content state by creating the node
	 * reference links into a single tree walk. Each node has a link
	 * reference to "parent", "children", "nextSibling" and "prevSibling"
	 * blockMap will be created using depth ordering.
	 */
	var decodeContentBlockNodes = function decodeContentBlockNodes(blocks, entityMap) {
	  return blocks
	  // ensure children have valid keys to enable sibling links
	  .map(addKeyIfMissing).reduce(function (blockMap, block, index) {
	    !Array.isArray(block.children) ?  true ? invariant(false, 'invalid RawDraftContentBlock can not be converted to ContentBlockNode') : invariant(false) : void 0;
	
	    // ensure children have valid keys to enable sibling links
	    var children = block.children.map(addKeyIfMissing);
	
	    // root level nodes
	    var contentBlockNode = new ContentBlockNode(_extends({}, decodeBlockNodeConfig(block, entityMap), {
	      prevSibling: index === 0 ? null : blocks[index - 1].key,
	      nextSibling: index === blocks.length - 1 ? null : blocks[index + 1].key,
	      children: List(children.map(function (child) {
	        return child.key;
	      }))
	    }));
	
	    // push root node to blockMap
	    blockMap = blockMap.set(contentBlockNode.getKey(), contentBlockNode);
	
	    // this stack is used to ensure we visit all nodes respecting depth ordering
	    var stack = updateNodeStack([], children, contentBlockNode);
	
	    // start computing children nodes
	    while (stack.length > 0) {
	      // we pop from the stack and start processing this node
	      var node = stack.pop();
	
	      // parentRef already points to a converted ContentBlockNode
	      var parentRef = node.parentRef;
	      var siblings = parentRef.getChildKeys();
	      var _index = siblings.indexOf(node.key);
	      var isValidBlock = Array.isArray(node.children);
	
	      if (!isValidBlock) {
	        !isValidBlock ?  true ? invariant(false, 'invalid RawDraftContentBlock can not be converted to ContentBlockNode') : invariant(false) : void 0;
	        break;
	      }
	
	      // ensure children have valid keys to enable sibling links
	      var _children = node.children.map(addKeyIfMissing);
	
	      var _contentBlockNode = new ContentBlockNode(_extends({}, decodeBlockNodeConfig(node, entityMap), {
	        parent: parentRef.getKey(),
	        children: List(_children.map(function (child) {
	          return child.key;
	        })),
	        prevSibling: _index === 0 ? null : siblings.get(_index - 1),
	        nextSibling: _index === siblings.size - 1 ? null : siblings.get(_index + 1)
	      }));
	
	      // push node to blockMap
	      blockMap = blockMap.set(_contentBlockNode.getKey(), _contentBlockNode);
	
	      // this stack is used to ensure we visit all nodes respecting depth ordering
	      stack = updateNodeStack(stack, _children, _contentBlockNode);
	    }
	
	    return blockMap;
	  }, OrderedMap());
	};
	
	var decodeContentBlocks = function decodeContentBlocks(blocks, entityMap) {
	  return OrderedMap(blocks.map(function (block) {
	    var contentBlock = new ContentBlock(decodeBlockNodeConfig(block, entityMap));
	    return [contentBlock.getKey(), contentBlock];
	  }));
	};
	
	var decodeRawBlocks = function decodeRawBlocks(rawState, entityMap) {
	  var isTreeRawBlock = Array.isArray(rawState.blocks[0].children);
	  var rawBlocks = experimentalTreeDataSupport && !isTreeRawBlock ? DraftTreeAdapter.fromRawStateToRawTreeState(rawState).blocks : rawState.blocks;
	
	  if (!experimentalTreeDataSupport) {
	    return decodeContentBlocks(isTreeRawBlock ? DraftTreeAdapter.fromRawTreeStateToRawState(rawState).blocks : rawBlocks, entityMap);
	  }
	
	  return decodeContentBlockNodes(rawBlocks, entityMap);
	};
	
	var decodeRawEntityMap = function decodeRawEntityMap(rawState) {
	  var rawEntityMap = rawState.entityMap;
	
	  var entityMap = {};
	
	  // TODO: Update this once we completely remove DraftEntity
	  Object.keys(rawEntityMap).forEach(function (rawEntityKey) {
	    var _rawEntityMap$rawEnti = rawEntityMap[rawEntityKey],
	        type = _rawEntityMap$rawEnti.type,
	        mutability = _rawEntityMap$rawEnti.mutability,
	        data = _rawEntityMap$rawEnti.data;
	
	    // get the key reference to created entity
	
	    entityMap[rawEntityKey] = DraftEntity.__create(type, mutability, data || {});
	  });
	
	  return entityMap;
	};
	
	var convertFromRawToDraftState = function convertFromRawToDraftState(rawState) {
	  !Array.isArray(rawState.blocks) ?  true ? invariant(false, 'invalid RawDraftContentState') : invariant(false) : void 0;
	
	  // decode entities
	  var entityMap = decodeRawEntityMap(rawState);
	
	  // decode blockMap
	  var blockMap = decodeRawBlocks(rawState, entityMap);
	
	  // create initial selection
	  var selectionState = blockMap.isEmpty() ? new SelectionState() : SelectionState.createEmpty(blockMap.first().getKey());
	
	  return new ContentState({
	    blockMap: blockMap,
	    entityMap: entityMap,
	    selectionBefore: selectionState,
	    selectionAfter: selectionState
	  });
	};
	
	module.exports = convertFromRawToDraftState;

/***/ }),
/* 504 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule createCharacterList
	 * @format
	 * 
	 */
	
	'use strict';
	
	var CharacterMetadata = __webpack_require__(27);
	var Immutable = __webpack_require__(11);
	
	var List = Immutable.List;
	
	
	function createCharacterList(inlineStyles, entities) {
	  var characterArray = inlineStyles.map(function (style, ii) {
	    var entity = entities[ii];
	    return CharacterMetadata.create({ style: style, entity: entity });
	  });
	  return List(characterArray);
	}
	
	module.exports = createCharacterList;

/***/ }),
/* 505 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule decodeEntityRanges
	 * @format
	 * 
	 */
	
	'use strict';
	
	var UnicodeUtils = __webpack_require__(51);
	
	var substr = UnicodeUtils.substr;
	
	/**
	 * Convert to native JavaScript string lengths to determine ranges.
	 */
	
	function decodeEntityRanges(text, ranges) {
	  var entities = Array(text.length).fill(null);
	  if (ranges) {
	    ranges.forEach(function (range) {
	      // Using Unicode-enabled substrings converted to JavaScript lengths,
	      // fill the output array with entity keys.
	      var start = substr(text, 0, range.offset).length;
	      var end = start + substr(text, range.offset, range.length).length;
	      for (var ii = start; ii < end; ii++) {
	        entities[ii] = range.key;
	      }
	    });
	  }
	  return entities;
	}
	
	module.exports = decodeEntityRanges;

/***/ }),
/* 506 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule decodeInlineStyleRanges
	 * @format
	 * 
	 */
	
	'use strict';
	
	var _require = __webpack_require__(11),
	    OrderedSet = _require.OrderedSet;
	
	var UnicodeUtils = __webpack_require__(51);
	
	var substr = UnicodeUtils.substr;
	
	
	var EMPTY_SET = OrderedSet();
	
	/**
	 * Convert to native JavaScript string lengths to determine ranges.
	 */
	function decodeInlineStyleRanges(text, ranges) {
	  var styles = Array(text.length).fill(EMPTY_SET);
	  if (ranges) {
	    ranges.forEach(function ( /*object*/range) {
	      var cursor = substr(text, 0, range.offset).length;
	      var end = cursor + substr(text, range.offset, range.length).length;
	      while (cursor < end) {
	        styles[cursor] = styles[cursor].add(range.style);
	        cursor++;
	      }
	    });
	  }
	  return styles;
	}
	
	module.exports = decodeInlineStyleRanges;

/***/ }),
/* 507 */
/***/ (function(module, exports, __webpack_require__) {

	/* WEBPACK VAR INJECTION */(function(global) {/**
	 * 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.
	 *
	 * @providesModule editOnBeforeInput
	 * @format
	 * 
	 */
	
	'use strict';
	
	var BlockTree = __webpack_require__(201);
	var DraftModifier = __webpack_require__(26);
	var EditorState = __webpack_require__(15);
	var UserAgent = __webpack_require__(36);
	
	var getEntityKeyForSelection = __webpack_require__(127);
	var isEventHandled = __webpack_require__(73);
	var isSelectionAtLeafStart = __webpack_require__(219);
	var nullthrows = __webpack_require__(33);
	var setImmediate = __webpack_require__(572);
	
	// When nothing is focused, Firefox regards two characters, `'` and `/`, as
	// commands that should open and focus the "quickfind" search bar. This should
	// *never* happen while a contenteditable is focused, but as of v28, it
	// sometimes does, even when the keypress event target is the contenteditable.
	// This breaks the input. Special case these characters to ensure that when
	// they are typed, we prevent default on the event to make sure not to
	// trigger quickfind.
	var FF_QUICKFIND_CHAR = "'";
	var FF_QUICKFIND_LINK_CHAR = '/';
	var isFirefox = UserAgent.isBrowser('Firefox');
	
	function mustPreventDefaultForCharacter(character) {
	  return isFirefox && (character == FF_QUICKFIND_CHAR || character == FF_QUICKFIND_LINK_CHAR);
	}
	
	/**
	 * Replace the current selection with the specified text string, with the
	 * inline style and entity key applied to the newly inserted text.
	 */
	function replaceText(editorState, text, inlineStyle, entityKey) {
	  var contentState = DraftModifier.replaceText(editorState.getCurrentContent(), editorState.getSelection(), text, inlineStyle, entityKey);
	  return EditorState.push(editorState, contentState, 'insert-characters');
	}
	
	/**
	 * When `onBeforeInput` executes, the browser is attempting to insert a
	 * character into the editor. Apply this character data to the document,
	 * allowing native insertion if possible.
	 *
	 * Native insertion is encouraged in order to limit re-rendering and to
	 * preserve spellcheck highlighting, which disappears or flashes if re-render
	 * occurs on the relevant text nodes.
	 */
	function editOnBeforeInput(editor, e) {
	  if (editor._pendingStateFromBeforeInput !== undefined) {
	    editor.update(editor._pendingStateFromBeforeInput);
	    editor._pendingStateFromBeforeInput = undefined;
	  }
	
	  var editorState = editor._latestEditorState;
	
	  var chars = e.data;
	
	  // In some cases (ex: IE ideographic space insertion) no character data
	  // is provided. There's nothing to do when this happens.
	  if (!chars) {
	    return;
	  }
	
	  // Allow the top-level component to handle the insertion manually. This is
	  // useful when triggering interesting behaviors for a character insertion,
	  // Simple examples: replacing a raw text ':)' with a smile emoji or image
	  // decorator, or setting a block to be a list item after typing '- ' at the
	  // start of the block.
	  if (editor.props.handleBeforeInput && isEventHandled(editor.props.handleBeforeInput(chars, editorState))) {
	    e.preventDefault();
	    return;
	  }
	
	  // If selection is collapsed, conditionally allow native behavior. This
	  // reduces re-renders and preserves spellcheck highlighting. If the selection
	  // is not collapsed, we will re-render.
	  var selection = editorState.getSelection();
	  var selectionStart = selection.getStartOffset();
	  var selectionEnd = selection.getEndOffset();
	  var anchorKey = selection.getAnchorKey();
	
	  if (!selection.isCollapsed()) {
	    e.preventDefault();
	
	    // If the currently selected text matches what the user is trying to
	    // replace it with, let's just update the `SelectionState`. If not, update
	    // the `ContentState` with the new text.
	    var currentlySelectedChars = editorState.getCurrentContent().getPlainText().slice(selectionStart, selectionEnd);
	    if (chars === currentlySelectedChars) {
	      editor.update(EditorState.forceSelection(editorState, selection.merge({
	        focusOffset: selectionEnd
	      })));
	    } else {
	      editor.update(replaceText(editorState, chars, editorState.getCurrentInlineStyle(), getEntityKeyForSelection(editorState.getCurrentContent(), editorState.getSelection())));
	    }
	    return;
	  }
	
	  var newEditorState = replaceText(editorState, chars, editorState.getCurrentInlineStyle(), getEntityKeyForSelection(editorState.getCurrentContent(), editorState.getSelection()));
	
	  // Bunch of different cases follow where we need to prevent native insertion.
	  var mustPreventNative = false;
	  if (!mustPreventNative) {
	    // Browsers tend to insert text in weird places in the DOM when typing at
	    // the start of a leaf, so we'll handle it ourselves.
	    mustPreventNative = isSelectionAtLeafStart(editor._latestCommittedEditorState);
	  }
	  if (!mustPreventNative) {
	    // Chrome will also split up a node into two pieces if it contains a Tab
	    // char, for no explicable reason. Seemingly caused by this commit:
	    // https://chromium.googlesource.com/chromium/src/+/013ac5eaf3%5E%21/
	    var nativeSelection = global.getSelection();
	    // Selection is necessarily collapsed at this point due to earlier check.
	    if (nativeSelection.anchorNode && nativeSelection.anchorNode.nodeType === Node.TEXT_NODE) {
	      // See isTabHTMLSpanElement in chromium EditingUtilities.cpp.
	      var parentNode = nativeSelection.anchorNode.parentNode;
	      mustPreventNative = parentNode.nodeName === 'SPAN' && parentNode.firstChild.nodeType === Node.TEXT_NODE && parentNode.firstChild.nodeValue.indexOf('\t') !== -1;
	    }
	  }
	  if (!mustPreventNative) {
	    // Check the old and new "fingerprints" of the current block to determine
	    // whether this insertion requires any addition or removal of text nodes,
	    // in which case we would prevent the native character insertion.
	    var originalFingerprint = BlockTree.getFingerprint(editorState.getBlockTree(anchorKey));
	    var newFingerprint = BlockTree.getFingerprint(newEditorState.getBlockTree(anchorKey));
	    mustPreventNative = originalFingerprint !== newFingerprint;
	  }
	  if (!mustPreventNative) {
	    mustPreventNative = mustPreventDefaultForCharacter(chars);
	  }
	  if (!mustPreventNative) {
	    mustPreventNative = nullthrows(newEditorState.getDirectionMap()).get(anchorKey) !== nullthrows(editorState.getDirectionMap()).get(anchorKey);
	  }
	
	  if (mustPreventNative) {
	    e.preventDefault();
	    editor.update(newEditorState);
	    return;
	  }
	
	  // We made it all the way! Let the browser do its thing and insert the char.
	  newEditorState = EditorState.set(newEditorState, {
	    nativelyRenderedContent: newEditorState.getCurrentContent()
	  });
	  // The native event is allowed to occur. To allow user onChange handlers to
	  // change the inserted text, we wait until the text is actually inserted
	  // before we actually update our state. That way when we rerender, the text
	  // we see in the DOM will already have been inserted properly.
	  editor._pendingStateFromBeforeInput = newEditorState;
	  setImmediate(function () {
	    if (editor._pendingStateFromBeforeInput !== undefined) {
	      editor.update(editor._pendingStateFromBeforeInput);
	      editor._pendingStateFromBeforeInput = undefined;
	    }
	  });
	}
	
	module.exports = editOnBeforeInput;
	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))

/***/ }),
/* 508 */
/***/ (function(module, exports, __webpack_require__) {

	/* WEBPACK VAR INJECTION */(function(global) {/**
	 * 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.
	 *
	 * @providesModule editOnBlur
	 * @format
	 * 
	 */
	
	'use strict';
	
	var EditorState = __webpack_require__(15);
	
	var containsNode = __webpack_require__(133);
	var getActiveElement = __webpack_require__(227);
	
	function editOnBlur(editor, e) {
	  // In a contentEditable element, when you select a range and then click
	  // another active element, this does trigger a `blur` event but will not
	  // remove the DOM selection from the contenteditable.
	  // This is consistent across all browsers, but we prefer that the editor
	  // behave like a textarea, where a `blur` event clears the DOM selection.
	  // We therefore force the issue to be certain, checking whether the active
	  // element is `body` to force it when blurring occurs within the window (as
	  // opposed to clicking to another tab or window).
	  if (getActiveElement() === document.body) {
	    var _selection = global.getSelection();
	    var editorNode = editor.editor;
	    if (_selection.rangeCount === 1 && containsNode(editorNode, _selection.anchorNode) && containsNode(editorNode, _selection.focusNode)) {
	      _selection.removeAllRanges();
	    }
	  }
	
	  var editorState = editor._latestEditorState;
	  var currentSelection = editorState.getSelection();
	  if (!currentSelection.getHasFocus()) {
	    return;
	  }
	
	  var selection = currentSelection.set('hasFocus', false);
	  editor.props.onBlur && editor.props.onBlur(e);
	  editor.update(EditorState.acceptSelection(editorState, selection));
	}
	
	module.exports = editOnBlur;
	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))

/***/ }),
/* 509 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule editOnCompositionStart
	 * @format
	 * 
	 */
	
	'use strict';
	
	var EditorState = __webpack_require__(15);
	
	/**
	 * The user has begun using an IME input system. Switching to `composite` mode
	 * allows handling composition input and disables other edit behavior.
	 */
	function editOnCompositionStart(editor, e) {
	  editor.setMode('composite');
	  editor.update(EditorState.set(editor._latestEditorState, { inCompositionMode: true }));
	  // Allow composition handler to interpret the compositionstart event
	  editor._onCompositionStart(e);
	}
	
	module.exports = editOnCompositionStart;

/***/ }),
/* 510 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule editOnCopy
	 * @format
	 * 
	 */
	
	'use strict';
	
	var getFragmentFromSelection = __webpack_require__(211);
	
	/**
	 * If we have a selection, create a ContentState fragment and store
	 * it in our internal clipboard. Subsequent paste events will use this
	 * fragment if no external clipboard data is supplied.
	 */
	function editOnCopy(editor, e) {
	  var editorState = editor._latestEditorState;
	  var selection = editorState.getSelection();
	
	  // No selection, so there's nothing to copy.
	  if (selection.isCollapsed()) {
	    e.preventDefault();
	    return;
	  }
	
	  editor.setClipboard(getFragmentFromSelection(editor._latestEditorState));
	}
	
	module.exports = editOnCopy;

/***/ }),
/* 511 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule editOnCut
	 * @format
	 * 
	 */
	
	'use strict';
	
	var DraftModifier = __webpack_require__(26);
	var EditorState = __webpack_require__(15);
	var Style = __webpack_require__(131);
	
	var getFragmentFromSelection = __webpack_require__(211);
	var getScrollPosition = __webpack_require__(134);
	
	/**
	 * On `cut` events, native behavior is allowed to occur so that the system
	 * clipboard is set properly. This means that we need to take steps to recover
	 * the editor DOM state after the `cut` has occurred in order to maintain
	 * control of the component.
	 *
	 * In addition, we can keep a copy of the removed fragment, including all
	 * styles and entities, for use as an internal paste.
	 */
	function editOnCut(editor, e) {
	  var editorState = editor._latestEditorState;
	  var selection = editorState.getSelection();
	  var element = e.target;
	  var scrollPosition = void 0;
	
	  // No selection, so there's nothing to cut.
	  if (selection.isCollapsed()) {
	    e.preventDefault();
	    return;
	  }
	
	  // Track the current scroll position so that it can be forced back in place
	  // after the editor regains control of the DOM.
	  if (element instanceof Node) {
	    scrollPosition = getScrollPosition(Style.getScrollParent(element));
	  }
	
	  var fragment = getFragmentFromSelection(editorState);
	  editor.setClipboard(fragment);
	
	  // Set `cut` mode to disable all event handling temporarily.
	  editor.setMode('cut');
	
	  // Let native `cut` behavior occur, then recover control.
	  setTimeout(function () {
	    editor.restoreEditorDOM(scrollPosition);
	    editor.exitCurrentMode();
	    editor.update(removeFragment(editorState));
	  }, 0);
	}
	
	function removeFragment(editorState) {
	  var newContent = DraftModifier.removeRange(editorState.getCurrentContent(), editorState.getSelection(), 'forward');
	  return EditorState.push(editorState, newContent, 'remove-range');
	}
	
	module.exports = editOnCut;

/***/ }),
/* 512 */
/***/ (function(module, exports) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule editOnDragOver
	 * @format
	 * 
	 */
	
	'use strict';
	
	/**
	 * Drag behavior has begun from outside the editor element.
	 */
	function editOnDragOver(editor, e) {
	  editor._internalDrag = false;
	  editor.setMode('drag');
	  e.preventDefault();
	}
	
	module.exports = editOnDragOver;

/***/ }),
/* 513 */
/***/ (function(module, exports) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule editOnDragStart
	 * @format
	 * 
	 */
	
	'use strict';
	
	/**
	 * A `dragstart` event has begun within the text editor component.
	 */
	function editOnDragStart(editor) {
	  editor._internalDrag = true;
	  editor.setMode('drag');
	}
	
	module.exports = editOnDragStart;

/***/ }),
/* 514 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule editOnFocus
	 * @format
	 * 
	 */
	
	'use strict';
	
	var EditorState = __webpack_require__(15);
	var UserAgent = __webpack_require__(36);
	
	function editOnFocus(editor, e) {
	  var editorState = editor._latestEditorState;
	  var currentSelection = editorState.getSelection();
	  if (currentSelection.getHasFocus()) {
	    return;
	  }
	
	  var selection = currentSelection.set('hasFocus', true);
	  editor.props.onFocus && editor.props.onFocus(e);
	
	  // When the tab containing this text editor is hidden and the user does a
	  // find-in-page in a _different_ tab, Chrome on Mac likes to forget what the
	  // selection was right after sending this focus event and (if you let it)
	  // moves the cursor back to the beginning of the editor, so we force the
	  // selection here instead of simply accepting it in order to preserve the
	  // old cursor position. See https://crbug.com/540004.
	  // But it looks like this is fixed in Chrome 60.0.3081.0.
	  // Other browsers also don't have this bug, so we prefer to acceptSelection
	  // when possible, to ensure that unfocusing and refocusing a Draft editor
	  // doesn't preserve the selection, matching how textareas work.
	  if (UserAgent.isBrowser('Chrome < 60.0.3081.0')) {
	    editor.update(EditorState.forceSelection(editorState, selection));
	  } else {
	    editor.update(EditorState.acceptSelection(editorState, selection));
	  }
	}
	
	module.exports = editOnFocus;

/***/ }),
/* 515 */
/***/ (function(module, exports, __webpack_require__) {

	/* WEBPACK VAR INJECTION */(function(global) {/**
	 * 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.
	 *
	 * @providesModule editOnInput
	 * @format
	 * 
	 */
	
	'use strict';
	
	var DraftFeatureFlags = __webpack_require__(42);
	var DraftModifier = __webpack_require__(26);
	var DraftOffsetKey = __webpack_require__(71);
	var EditorState = __webpack_require__(15);
	var UserAgent = __webpack_require__(36);
	
	var findAncestorOffsetKey = __webpack_require__(126);
	var nullthrows = __webpack_require__(33);
	
	var isGecko = UserAgent.isEngine('Gecko');
	
	var DOUBLE_NEWLINE = '\n\n';
	
	/**
	 * This function is intended to handle spellcheck and autocorrect changes,
	 * which occur in the DOM natively without any opportunity to observe or
	 * interpret the changes before they occur.
	 *
	 * The `input` event fires in contentEditable elements reliably for non-IE
	 * browsers, immediately after changes occur to the editor DOM. Since our other
	 * handlers override or otherwise handle cover other varieties of text input,
	 * the DOM state should match the model in all controlled input cases. Thus,
	 * when an `input` change leads to a DOM/model mismatch, the change should be
	 * due to a spellcheck change, and we can incorporate it into our model.
	 */
	function editOnInput(editor) {
	  if (editor._pendingStateFromBeforeInput !== undefined) {
	    editor.update(editor._pendingStateFromBeforeInput);
	    editor._pendingStateFromBeforeInput = undefined;
	  }
	
	  var domSelection = global.getSelection();
	
	  var anchorNode = domSelection.anchorNode,
	      isCollapsed = domSelection.isCollapsed;
	
	  var isNotTextNode = anchorNode.nodeType !== Node.TEXT_NODE;
	  var isNotTextOrElementNode = anchorNode.nodeType !== Node.TEXT_NODE && anchorNode.nodeType !== Node.ELEMENT_NODE;
	
	  if (DraftFeatureFlags.draft_killswitch_allow_nontextnodes) {
	    if (isNotTextNode) {
	      return;
	    }
	  } else {
	    if (isNotTextOrElementNode) {
	      // TODO: (t16149272) figure out context for this change
	      return;
	    }
	  }
	
	  if (anchorNode.nodeType === Node.TEXT_NODE && (anchorNode.previousSibling !== null || anchorNode.nextSibling !== null)) {
	    // When typing at the beginning of a visual line, Chrome splits the text
	    // nodes into two. Why? No one knows. This commit is suspicious:
	    // https://chromium.googlesource.com/chromium/src/+/a3b600981286b135632371477f902214c55a1724
	    // To work around, we'll merge the sibling text nodes back into this one.
	    var span = anchorNode.parentNode;
	    anchorNode.nodeValue = span.textContent;
	    for (var child = span.firstChild; child !== null; child = child.nextSibling) {
	      if (child !== anchorNode) {
	        span.removeChild(child);
	      }
	    }
	  }
	
	  var domText = anchorNode.textContent;
	  var editorState = editor._latestEditorState;
	  var offsetKey = nullthrows(findAncestorOffsetKey(anchorNode));
	
	  var _DraftOffsetKey$decod = DraftOffsetKey.decode(offsetKey),
	      blockKey = _DraftOffsetKey$decod.blockKey,
	      decoratorKey = _DraftOffsetKey$decod.decoratorKey,
	      leafKey = _DraftOffsetKey$decod.leafKey;
	
	  var _editorState$getBlock = editorState.getBlockTree(blockKey).getIn([decoratorKey, 'leaves', leafKey]),
	      start = _editorState$getBlock.start,
	      end = _editorState$getBlock.end;
	
	  var content = editorState.getCurrentContent();
	  var block = content.getBlockForKey(blockKey);
	  var modelText = block.getText().slice(start, end);
	
	  // Special-case soft newlines here. If the DOM text ends in a soft newline,
	  // we will have manually inserted an extra soft newline in DraftEditorLeaf.
	  // We want to remove this extra newline for the purpose of our comparison
	  // of DOM and model text.
	  if (domText.endsWith(DOUBLE_NEWLINE)) {
	    domText = domText.slice(0, -1);
	  }
	
	  // No change -- the DOM is up to date. Nothing to do here.
	  if (domText === modelText) {
	    // This can be buggy for some Android keyboards because they don't fire
	    // standard onkeydown/pressed events and only fired editOnInput
	    // so domText is already changed by the browser and ends up being equal
	    // to modelText unexpectedly
	    return;
	  }
	
	  var selection = editorState.getSelection();
	
	  // We'll replace the entire leaf with the text content of the target.
	  var targetRange = selection.merge({
	    anchorOffset: start,
	    focusOffset: end,
	    isBackward: false
	  });
	
	  var entityKey = block.getEntityAt(start);
	  var entity = entityKey && content.getEntity(entityKey);
	  var entityType = entity && entity.getMutability();
	  var preserveEntity = entityType === 'MUTABLE';
	
	  // Immutable or segmented entities cannot properly be handled by the
	  // default browser undo, so we have to use a different change type to
	  // force using our internal undo method instead of falling through to the
	  // native browser undo.
	  var changeType = preserveEntity ? 'spellcheck-change' : 'apply-entity';
	
	  var newContent = DraftModifier.replaceText(content, targetRange, domText, block.getInlineStyleAt(start), preserveEntity ? block.getEntityAt(start) : null);
	
	  var anchorOffset, focusOffset, startOffset, endOffset;
	
	  if (isGecko) {
	    // Firefox selection does not change while the context menu is open, so
	    // we preserve the anchor and focus values of the DOM selection.
	    anchorOffset = domSelection.anchorOffset;
	    focusOffset = domSelection.focusOffset;
	    startOffset = start + Math.min(anchorOffset, focusOffset);
	    endOffset = startOffset + Math.abs(anchorOffset - focusOffset);
	    anchorOffset = startOffset;
	    focusOffset = endOffset;
	  } else {
	    // Browsers other than Firefox may adjust DOM selection while the context
	    // menu is open, and Safari autocorrect is prone to providing an inaccurate
	    // DOM selection. Don't trust it. Instead, use our existing SelectionState
	    // and adjust it based on the number of characters changed during the
	    // mutation.
	    var charDelta = domText.length - modelText.length;
	    startOffset = selection.getStartOffset();
	    endOffset = selection.getEndOffset();
	
	    anchorOffset = isCollapsed ? endOffset + charDelta : startOffset;
	    focusOffset = endOffset + charDelta;
	  }
	
	  // Segmented entities are completely or partially removed when their
	  // text content changes. For this case we do not want any text to be selected
	  // after the change, so we are not merging the selection.
	  var contentWithAdjustedDOMSelection = newContent.merge({
	    selectionBefore: content.getSelectionAfter(),
	    selectionAfter: selection.merge({ anchorOffset: anchorOffset, focusOffset: focusOffset })
	  });
	
	  editor.update(EditorState.push(editorState, contentWithAdjustedDOMSelection, changeType));
	}
	
	module.exports = editOnInput;
	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))

/***/ }),
/* 516 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule editOnKeyDown
	 * @format
	 * 
	 */
	
	'use strict';
	
	var DraftModifier = __webpack_require__(26);
	var EditorState = __webpack_require__(15);
	var KeyBindingUtil = __webpack_require__(125);
	var Keys = __webpack_require__(130);
	var SecondaryClipboard = __webpack_require__(498);
	var UserAgent = __webpack_require__(36);
	
	var isEventHandled = __webpack_require__(73);
	var keyCommandBackspaceToStartOfLine = __webpack_require__(529);
	var keyCommandBackspaceWord = __webpack_require__(530);
	var keyCommandDeleteWord = __webpack_require__(531);
	var keyCommandInsertNewline = __webpack_require__(532);
	var keyCommandMoveSelectionToEndOfBlock = __webpack_require__(533);
	var keyCommandMoveSelectionToStartOfBlock = __webpack_require__(534);
	var keyCommandPlainBackspace = __webpack_require__(535);
	var keyCommandPlainDelete = __webpack_require__(536);
	var keyCommandTransposeCharacters = __webpack_require__(537);
	var keyCommandUndo = __webpack_require__(538);
	
	var isOptionKeyCommand = KeyBindingUtil.isOptionKeyCommand;
	
	var isChrome = UserAgent.isBrowser('Chrome');
	
	/**
	 * Map a `DraftEditorCommand` command value to a corresponding function.
	 */
	function onKeyCommand(command, editorState) {
	  switch (command) {
	    case 'redo':
	      return EditorState.redo(editorState);
	    case 'delete':
	      return keyCommandPlainDelete(editorState);
	    case 'delete-word':
	      return keyCommandDeleteWord(editorState);
	    case 'backspace':
	      return keyCommandPlainBackspace(editorState);
	    case 'backspace-word':
	      return keyCommandBackspaceWord(editorState);
	    case 'backspace-to-start-of-line':
	      return keyCommandBackspaceToStartOfLine(editorState);
	    case 'split-block':
	      return keyCommandInsertNewline(editorState);
	    case 'transpose-characters':
	      return keyCommandTransposeCharacters(editorState);
	    case 'move-selection-to-start-of-block':
	      return keyCommandMoveSelectionToStartOfBlock(editorState);
	    case 'move-selection-to-end-of-block':
	      return keyCommandMoveSelectionToEndOfBlock(editorState);
	    case 'secondary-cut':
	      return SecondaryClipboard.cut(editorState);
	    case 'secondary-paste':
	      return SecondaryClipboard.paste(editorState);
	    default:
	      return editorState;
	  }
	}
	
	/**
	 * Intercept keydown behavior to handle keys and commands manually, if desired.
	 *
	 * Keydown combinations may be mapped to `DraftCommand` values, which may
	 * correspond to command functions that modify the editor or its contents.
	 *
	 * See `getDefaultKeyBinding` for defaults. Alternatively, the top-level
	 * component may provide a custom mapping via the `keyBindingFn` prop.
	 */
	function editOnKeyDown(editor, e) {
	  var keyCode = e.which;
	  var editorState = editor._latestEditorState;
	
	  switch (keyCode) {
	    case Keys.RETURN:
	      e.preventDefault();
	      // The top-level component may manually handle newline insertion. If
	      // no special handling is performed, fall through to command handling.
	      if (editor.props.handleReturn && isEventHandled(editor.props.handleReturn(e, editorState))) {
	        return;
	      }
	      break;
	    case Keys.ESC:
	      e.preventDefault();
	      editor.props.onEscape && editor.props.onEscape(e);
	      return;
	    case Keys.TAB:
	      editor.props.onTab && editor.props.onTab(e);
	      return;
	    case Keys.UP:
	      editor.props.onUpArrow && editor.props.onUpArrow(e);
	      return;
	    case Keys.RIGHT:
	      editor.props.onRightArrow && editor.props.onRightArrow(e);
	      return;
	    case Keys.DOWN:
	      editor.props.onDownArrow && editor.props.onDownArrow(e);
	      return;
	    case Keys.LEFT:
	      editor.props.onLeftArrow && editor.props.onLeftArrow(e);
	      return;
	    case Keys.SPACE:
	      // Handling for OSX where option + space scrolls.
	      if (isChrome && isOptionKeyCommand(e)) {
	        e.preventDefault();
	        // Insert a nbsp into the editor.
	        var contentState = DraftModifier.replaceText(editorState.getCurrentContent(), editorState.getSelection(), '\xA0');
	        editor.update(EditorState.push(editorState, contentState, 'insert-characters'));
	        return;
	      }
	  }
	
	  var command = editor.props.keyBindingFn(e);
	
	  // If no command is specified, allow keydown event to continue.
	  if (!command) {
	    return;
	  }
	
	  if (command === 'undo') {
	    // Since undo requires some special updating behavior to keep the editor
	    // in sync, handle it separately.
	    keyCommandUndo(e, editorState, editor.update);
	    return;
	  }
	
	  // At this point, we know that we're handling a command of some kind, so
	  // we don't want to insert a character following the keydown.
	  e.preventDefault();
	
	  // Allow components higher up the tree to handle the command first.
	  if (editor.props.handleKeyCommand && isEventHandled(editor.props.handleKeyCommand(command, editorState))) {
	    return;
	  }
	
	  var newState = onKeyCommand(command, editorState);
	  if (newState !== editorState) {
	    editor.update(newState);
	  }
	}
	
	module.exports = editOnKeyDown;

/***/ }),
/* 517 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule editOnPaste
	 * @format
	 * 
	 */
	
	'use strict';
	
	var BlockMapBuilder = __webpack_require__(70);
	var CharacterMetadata = __webpack_require__(27);
	var DataTransfer = __webpack_require__(224);
	var DraftModifier = __webpack_require__(26);
	var DraftPasteProcessor = __webpack_require__(495);
	var EditorState = __webpack_require__(15);
	var RichTextEditorUtil = __webpack_require__(207);
	
	var getEntityKeyForSelection = __webpack_require__(127);
	var getTextContentFromFiles = __webpack_require__(216);
	var isEventHandled = __webpack_require__(73);
	var splitTextIntoTextBlocks = __webpack_require__(544);
	
	/**
	 * Paste content.
	 */
	function editOnPaste(editor, e) {
	  e.preventDefault();
	  var data = new DataTransfer(e.clipboardData);
	
	  // Get files, unless this is likely to be a string the user wants inline.
	  if (!data.isRichText()) {
	    var files = data.getFiles();
	    var defaultFileText = data.getText();
	    if (files.length > 0) {
	      // Allow customized paste handling for images, etc. Otherwise, fall
	      // through to insert text contents into the editor.
	      if (editor.props.handlePastedFiles && isEventHandled(editor.props.handlePastedFiles(files))) {
	        return;
	      }
	
	      getTextContentFromFiles(files, function ( /*string*/fileText) {
	        fileText = fileText || defaultFileText;
	        if (!fileText) {
	          return;
	        }
	
	        var editorState = editor._latestEditorState;
	        var blocks = splitTextIntoTextBlocks(fileText);
	        var character = CharacterMetadata.create({
	          style: editorState.getCurrentInlineStyle(),
	          entity: getEntityKeyForSelection(editorState.getCurrentContent(), editorState.getSelection())
	        });
	        var currentBlockType = RichTextEditorUtil.getCurrentBlockType(editorState);
	
	        var text = DraftPasteProcessor.processText(blocks, character, currentBlockType);
	        var fragment = BlockMapBuilder.createFromArray(text);
	
	        var withInsertedText = DraftModifier.replaceWithFragment(editorState.getCurrentContent(), editorState.getSelection(), fragment);
	
	        editor.update(EditorState.push(editorState, withInsertedText, 'insert-fragment'));
	      });
	
	      return;
	    }
	  }
	
	  var textBlocks = [];
	  var text = data.getText();
	  var html = data.getHTML();
	  var editorState = editor._latestEditorState;
	
	  if (editor.props.handlePastedText && isEventHandled(editor.props.handlePastedText(text, html, editorState))) {
	    return;
	  }
	
	  if (text) {
	    textBlocks = splitTextIntoTextBlocks(text);
	  }
	
	  if (!editor.props.stripPastedStyles) {
	    // If the text from the paste event is rich content that matches what we
	    // already have on the internal clipboard, assume that we should just use
	    // the clipboard fragment for the paste. This will allow us to preserve
	    // styling and entities, if any are present. Note that newlines are
	    // stripped during comparison -- this is because copy/paste within the
	    // editor in Firefox and IE will not include empty lines. The resulting
	    // paste will preserve the newlines correctly.
	    var internalClipboard = editor.getClipboard();
	    if (data.isRichText() && internalClipboard) {
	      if (
	      // If the editorKey is present in the pasted HTML, it should be safe to
	      // assume this is an internal paste.
	      html.indexOf(editor.getEditorKey()) !== -1 ||
	      // The copy may have been made within a single block, in which case the
	      // editor key won't be part of the paste. In this case, just check
	      // whether the pasted text matches the internal clipboard.
	      textBlocks.length === 1 && internalClipboard.size === 1 && internalClipboard.first().getText() === text) {
	        editor.update(insertFragment(editor._latestEditorState, internalClipboard));
	        return;
	      }
	    } else if (internalClipboard && data.types.includes('com.apple.webarchive') && !data.types.includes('text/html') && areTextBlocksAndClipboardEqual(textBlocks, internalClipboard)) {
	      // Safari does not properly store text/html in some cases.
	      // Use the internalClipboard if present and equal to what is on
	      // the clipboard. See https://bugs.webkit.org/show_bug.cgi?id=19893.
	      editor.update(insertFragment(editor._latestEditorState, internalClipboard));
	      return;
	    }
	
	    // If there is html paste data, try to parse that.
	    if (html) {
	      var htmlFragment = DraftPasteProcessor.processHTML(html, editor.props.blockRenderMap);
	      if (htmlFragment) {
	        var contentBlocks = htmlFragment.contentBlocks,
	            entityMap = htmlFragment.entityMap;
	
	        if (contentBlocks) {
	          var htmlMap = BlockMapBuilder.createFromArray(contentBlocks);
	          editor.update(insertFragment(editor._latestEditorState, htmlMap, entityMap));
	          return;
	        }
	      }
	    }
	
	    // Otherwise, create a new fragment from our pasted text. Also
	    // empty the internal clipboard, since it's no longer valid.
	    editor.setClipboard(null);
	  }
	
	  if (textBlocks.length) {
	    var character = CharacterMetadata.create({
	      style: editorState.getCurrentInlineStyle(),
	      entity: getEntityKeyForSelection(editorState.getCurrentContent(), editorState.getSelection())
	    });
	
	    var currentBlockType = RichTextEditorUtil.getCurrentBlockType(editorState);
	
	    var textFragment = DraftPasteProcessor.processText(textBlocks, character, currentBlockType);
	
	    var textMap = BlockMapBuilder.createFromArray(textFragment);
	    editor.update(insertFragment(editor._latestEditorState, textMap));
	  }
	}
	
	function insertFragment(editorState, fragment, entityMap) {
	  var newContent = DraftModifier.replaceWithFragment(editorState.getCurrentContent(), editorState.getSelection(), fragment);
	  // TODO: merge the entity map once we stop using DraftEntity
	  // like this:
	  // const mergedEntityMap = newContent.getEntityMap().merge(entityMap);
	
	  return EditorState.push(editorState, newContent.set('entityMap', entityMap), 'insert-fragment');
	}
	
	function areTextBlocksAndClipboardEqual(textBlocks, blockMap) {
	  return textBlocks.length === blockMap.size && blockMap.valueSeq().every(function (block, ii) {
	    return block.getText() === textBlocks[ii];
	  });
	}
	
	module.exports = editOnPaste;

/***/ }),
/* 518 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule editOnSelect
	 * @format
	 * 
	 */
	
	'use strict';
	
	var EditorState = __webpack_require__(15);
	var ReactDOM = __webpack_require__(10);
	
	var getDraftEditorSelection = __webpack_require__(523);
	var invariant = __webpack_require__(12);
	
	function editOnSelect(editor) {
	  if (editor._blockSelectEvents || editor._latestEditorState !== editor.props.editorState) {
	    return;
	  }
	
	  var editorState = editor.props.editorState;
	  var editorNode = ReactDOM.findDOMNode(editor.editorContainer);
	  !editorNode ?  true ? invariant(false, 'Missing editorNode') : invariant(false) : void 0;
	  !(editorNode.firstChild instanceof HTMLElement) ?  true ? invariant(false, 'editorNode.firstChild is not an HTMLElement') : invariant(false) : void 0;
	  var documentSelection = getDraftEditorSelection(editorState, editorNode.firstChild);
	  var updatedSelectionState = documentSelection.selectionState;
	
	  if (updatedSelectionState !== editorState.getSelection()) {
	    if (documentSelection.needsRecovery) {
	      editorState = EditorState.forceSelection(editorState, updatedSelectionState);
	    } else {
	      editorState = EditorState.acceptSelection(editorState, updatedSelectionState);
	    }
	    editor.update(editorState);
	  }
	}
	
	module.exports = editOnSelect;

/***/ }),
/* 519 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule encodeEntityRanges
	 * @format
	 * 
	 */
	
	'use strict';
	
	var DraftStringKey = __webpack_require__(206);
	var UnicodeUtils = __webpack_require__(51);
	
	var strlen = UnicodeUtils.strlen;
	
	/**
	 * Convert to UTF-8 character counts for storage.
	 */
	
	function encodeEntityRanges(block, storageMap) {
	  var encoded = [];
	  block.findEntityRanges(function (character) {
	    return !!character.getEntity();
	  }, function ( /*number*/start, /*number*/end) {
	    var text = block.getText();
	    var key = block.getEntityAt(start);
	    encoded.push({
	      offset: strlen(text.slice(0, start)),
	      length: strlen(text.slice(start, end)),
	      // Encode the key as a number for range storage.
	      key: Number(storageMap[DraftStringKey.stringify(key)])
	    });
	  });
	  return encoded;
	}
	
	module.exports = encodeEntityRanges;

/***/ }),
/* 520 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule encodeInlineStyleRanges
	 * @format
	 * 
	 */
	
	'use strict';
	
	var UnicodeUtils = __webpack_require__(51);
	
	var findRangesImmutable = __webpack_require__(72);
	
	var areEqual = function areEqual(a, b) {
	  return a === b;
	};
	var isTruthy = function isTruthy(a) {
	  return !!a;
	};
	var EMPTY_ARRAY = [];
	
	/**
	 * Helper function for getting encoded styles for each inline style. Convert
	 * to UTF-8 character counts for storage.
	 */
	function getEncodedInlinesForType(block, styleList, styleToEncode) {
	  var ranges = [];
	
	  // Obtain an array with ranges for only the specified style.
	  var filteredInlines = styleList.map(function (style) {
	    return style.has(styleToEncode);
	  }).toList();
	
	  findRangesImmutable(filteredInlines, areEqual,
	  // We only want to keep ranges with nonzero style values.
	  isTruthy, function (start, end) {
	    var text = block.getText();
	    ranges.push({
	      offset: UnicodeUtils.strlen(text.slice(0, start)),
	      length: UnicodeUtils.strlen(text.slice(start, end)),
	      style: styleToEncode
	    });
	  });
	
	  return ranges;
	}
	
	/*
	 * Retrieve the encoded arrays of inline styles, with each individual style
	 * treated separately.
	 */
	function encodeInlineStyleRanges(block) {
	  var styleList = block.getCharacterList().map(function (c) {
	    return c.getStyle();
	  }).toList();
	  var ranges = styleList.flatten().toSet().map(function (style) {
	    return getEncodedInlinesForType(block, styleList, style);
	  });
	
	  return Array.prototype.concat.apply(EMPTY_ARRAY, ranges.toJS());
	}
	
	module.exports = encodeInlineStyleRanges;

/***/ }),
/* 521 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule expandRangeToStartOfLine
	 * @format
	 * 
	 */
	
	var UnicodeUtils = __webpack_require__(51);
	
	var getRangeClientRects = __webpack_require__(213);
	var invariant = __webpack_require__(12);
	
	/**
	 * Return the computed line height, in pixels, for the provided element.
	 */
	function getLineHeightPx(element) {
	  var computed = getComputedStyle(element);
	  var div = document.createElement('div');
	  div.style.fontFamily = computed.fontFamily;
	  div.style.fontSize = computed.fontSize;
	  div.style.fontStyle = computed.fontStyle;
	  div.style.fontWeight = computed.fontWeight;
	  div.style.lineHeight = computed.lineHeight;
	  div.style.position = 'absolute';
	  div.textContent = 'M';
	
	  var documentBody = document.body;
	  !documentBody ?  true ? invariant(false, 'Missing document.body') : invariant(false) : void 0;
	
	  // forced layout here
	  documentBody.appendChild(div);
	  var rect = div.getBoundingClientRect();
	  documentBody.removeChild(div);
	
	  return rect.height;
	}
	
	/**
	 * Return whether every ClientRect in the provided list lies on the same line.
	 *
	 * We assume that the rects on the same line all contain the baseline, so the
	 * lowest top line needs to be above the highest bottom line (i.e., if you were
	 * to project the rects onto the y-axis, their intersection would be nonempty).
	 *
	 * In addition, we require that no two boxes are lineHeight (or more) apart at
	 * either top or bottom, which helps protect against false positives for fonts
	 * with extremely large glyph heights (e.g., with a font size of 17px, Zapfino
	 * produces rects of height 58px!).
	 */
	function areRectsOnOneLine(rects, lineHeight) {
	  var minTop = Infinity;
	  var minBottom = Infinity;
	  var maxTop = -Infinity;
	  var maxBottom = -Infinity;
	
	  for (var ii = 0; ii < rects.length; ii++) {
	    var rect = rects[ii];
	    if (rect.width === 0 || rect.width === 1) {
	      // When a range starts or ends a soft wrap, many browsers (Chrome, IE,
	      // Safari) include an empty rect on the previous or next line. When the
	      // text lies in a container whose position is not integral (e.g., from
	      // margin: auto), Safari makes these empty rects have width 1 (instead of
	      // 0). Having one-pixel-wide characters seems unlikely (and most browsers
	      // report widths in subpixel precision anyway) so it's relatively safe to
	      // skip over them.
	      continue;
	    }
	    minTop = Math.min(minTop, rect.top);
	    minBottom = Math.min(minBottom, rect.bottom);
	    maxTop = Math.max(maxTop, rect.top);
	    maxBottom = Math.max(maxBottom, rect.bottom);
	  }
	
	  return maxTop <= minBottom && maxTop - minTop < lineHeight && maxBottom - minBottom < lineHeight;
	}
	
	/**
	 * Return the length of a node, as used by Range offsets.
	 */
	function getNodeLength(node) {
	  // http://www.w3.org/TR/dom/#concept-node-length
	  switch (node.nodeType) {
	    case Node.DOCUMENT_TYPE_NODE:
	      return 0;
	    case Node.TEXT_NODE:
	    case Node.PROCESSING_INSTRUCTION_NODE:
	    case Node.COMMENT_NODE:
	      return node.length;
	    default:
	      return node.childNodes.length;
	  }
	}
	
	/**
	 * Given a collapsed range, move the start position backwards as far as
	 * possible while the range still spans only a single line.
	 */
	function expandRangeToStartOfLine(range) {
	  !range.collapsed ?  true ? invariant(false, 'expandRangeToStartOfLine: Provided range is not collapsed.') : invariant(false) : void 0;
	  range = range.cloneRange();
	
	  var containingElement = range.startContainer;
	  if (containingElement.nodeType !== 1) {
	    containingElement = containingElement.parentNode;
	  }
	  var lineHeight = getLineHeightPx(containingElement);
	
	  // Imagine our text looks like:
	  //   <div><span>once upon a time, there was a <em>boy
	  //   who lived</em> </span><q><strong>under^ the
	  //   stairs</strong> in a small closet.</q></div>
	  // where the caret represents the cursor. First, we crawl up the tree until
	  // the range spans multiple lines (setting the start point to before
	  // "<strong>", then before "<div>"), then at each level we do a search to
	  // find the latest point which is still on a previous line. We'll find that
	  // the break point is inside the span, then inside the <em>, then in its text
	  // node child, the actual break point before "who".
	
	  var bestContainer = range.endContainer;
	  var bestOffset = range.endOffset;
	  range.setStart(range.startContainer, 0);
	
	  while (areRectsOnOneLine(getRangeClientRects(range), lineHeight)) {
	    bestContainer = range.startContainer;
	    bestOffset = range.startOffset;
	    !bestContainer.parentNode ?  true ? invariant(false, 'Found unexpected detached subtree when traversing.') : invariant(false) : void 0;
	    range.setStartBefore(bestContainer);
	    if (bestContainer.nodeType === 1 && getComputedStyle(bestContainer).display !== 'inline') {
	      // The start of the line is never in a different block-level container.
	      break;
	    }
	  }
	
	  // In the above example, range now spans from "<div>" to "under",
	  // bestContainer is <div>, and bestOffset is 1 (index of <q> inside <div>)].
	  // Picking out which child to recurse into here is a special case since we
	  // don't want to check past <q> -- once we find that the final range starts
	  // in <span>, we can look at all of its children (and all of their children)
	  // to find the break point.
	
	  // At all times, (bestContainer, bestOffset) is the latest single-line start
	  // point that we know of.
	  var currentContainer = bestContainer;
	  var maxIndexToConsider = bestOffset - 1;
	
	  do {
	    var nodeValue = currentContainer.nodeValue;
	
	    for (var ii = maxIndexToConsider; ii >= 0; ii--) {
	      if (nodeValue != null && ii > 0 && UnicodeUtils.isSurrogatePair(nodeValue, ii - 1)) {
	        // We're in the middle of a surrogate pair -- skip over so we never
	        // return a range with an endpoint in the middle of a code point.
	        continue;
	      }
	
	      range.setStart(currentContainer, ii);
	      if (areRectsOnOneLine(getRangeClientRects(range), lineHeight)) {
	        bestContainer = currentContainer;
	        bestOffset = ii;
	      } else {
	        break;
	      }
	    }
	
	    if (ii === -1 || currentContainer.childNodes.length === 0) {
	      // If ii === -1, then (bestContainer, bestOffset), which is equal to
	      // (currentContainer, 0), was a single-line start point but a start
	      // point before currentContainer wasn't, so the line break seems to
	      // have occurred immediately after currentContainer's start tag
	      //
	      // If currentContainer.childNodes.length === 0, we're already at a
	      // terminal node (e.g., text node) and should return our current best.
	      break;
	    }
	
	    currentContainer = currentContainer.childNodes[ii];
	    maxIndexToConsider = getNodeLength(currentContainer);
	  } while (true);
	
	  range.setStart(bestContainer, bestOffset);
	  return range;
	}
	
	module.exports = expandRangeToStartOfLine;

/***/ }),
/* 522 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule getCharacterRemovalRange
	 * @format
	 * 
	 */
	
	'use strict';
	
	var DraftEntitySegments = __webpack_require__(492);
	
	var getRangesForDraftEntity = __webpack_require__(525);
	var invariant = __webpack_require__(12);
	
	/**
	 * Given a SelectionState and a removal direction, determine the entire range
	 * that should be removed from a ContentState. This is based on any entities
	 * within the target, with their `mutability` values taken into account.
	 *
	 * For instance, if we are attempting to remove part of an "immutable" entity
	 * range, the entire entity must be removed. The returned `SelectionState`
	 * will be adjusted accordingly.
	 */
	function getCharacterRemovalRange(entityMap, startBlock, endBlock, selectionState, direction) {
	  var start = selectionState.getStartOffset();
	  var end = selectionState.getEndOffset();
	  var startEntityKey = startBlock.getEntityAt(start);
	  var endEntityKey = endBlock.getEntityAt(end - 1);
	  if (!startEntityKey && !endEntityKey) {
	    return selectionState;
	  }
	  var newSelectionState = selectionState;
	  if (startEntityKey && startEntityKey === endEntityKey) {
	    newSelectionState = getEntityRemovalRange(entityMap, startBlock, newSelectionState, direction, startEntityKey, true, true);
	  } else if (startEntityKey && endEntityKey) {
	    var startSelectionState = getEntityRemovalRange(entityMap, startBlock, newSelectionState, direction, startEntityKey, false, true);
	    var endSelectionState = getEntityRemovalRange(entityMap, endBlock, newSelectionState, direction, endEntityKey, false, false);
	    newSelectionState = newSelectionState.merge({
	      anchorOffset: startSelectionState.getAnchorOffset(),
	      focusOffset: endSelectionState.getFocusOffset(),
	      isBackward: false
	    });
	  } else if (startEntityKey) {
	    var _startSelectionState = getEntityRemovalRange(entityMap, startBlock, newSelectionState, direction, startEntityKey, false, true);
	    newSelectionState = newSelectionState.merge({
	      anchorOffset: _startSelectionState.getStartOffset(),
	      isBackward: false
	    });
	  } else if (endEntityKey) {
	    var _endSelectionState = getEntityRemovalRange(entityMap, endBlock, newSelectionState, direction, endEntityKey, false, false);
	    newSelectionState = newSelectionState.merge({
	      focusOffset: _endSelectionState.getEndOffset(),
	      isBackward: false
	    });
	  }
	  return newSelectionState;
	}
	
	function getEntityRemovalRange(entityMap, block, selectionState, direction, entityKey, isEntireSelectionWithinEntity, isEntityAtStart) {
	  var start = selectionState.getStartOffset();
	  var end = selectionState.getEndOffset();
	  var entity = entityMap.__get(entityKey);
	  var mutability = entity.getMutability();
	  var sideToConsider = isEntityAtStart ? start : end;
	
	  // `MUTABLE` entities can just have the specified range of text removed
	  // directly. No adjustments are needed.
	  if (mutability === 'MUTABLE') {
	    return selectionState;
	  }
	
	  // Find the entity range that overlaps with our removal range.
	  var entityRanges = getRangesForDraftEntity(block, entityKey).filter(function (range) {
	    return sideToConsider <= range.end && sideToConsider >= range.start;
	  });
	
	  !(entityRanges.length == 1) ?  true ? invariant(false, 'There should only be one entity range within this removal range.') : invariant(false) : void 0;
	
	  var entityRange = entityRanges[0];
	
	  // For `IMMUTABLE` entity types, we will remove the entire entity range.
	  if (mutability === 'IMMUTABLE') {
	    return selectionState.merge({
	      anchorOffset: entityRange.start,
	      focusOffset: entityRange.end,
	      isBackward: false
	    });
	  }
	
	  // For `SEGMENTED` entity types, determine the appropriate segment to
	  // remove.
	  if (!isEntireSelectionWithinEntity) {
	    if (isEntityAtStart) {
	      end = entityRange.end;
	    } else {
	      start = entityRange.start;
	    }
	  }
	
	  var removalRange = DraftEntitySegments.getRemovalRange(start, end, block.getText().slice(entityRange.start, entityRange.end), entityRange.start, direction);
	
	  return selectionState.merge({
	    anchorOffset: removalRange.start,
	    focusOffset: removalRange.end,
	    isBackward: false
	  });
	}
	
	module.exports = getCharacterRemovalRange;

/***/ }),
/* 523 */
/***/ (function(module, exports, __webpack_require__) {

	/* WEBPACK VAR INJECTION */(function(global) {/**
	 * 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.
	 *
	 * @providesModule getDraftEditorSelection
	 * @format
	 * 
	 */
	
	'use strict';
	
	var getDraftEditorSelectionWithNodes = __webpack_require__(210);
	
	/**
	 * Convert the current selection range to an anchor/focus pair of offset keys
	 * and values that can be interpreted by components.
	 */
	function getDraftEditorSelection(editorState, root) {
	  var selection = global.getSelection();
	
	  // No active selection.
	  if (selection.rangeCount === 0) {
	    return {
	      selectionState: editorState.getSelection().set('hasFocus', false),
	      needsRecovery: false
	    };
	  }
	
	  return getDraftEditorSelectionWithNodes(editorState, root, selection.anchorNode, selection.anchorOffset, selection.focusNode, selection.focusOffset);
	}
	
	module.exports = getDraftEditorSelection;
	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))

/***/ }),
/* 524 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule getRangeBoundingClientRect
	 * @format
	 * 
	 */
	
	'use strict';
	
	var getRangeClientRects = __webpack_require__(213);
	
	/**
	 * Like range.getBoundingClientRect() but normalizes for browser bugs.
	 */
	function getRangeBoundingClientRect(range) {
	  // "Return a DOMRect object describing the smallest rectangle that includes
	  // the first rectangle in list and all of the remaining rectangles of which
	  // the height or width is not zero."
	  // http://www.w3.org/TR/cssom-view/#dom-range-getboundingclientrect
	  var rects = getRangeClientRects(range);
	  var top = 0;
	  var right = 0;
	  var bottom = 0;
	  var left = 0;
	
	  if (rects.length) {
	    // If the first rectangle has 0 width, we use the second, this is needed
	    // because Chrome renders a 0 width rectangle when the selection contains
	    // a line break.
	    if (rects.length > 1 && rects[0].width === 0) {
	      var _rects$ = rects[1];
	      top = _rects$.top;
	      right = _rects$.right;
	      bottom = _rects$.bottom;
	      left = _rects$.left;
	    } else {
	      var _rects$2 = rects[0];
	      top = _rects$2.top;
	      right = _rects$2.right;
	      bottom = _rects$2.bottom;
	      left = _rects$2.left;
	    }
	
	    for (var ii = 1; ii < rects.length; ii++) {
	      var rect = rects[ii];
	      if (rect.height !== 0 && rect.width !== 0) {
	        top = Math.min(top, rect.top);
	        right = Math.max(right, rect.right);
	        bottom = Math.max(bottom, rect.bottom);
	        left = Math.min(left, rect.left);
	      }
	    }
	  }
	
	  return {
	    top: top,
	    right: right,
	    bottom: bottom,
	    left: left,
	    width: right - left,
	    height: bottom - top
	  };
	}
	
	module.exports = getRangeBoundingClientRect;

/***/ }),
/* 525 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule getRangesForDraftEntity
	 * @format
	 * 
	 */
	
	'use strict';
	
	var invariant = __webpack_require__(12);
	
	/**
	 * Obtain the start and end positions of the range that has the
	 * specified entity applied to it.
	 *
	 * Entity keys are applied only to contiguous stretches of text, so this
	 * method searches for the first instance of the entity key and returns
	 * the subsequent range.
	 */
	function getRangesForDraftEntity(block, key) {
	  var ranges = [];
	  block.findEntityRanges(function (c) {
	    return c.getEntity() === key;
	  }, function (start, end) {
	    ranges.push({ start: start, end: end });
	  });
	
	  !!!ranges.length ?  true ? invariant(false, 'Entity key not found in this range.') : invariant(false) : void 0;
	
	  return ranges;
	}
	
	module.exports = getRangesForDraftEntity;

/***/ }),
/* 526 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule getVisibleSelectionRect
	 * @format
	 * 
	 */
	
	'use strict';
	
	var getRangeBoundingClientRect = __webpack_require__(524);
	
	/**
	 * Return the bounding ClientRect for the visible DOM selection, if any.
	 * In cases where there are no selected ranges or the bounding rect is
	 * temporarily invalid, return null.
	 */
	function getVisibleSelectionRect(global) {
	  var selection = global.getSelection();
	  if (!selection.rangeCount) {
	    return null;
	  }
	
	  var range = selection.getRangeAt(0);
	  var boundingRect = getRangeBoundingClientRect(range);
	  var top = boundingRect.top,
	      right = boundingRect.right,
	      bottom = boundingRect.bottom,
	      left = boundingRect.left;
	
	  // When a re-render leads to a node being removed, the DOM selection will
	  // temporarily be placed on an ancestor node, which leads to an invalid
	  // bounding rect. Discard this state.
	
	  if (top === 0 && right === 0 && bottom === 0 && left === 0) {
	    return null;
	  }
	
	  return boundingRect;
	}
	
	module.exports = getVisibleSelectionRect;

/***/ }),
/* 527 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule insertFragmentIntoContentState
	 * @format
	 * 
	 */
	
	'use strict';
	
	var BlockMapBuilder = __webpack_require__(70);
	var ContentBlockNode = __webpack_require__(30);
	var Immutable = __webpack_require__(11);
	
	var insertIntoList = __webpack_require__(218);
	var invariant = __webpack_require__(12);
	var randomizeBlockMapKeys = __webpack_require__(221);
	
	var List = Immutable.List;
	
	
	var updateExistingBlock = function updateExistingBlock(contentState, selectionState, blockMap, fragmentBlock, targetKey, targetOffset) {
	  var targetBlock = blockMap.get(targetKey);
	  var text = targetBlock.getText();
	  var chars = targetBlock.getCharacterList();
	  var finalKey = targetKey;
	  var finalOffset = targetOffset + fragmentBlock.getText().length;
	
	  var newBlock = targetBlock.merge({
	    text: text.slice(0, targetOffset) + fragmentBlock.getText() + text.slice(targetOffset),
	    characterList: insertIntoList(chars, fragmentBlock.getCharacterList(), targetOffset),
	    data: fragmentBlock.getData()
	  });
	
	  return contentState.merge({
	    blockMap: blockMap.set(targetKey, newBlock),
	    selectionBefore: selectionState,
	    selectionAfter: selectionState.merge({
	      anchorKey: finalKey,
	      anchorOffset: finalOffset,
	      focusKey: finalKey,
	      focusOffset: finalOffset,
	      isBackward: false
	    })
	  });
	};
	
	/**
	 * Appends text/characterList from the fragment first block to
	 * target block.
	 */
	var updateHead = function updateHead(block, targetOffset, fragment) {
	  var text = block.getText();
	  var chars = block.getCharacterList();
	
	  // Modify head portion of block.
	  var headText = text.slice(0, targetOffset);
	  var headCharacters = chars.slice(0, targetOffset);
	  var appendToHead = fragment.first();
	
	  return block.merge({
	    text: headText + appendToHead.getText(),
	    characterList: headCharacters.concat(appendToHead.getCharacterList()),
	    type: headText ? block.getType() : appendToHead.getType(),
	    data: appendToHead.getData()
	  });
	};
	
	/**
	 * Appends offset text/characterList from the target block to the last
	 * fragment block.
	 */
	var updateTail = function updateTail(block, targetOffset, fragment) {
	  // Modify tail portion of block.
	  var text = block.getText();
	  var chars = block.getCharacterList();
	
	  // Modify head portion of block.
	  var blockSize = text.length;
	  var tailText = text.slice(targetOffset, blockSize);
	  var tailCharacters = chars.slice(targetOffset, blockSize);
	  var prependToTail = fragment.last();
	
	  return prependToTail.merge({
	    text: prependToTail.getText() + tailText,
	    characterList: prependToTail.getCharacterList().concat(tailCharacters),
	    data: prependToTail.getData()
	  });
	};
	
	var getRootBlocks = function getRootBlocks(block, blockMap) {
	  var headKey = block.getKey();
	  var rootBlock = block;
	  var rootBlocks = [];
	
	  // sometimes the fragment head block will not be part of the blockMap itself this can happen when
	  // the fragment head is used to update the target block, however when this does not happen we need
	  // to make sure that we include it on the rootBlocks since the first block of a fragment is always a
	  // fragment root block
	  if (blockMap.get(headKey)) {
	    rootBlocks.push(headKey);
	  }
	
	  while (rootBlock && rootBlock.getNextSiblingKey()) {
	    var lastSiblingKey = rootBlock.getNextSiblingKey();
	
	    if (!lastSiblingKey) {
	      break;
	    }
	
	    rootBlocks.push(lastSiblingKey);
	    rootBlock = blockMap.get(lastSiblingKey);
	  }
	
	  return rootBlocks;
	};
	
	var updateBlockMapLinks = function updateBlockMapLinks(blockMap, originalBlockMap, targetBlock, fragmentHeadBlock) {
	  return blockMap.withMutations(function (blockMapState) {
	    var targetKey = targetBlock.getKey();
	    var headKey = fragmentHeadBlock.getKey();
	    var targetNextKey = targetBlock.getNextSiblingKey();
	    var targetParentKey = targetBlock.getParentKey();
	    var fragmentRootBlocks = getRootBlocks(fragmentHeadBlock, blockMap);
	    var lastRootFragmentBlockKey = fragmentRootBlocks[fragmentRootBlocks.length - 1];
	
	    if (blockMapState.get(headKey)) {
	      // update the fragment head when it is part of the blockMap otherwise
	      blockMapState.setIn([targetKey, 'nextSibling'], headKey);
	      blockMapState.setIn([headKey, 'prevSibling'], targetKey);
	    } else {
	      // update the target block that had the fragment head contents merged into it
	      blockMapState.setIn([targetKey, 'nextSibling'], fragmentHeadBlock.getNextSiblingKey());
	      blockMapState.setIn([fragmentHeadBlock.getNextSiblingKey(), 'prevSibling'], targetKey);
	    }
	
	    // update the last root block fragment
	    blockMapState.setIn([lastRootFragmentBlockKey, 'nextSibling'], targetNextKey);
	
	    // update the original target next block
	    if (targetNextKey) {
	      blockMapState.setIn([targetNextKey, 'prevSibling'], lastRootFragmentBlockKey);
	    }
	
	    // update fragment parent links
	    fragmentRootBlocks.forEach(function (blockKey) {
	      return blockMapState.setIn([blockKey, 'parent'], targetParentKey);
	    });
	
	    // update targetBlock parent child links
	    if (targetParentKey) {
	      var targetParent = blockMap.get(targetParentKey);
	      var originalTargetParentChildKeys = targetParent.getChildKeys();
	
	      var targetBlockIndex = originalTargetParentChildKeys.indexOf(targetKey);
	      var insertionIndex = targetBlockIndex + 1;
	
	      var newChildrenKeysArray = originalTargetParentChildKeys.toArray();
	
	      // insert fragment children
	      newChildrenKeysArray.splice.apply(newChildrenKeysArray, [insertionIndex, 0].concat(fragmentRootBlocks));
	
	      blockMapState.setIn([targetParentKey, 'children'], List(newChildrenKeysArray));
	    }
	  });
	};
	
	var insertFragment = function insertFragment(contentState, selectionState, blockMap, fragment, targetKey, targetOffset) {
	  var isTreeBasedBlockMap = blockMap.first() instanceof ContentBlockNode;
	  var newBlockArr = [];
	  var fragmentSize = fragment.size;
	  var target = blockMap.get(targetKey);
	  var head = fragment.first();
	  var tail = fragment.last();
	  var finalOffset = tail.getLength();
	  var finalKey = tail.getKey();
	  var shouldNotUpdateFromFragmentBlock = isTreeBasedBlockMap && (!target.getChildKeys().isEmpty() || !head.getChildKeys().isEmpty());
	
	  blockMap.forEach(function (block, blockKey) {
	    if (blockKey !== targetKey) {
	      newBlockArr.push(block);
	      return;
	    }
	
	    if (shouldNotUpdateFromFragmentBlock) {
	      newBlockArr.push(block);
	    } else {
	      newBlockArr.push(updateHead(block, targetOffset, fragment));
	    }
	
	    // Insert fragment blocks after the head and before the tail.
	    fragment
	    // when we are updating the target block with the head fragment block we skip the first fragment
	    // head since its contents have already been merged with the target block otherwise we include
	    // the whole fragment
	    .slice(shouldNotUpdateFromFragmentBlock ? 0 : 1, fragmentSize - 1).forEach(function (fragmentBlock) {
	      return newBlockArr.push(fragmentBlock);
	    });
	
	    // update tail
	    newBlockArr.push(updateTail(block, targetOffset, fragment));
	  });
	
	  var updatedBlockMap = BlockMapBuilder.createFromArray(newBlockArr);
	
	  if (isTreeBasedBlockMap) {
	    updatedBlockMap = updateBlockMapLinks(updatedBlockMap, blockMap, target, head);
	  }
	
	  return contentState.merge({
	    blockMap: updatedBlockMap,
	    selectionBefore: selectionState,
	    selectionAfter: selectionState.merge({
	      anchorKey: finalKey,
	      anchorOffset: finalOffset,
	      focusKey: finalKey,
	      focusOffset: finalOffset,
	      isBackward: false
	    })
	  });
	};
	
	var insertFragmentIntoContentState = function insertFragmentIntoContentState(contentState, selectionState, fragmentBlockMap) {
	  !selectionState.isCollapsed() ?  true ? invariant(false, '`insertFragment` should only be called with a collapsed selection state.') : invariant(false) : void 0;
	
	  var blockMap = contentState.getBlockMap();
	  var fragment = randomizeBlockMapKeys(fragmentBlockMap);
	  var targetKey = selectionState.getStartKey();
	  var targetOffset = selectionState.getStartOffset();
	
	  var targetBlock = blockMap.get(targetKey);
	
	  if (targetBlock instanceof ContentBlockNode) {
	    !targetBlock.getChildKeys().isEmpty() ?  true ? invariant(false, '`insertFragment` should not be called when a container node is selected.') : invariant(false) : void 0;
	  }
	
	  // When we insert a fragment with a single block we simply update the target block
	  // with the contents of the inserted fragment block
	  if (fragment.size === 1) {
	    return updateExistingBlock(contentState, selectionState, blockMap, fragment.first(), targetKey, targetOffset);
	  }
	
	  return insertFragment(contentState, selectionState, blockMap, fragment, targetKey, targetOffset);
	};
	
	module.exports = insertFragmentIntoContentState;

/***/ }),
/* 528 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule insertTextIntoContentState
	 * @format
	 * 
	 */
	
	'use strict';
	
	var Immutable = __webpack_require__(11);
	
	var insertIntoList = __webpack_require__(218);
	var invariant = __webpack_require__(12);
	
	var Repeat = Immutable.Repeat;
	
	
	function insertTextIntoContentState(contentState, selectionState, text, characterMetadata) {
	  !selectionState.isCollapsed() ?  true ? invariant(false, '`insertText` should only be called with a collapsed range.') : invariant(false) : void 0;
	
	  var len = text.length;
	  if (!len) {
	    return contentState;
	  }
	
	  var blockMap = contentState.getBlockMap();
	  var key = selectionState.getStartKey();
	  var offset = selectionState.getStartOffset();
	  var block = blockMap.get(key);
	  var blockText = block.getText();
	
	  var newBlock = block.merge({
	    text: blockText.slice(0, offset) + text + blockText.slice(offset, block.getLength()),
	    characterList: insertIntoList(block.getCharacterList(), Repeat(characterMetadata, len).toList(), offset)
	  });
	
	  var newOffset = offset + len;
	
	  return contentState.merge({
	    blockMap: blockMap.set(key, newBlock),
	    selectionAfter: selectionState.merge({
	      anchorOffset: newOffset,
	      focusOffset: newOffset
	    })
	  });
	}
	
	module.exports = insertTextIntoContentState;

/***/ }),
/* 529 */
/***/ (function(module, exports, __webpack_require__) {

	/* WEBPACK VAR INJECTION */(function(global) {/**
	 * 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.
	 *
	 * @providesModule keyCommandBackspaceToStartOfLine
	 * @format
	 * 
	 */
	
	'use strict';
	
	var EditorState = __webpack_require__(15);
	
	var expandRangeToStartOfLine = __webpack_require__(521);
	var getDraftEditorSelectionWithNodes = __webpack_require__(210);
	var moveSelectionBackward = __webpack_require__(128);
	var removeTextWithStrategy = __webpack_require__(74);
	
	function keyCommandBackspaceToStartOfLine(editorState) {
	  var afterRemoval = removeTextWithStrategy(editorState, function (strategyState) {
	    var selection = strategyState.getSelection();
	    if (selection.isCollapsed() && selection.getAnchorOffset() === 0) {
	      return moveSelectionBackward(strategyState, 1);
	    }
	
	    var domSelection = global.getSelection();
	    var range = domSelection.getRangeAt(0);
	    range = expandRangeToStartOfLine(range);
	
	    return getDraftEditorSelectionWithNodes(strategyState, null, range.endContainer, range.endOffset, range.startContainer, range.startOffset).selectionState;
	  }, 'backward');
	
	  if (afterRemoval === editorState.getCurrentContent()) {
	    return editorState;
	  }
	
	  return EditorState.push(editorState, afterRemoval, 'remove-range');
	}
	
	module.exports = keyCommandBackspaceToStartOfLine;
	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))

/***/ }),
/* 530 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule keyCommandBackspaceWord
	 * @format
	 * 
	 */
	
	'use strict';
	
	var DraftRemovableWord = __webpack_require__(205);
	var EditorState = __webpack_require__(15);
	
	var moveSelectionBackward = __webpack_require__(128);
	var removeTextWithStrategy = __webpack_require__(74);
	
	/**
	 * Delete the word that is left of the cursor, as well as any spaces or
	 * punctuation after the word.
	 */
	function keyCommandBackspaceWord(editorState) {
	  var afterRemoval = removeTextWithStrategy(editorState, function (strategyState) {
	    var selection = strategyState.getSelection();
	    var offset = selection.getStartOffset();
	    // If there are no words before the cursor, remove the preceding newline.
	    if (offset === 0) {
	      return moveSelectionBackward(strategyState, 1);
	    }
	    var key = selection.getStartKey();
	    var content = strategyState.getCurrentContent();
	    var text = content.getBlockForKey(key).getText().slice(0, offset);
	    var toRemove = DraftRemovableWord.getBackward(text);
	    return moveSelectionBackward(strategyState, toRemove.length || 1);
	  }, 'backward');
	
	  if (afterRemoval === editorState.getCurrentContent()) {
	    return editorState;
	  }
	
	  return EditorState.push(editorState, afterRemoval, 'remove-range');
	}
	
	module.exports = keyCommandBackspaceWord;

/***/ }),
/* 531 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule keyCommandDeleteWord
	 * @format
	 * 
	 */
	
	'use strict';
	
	var DraftRemovableWord = __webpack_require__(205);
	var EditorState = __webpack_require__(15);
	
	var moveSelectionForward = __webpack_require__(220);
	var removeTextWithStrategy = __webpack_require__(74);
	
	/**
	 * Delete the word that is right of the cursor, as well as any spaces or
	 * punctuation before the word.
	 */
	function keyCommandDeleteWord(editorState) {
	  var afterRemoval = removeTextWithStrategy(editorState, function (strategyState) {
	    var selection = strategyState.getSelection();
	    var offset = selection.getStartOffset();
	    var key = selection.getStartKey();
	    var content = strategyState.getCurrentContent();
	    var text = content.getBlockForKey(key).getText().slice(offset);
	    var toRemove = DraftRemovableWord.getForward(text);
	
	    // If there are no words in front of the cursor, remove the newline.
	    return moveSelectionForward(strategyState, toRemove.length || 1);
	  }, 'forward');
	
	  if (afterRemoval === editorState.getCurrentContent()) {
	    return editorState;
	  }
	
	  return EditorState.push(editorState, afterRemoval, 'remove-range');
	}
	
	module.exports = keyCommandDeleteWord;

/***/ }),
/* 532 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule keyCommandInsertNewline
	 * @format
	 * 
	 */
	
	'use strict';
	
	var DraftModifier = __webpack_require__(26);
	var EditorState = __webpack_require__(15);
	
	function keyCommandInsertNewline(editorState) {
	  var contentState = DraftModifier.splitBlock(editorState.getCurrentContent(), editorState.getSelection());
	  return EditorState.push(editorState, contentState, 'split-block');
	}
	
	module.exports = keyCommandInsertNewline;

/***/ }),
/* 533 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule keyCommandMoveSelectionToEndOfBlock
	 * @format
	 * 
	 */
	
	'use strict';
	
	var EditorState = __webpack_require__(15);
	
	/**
	 * See comment for `moveSelectionToStartOfBlock`.
	 */
	function keyCommandMoveSelectionToEndOfBlock(editorState) {
	  var selection = editorState.getSelection();
	  var endKey = selection.getEndKey();
	  var content = editorState.getCurrentContent();
	  var textLength = content.getBlockForKey(endKey).getLength();
	  return EditorState.set(editorState, {
	    selection: selection.merge({
	      anchorKey: endKey,
	      anchorOffset: textLength,
	      focusKey: endKey,
	      focusOffset: textLength,
	      isBackward: false
	    }),
	    forceSelection: true
	  });
	}
	
	module.exports = keyCommandMoveSelectionToEndOfBlock;

/***/ }),
/* 534 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule keyCommandMoveSelectionToStartOfBlock
	 * @format
	 * 
	 */
	
	'use strict';
	
	var EditorState = __webpack_require__(15);
	
	/**
	 * Collapse selection at the start of the first selected block. This is used
	 * for Firefox versions that attempt to navigate forward/backward instead of
	 * moving the cursor. Other browsers are able to move the cursor natively.
	 */
	function keyCommandMoveSelectionToStartOfBlock(editorState) {
	  var selection = editorState.getSelection();
	  var startKey = selection.getStartKey();
	  return EditorState.set(editorState, {
	    selection: selection.merge({
	      anchorKey: startKey,
	      anchorOffset: 0,
	      focusKey: startKey,
	      focusOffset: 0,
	      isBackward: false
	    }),
	    forceSelection: true
	  });
	}
	
	module.exports = keyCommandMoveSelectionToStartOfBlock;

/***/ }),
/* 535 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule keyCommandPlainBackspace
	 * @format
	 * 
	 */
	
	'use strict';
	
	var EditorState = __webpack_require__(15);
	var UnicodeUtils = __webpack_require__(51);
	
	var moveSelectionBackward = __webpack_require__(128);
	var removeTextWithStrategy = __webpack_require__(74);
	
	/**
	 * Remove the selected range. If the cursor is collapsed, remove the preceding
	 * character. This operation is Unicode-aware, so removing a single character
	 * will remove a surrogate pair properly as well.
	 */
	function keyCommandPlainBackspace(editorState) {
	  var afterRemoval = removeTextWithStrategy(editorState, function (strategyState) {
	    var selection = strategyState.getSelection();
	    var content = strategyState.getCurrentContent();
	    var key = selection.getAnchorKey();
	    var offset = selection.getAnchorOffset();
	    var charBehind = content.getBlockForKey(key).getText()[offset - 1];
	    return moveSelectionBackward(strategyState, charBehind ? UnicodeUtils.getUTF16Length(charBehind, 0) : 1);
	  }, 'backward');
	
	  if (afterRemoval === editorState.getCurrentContent()) {
	    return editorState;
	  }
	
	  var selection = editorState.getSelection();
	  return EditorState.push(editorState, afterRemoval.set('selectionBefore', selection), selection.isCollapsed() ? 'backspace-character' : 'remove-range');
	}
	
	module.exports = keyCommandPlainBackspace;

/***/ }),
/* 536 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule keyCommandPlainDelete
	 * @format
	 * 
	 */
	
	'use strict';
	
	var EditorState = __webpack_require__(15);
	var UnicodeUtils = __webpack_require__(51);
	
	var moveSelectionForward = __webpack_require__(220);
	var removeTextWithStrategy = __webpack_require__(74);
	
	/**
	 * Remove the selected range. If the cursor is collapsed, remove the following
	 * character. This operation is Unicode-aware, so removing a single character
	 * will remove a surrogate pair properly as well.
	 */
	function keyCommandPlainDelete(editorState) {
	  var afterRemoval = removeTextWithStrategy(editorState, function (strategyState) {
	    var selection = strategyState.getSelection();
	    var content = strategyState.getCurrentContent();
	    var key = selection.getAnchorKey();
	    var offset = selection.getAnchorOffset();
	    var charAhead = content.getBlockForKey(key).getText()[offset];
	    return moveSelectionForward(strategyState, charAhead ? UnicodeUtils.getUTF16Length(charAhead, 0) : 1);
	  }, 'forward');
	
	  if (afterRemoval === editorState.getCurrentContent()) {
	    return editorState;
	  }
	
	  var selection = editorState.getSelection();
	
	  return EditorState.push(editorState, afterRemoval.set('selectionBefore', selection), selection.isCollapsed() ? 'delete-character' : 'remove-range');
	}
	
	module.exports = keyCommandPlainDelete;

/***/ }),
/* 537 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule keyCommandTransposeCharacters
	 * @format
	 * 
	 */
	
	'use strict';
	
	var DraftModifier = __webpack_require__(26);
	var EditorState = __webpack_require__(15);
	
	var getContentStateFragment = __webpack_require__(90);
	
	/**
	 * Transpose the characters on either side of a collapsed cursor, or
	 * if the cursor is at the end of the block, transpose the last two
	 * characters.
	 */
	function keyCommandTransposeCharacters(editorState) {
	  var selection = editorState.getSelection();
	  if (!selection.isCollapsed()) {
	    return editorState;
	  }
	
	  var offset = selection.getAnchorOffset();
	  if (offset === 0) {
	    return editorState;
	  }
	
	  var blockKey = selection.getAnchorKey();
	  var content = editorState.getCurrentContent();
	  var block = content.getBlockForKey(blockKey);
	  var length = block.getLength();
	
	  // Nothing to transpose if there aren't two characters.
	  if (length <= 1) {
	    return editorState;
	  }
	
	  var removalRange;
	  var finalSelection;
	
	  if (offset === length) {
	    // The cursor is at the end of the block. Swap the last two characters.
	    removalRange = selection.set('anchorOffset', offset - 1);
	    finalSelection = selection;
	  } else {
	    removalRange = selection.set('focusOffset', offset + 1);
	    finalSelection = removalRange.set('anchorOffset', offset + 1);
	  }
	
	  // Extract the character to move as a fragment. This preserves its
	  // styling and entity, if any.
	  var movedFragment = getContentStateFragment(content, removalRange);
	  var afterRemoval = DraftModifier.removeRange(content, removalRange, 'backward');
	
	  // After the removal, the insertion target is one character back.
	  var selectionAfter = afterRemoval.getSelectionAfter();
	  var targetOffset = selectionAfter.getAnchorOffset() - 1;
	  var targetRange = selectionAfter.merge({
	    anchorOffset: targetOffset,
	    focusOffset: targetOffset
	  });
	
	  var afterInsert = DraftModifier.replaceWithFragment(afterRemoval, targetRange, movedFragment);
	
	  var newEditorState = EditorState.push(editorState, afterInsert, 'insert-fragment');
	
	  return EditorState.acceptSelection(newEditorState, finalSelection);
	}
	
	module.exports = keyCommandTransposeCharacters;

/***/ }),
/* 538 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule keyCommandUndo
	 * @format
	 * 
	 */
	
	'use strict';
	
	var EditorState = __webpack_require__(15);
	
	function keyCommandUndo(e, editorState, updateFn) {
	  var undoneState = EditorState.undo(editorState);
	
	  // If the last change to occur was a spellcheck change, allow the undo
	  // event to fall through to the browser. This allows the browser to record
	  // the unwanted change, which should soon lead it to learn not to suggest
	  // the correction again.
	  if (editorState.getLastChangeType() === 'spellcheck-change') {
	    var nativelyRenderedContent = undoneState.getCurrentContent();
	    updateFn(EditorState.set(undoneState, { nativelyRenderedContent: nativelyRenderedContent }));
	    return;
	  }
	
	  // Otheriwse, manage the undo behavior manually.
	  e.preventDefault();
	  if (!editorState.getNativelyRenderedContent()) {
	    updateFn(undoneState);
	    return;
	  }
	
	  // Trigger a re-render with the current content state to ensure that the
	  // component tree has up-to-date props for comparison.
	  updateFn(EditorState.set(editorState, { nativelyRenderedContent: null }));
	
	  // Wait to ensure that the re-render has occurred before performing
	  // the undo action.
	  setTimeout(function () {
	    updateFn(undoneState);
	  }, 0);
	}
	
	module.exports = keyCommandUndo;

/***/ }),
/* 539 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule modifyBlockForContentState
	 * @format
	 * 
	 */
	
	'use strict';
	
	var Immutable = __webpack_require__(11);
	
	var Map = Immutable.Map;
	
	
	function modifyBlockForContentState(contentState, selectionState, operation) {
	  var startKey = selectionState.getStartKey();
	  var endKey = selectionState.getEndKey();
	  var blockMap = contentState.getBlockMap();
	  var newBlocks = blockMap.toSeq().skipUntil(function (_, k) {
	    return k === startKey;
	  }).takeUntil(function (_, k) {
	    return k === endKey;
	  }).concat(Map([[endKey, blockMap.get(endKey)]])).map(operation);
	
	  return contentState.merge({
	    blockMap: blockMap.merge(newBlocks),
	    selectionBefore: selectionState,
	    selectionAfter: selectionState
	  });
	}
	
	module.exports = modifyBlockForContentState;

/***/ }),
/* 540 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule moveBlockInContentState
	 * @format
	 * 
	 */
	
	'use strict';
	
	var ContentBlockNode = __webpack_require__(30);
	var Immutable = __webpack_require__(11);
	
	var getNextDelimiterBlockKey = __webpack_require__(212);
	var invariant = __webpack_require__(12);
	
	var OrderedMap = Immutable.OrderedMap,
	    List = Immutable.List;
	
	
	var transformBlock = function transformBlock(key, blockMap, func) {
	  if (!key) {
	    return;
	  }
	
	  var block = blockMap.get(key);
	
	  if (!block) {
	    return;
	  }
	
	  blockMap.set(key, func(block));
	};
	
	var updateBlockMapLinks = function updateBlockMapLinks(blockMap, originalBlockToBeMoved, originalTargetBlock, insertionMode, isExperimentalTreeBlock) {
	  if (!isExperimentalTreeBlock) {
	    return blockMap;
	  }
	  // possible values of 'insertionMode' are: 'after', 'before'
	  var isInsertedAfterTarget = insertionMode === 'after';
	
	  var originalBlockKey = originalBlockToBeMoved.getKey();
	  var originalTargetKey = originalTargetBlock.getKey();
	  var originalParentKey = originalBlockToBeMoved.getParentKey();
	  var originalNextSiblingKey = originalBlockToBeMoved.getNextSiblingKey();
	  var originalPrevSiblingKey = originalBlockToBeMoved.getPrevSiblingKey();
	  var newParentKey = originalTargetBlock.getParentKey();
	  var newNextSiblingKey = isInsertedAfterTarget ? originalTargetBlock.getNextSiblingKey() : originalTargetKey;
	  var newPrevSiblingKey = isInsertedAfterTarget ? originalTargetKey : originalTargetBlock.getPrevSiblingKey();
	
	  return blockMap.withMutations(function (blocks) {
	    // update old parent
	    transformBlock(originalParentKey, blocks, function (block) {
	      var parentChildrenList = block.getChildKeys();
	      return block.merge({
	        children: parentChildrenList['delete'](parentChildrenList.indexOf(originalBlockKey))
	      });
	    });
	
	    // update old prev
	    transformBlock(originalPrevSiblingKey, blocks, function (block) {
	      return block.merge({
	        nextSibling: originalNextSiblingKey
	      });
	    });
	
	    // update old next
	    transformBlock(originalNextSiblingKey, blocks, function (block) {
	      return block.merge({
	        prevSibling: originalPrevSiblingKey
	      });
	    });
	
	    // update new next
	    transformBlock(newNextSiblingKey, blocks, function (block) {
	      return block.merge({
	        prevSibling: originalBlockKey
	      });
	    });
	
	    // update new prev
	    transformBlock(newPrevSiblingKey, blocks, function (block) {
	      return block.merge({
	        nextSibling: originalBlockKey
	      });
	    });
	
	    // update new parent
	    transformBlock(newParentKey, blocks, function (block) {
	      var newParentChildrenList = block.getChildKeys();
	      var targetBlockIndex = newParentChildrenList.indexOf(originalTargetKey);
	
	      var insertionIndex = isInsertedAfterTarget ? targetBlockIndex + 1 : targetBlockIndex !== 0 ? targetBlockIndex - 1 : 0;
	
	      var newChildrenArray = newParentChildrenList.toArray();
	      newChildrenArray.splice(insertionIndex, 0, originalBlockKey);
	
	      return block.merge({
	        children: List(newChildrenArray)
	      });
	    });
	
	    // update block
	    transformBlock(originalBlockKey, blocks, function (block) {
	      return block.merge({
	        nextSibling: newNextSiblingKey,
	        prevSibling: newPrevSiblingKey,
	        parent: newParentKey
	      });
	    });
	  });
	};
	
	var moveBlockInContentState = function moveBlockInContentState(contentState, blockToBeMoved, targetBlock, insertionMode) {
	  !(insertionMode !== 'replace') ?  true ? invariant(false, 'Replacing blocks is not supported.') : invariant(false) : void 0;
	
	  var targetKey = targetBlock.getKey();
	  var blockKey = blockToBeMoved.getKey();
	
	  !(blockKey !== targetKey) ?  true ? invariant(false, 'Block cannot be moved next to itself.') : invariant(false) : void 0;
	
	  var blockMap = contentState.getBlockMap();
	  var isExperimentalTreeBlock = blockToBeMoved instanceof ContentBlockNode;
	
	  var blocksToBeMoved = [blockToBeMoved];
	  var blockMapWithoutBlocksToBeMoved = blockMap['delete'](blockKey);
	
	  if (isExperimentalTreeBlock) {
	    blocksToBeMoved = [];
	    blockMapWithoutBlocksToBeMoved = blockMap.withMutations(function (blocks) {
	      var nextSiblingKey = blockToBeMoved.getNextSiblingKey();
	      var nextDelimiterBlockKey = getNextDelimiterBlockKey(blockToBeMoved, blocks);
	
	      blocks.toSeq().skipUntil(function (block) {
	        return block.getKey() === blockKey;
	      }).takeWhile(function (block) {
	        var key = block.getKey();
	        var isBlockToBeMoved = key === blockKey;
	        var hasNextSiblingAndIsNotNextSibling = nextSiblingKey && key !== nextSiblingKey;
	        var doesNotHaveNextSiblingAndIsNotDelimiter = !nextSiblingKey && block.getParentKey() && (!nextDelimiterBlockKey || key !== nextDelimiterBlockKey);
	
	        return !!(isBlockToBeMoved || hasNextSiblingAndIsNotNextSibling || doesNotHaveNextSiblingAndIsNotDelimiter);
	      }).forEach(function (block) {
	        blocksToBeMoved.push(block);
	        blocks['delete'](block.getKey());
	      });
	    });
	  }
	
	  var blocksBefore = blockMapWithoutBlocksToBeMoved.toSeq().takeUntil(function (v) {
	    return v === targetBlock;
	  });
	
	  var blocksAfter = blockMapWithoutBlocksToBeMoved.toSeq().skipUntil(function (v) {
	    return v === targetBlock;
	  }).skip(1);
	
	  var slicedBlocks = blocksToBeMoved.map(function (block) {
	    return [block.getKey(), block];
	  });
	
	  var newBlocks = OrderedMap();
	
	  if (insertionMode === 'before') {
	    var blockBefore = contentState.getBlockBefore(targetKey);
	
	    !(!blockBefore || blockBefore.getKey() !== blockToBeMoved.getKey()) ?  true ? invariant(false, 'Block cannot be moved next to itself.') : invariant(false) : void 0;
	
	    newBlocks = blocksBefore.concat([].concat(slicedBlocks, [[targetKey, targetBlock]]), blocksAfter).toOrderedMap();
	  } else if (insertionMode === 'after') {
	    var blockAfter = contentState.getBlockAfter(targetKey);
	
	    !(!blockAfter || blockAfter.getKey() !== blockKey) ?  true ? invariant(false, 'Block cannot be moved next to itself.') : invariant(false) : void 0;
	
	    newBlocks = blocksBefore.concat([[targetKey, targetBlock]].concat(slicedBlocks), blocksAfter).toOrderedMap();
	  }
	
	  return contentState.merge({
	    blockMap: updateBlockMapLinks(newBlocks, blockToBeMoved, targetBlock, insertionMode, isExperimentalTreeBlock),
	    selectionBefore: contentState.getSelectionAfter(),
	    selectionAfter: contentState.getSelectionAfter().merge({
	      anchorKey: blockKey,
	      focusKey: blockKey
	    })
	  });
	};
	
	module.exports = moveBlockInContentState;

/***/ }),
/* 541 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule removeRangeFromContentState
	 * @format
	 * 
	 */
	
	'use strict';
	
	var ContentBlockNode = __webpack_require__(30);
	var Immutable = __webpack_require__(11);
	
	var getNextDelimiterBlockKey = __webpack_require__(212);
	
	var List = Immutable.List,
	    Map = Immutable.Map;
	
	
	var transformBlock = function transformBlock(key, blockMap, func) {
	  if (!key) {
	    return;
	  }
	
	  var block = blockMap.get(key);
	
	  if (!block) {
	    return;
	  }
	
	  blockMap.set(key, func(block));
	};
	
	/**
	 * Ancestors needs to be preserved when there are non selected
	 * children to make sure we do not leave any orphans behind
	 */
	var getAncestorsKeys = function getAncestorsKeys(blockKey, blockMap) {
	  var parents = [];
	
	  if (!blockKey) {
	    return parents;
	  }
	
	  var blockNode = blockMap.get(blockKey);
	  while (blockNode && blockNode.getParentKey()) {
	    var parentKey = blockNode.getParentKey();
	    if (parentKey) {
	      parents.push(parentKey);
	    }
	    blockNode = parentKey ? blockMap.get(parentKey) : null;
	  }
	
	  return parents;
	};
	
	/**
	 * Get all next delimiter keys until we hit a root delimiter and return
	 * an array of key references
	 */
	var getNextDelimitersBlockKeys = function getNextDelimitersBlockKeys(block, blockMap) {
	  var nextDelimiters = [];
	
	  if (!block) {
	    return nextDelimiters;
	  }
	
	  var nextDelimiter = getNextDelimiterBlockKey(block, blockMap);
	  while (nextDelimiter && blockMap.get(nextDelimiter)) {
	    var _block = blockMap.get(nextDelimiter);
	    nextDelimiters.push(nextDelimiter);
	
	    // we do not need to keep checking all root node siblings, just the first occurance
	    nextDelimiter = _block.getParentKey() ? getNextDelimiterBlockKey(_block, blockMap) : null;
	  }
	
	  return nextDelimiters;
	};
	
	var getNextValidSibling = function getNextValidSibling(block, blockMap, originalBlockMap) {
	  if (!block) {
	    return null;
	  }
	
	  // note that we need to make sure we refer to the original block since this
	  // function is called within a withMutations
	  var nextValidSiblingKey = originalBlockMap.get(block.getKey()).getNextSiblingKey();
	
	  while (nextValidSiblingKey && !blockMap.get(nextValidSiblingKey)) {
	    nextValidSiblingKey = originalBlockMap.get(nextValidSiblingKey).getNextSiblingKey() || null;
	  }
	
	  return nextValidSiblingKey;
	};
	
	var getPrevValidSibling = function getPrevValidSibling(block, blockMap, originalBlockMap) {
	  if (!block) {
	    return null;
	  }
	
	  // note that we need to make sure we refer to the original block since this
	  // function is called within a withMutations
	  var prevValidSiblingKey = originalBlockMap.get(block.getKey()).getPrevSiblingKey();
	
	  while (prevValidSiblingKey && !blockMap.get(prevValidSiblingKey)) {
	    prevValidSiblingKey = originalBlockMap.get(prevValidSiblingKey).getPrevSiblingKey() || null;
	  }
	
	  return prevValidSiblingKey;
	};
	
	var updateBlockMapLinks = function updateBlockMapLinks(blockMap, startBlock, endBlock, originalBlockMap) {
	  return blockMap.withMutations(function (blocks) {
	    // update start block if its retained
	    transformBlock(startBlock.getKey(), blocks, function (block) {
	      return block.merge({
	        nextSibling: getNextValidSibling(startBlock, blocks, originalBlockMap),
	        prevSibling: getPrevValidSibling(startBlock, blocks, originalBlockMap)
	      });
	    });
	
	    // update endblock if its retained
	    transformBlock(endBlock.getKey(), blocks, function (block) {
	      return block.merge({
	        nextSibling: getNextValidSibling(endBlock, blocks, originalBlockMap),
	        prevSibling: getPrevValidSibling(endBlock, blocks, originalBlockMap)
	      });
	    });
	
	    // update start block parent ancestors
	    getAncestorsKeys(startBlock.getKey(), originalBlockMap).forEach(function (parentKey) {
	      return transformBlock(parentKey, blocks, function (block) {
	        return block.merge({
	          children: block.getChildKeys().filter(function (key) {
	            return blocks.get(key);
	          }),
	          nextSibling: getNextValidSibling(block, blocks, originalBlockMap),
	          prevSibling: getPrevValidSibling(block, blocks, originalBlockMap)
	        });
	      });
	    });
	
	    // update start block next - can only happen if startBlock == endBlock
	    transformBlock(startBlock.getNextSiblingKey(), blocks, function (block) {
	      return block.merge({
	        prevSibling: startBlock.getPrevSiblingKey()
	      });
	    });
	
	    // update start block prev
	    transformBlock(startBlock.getPrevSiblingKey(), blocks, function (block) {
	      return block.merge({
	        nextSibling: getNextValidSibling(startBlock, blocks, originalBlockMap)
	      });
	    });
	
	    // update end block next
	    transformBlock(endBlock.getNextSiblingKey(), blocks, function (block) {
	      return block.merge({
	        prevSibling: getPrevValidSibling(endBlock, blocks, originalBlockMap)
	      });
	    });
	
	    // update end block prev
	    transformBlock(endBlock.getPrevSiblingKey(), blocks, function (block) {
	      return block.merge({
	        nextSibling: endBlock.getNextSiblingKey()
	      });
	    });
	
	    // update end block parent ancestors
	    getAncestorsKeys(endBlock.getKey(), originalBlockMap).forEach(function (parentKey) {
	      transformBlock(parentKey, blocks, function (block) {
	        return block.merge({
	          children: block.getChildKeys().filter(function (key) {
	            return blocks.get(key);
	          }),
	          nextSibling: getNextValidSibling(block, blocks, originalBlockMap),
	          prevSibling: getPrevValidSibling(block, blocks, originalBlockMap)
	        });
	      });
	    });
	
	    // update next delimiters all the way to a root delimiter
	    getNextDelimitersBlockKeys(endBlock, originalBlockMap).forEach(function (delimiterKey) {
	      return transformBlock(delimiterKey, blocks, function (block) {
	        return block.merge({
	          nextSibling: getNextValidSibling(block, blocks, originalBlockMap),
	          prevSibling: getPrevValidSibling(block, blocks, originalBlockMap)
	        });
	      });
	    });
	  });
	};
	
	var removeRangeFromContentState = function removeRangeFromContentState(contentState, selectionState) {
	  if (selectionState.isCollapsed()) {
	    return contentState;
	  }
	
	  var blockMap = contentState.getBlockMap();
	  var startKey = selectionState.getStartKey();
	  var startOffset = selectionState.getStartOffset();
	  var endKey = selectionState.getEndKey();
	  var endOffset = selectionState.getEndOffset();
	
	  var startBlock = blockMap.get(startKey);
	  var endBlock = blockMap.get(endKey);
	
	  // we assume that ContentBlockNode and ContentBlocks are not mixed together
	  var isExperimentalTreeBlock = startBlock instanceof ContentBlockNode;
	
	  // used to retain blocks that should not be deleted to avoid orphan children
	  var parentAncestors = [];
	
	  if (isExperimentalTreeBlock) {
	    var endBlockchildrenKeys = endBlock.getChildKeys();
	    var endBlockAncestors = getAncestorsKeys(endKey, blockMap);
	
	    // endBlock has unselected sibblings so we can not remove its ancestors parents
	    if (endBlock.getNextSiblingKey()) {
	      parentAncestors = parentAncestors.concat(endBlockAncestors);
	    }
	
	    // endBlock has children so can not remove this block or any of its ancestors
	    if (!endBlockchildrenKeys.isEmpty()) {
	      parentAncestors = parentAncestors.concat(endBlockAncestors.concat([endKey]));
	    }
	
	    // we need to retain all ancestors of the next delimiter block
	    parentAncestors = parentAncestors.concat(getAncestorsKeys(getNextDelimiterBlockKey(endBlock, blockMap), blockMap));
	  }
	
	  var characterList = void 0;
	
	  if (startBlock === endBlock) {
	    characterList = removeFromList(startBlock.getCharacterList(), startOffset, endOffset);
	  } else {
	    characterList = startBlock.getCharacterList().slice(0, startOffset).concat(endBlock.getCharacterList().slice(endOffset));
	  }
	
	  var modifiedStart = startBlock.merge({
	    text: startBlock.getText().slice(0, startOffset) + endBlock.getText().slice(endOffset),
	    characterList: characterList
	  });
	
	  var newBlocks = blockMap.toSeq().skipUntil(function (_, k) {
	    return k === startKey;
	  }).takeUntil(function (_, k) {
	    return k === endKey;
	  }).filter(function (_, k) {
	    return parentAncestors.indexOf(k) === -1;
	  }).concat(Map([[endKey, null]])).map(function (_, k) {
	    return k === startKey ? modifiedStart : null;
	  });
	
	  var updatedBlockMap = blockMap.merge(newBlocks).filter(function (block) {
	    return !!block;
	  });
	
	  if (isExperimentalTreeBlock) {
	    updatedBlockMap = updateBlockMapLinks(updatedBlockMap, startBlock, endBlock, blockMap);
	  }
	
	  return contentState.merge({
	    blockMap: updatedBlockMap,
	    selectionBefore: selectionState,
	    selectionAfter: selectionState.merge({
	      anchorKey: startKey,
	      anchorOffset: startOffset,
	      focusKey: startKey,
	      focusOffset: startOffset,
	      isBackward: false
	    })
	  });
	};
	
	/**
	 * Maintain persistence for target list when removing characters on the
	 * head and tail of the character list.
	 */
	var removeFromList = function removeFromList(targetList, startOffset, endOffset) {
	  if (startOffset === 0) {
	    while (startOffset < endOffset) {
	      targetList = targetList.shift();
	      startOffset++;
	    }
	  } else if (endOffset === targetList.count()) {
	    while (endOffset > startOffset) {
	      targetList = targetList.pop();
	      endOffset--;
	    }
	  } else {
	    var head = targetList.slice(0, startOffset);
	    var tail = targetList.slice(endOffset);
	    targetList = head.concat(tail).toList();
	  }
	  return targetList;
	};
	
	module.exports = removeRangeFromContentState;

/***/ }),
/* 542 */
/***/ (function(module, exports, __webpack_require__) {

	/* WEBPACK VAR INJECTION */(function(global) {/**
	 * 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.
	 *
	 * @providesModule setDraftEditorSelection
	 * @format
	 * 
	 */
	
	'use strict';
	
	var DraftJsDebugLogging = __webpack_require__(494);
	
	var containsNode = __webpack_require__(133);
	var getActiveElement = __webpack_require__(227);
	var invariant = __webpack_require__(12);
	
	function getAnonymizedDOM(node, getNodeLabels) {
	  if (!node) {
	    return '[empty]';
	  }
	
	  var anonymized = anonymizeTextWithin(node, getNodeLabels);
	  if (anonymized.nodeType === Node.TEXT_NODE) {
	    return anonymized.textContent;
	  }
	
	  !(anonymized instanceof Element) ?  true ? invariant(false, 'Node must be an Element if it is not a text node.') : invariant(false) : void 0;
	  return anonymized.outerHTML;
	}
	
	function anonymizeTextWithin(node, getNodeLabels) {
	  var labels = getNodeLabels !== undefined ? getNodeLabels(node) : [];
	
	  if (node.nodeType === Node.TEXT_NODE) {
	    var length = node.textContent.length;
	    return document.createTextNode('[text ' + length + (labels.length ? ' | ' + labels.join(', ') : '') + ']');
	  }
	
	  var clone = node.cloneNode();
	  if (clone.nodeType === 1 && labels.length) {
	    clone.setAttribute('data-labels', labels.join(', '));
	  }
	  var childNodes = node.childNodes;
	  for (var ii = 0; ii < childNodes.length; ii++) {
	    clone.appendChild(anonymizeTextWithin(childNodes[ii], getNodeLabels));
	  }
	
	  return clone;
	}
	
	function getAnonymizedEditorDOM(node, getNodeLabels) {
	  // grabbing the DOM content of the Draft editor
	  var currentNode = node;
	  while (currentNode) {
	    if (currentNode instanceof Element && currentNode.hasAttribute('contenteditable')) {
	      // found the Draft editor container
	      return getAnonymizedDOM(currentNode, getNodeLabels);
	    } else {
	      currentNode = currentNode.parentNode;
	    }
	  }
	  return 'Could not find contentEditable parent of node';
	}
	
	function getNodeLength(node) {
	  return node.nodeValue === null ? node.childNodes.length : node.nodeValue.length;
	}
	
	/**
	 * 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 programatically create a backward selection. Thus, for all IE
	 * versions, we use the old IE API to create our selections.
	 */
	function setDraftEditorSelection(selectionState, node, blockKey, nodeStart, nodeEnd) {
	  // It's possible that the editor has been removed from the DOM but
	  // our selection code doesn't know it yet. Forcing selection in
	  // this case may lead to errors, so just bail now.
	  if (!containsNode(document.documentElement, node)) {
	    return;
	  }
	
	  var selection = global.getSelection();
	  var anchorKey = selectionState.getAnchorKey();
	  var anchorOffset = selectionState.getAnchorOffset();
	  var focusKey = selectionState.getFocusKey();
	  var focusOffset = selectionState.getFocusOffset();
	  var isBackward = selectionState.getIsBackward();
	
	  // IE doesn't support backward selection. Swap key/offset pairs.
	  if (!selection.extend && isBackward) {
	    var tempKey = anchorKey;
	    var tempOffset = anchorOffset;
	    anchorKey = focusKey;
	    anchorOffset = focusOffset;
	    focusKey = tempKey;
	    focusOffset = tempOffset;
	    isBackward = false;
	  }
	
	  var hasAnchor = anchorKey === blockKey && nodeStart <= anchorOffset && nodeEnd >= anchorOffset;
	
	  var hasFocus = focusKey === blockKey && nodeStart <= focusOffset && nodeEnd >= focusOffset;
	
	  // If the selection is entirely bound within this node, set the selection
	  // and be done.
	  if (hasAnchor && hasFocus) {
	    selection.removeAllRanges();
	    addPointToSelection(selection, node, anchorOffset - nodeStart, selectionState);
	    addFocusToSelection(selection, node, focusOffset - nodeStart, selectionState);
	    return;
	  }
	
	  if (!isBackward) {
	    // If the anchor is within this node, set the range start.
	    if (hasAnchor) {
	      selection.removeAllRanges();
	      addPointToSelection(selection, node, anchorOffset - nodeStart, selectionState);
	    }
	
	    // If the focus is within this node, we can assume that we have
	    // already set the appropriate start range on the selection, and
	    // can simply extend the selection.
	    if (hasFocus) {
	      addFocusToSelection(selection, node, focusOffset - nodeStart, selectionState);
	    }
	  } else {
	    // If this node has the focus, set the selection range to be a
	    // collapsed range beginning here. Later, when we encounter the anchor,
	    // we'll use this information to extend the selection.
	    if (hasFocus) {
	      selection.removeAllRanges();
	      addPointToSelection(selection, node, focusOffset - nodeStart, selectionState);
	    }
	
	    // If this node has the anchor, we may assume that the correct
	    // focus information is already stored on the selection object.
	    // We keep track of it, reset the selection range, and extend it
	    // back to the focus point.
	    if (hasAnchor) {
	      var storedFocusNode = selection.focusNode;
	      var storedFocusOffset = selection.focusOffset;
	
	      selection.removeAllRanges();
	      addPointToSelection(selection, node, anchorOffset - nodeStart, selectionState);
	      addFocusToSelection(selection, storedFocusNode, storedFocusOffset, selectionState);
	    }
	  }
	}
	
	/**
	 * Extend selection towards focus point.
	 */
	function addFocusToSelection(selection, node, offset, selectionState) {
	  var activeElement = getActiveElement();
	  if (selection.extend && containsNode(activeElement, node)) {
	    // If `extend` is called while another element has focus, an error is
	    // thrown. We therefore disable `extend` if the active element is somewhere
	    // other than the node we are selecting. This should only occur in Firefox,
	    // since it is the only browser to support multiple selections.
	    // See https://bugzilla.mozilla.org/show_bug.cgi?id=921444.
	
	    // logging to catch bug that is being reported in t16250795
	    if (offset > getNodeLength(node)) {
	      // the call to 'selection.extend' is about to throw
	      DraftJsDebugLogging.logSelectionStateFailure({
	        anonymizedDom: getAnonymizedEditorDOM(node),
	        extraParams: JSON.stringify({ offset: offset }),
	        selectionState: JSON.stringify(selectionState.toJS())
	      });
	    }
	
	    // logging to catch bug that is being reported in t18110632
	    var nodeWasFocus = node === selection.focusNode;
	    try {
	      selection.extend(node, offset);
	    } catch (e) {
	      DraftJsDebugLogging.logSelectionStateFailure({
	        anonymizedDom: getAnonymizedEditorDOM(node, function (n) {
	          var labels = [];
	          if (n === activeElement) {
	            labels.push('active element');
	          }
	          if (n === selection.anchorNode) {
	            labels.push('selection anchor node');
	          }
	          if (n === selection.focusNode) {
	            labels.push('selection focus node');
	          }
	          return labels;
	        }),
	        extraParams: JSON.stringify({
	          activeElementName: activeElement ? activeElement.nodeName : null,
	          nodeIsFocus: node === selection.focusNode,
	          nodeWasFocus: nodeWasFocus,
	          selectionRangeCount: selection.rangeCount,
	          selectionAnchorNodeName: selection.anchorNode ? selection.anchorNode.nodeName : null,
	          selectionAnchorOffset: selection.anchorOffset,
	          selectionFocusNodeName: selection.focusNode ? selection.focusNode.nodeName : null,
	          selectionFocusOffset: selection.focusOffset,
	          message: e ? '' + e : null,
	          offset: offset
	        }, null, 2),
	        selectionState: JSON.stringify(selectionState.toJS(), null, 2)
	      });
	      // allow the error to be thrown -
	      // better than continuing in a broken state
	      throw e;
	    }
	  } else {
	    // IE doesn't support extend. This will mean no backward selection.
	    // Extract the existing selection range and add focus to it.
	    // Additionally, clone the selection range. IE11 throws an
	    // InvalidStateError when attempting to access selection properties
	    // after the range is detached.
	    var range = selection.getRangeAt(0);
	    range.setEnd(node, offset);
	    selection.addRange(range.cloneRange());
	  }
	}
	
	function addPointToSelection(selection, node, offset, selectionState) {
	  var range = document.createRange();
	  // logging to catch bug that is being reported in t16250795
	  if (offset > getNodeLength(node)) {
	    // in this case we know that the call to 'range.setStart' is about to throw
	    DraftJsDebugLogging.logSelectionStateFailure({
	      anonymizedDom: getAnonymizedEditorDOM(node),
	      extraParams: JSON.stringify({ offset: offset }),
	      selectionState: JSON.stringify(selectionState.toJS())
	    });
	  }
	  range.setStart(node, offset);
	  selection.addRange(range);
	}
	
	module.exports = setDraftEditorSelection;
	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))

/***/ }),
/* 543 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule splitBlockInContentState
	 * @format
	 * 
	 */
	
	'use strict';
	
	var ContentBlockNode = __webpack_require__(30);
	var Immutable = __webpack_require__(11);
	
	var generateRandomKey = __webpack_require__(37);
	var invariant = __webpack_require__(12);
	
	var List = Immutable.List,
	    Map = Immutable.Map;
	
	
	var transformBlock = function transformBlock(key, blockMap, func) {
	  if (!key) {
	    return;
	  }
	
	  var block = blockMap.get(key);
	
	  if (!block) {
	    return;
	  }
	
	  blockMap.set(key, func(block));
	};
	
	var updateBlockMapLinks = function updateBlockMapLinks(blockMap, originalBlock, belowBlock) {
	  return blockMap.withMutations(function (blocks) {
	    var originalBlockKey = originalBlock.getKey();
	    var belowBlockKey = belowBlock.getKey();
	
	    // update block parent
	    transformBlock(originalBlock.getParentKey(), blocks, function (block) {
	      var parentChildrenList = block.getChildKeys();
	      var insertionIndex = parentChildrenList.indexOf(originalBlockKey) + 1;
	      var newChildrenArray = parentChildrenList.toArray();
	
	      newChildrenArray.splice(insertionIndex, 0, belowBlockKey);
	
	      return block.merge({
	        children: List(newChildrenArray)
	      });
	    });
	
	    // update original next block
	    transformBlock(originalBlock.getNextSiblingKey(), blocks, function (block) {
	      return block.merge({
	        prevSibling: belowBlockKey
	      });
	    });
	
	    // update original block
	    transformBlock(originalBlockKey, blocks, function (block) {
	      return block.merge({
	        nextSibling: belowBlockKey
	      });
	    });
	
	    // update below block
	    transformBlock(belowBlockKey, blocks, function (block) {
	      return block.merge({
	        prevSibling: originalBlockKey
	      });
	    });
	  });
	};
	
	var splitBlockInContentState = function splitBlockInContentState(contentState, selectionState) {
	  !selectionState.isCollapsed() ?  true ? invariant(false, 'Selection range must be collapsed.') : invariant(false) : void 0;
	
	  var key = selectionState.getAnchorKey();
	  var offset = selectionState.getAnchorOffset();
	  var blockMap = contentState.getBlockMap();
	  var blockToSplit = blockMap.get(key);
	  var text = blockToSplit.getText();
	  var chars = blockToSplit.getCharacterList();
	  var keyBelow = generateRandomKey();
	  var isExperimentalTreeBlock = blockToSplit instanceof ContentBlockNode;
	
	  var blockAbove = blockToSplit.merge({
	    text: text.slice(0, offset),
	    characterList: chars.slice(0, offset)
	  });
	  var blockBelow = blockAbove.merge({
	    key: keyBelow,
	    text: text.slice(offset),
	    characterList: chars.slice(offset),
	    data: Map()
	  });
	
	  var blocksBefore = blockMap.toSeq().takeUntil(function (v) {
	    return v === blockToSplit;
	  });
	  var blocksAfter = blockMap.toSeq().skipUntil(function (v) {
	    return v === blockToSplit;
	  }).rest();
	  var newBlocks = blocksBefore.concat([[key, blockAbove], [keyBelow, blockBelow]], blocksAfter).toOrderedMap();
	
	  if (isExperimentalTreeBlock) {
	    !blockToSplit.getChildKeys().isEmpty() ?  true ? invariant(false, 'ContentBlockNode must not have children') : invariant(false) : void 0;
	
	    newBlocks = updateBlockMapLinks(newBlocks, blockAbove, blockBelow);
	  }
	
	  return contentState.merge({
	    blockMap: newBlocks,
	    selectionBefore: selectionState,
	    selectionAfter: selectionState.merge({
	      anchorKey: keyBelow,
	      anchorOffset: 0,
	      focusKey: keyBelow,
	      focusOffset: 0,
	      isBackward: false
	    })
	  });
	};
	
	module.exports = splitBlockInContentState;

/***/ }),
/* 544 */
/***/ (function(module, exports) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule splitTextIntoTextBlocks
	 * @format
	 * 
	 */
	
	'use strict';
	
	var NEWLINE_REGEX = /\r\n?|\n/g;
	
	function splitTextIntoTextBlocks(text) {
	  return text.split(NEWLINE_REGEX);
	}
	
	module.exports = splitTextIntoTextBlocks;

/***/ }),
/* 545 */
/***/ (function(module, exports, __webpack_require__) {

	var QueryHandler = __webpack_require__(547);
	var each = __webpack_require__(223).each;
	
	/**
	 * Represents a single media query, manages it's state and registered handlers for this query
	 *
	 * @constructor
	 * @param {string} query the media query string
	 * @param {boolean} [isUnconditional=false] whether the media query should run regardless of whether the conditions are met. Primarily for helping older browsers deal with mobile-first design
	 */
	function MediaQuery(query, isUnconditional) {
	    this.query = query;
	    this.isUnconditional = isUnconditional;
	    this.handlers = [];
	    this.mql = window.matchMedia(query);
	
	    var self = this;
	    this.listener = function(mql) {
	        // Chrome passes an MediaQueryListEvent object, while other browsers pass MediaQueryList directly
	        self.mql = mql.currentTarget || mql;
	        self.assess();
	    };
	    this.mql.addListener(this.listener);
	}
	
	MediaQuery.prototype = {
	
	    constuctor : MediaQuery,
	
	    /**
	     * add a handler for this query, triggering if already active
	     *
	     * @param {object} handler
	     * @param {function} handler.match callback for when query is activated
	     * @param {function} [handler.unmatch] callback for when query is deactivated
	     * @param {function} [handler.setup] callback for immediate execution when a query handler is registered
	     * @param {boolean} [handler.deferSetup=false] should the setup callback be deferred until the first time the handler is matched?
	     */
	    addHandler : function(handler) {
	        var qh = new QueryHandler(handler);
	        this.handlers.push(qh);
	
	        this.matches() && qh.on();
	    },
	
	    /**
	     * removes the given handler from the collection, and calls it's destroy methods
	     *
	     * @param {object || function} handler the handler to remove
	     */
	    removeHandler : function(handler) {
	        var handlers = this.handlers;
	        each(handlers, function(h, i) {
	            if(h.equals(handler)) {
	                h.destroy();
	                return !handlers.splice(i,1); //remove from array and exit each early
	            }
	        });
	    },
	
	    /**
	     * Determine whether the media query should be considered a match
	     *
	     * @return {Boolean} true if media query can be considered a match, false otherwise
	     */
	    matches : function() {
	        return this.mql.matches || this.isUnconditional;
	    },
	
	    /**
	     * Clears all handlers and unbinds events
	     */
	    clear : function() {
	        each(this.handlers, function(handler) {
	            handler.destroy();
	        });
	        this.mql.removeListener(this.listener);
	        this.handlers.length = 0; //clear array
	    },
	
	    /*
	        * Assesses the query, turning on all handlers if it matches, turning them off if it doesn't match
	        */
	    assess : function() {
	        var action = this.matches() ? 'on' : 'off';
	
	        each(this.handlers, function(handler) {
	            handler[action]();
	        });
	    }
	};
	
	module.exports = MediaQuery;


/***/ }),
/* 546 */
/***/ (function(module, exports, __webpack_require__) {

	var MediaQuery = __webpack_require__(545);
	var Util = __webpack_require__(223);
	var each = Util.each;
	var isFunction = Util.isFunction;
	var isArray = Util.isArray;
	
	/**
	 * Allows for registration of query handlers.
	 * Manages the query handler's state and is responsible for wiring up browser events
	 *
	 * @constructor
	 */
	function MediaQueryDispatch () {
	    if(!window.matchMedia) {
	        throw new Error('matchMedia not present, legacy browsers require a polyfill');
	    }
	
	    this.queries = {};
	    this.browserIsIncapable = !window.matchMedia('only all').matches;
	}
	
	MediaQueryDispatch.prototype = {
	
	    constructor : MediaQueryDispatch,
	
	    /**
	     * Registers a handler for the given media query
	     *
	     * @param {string} q the media query
	     * @param {object || Array || Function} options either a single query handler object, a function, or an array of query handlers
	     * @param {function} options.match fired when query matched
	     * @param {function} [options.unmatch] fired when a query is no longer matched
	     * @param {function} [options.setup] fired when handler first triggered
	     * @param {boolean} [options.deferSetup=false] whether setup should be run immediately or deferred until query is first matched
	     * @param {boolean} [shouldDegrade=false] whether this particular media query should always run on incapable browsers
	     */
	    register : function(q, options, shouldDegrade) {
	        var queries         = this.queries,
	            isUnconditional = shouldDegrade && this.browserIsIncapable;
	
	        if(!queries[q]) {
	            queries[q] = new MediaQuery(q, isUnconditional);
	        }
	
	        //normalise to object in an array
	        if(isFunction(options)) {
	            options = { match : options };
	        }
	        if(!isArray(options)) {
	            options = [options];
	        }
	        each(options, function(handler) {
	            if (isFunction(handler)) {
	                handler = { match : handler };
	            }
	            queries[q].addHandler(handler);
	        });
	
	        return this;
	    },
	
	    /**
	     * unregisters a query and all it's handlers, or a specific handler for a query
	     *
	     * @param {string} q the media query to target
	     * @param {object || function} [handler] specific handler to unregister
	     */
	    unregister : function(q, handler) {
	        var query = this.queries[q];
	
	        if(query) {
	            if(handler) {
	                query.removeHandler(handler);
	            }
	            else {
	                query.clear();
	                delete this.queries[q];
	            }
	        }
	
	        return this;
	    }
	};
	
	module.exports = MediaQueryDispatch;


/***/ }),
/* 547 */
/***/ (function(module, exports) {

	/**
	 * Delegate to handle a media query being matched and unmatched.
	 *
	 * @param {object} options
	 * @param {function} options.match callback for when the media query is matched
	 * @param {function} [options.unmatch] callback for when the media query is unmatched
	 * @param {function} [options.setup] one-time callback triggered the first time a query is matched
	 * @param {boolean} [options.deferSetup=false] should the setup callback be run immediately, rather than first time query is matched?
	 * @constructor
	 */
	function QueryHandler(options) {
	    this.options = options;
	    !options.deferSetup && this.setup();
	}
	
	QueryHandler.prototype = {
	
	    constructor : QueryHandler,
	
	    /**
	     * coordinates setup of the handler
	     *
	     * @function
	     */
	    setup : function() {
	        if(this.options.setup) {
	            this.options.setup();
	        }
	        this.initialised = true;
	    },
	
	    /**
	     * coordinates setup and triggering of the handler
	     *
	     * @function
	     */
	    on : function() {
	        !this.initialised && this.setup();
	        this.options.match && this.options.match();
	    },
	
	    /**
	     * coordinates the unmatch event for the handler
	     *
	     * @function
	     */
	    off : function() {
	        this.options.unmatch && this.options.unmatch();
	    },
	
	    /**
	     * called when a handler is to be destroyed.
	     * delegates to the destroy or unmatch callbacks, depending on availability.
	     *
	     * @function
	     */
	    destroy : function() {
	        this.options.destroy ? this.options.destroy() : this.off();
	    },
	
	    /**
	     * determines equality by reference.
	     * if object is supplied compare options, if function, compare match callback
	     *
	     * @function
	     * @param {object || function} [target] the target for comparison
	     */
	    equals : function(target) {
	        return this.options === target || this.options.match === target;
	    }
	
	};
	
	module.exports = QueryHandler;


/***/ }),
/* 548 */
/***/ (function(module, exports, __webpack_require__) {

	var MediaQueryDispatch = __webpack_require__(546);
	module.exports = new MediaQueryDispatch();


/***/ }),
/* 549 */
/***/ (function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__;(function(root,factory){
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.call(exports, __webpack_require__, exports, module)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
	    } else if (typeof exports === 'object') {
	        module.exports = factory();
	    } else {
	        root.eventListener = factory();
	  }
	}(this, function () {
		function wrap(standard, fallback) {
			return function (el, evtName, listener, useCapture) {
				if (el[standard]) {
					el[standard](evtName, listener, useCapture);
				} else if (el[fallback]) {
					el[fallback]('on' + evtName, listener);
				}
			}
		}
	
	    return {
			add: wrap('addEventListener', 'attachEvent'),
			remove: wrap('removeEventListener', 'detachEvent')
		};
	}));

/***/ }),
/* 550 */
17,
/* 551 */
/***/ (function(module, exports) {

	'use strict';
	
	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 */
	var PhotosMimeType = {
	  isImage: function isImage(mimeString) {
	    return getParts(mimeString)[0] === 'image';
	  },
	  isJpeg: function isJpeg(mimeString) {
	    var parts = getParts(mimeString);
	    return PhotosMimeType.isImage(mimeString) && (
	    // see http://fburl.com/10972194
	    parts[1] === 'jpeg' || parts[1] === 'pjpeg');
	  }
	};
	
	function getParts(mimeString) {
	  return mimeString.split('/');
	}
	
	module.exports = PhotosMimeType;

/***/ }),
/* 552 */
/***/ (function(module, exports) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 * @typechecks
	 * @stub
	 * 
	 */
	
	'use strict';
	
	// \u00a1-\u00b1\u00b4-\u00b8\u00ba\u00bb\u00bf
	//             is latin supplement punctuation except fractions and superscript
	//             numbers
	// \u2010-\u2027\u2030-\u205e
	//             is punctuation from the general punctuation block:
	//             weird quotes, commas, bullets, dashes, etc.
	// \u30fb\u3001\u3002\u3008-\u3011\u3014-\u301f
	//             is CJK punctuation
	// \uff1a-\uff1f\uff01-\uff0f\uff3b-\uff40\uff5b-\uff65
	//             is some full-width/half-width punctuation
	// \u2E2E\u061f\u066a-\u066c\u061b\u060c\u060d\uFD3e\uFD3F
	//             is some Arabic punctuation marks
	// \u1801\u0964\u104a\u104b
	//             is misc. other language punctuation marks
	
	var PUNCTUATION = '[.,+*?$|#{}()\'\\^\\-\\[\\]\\\\\\/!@%"~=<>_:;' + '\u30FB\u3001\u3002\u3008-\u3011\u3014-\u301F\uFF1A-\uFF1F\uFF01-\uFF0F' + '\uFF3B-\uFF40\uFF5B-\uFF65\u2E2E\u061F\u066A-\u066C\u061B\u060C\u060D' + '\uFD3E\uFD3F\u1801\u0964\u104A\u104B\u2010-\u2027\u2030-\u205E' + '\xA1-\xB1\xB4-\xB8\xBA\xBB\xBF]';
	
	module.exports = {
	  getPunctuation: function getPunctuation() {
	    return PUNCTUATION;
	  }
	};

/***/ }),
/* 553 */
/***/ (function(module, exports) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 * 
	 */
	
	'use strict';
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	var URI = function () {
	  function URI(uri) {
	    _classCallCheck(this, URI);
	
	    this._uri = uri;
	  }
	
	  URI.prototype.toString = function toString() {
	    return this._uri;
	  };
	
	  return URI;
	}();
	
	module.exports = URI;

/***/ }),
/* 554 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 * @typechecks
	 * 
	 */
	
	/**
	 * Stateful API for text direction detection
	 *
	 * This class can be used in applications where you need to detect the
	 * direction of a sequence of text blocks, where each direction shall be used
	 * as the fallback direction for the next one.
	 *
	 * NOTE: A default direction, if not provided, is set based on the global
	 *       direction, as defined by `UnicodeBidiDirection`.
	 *
	 * == Example ==
	 * ```
	 * var UnicodeBidiService = require('UnicodeBidiService');
	 *
	 * var bidiService = new UnicodeBidiService();
	 *
	 * ...
	 *
	 * bidiService.reset();
	 * for (var para in paragraphs) {
	 *   var dir = bidiService.getDirection(para);
	 *   ...
	 * }
	 * ```
	 *
	 * Part of our implementation of Unicode Bidirectional Algorithm (UBA)
	 * Unicode Standard Annex #9 (UAX9)
	 * http://www.unicode.org/reports/tr9/
	 */
	
	'use strict';
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	var UnicodeBidi = __webpack_require__(226);
	var UnicodeBidiDirection = __webpack_require__(132);
	
	var invariant = __webpack_require__(12);
	
	var UnicodeBidiService = function () {
	
	  /**
	   * Stateful class for paragraph direction detection
	   *
	   * @param defaultDir  Default direction of the service
	   */
	  function UnicodeBidiService(defaultDir) {
	    _classCallCheck(this, UnicodeBidiService);
	
	    if (!defaultDir) {
	      defaultDir = UnicodeBidiDirection.getGlobalDir();
	    } else {
	      !UnicodeBidiDirection.isStrong(defaultDir) ?  true ? invariant(false, 'Default direction must be a strong direction (LTR or RTL)') : invariant(false) : void 0;
	    }
	    this._defaultDir = defaultDir;
	    this.reset();
	  }
	
	  /**
	   * Reset the internal state
	   *
	   * Instead of creating a new instance, you can just reset() your instance
	   * everytime you start a new loop.
	   */
	
	
	  UnicodeBidiService.prototype.reset = function reset() {
	    this._lastDir = this._defaultDir;
	  };
	
	  /**
	   * Returns the direction of a block of text, and remembers it as the
	   * fall-back direction for the next paragraph.
	   *
	   * @param str  A text block, e.g. paragraph, table cell, tag
	   * @return     The resolved direction
	   */
	
	
	  UnicodeBidiService.prototype.getDirection = function getDirection(str) {
	    this._lastDir = UnicodeBidi.getDirection(str, this._lastDir);
	    return this._lastDir;
	  };
	
	  return UnicodeBidiService;
	}();
	
	module.exports = UnicodeBidiService;

/***/ }),
/* 555 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 */
	
	/**
	 * Usage note:
	 * This module makes a best effort to export the same data we would internally.
	 * At Facebook we use a server-generated module that does the parsing and
	 * exports the data for the client to use. We can't rely on a server-side
	 * implementation in open source so instead we make use of an open source
	 * library to do the heavy lifting and then make some adjustments as necessary.
	 * It's likely there will be some differences. Some we can smooth over.
	 * Others are going to be harder.
	 */
	
	'use strict';
	
	var UAParser = __webpack_require__(805);
	
	var UNKNOWN = 'Unknown';
	
	var PLATFORM_MAP = {
	  'Mac OS': 'Mac OS X'
	};
	
	/**
	 * Convert from UAParser platform name to what we expect.
	 */
	function convertPlatformName(name) {
	  return PLATFORM_MAP[name] || name;
	}
	
	/**
	 * Get the version number in parts. This is very naive. We actually get major
	 * version as a part of UAParser already, which is generally good enough, but
	 * let's get the minor just in case.
	 */
	function getBrowserVersion(version) {
	  if (!version) {
	    return {
	      major: '',
	      minor: ''
	    };
	  }
	  var parts = version.split('.');
	  return {
	    major: parts[0],
	    minor: parts[1]
	  };
	}
	
	/**
	 * Get the UA data fom UAParser and then convert it to the format we're
	 * expecting for our APIS.
	 */
	var parser = new UAParser();
	var results = parser.getResult();
	
	// Do some conversion first.
	var browserVersionData = getBrowserVersion(results.browser.version);
	var uaData = {
	  browserArchitecture: results.cpu.architecture || UNKNOWN,
	  browserFullVersion: results.browser.version || UNKNOWN,
	  browserMinorVersion: browserVersionData.minor || UNKNOWN,
	  browserName: results.browser.name || UNKNOWN,
	  browserVersion: results.browser.major || UNKNOWN,
	  deviceName: results.device.model || UNKNOWN,
	  engineName: results.engine.name || UNKNOWN,
	  engineVersion: results.engine.version || UNKNOWN,
	  platformArchitecture: results.cpu.architecture || UNKNOWN,
	  platformName: convertPlatformName(results.os.name) || UNKNOWN,
	  platformVersion: results.os.version || UNKNOWN,
	  platformFullVersion: results.os.version || UNKNOWN
	};
	
	module.exports = uaData;

/***/ }),
/* 556 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 */
	
	'use strict';
	
	var invariant = __webpack_require__(12);
	
	var componentRegex = /\./;
	var orRegex = /\|\|/;
	var rangeRegex = /\s+\-\s+/;
	var modifierRegex = /^(<=|<|=|>=|~>|~|>|)?\s*(.+)/;
	var numericRegex = /^(\d*)(.*)/;
	
	/**
	 * Splits input `range` on "||" and returns true if any subrange matches
	 * `version`.
	 *
	 * @param {string} range
	 * @param {string} version
	 * @returns {boolean}
	 */
	function checkOrExpression(range, version) {
	  var expressions = range.split(orRegex);
	
	  if (expressions.length > 1) {
	    return expressions.some(function (range) {
	      return VersionRange.contains(range, version);
	    });
	  } else {
	    range = expressions[0].trim();
	    return checkRangeExpression(range, version);
	  }
	}
	
	/**
	 * Splits input `range` on " - " (the surrounding whitespace is required) and
	 * returns true if version falls between the two operands.
	 *
	 * @param {string} range
	 * @param {string} version
	 * @returns {boolean}
	 */
	function checkRangeExpression(range, version) {
	  var expressions = range.split(rangeRegex);
	
	  !(expressions.length > 0 && expressions.length <= 2) ?  true ? invariant(false, 'the "-" operator expects exactly 2 operands') : invariant(false) : void 0;
	
	  if (expressions.length === 1) {
	    return checkSimpleExpression(expressions[0], version);
	  } else {
	    var startVersion = expressions[0],
	        endVersion = expressions[1];
	
	    !(isSimpleVersion(startVersion) && isSimpleVersion(endVersion)) ?  true ? invariant(false, 'operands to the "-" operator must be simple (no modifiers)') : invariant(false) : void 0;
	
	    return checkSimpleExpression('>=' + startVersion, version) && checkSimpleExpression('<=' + endVersion, version);
	  }
	}
	
	/**
	 * Checks if `range` matches `version`. `range` should be a "simple" range (ie.
	 * not a compound range using the " - " or "||" operators).
	 *
	 * @param {string} range
	 * @param {string} version
	 * @returns {boolean}
	 */
	function checkSimpleExpression(range, version) {
	  range = range.trim();
	  if (range === '') {
	    return true;
	  }
	
	  var versionComponents = version.split(componentRegex);
	
	  var _getModifierAndCompon = getModifierAndComponents(range),
	      modifier = _getModifierAndCompon.modifier,
	      rangeComponents = _getModifierAndCompon.rangeComponents;
	
	  switch (modifier) {
	    case '<':
	      return checkLessThan(versionComponents, rangeComponents);
	    case '<=':
	      return checkLessThanOrEqual(versionComponents, rangeComponents);
	    case '>=':
	      return checkGreaterThanOrEqual(versionComponents, rangeComponents);
	    case '>':
	      return checkGreaterThan(versionComponents, rangeComponents);
	    case '~':
	    case '~>':
	      return checkApproximateVersion(versionComponents, rangeComponents);
	    default:
	      return checkEqual(versionComponents, rangeComponents);
	  }
	}
	
	/**
	 * Checks whether `a` is less than `b`.
	 *
	 * @param {array<string>} a
	 * @param {array<string>} b
	 * @returns {boolean}
	 */
	function checkLessThan(a, b) {
	  return compareComponents(a, b) === -1;
	}
	
	/**
	 * Checks whether `a` is less than or equal to `b`.
	 *
	 * @param {array<string>} a
	 * @param {array<string>} b
	 * @returns {boolean}
	 */
	function checkLessThanOrEqual(a, b) {
	  var result = compareComponents(a, b);
	  return result === -1 || result === 0;
	}
	
	/**
	 * Checks whether `a` is equal to `b`.
	 *
	 * @param {array<string>} a
	 * @param {array<string>} b
	 * @returns {boolean}
	 */
	function checkEqual(a, b) {
	  return compareComponents(a, b) === 0;
	}
	
	/**
	 * Checks whether `a` is greater than or equal to `b`.
	 *
	 * @param {array<string>} a
	 * @param {array<string>} b
	 * @returns {boolean}
	 */
	function checkGreaterThanOrEqual(a, b) {
	  var result = compareComponents(a, b);
	  return result === 1 || result === 0;
	}
	
	/**
	 * Checks whether `a` is greater than `b`.
	 *
	 * @param {array<string>} a
	 * @param {array<string>} b
	 * @returns {boolean}
	 */
	function checkGreaterThan(a, b) {
	  return compareComponents(a, b) === 1;
	}
	
	/**
	 * Checks whether `a` is "reasonably close" to `b` (as described in
	 * https://www.npmjs.org/doc/misc/semver.html). For example, if `b` is "1.3.1"
	 * then "reasonably close" is defined as ">= 1.3.1 and < 1.4".
	 *
	 * @param {array<string>} a
	 * @param {array<string>} b
	 * @returns {boolean}
	 */
	function checkApproximateVersion(a, b) {
	  var lowerBound = b.slice();
	  var upperBound = b.slice();
	
	  if (upperBound.length > 1) {
	    upperBound.pop();
	  }
	  var lastIndex = upperBound.length - 1;
	  var numeric = parseInt(upperBound[lastIndex], 10);
	  if (isNumber(numeric)) {
	    upperBound[lastIndex] = numeric + 1 + '';
	  }
	
	  return checkGreaterThanOrEqual(a, lowerBound) && checkLessThan(a, upperBound);
	}
	
	/**
	 * Extracts the optional modifier (<, <=, =, >=, >, ~, ~>) and version
	 * components from `range`.
	 *
	 * For example, given `range` ">= 1.2.3" returns an object with a `modifier` of
	 * `">="` and `components` of `[1, 2, 3]`.
	 *
	 * @param {string} range
	 * @returns {object}
	 */
	function getModifierAndComponents(range) {
	  var rangeComponents = range.split(componentRegex);
	  var matches = rangeComponents[0].match(modifierRegex);
	  !matches ?  true ? invariant(false, 'expected regex to match but it did not') : invariant(false) : void 0;
	
	  return {
	    modifier: matches[1],
	    rangeComponents: [matches[2]].concat(rangeComponents.slice(1))
	  };
	}
	
	/**
	 * Determines if `number` is a number.
	 *
	 * @param {mixed} number
	 * @returns {boolean}
	 */
	function isNumber(number) {
	  return !isNaN(number) && isFinite(number);
	}
	
	/**
	 * Tests whether `range` is a "simple" version number without any modifiers
	 * (">", "~" etc).
	 *
	 * @param {string} range
	 * @returns {boolean}
	 */
	function isSimpleVersion(range) {
	  return !getModifierAndComponents(range).modifier;
	}
	
	/**
	 * Zero-pads array `array` until it is at least `length` long.
	 *
	 * @param {array} array
	 * @param {number} length
	 */
	function zeroPad(array, length) {
	  for (var i = array.length; i < length; i++) {
	    array[i] = '0';
	  }
	}
	
	/**
	 * Normalizes `a` and `b` in preparation for comparison by doing the following:
	 *
	 * - zero-pads `a` and `b`
	 * - marks any "x", "X" or "*" component in `b` as equivalent by zero-ing it out
	 *   in both `a` and `b`
	 * - marks any final "*" component in `b` as a greedy wildcard by zero-ing it
	 *   and all of its successors in `a`
	 *
	 * @param {array<string>} a
	 * @param {array<string>} b
	 * @returns {array<array<string>>}
	 */
	function normalizeVersions(a, b) {
	  a = a.slice();
	  b = b.slice();
	
	  zeroPad(a, b.length);
	
	  // mark "x" and "*" components as equal
	  for (var i = 0; i < b.length; i++) {
	    var matches = b[i].match(/^[x*]$/i);
	    if (matches) {
	      b[i] = a[i] = '0';
	
	      // final "*" greedily zeros all remaining components
	      if (matches[0] === '*' && i === b.length - 1) {
	        for (var j = i; j < a.length; j++) {
	          a[j] = '0';
	        }
	      }
	    }
	  }
	
	  zeroPad(b, a.length);
	
	  return [a, b];
	}
	
	/**
	 * Returns the numerical -- not the lexicographical -- ordering of `a` and `b`.
	 *
	 * For example, `10-alpha` is greater than `2-beta`.
	 *
	 * @param {string} a
	 * @param {string} b
	 * @returns {number} -1, 0 or 1 to indicate whether `a` is less than, equal to,
	 * or greater than `b`, respectively
	 */
	function compareNumeric(a, b) {
	  var aPrefix = a.match(numericRegex)[1];
	  var bPrefix = b.match(numericRegex)[1];
	  var aNumeric = parseInt(aPrefix, 10);
	  var bNumeric = parseInt(bPrefix, 10);
	
	  if (isNumber(aNumeric) && isNumber(bNumeric) && aNumeric !== bNumeric) {
	    return compare(aNumeric, bNumeric);
	  } else {
	    return compare(a, b);
	  }
	}
	
	/**
	 * Returns the ordering of `a` and `b`.
	 *
	 * @param {string|number} a
	 * @param {string|number} b
	 * @returns {number} -1, 0 or 1 to indicate whether `a` is less than, equal to,
	 * or greater than `b`, respectively
	 */
	function compare(a, b) {
	  !(typeof a === typeof b) ?  true ? invariant(false, '"a" and "b" must be of the same type') : invariant(false) : void 0;
	
	  if (a > b) {
	    return 1;
	  } else if (a < b) {
	    return -1;
	  } else {
	    return 0;
	  }
	}
	
	/**
	 * Compares arrays of version components.
	 *
	 * @param {array<string>} a
	 * @param {array<string>} b
	 * @returns {number} -1, 0 or 1 to indicate whether `a` is less than, equal to,
	 * or greater than `b`, respectively
	 */
	function compareComponents(a, b) {
	  var _normalizeVersions = normalizeVersions(a, b),
	      aNormalized = _normalizeVersions[0],
	      bNormalized = _normalizeVersions[1];
	
	  for (var i = 0; i < bNormalized.length; i++) {
	    var result = compareNumeric(aNormalized[i], bNormalized[i]);
	    if (result) {
	      return result;
	    }
	  }
	
	  return 0;
	}
	
	var VersionRange = {
	  /**
	   * Checks whether `version` satisfies the `range` specification.
	   *
	   * We support a subset of the expressions defined in
	   * https://www.npmjs.org/doc/misc/semver.html:
	   *
	   *    version   Must match version exactly
	   *    =version  Same as just version
	   *    >version  Must be greater than version
	   *    >=version Must be greater than or equal to version
	   *    <version  Must be less than version
	   *    <=version Must be less than or equal to version
	   *    ~version  Must be at least version, but less than the next significant
	   *              revision above version:
	   *              "~1.2.3" is equivalent to ">= 1.2.3 and < 1.3"
	   *    ~>version Equivalent to ~version
	   *    1.2.x     Must match "1.2.x", where "x" is a wildcard that matches
	   *              anything
	   *    1.2.*     Similar to "1.2.x", but "*" in the trailing position is a
	   *              "greedy" wildcard, so will match any number of additional
	   *              components:
	   *              "1.2.*" will match "1.2.1", "1.2.1.1", "1.2.1.1.1" etc
	   *    *         Any version
	   *    ""        (Empty string) Same as *
	   *    v1 - v2   Equivalent to ">= v1 and <= v2"
	   *    r1 || r2  Passes if either r1 or r2 are satisfied
	   *
	   * @param {string} range
	   * @param {string} version
	   * @returns {boolean}
	   */
	  contains: function contains(range, version) {
	    return checkOrExpression(range.trim(), version.trim());
	  }
	};
	
	module.exports = VersionRange;

/***/ }),
/* 557 */
/***/ (function(module, exports) {

	"use strict";
	
	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 * @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;

/***/ }),
/* 558 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 * @typechecks
	 */
	
	var invariant = __webpack_require__(12);
	
	/**
	 * 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')) ?  true ? invariant(false, 'toArray: Array-like object expected') : invariant(false) : void 0;
	
	  !(typeof length === 'number') ?  true ? invariant(false, 'toArray: Object needs a length property') : invariant(false) : void 0;
	
	  !(length === 0 || length - 1 in obj) ?  true ? invariant(false, 'toArray: Object should have keys for indices') : invariant(false) : void 0;
	
	  !(typeof obj.callee !== 'function') ?  true ? 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;

/***/ }),
/* 559 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 */
	
	'use strict';
	
	var emptyObject = {};
	
	if (true) {
	  Object.freeze(emptyObject);
	}
	
	module.exports = emptyObject;

/***/ }),
/* 560 */
/***/ (function(module, exports) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 * @typechecks
	 */
	
	'use strict';
	
	var isWebkit = typeof navigator !== 'undefined' && navigator.userAgent.indexOf('AppleWebKit') > -1;
	
	/**
	 * Gets the element with the document scroll properties such as `scrollLeft` and
	 * `scrollHeight`. This may differ across different browsers.
	 *
	 * NOTE: The return value can be null if the DOM is not yet ready.
	 *
	 * @param {?DOMDocument} doc Defaults to current document.
	 * @return {?DOMElement}
	 */
	function getDocumentScrollElement(doc) {
	  doc = doc || document;
	  if (doc.scrollingElement) {
	    return doc.scrollingElement;
	  }
	  return !isWebkit && doc.compatMode === 'CSS1Compat' ? doc.documentElement : doc.body;
	}
	
	module.exports = getDocumentScrollElement;

/***/ }),
/* 561 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 * @typechecks
	 */
	
	var getElementRect = __webpack_require__(562);
	
	/**
	 * Gets an element's position in pixels relative to the viewport. The returned
	 * object represents the position of the element's top left corner.
	 *
	 * @param {DOMElement} element
	 * @return {object}
	 */
	function getElementPosition(element) {
	  var rect = getElementRect(element);
	  return {
	    x: rect.left,
	    y: rect.top,
	    width: rect.right - rect.left,
	    height: rect.bottom - rect.top
	  };
	}
	
	module.exports = getElementPosition;

/***/ }),
/* 562 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 * @typechecks
	 */
	
	var containsNode = __webpack_require__(133);
	
	/**
	 * Gets an element's bounding rect in pixels relative to the viewport.
	 *
	 * @param {DOMElement} elem
	 * @return {object}
	 */
	function getElementRect(elem) {
	  var docElem = elem.ownerDocument.documentElement;
	
	  // FF 2, Safari 3 and Opera 9.5- do not support getBoundingClientRect().
	  // IE9- will throw if the element is not in the document.
	  if (!('getBoundingClientRect' in elem) || !containsNode(docElem, elem)) {
	    return {
	      left: 0,
	      right: 0,
	      top: 0,
	      bottom: 0
	    };
	  }
	
	  // Subtracts clientTop/Left because IE8- added a 2px border to the
	  // <html> element (see http://fburl.com/1493213). IE 7 in
	  // Quicksmode does not report clientLeft/clientTop so there
	  // will be an unaccounted offset of 2px when in quirksmode
	  var rect = elem.getBoundingClientRect();
	
	  return {
	    left: Math.round(rect.left) - docElem.clientLeft,
	    right: Math.round(rect.right) - docElem.clientLeft,
	    top: Math.round(rect.top) - docElem.clientTop,
	    bottom: Math.round(rect.bottom) - docElem.clientTop
	  };
	}
	
	module.exports = getElementRect;

/***/ }),
/* 563 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 * @typechecks
	 */
	
	var camelize = __webpack_require__(557);
	var hyphenate = __webpack_require__(566);
	
	function asString(value) /*?string*/{
	  return value == null ? value : String(value);
	}
	
	function getStyleProperty( /*DOMNode*/node, /*string*/name) /*?string*/{
	  var computedStyle = void 0;
	
	  // W3C Standard
	  if (window.getComputedStyle) {
	    // In certain cases such as within an iframe in FF3, this returns null.
	    computedStyle = window.getComputedStyle(node, null);
	    if (computedStyle) {
	      return asString(computedStyle.getPropertyValue(hyphenate(name)));
	    }
	  }
	  // Safari
	  if (document.defaultView && document.defaultView.getComputedStyle) {
	    computedStyle = document.defaultView.getComputedStyle(node, null);
	    // A Safari bug causes this to return null for `display: none` elements.
	    if (computedStyle) {
	      return asString(computedStyle.getPropertyValue(hyphenate(name)));
	    }
	    if (name === 'display') {
	      return 'none';
	    }
	  }
	  // Internet Explorer
	  if (node.currentStyle) {
	    if (name === 'float') {
	      return asString(node.currentStyle.cssFloat || node.currentStyle.styleFloat);
	    }
	    return asString(node.currentStyle[camelize(name)]);
	  }
	  return asString(node.style && node.style[camelize(name)]);
	}
	
	module.exports = getStyleProperty;

/***/ }),
/* 564 */
/***/ (function(module, exports) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 * @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 && scrollable instanceof scrollable.Window) {
	    return {
	      x: scrollable.pageXOffset || scrollable.document.documentElement.scrollLeft,
	      y: scrollable.pageYOffset || scrollable.document.documentElement.scrollTop
	    };
	  }
	  return {
	    x: scrollable.scrollLeft,
	    y: scrollable.scrollTop
	  };
	}
	
	module.exports = getUnboundedScrollPosition;

/***/ }),
/* 565 */
/***/ (function(module, exports) {

	"use strict";
	
	function getViewportWidth() {
	  var width = void 0;
	  if (document.documentElement) {
	    width = document.documentElement.clientWidth;
	  }
	
	  if (!width && document.body) {
	    width = document.body.clientWidth;
	  }
	
	  return width || 0;
	} /**
	   * Copyright (c) 2013-present, Facebook, Inc.
	   *
	   * This source code is licensed under the MIT license found in the
	   * LICENSE file in the root directory of this source tree.
	   *
	   * 
	   * @typechecks
	   */
	
	function getViewportHeight() {
	  var height = void 0;
	  if (document.documentElement) {
	    height = document.documentElement.clientHeight;
	  }
	
	  if (!height && document.body) {
	    height = document.body.clientHeight;
	  }
	
	  return height || 0;
	}
	
	/**
	 * Gets the viewport dimensions including any scrollbars.
	 */
	function getViewportDimensions() {
	  return {
	    width: window.innerWidth || getViewportWidth(),
	    height: window.innerHeight || getViewportHeight()
	  };
	}
	
	/**
	 * Gets the viewport dimensions excluding any scrollbars.
	 */
	getViewportDimensions.withoutScrollbars = function () {
	  return {
	    width: getViewportWidth(),
	    height: getViewportHeight()
	  };
	};
	
	module.exports = getViewportDimensions;

/***/ }),
/* 566 */
/***/ (function(module, exports) {

	'use strict';
	
	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 * @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;

/***/ }),
/* 567 */
/***/ (function(module, exports) {

	'use strict';
	
	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 * @typechecks
	 */
	
	/**
	 * @param {*} object The object to check.
	 * @return {boolean} Whether or not the object is a DOM node.
	 */
	function isNode(object) {
	  var doc = object ? object.ownerDocument || object : document;
	  var defaultView = doc.defaultView || window;
	  return !!(object && (typeof defaultView.Node === 'function' ? object instanceof defaultView.Node : typeof object === 'object' && typeof object.nodeType === 'number' && typeof object.nodeName === 'string'));
	}
	
	module.exports = isNode;

/***/ }),
/* 568 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 * @typechecks
	 */
	
	var isNode = __webpack_require__(567);
	
	/**
	 * @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;

/***/ }),
/* 569 */
/***/ (function(module, exports) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 * @typechecks static-only
	 */
	
	'use strict';
	
	/**
	 * Combines multiple className strings into one.
	 * http://jsperf.com/joinclasses-args-vs-array
	 *
	 * @param {...?string} className
	 * @return {string}
	 */
	
	function joinClasses(className /*, ... */) {
	  if (!className) {
	    className = '';
	  }
	  var nextClass = void 0;
	  var argLength = arguments.length;
	  if (argLength > 1) {
	    for (var ii = 1; ii < argLength; ii++) {
	      nextClass = arguments[ii];
	      if (nextClass) {
	        className = (className ? className + ' ' : '') + nextClass;
	      }
	    }
	  }
	  return className;
	}
	
	module.exports = joinClasses;

/***/ }),
/* 570 */
/***/ (function(module, exports) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 */
	
	'use strict';
	
	var hasOwnProperty = Object.prototype.hasOwnProperty;
	
	/**
	 * Executes the provided `callback` once for each enumerable own property in the
	 * object and constructs a new object from the results. The `callback` is
	 * invoked with three arguments:
	 *
	 *  - the property value
	 *  - the property name
	 *  - the object being traversed
	 *
	 * Properties that are added after the call to `mapObject` will not be visited
	 * by `callback`. If the values of existing properties are changed, the value
	 * passed to `callback` will be the value at the time `mapObject` visits them.
	 * Properties that are deleted before being visited are not visited.
	 *
	 * @grep function objectMap()
	 * @grep function objMap()
	 *
	 * @param {?object} object
	 * @param {function} callback
	 * @param {*} context
	 * @return {?object}
	 */
	function mapObject(object, callback, context) {
	  if (!object) {
	    return null;
	  }
	  var result = {};
	  for (var name in object) {
	    if (hasOwnProperty.call(object, name)) {
	      result[name] = callback.call(context, object[name], name, object);
	    }
	  }
	  return result;
	}
	
	module.exports = mapObject;

/***/ }),
/* 571 */
/***/ (function(module, exports) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 * 
	 * @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;

/***/ }),
/* 572 */
/***/ (function(module, exports, __webpack_require__) {

	/* WEBPACK VAR INJECTION */(function(global) {/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 */
	
	'use strict';
	
	// setimmediate adds setImmediate to the global. We want to make sure we export
	// the actual function.
	
	__webpack_require__(155);
	module.exports = global.setImmediate;
	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))

/***/ }),
/* 573 */
/***/ (function(module, exports) {

	/**
	 * Copyright 2015, Yahoo! Inc.
	 * Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
	 */
	'use strict';
	
	var REACT_STATICS = {
	    childContextTypes: true,
	    contextTypes: true,
	    defaultProps: true,
	    displayName: true,
	    getDefaultProps: true,
	    mixins: true,
	    propTypes: true,
	    type: true
	};
	
	var KNOWN_STATICS = {
	    name: true,
	    length: true,
	    prototype: true,
	    caller: true,
	    arguments: true,
	    arity: true
	};
	
	var isGetOwnPropertySymbolsAvailable = typeof Object.getOwnPropertySymbols === 'function';
	
	module.exports = function hoistNonReactStatics(targetComponent, sourceComponent, customStatics) {
	    if (typeof sourceComponent !== 'string') { // don't hoist over string (html) components
	        var keys = Object.getOwnPropertyNames(sourceComponent);
	
	        /* istanbul ignore else */
	        if (isGetOwnPropertySymbolsAvailable) {
	            keys = keys.concat(Object.getOwnPropertySymbols(sourceComponent));
	        }
	
	        for (var i = 0; i < keys.length; ++i) {
	            if (!REACT_STATICS[keys[i]] && !KNOWN_STATICS[keys[i]] && (!customStatics || !customStatics[keys[i]])) {
	                try {
	                    targetComponent[keys[i]] = sourceComponent[keys[i]];
	                } catch (error) {
	
	                }
	            }
	        }
	    }
	
	    return targetComponent;
	};


/***/ }),
/* 574 */
/***/ (function(module, exports) {

	module.exports = {"name":"antd","version":"2.13.14","title":"Ant Design","description":"An enterprise-class UI design language and React-based implementation","homepage":"http://ant.design/","keywords":["ant","design","react","react-component","component","components","ui","framework","frontend"],"contributors":["ant"],"repository":{"type":"git","url":"https://github.com/ant-design/ant-design"},"bugs":{"url":"https://github.com/ant-design/ant-design/issues"},"main":"lib/index.js","module":"es/index.js","files":["dist","lib","es"],"typings":"lib/index.d.ts","license":"MIT","peerDependencies":{"react":"~0.14.0 || >=15.0.0","react-dom":"~0.14.0 || >=15.0.0"},"dependencies":{"array-tree-filter":"~1.0.0","babel-runtime":"6.x","classnames":"~2.2.0","create-react-class":"^15.6.0","css-animation":"^1.2.5","dom-closest":"^0.2.0","lodash.debounce":"^4.0.8","lodash.uniqby":"^4.7.0","moment":"^2.19.3","omit.js":"^1.0.0","prop-types":"^15.5.7","rc-animate":"^2.4.1","rc-calendar":"~9.0.0","rc-cascader":"~0.11.3","rc-checkbox":"~2.0.3","rc-collapse":"~1.7.5","rc-dialog":"~6.5.10","rc-dropdown":"~1.5.0","rc-editor-mention":"~0.6.12","rc-form":"~1.4.0","rc-input-number":"~3.6.0","rc-menu":"~5.0.10","rc-notification":"~2.0.0","rc-pagination":"~1.12.4","rc-progress":"~2.2.2","rc-rate":"~2.1.1","rc-select":"~6.9.0","rc-slider":"~8.3.0","rc-steps":"~2.5.1","rc-switch":"~1.5.1","rc-table":"~5.6.9","rc-tabs":"~9.1.2","rc-time-picker":"~2.4.1","rc-tooltip":"~3.4.6","rc-tree":"~1.7.0","rc-tree-select":"~1.10.2","rc-upload":"~2.4.0","rc-util":"^4.0.4","react-lazy-load":"^3.0.12","react-slick":"~0.15.4","shallowequal":"^1.0.1","warning":"~3.0.0"},"devDependencies":{"@types/react":"16.0.21","@types/react-dom":"0.14.18","ansi-styles":"^3.2.0","antd-tools":"~2.1.0","babel-cli":"^6.18.0","babel-eslint":"8.0.2","babel-plugin-import":"^1.0.0","babel-plugin-transform-runtime":"^6.23.0","babel-preset-es2015":"^6.18.0","babel-preset-react":"^6.16.0","babel-preset-stage-0":"^6.16.0","bezier-easing":"^2.0.3","bisheng":"^0.25.0","bisheng-plugin-antd":"^0.15.0","bisheng-plugin-description":"^0.1.1","bisheng-plugin-react":"^0.5.0","bisheng-plugin-toc":"^0.4.0","color-standalone":"^0.11.6","commander":"^2.11.0","cross-env":"^5.0.3","css-split-webpack-plugin":"^0.2.3","dekko":"^0.2.0","delegate":"^3.1.2","dora-plugin-upload":"^0.3.1","enquire.js":"^2.1.1","enzyme":"^2.6.0","enzyme-to-json":"^1.3.0","eslint":"^4.8.0","eslint-config-airbnb":"latest","eslint-plugin-babel":"^4.0.0","eslint-plugin-import":"^2.2.0","eslint-plugin-jsx-a11y":"^6.0.2","eslint-plugin-markdown":"~1.0.0-beta.4","eslint-plugin-react":"7.4.0","eslint-tinker":"^0.4.0","fetch-jsonp":"^1.0.3","glob":"^7.1.1","jest":"^21.1.0","jsonml.js":"^0.1.0","lint-staged":"^4.0.2","majo":"^0.4.1","mockdate":"^2.0.1","moment-timezone":"^0.5.5","pre-commit":"^1.2.2","preact":"^8.2.5","preact-compat":"^3.17.0","querystring":"^0.2.0","rc-queue-anim":"^1.0.1","rc-scroll-anim":"^1.0.3","rc-tween-one":"^1.1.2","react":"^15.0.0","react-color":"^2.11.7","react-copy-to-clipboard":"^5.0.0","react-document-title":"^2.0.1","react-dom":"^15.0.0","react-github-button":"^0.1.1","react-intl":"^2.0.1","react-sublime-video":"^0.2.0","react-test-renderer":"^15.5.4","remark-frontmatter":"^1.1.0","remark-parse":"^4.0.0","remark-stringify":"^4.0.0","remark-yaml-config":"^4.0.1","reqwest":"^2.0.5","rimraf":"^2.5.4","stylelint":"^8.0.0","stylelint-config-standard":"^17.0.0","typescript":"~2.5.3","unified":"^6.1.5","values.js":"^1.0.3","xhr2":"^0.1.3"},"scripts":{"test":"jest --config .jest.js","test-node":"jest --config .jest.node.js","test-all":"./scripts/test-all.sh","lint":"npm run lint:ts && npm run lint:es && npm run lint:demo && npm run lint:style","lint:ts":"npm run tsc && antd-tools run ts-lint","lint:es":"eslint tests site scripts components ./.eslintrc.js ./webpack.config.js --ext '.js,.jsx'","lint:demo":"cross-env RUN_ENV=DEMO eslint components/*/demo/*.md --ext '.md'","lint:style":"stylelint \"{site,components}/**/*.less\" --syntax less","lint-fix:ts":"npm run tsc && antd-tools run ts-lint-fix","lint-fix":"npm run lint-fix:code && npm run lint-fix:demo","lint-fix:code":"eslint --fix tests site scripts components ./.eslintrc.js ./webpack.config.js --ext '.js,.jsx'","lint-fix:demo":"eslint-tinker ./components/*/demo/*.md","sort-api":"node ./scripts/sort-api-table.js","dist":"antd-tools run dist","compile":"antd-tools run compile","tsc":"tsc","start":"node ./scripts/generateColorLess.js && cross-env NODE_ENV=development bisheng start -c ./site/bisheng.config.js --no-livereload","start:preact":"node ./scripts/generateColorLess.js && cross-env NODE_ENV=development REACT_ENV=preact bisheng start -c ./site/bisheng.config.js --no-livereload","site":"cross-env NODE_ENV=production bisheng build --ssr -c ./site/bisheng.config.js","deploy":"antd-tools run clean && npm run site && node ./scripts/generateColorLess.js && bisheng gh-pages --push-only","pub":"antd-tools run pub --npm-tag=latest-2","prepublish":"antd-tools run guard","pre-publish":"npm run test-all && node ./scripts/prepub","authors":"git log --format='%aN <%aE>' | sort -u | grep -v 'users.noreply.github.com' | grep -v 'gitter.im' | grep -v '.local>' | grep -v 'alibaba-inc.com' | grep -v 'alipay.com' | grep -v 'taobao.com' > AUTHORS.txt","lint-staged":"lint-staged","lint-staged:ts":"tsc && node node_modules/tslint/bin/tslint -c node_modules/antd-tools/lib/tslint.json","lint-staged:es":"eslint ./.eslintrc.js ./webpack.config.js","lint-staged:demo":"cross-env RUN_ENV=DEMO eslint --ext '.md'"},"lint-staged":{"components/**/*.tsx":["lint-staged:ts"],"{tests,site,scripts,components}/**/*.{js,jsx}":["lint-staged:es"],"{site,components}/**/*.less":"stylelint --syntax less","components/*/demo/*.md":["lint-staged:demo"]},"pre-commit":["lint-staged"]}

/***/ }),
/* 575 */
/***/ (function(module, exports, __webpack_require__) {

	var camel2hyphen = __webpack_require__(804);
	
	var isDimension = function (feature) {
	  var re = /[height|width]$/;
	  return re.test(feature);
	};
	
	var obj2mq = function (obj) {
	  var mq = '';
	  var features = Object.keys(obj);
	  features.forEach(function (feature, index) {
	    var value = obj[feature];
	    feature = camel2hyphen(feature);
	    // Add px to dimension features
	    if (isDimension(feature) && typeof value === 'number') {
	      value = value + 'px';
	    }
	    if (value === true) {
	      mq += feature;
	    } else if (value === false) {
	      mq += 'not ' + feature;
	    } else {
	      mq += '(' + feature + ': ' + value + ')';
	    }
	    if (index < features.length-1) {
	      mq += ' and '
	    }
	  });
	  return mq;
	};
	
	var json2mq = function (query) {
	  var mq = '';
	  if (typeof query === 'string') {
	    return query;
	  }
	  // Handling array of media queries
	  if (query instanceof Array) {
	    query.forEach(function (q, index) {
	      mq += obj2mq(q);
	      if (index < query.length-1) {
	        mq += ', '
	      }
	    });
	    return mq;
	  }
	  // Handling single media query
	  return obj2mq(query);
	};
	
	module.exports = json2mq;

/***/ }),
/* 576 */
/***/ (function(module, exports) {

	/**
	 * lodash 3.9.1 (Custom Build) <https://lodash.com/>
	 * Build: `lodash modern modularize exports="npm" -o ./`
	 * Copyright 2012-2015 The Dojo Foundation <http://dojofoundation.org/>
	 * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
	 * Copyright 2009-2015 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
	 * Available under MIT license <https://lodash.com/license>
	 */
	
	/** `Object#toString` result references. */
	var funcTag = '[object Function]';
	
	/** Used to detect host constructors (Safari > 5). */
	var reIsHostCtor = /^\[object .+?Constructor\]$/;
	
	/**
	 * Checks if `value` is object-like.
	 *
	 * @private
	 * @param {*} value The value to check.
	 * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
	 */
	function isObjectLike(value) {
	  return !!value && typeof value == 'object';
	}
	
	/** Used for native method references. */
	var objectProto = Object.prototype;
	
	/** Used to resolve the decompiled source of functions. */
	var fnToString = Function.prototype.toString;
	
	/** Used to check objects for own properties. */
	var hasOwnProperty = objectProto.hasOwnProperty;
	
	/**
	 * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)
	 * of values.
	 */
	var objToString = objectProto.toString;
	
	/** Used to detect if a method is native. */
	var reIsNative = RegExp('^' +
	  fnToString.call(hasOwnProperty).replace(/[\\^$.*+?()[\]{}|]/g, '\\$&')
	  .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
	);
	
	/**
	 * 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 = object == null ? undefined : object[key];
	  return isNative(value) ? value : undefined;
	}
	
	/**
	 * Checks if `value` is classified as a `Function` object.
	 *
	 * @static
	 * @memberOf _
	 * @category Lang
	 * @param {*} value The value to check.
	 * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
	 * @example
	 *
	 * _.isFunction(_);
	 * // => true
	 *
	 * _.isFunction(/abc/);
	 * // => false
	 */
	function isFunction(value) {
	  // The use of `Object#toString` avoids issues with the `typeof` operator
	  // in older versions of Chrome and Safari which return 'function' for regexes
	  // and Safari 8 equivalents which return 'object' for typed array constructors.
	  return isObject(value) && objToString.call(value) == funcTag;
	}
	
	/**
	 * Checks if `value` is the [language type](https://es5.github.io/#x8) of `Object`.
	 * (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
	 *
	 * @static
	 * @memberOf _
	 * @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(1);
	 * // => false
	 */
	function isObject(value) {
	  // Avoid a V8 JIT bug in Chrome 19-20.
	  // See https://code.google.com/p/v8/issues/detail?id=2291 for more details.
	  var type = typeof value;
	  return !!value && (type == 'object' || type == 'function');
	}
	
	/**
	 * Checks if `value` is a native function.
	 *
	 * @static
	 * @memberOf _
	 * @category Lang
	 * @param {*} value The value to check.
	 * @returns {boolean} Returns `true` if `value` is a native function, else `false`.
	 * @example
	 *
	 * _.isNative(Array.prototype.push);
	 * // => true
	 *
	 * _.isNative(_);
	 * // => false
	 */
	function isNative(value) {
	  if (value == null) {
	    return false;
	  }
	  if (isFunction(value)) {
	    return reIsNative.test(fnToString.call(value));
	  }
	  return isObjectLike(value) && reIsHostCtor.test(value);
	}
	
	module.exports = getNative;


/***/ }),
/* 577 */
/***/ (function(module, exports) {

	/* WEBPACK VAR INJECTION */(function(global) {/**
	 * lodash (Custom Build) <https://lodash.com/>
	 * Build: `lodash modularize exports="npm" -o ./`
	 * Copyright jQuery Foundation and other contributors <https://jquery.org/>
	 * Released under MIT license <https://lodash.com/license>
	 * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
	 * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
	 */
	
	/** Used as the `TypeError` message for "Functions" methods. */
	var FUNC_ERROR_TEXT = 'Expected a function';
	
	/** Used to stand-in for `undefined` hash values. */
	var HASH_UNDEFINED = '__lodash_hash_undefined__';
	
	/** Used as references for various `Number` constants. */
	var INFINITY = 1 / 0;
	
	/** `Object#toString` result references. */
	var funcTag = '[object Function]',
	    genTag = '[object GeneratorFunction]',
	    symbolTag = '[object Symbol]';
	
	/** Used to match property names within property paths. */
	var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,
	    reIsPlainProp = /^\w*$/,
	    reLeadingDot = /^\./,
	    rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
	
	/**
	 * Used to match `RegExp`
	 * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
	 */
	var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
	
	/** Used to match backslashes in property paths. */
	var reEscapeChar = /\\(\\)?/g;
	
	/** Used to detect host constructors (Safari). */
	var reIsHostCtor = /^\[object .+?Constructor\]$/;
	
	/** Detect free variable `global` from Node.js. */
	var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;
	
	/** 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')();
	
	/**
	 * 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];
	}
	
	/**
	 * Checks if `value` is a host object in IE < 9.
	 *
	 * @private
	 * @param {*} value The value to check.
	 * @returns {boolean} Returns `true` if `value` is a host object, else `false`.
	 */
	function isHostObject(value) {
	  // Many host objects are `Object` objects that can coerce to strings
	  // despite having improperly defined `toString` methods.
	  var result = false;
	  if (value != null && typeof value.toString != 'function') {
	    try {
	      result = !!(value + '');
	    } catch (e) {}
	  }
	  return result;
	}
	
	/** Used for built-in method references. */
	var arrayProto = Array.prototype,
	    funcProto = Function.prototype,
	    objectProto = Object.prototype;
	
	/** Used to detect overreaching core-js shims. */
	var coreJsData = root['__core-js_shared__'];
	
	/** 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) : '';
	}());
	
	/** 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 resolve the
	 * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
	 * of values.
	 */
	var objectToString = objectProto.toString;
	
	/** Used to detect if a method is native. */
	var reIsNative = RegExp('^' +
	  funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&')
	  .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
	);
	
	/** Built-in value references. */
	var Symbol = root.Symbol,
	    splice = arrayProto.splice;
	
	/* Built-in method references that are verified to be native. */
	var Map = getNative(root, 'Map'),
	    nativeCreate = getNative(Object, 'create');
	
	/** Used to convert symbols to primitives and strings. */
	var symbolProto = Symbol ? Symbol.prototype : undefined,
	    symbolToString = symbolProto ? symbolProto.toString : undefined;
	
	/**
	 * Creates a hash object.
	 *
	 * @private
	 * @constructor
	 * @param {Array} [entries] The key-value pairs to cache.
	 */
	function Hash(entries) {
	  var index = -1,
	      length = entries ? entries.length : 0;
	
	  this.clear();
	  while (++index < length) {
	    var entry = entries[index];
	    this.set(entry[0], entry[1]);
	  }
	}
	
	/**
	 * Removes all key-value entries from the hash.
	 *
	 * @private
	 * @name clear
	 * @memberOf Hash
	 */
	function hashClear() {
	  this.__data__ = nativeCreate ? nativeCreate(null) : {};
	}
	
	/**
	 * 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) {
	  return this.has(key) && delete this.__data__[key];
	}
	
	/**
	 * 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;
	}
	
	/**
	 * 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);
	}
	
	/**
	 * 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__;
	  data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;
	  return this;
	}
	
	// Add methods to `Hash`.
	Hash.prototype.clear = hashClear;
	Hash.prototype['delete'] = hashDelete;
	Hash.prototype.get = hashGet;
	Hash.prototype.has = hashHas;
	Hash.prototype.set = hashSet;
	
	/**
	 * Creates an list cache object.
	 *
	 * @private
	 * @constructor
	 * @param {Array} [entries] The key-value pairs to cache.
	 */
	function ListCache(entries) {
	  var index = -1,
	      length = entries ? entries.length : 0;
	
	  this.clear();
	  while (++index < length) {
	    var entry = entries[index];
	    this.set(entry[0], entry[1]);
	  }
	}
	
	/**
	 * Removes all key-value entries from the list cache.
	 *
	 * @private
	 * @name clear
	 * @memberOf ListCache
	 */
	function listCacheClear() {
	  this.__data__ = [];
	}
	
	/**
	 * 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);
	  }
	  return true;
	}
	
	/**
	 * 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];
	}
	
	/**
	 * 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;
	}
	
	/**
	 * 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) {
	    data.push([key, value]);
	  } else {
	    data[index][1] = value;
	  }
	  return this;
	}
	
	// Add methods to `ListCache`.
	ListCache.prototype.clear = listCacheClear;
	ListCache.prototype['delete'] = listCacheDelete;
	ListCache.prototype.get = listCacheGet;
	ListCache.prototype.has = listCacheHas;
	ListCache.prototype.set = listCacheSet;
	
	/**
	 * 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 ? entries.length : 0;
	
	  this.clear();
	  while (++index < length) {
	    var entry = entries[index];
	    this.set(entry[0], entry[1]);
	  }
	}
	
	/**
	 * Removes all key-value entries from the map.
	 *
	 * @private
	 * @name clear
	 * @memberOf MapCache
	 */
	function mapCacheClear() {
	  this.__data__ = {
	    'hash': new Hash,
	    'map': new (Map || ListCache),
	    'string': new Hash
	  };
	}
	
	/**
	 * 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) {
	  return getMapData(this, key)['delete'](key);
	}
	
	/**
	 * 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);
	}
	
	/**
	 * 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);
	}
	
	/**
	 * 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) {
	  getMapData(this, key).set(key, value);
	  return this;
	}
	
	// Add methods to `MapCache`.
	MapCache.prototype.clear = mapCacheClear;
	MapCache.prototype['delete'] = mapCacheDelete;
	MapCache.prototype.get = mapCacheGet;
	MapCache.prototype.has = mapCacheHas;
	MapCache.prototype.set = mapCacheSet;
	
	/**
	 * 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;
	}
	
	/**
	 * 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 = isKey(path, object) ? [path] : castPath(path);
	
	  var index = 0,
	      length = path.length;
	
	  while (object != null && index < length) {
	    object = object[toKey(path[index++])];
	  }
	  return (index && index == length) ? object : undefined;
	}
	
	/**
	 * 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) || isHostObject(value)) ? reIsNative : reIsHostCtor;
	  return pattern.test(toSource(value));
	}
	
	/**
	 * 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 (isSymbol(value)) {
	    return symbolToString ? symbolToString.call(value) : '';
	  }
	  var result = (value + '');
	  return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
	}
	
	/**
	 * Casts `value` to a path array if it's not one.
	 *
	 * @private
	 * @param {*} value The value to inspect.
	 * @returns {Array} Returns the cast property path array.
	 */
	function castPath(value) {
	  return isArray(value) ? value : stringToPath(value);
	}
	
	/**
	 * 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;
	}
	
	/**
	 * 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;
	}
	
	/**
	 * 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));
	}
	
	/**
	 * 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);
	}
	
	/**
	 * 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);
	}
	
	/**
	 * Converts `string` to a property path array.
	 *
	 * @private
	 * @param {string} string The string to convert.
	 * @returns {Array} Returns the property path array.
	 */
	var stringToPath = memoize(function(string) {
	  string = toString(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;
	});
	
	/**
	 * 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;
	}
	
	/**
	 * Converts `func` to its source code.
	 *
	 * @private
	 * @param {Function} func The function to process.
	 * @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 '';
	}
	
	/**
	 * 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 `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 && 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);
	    return result;
	  };
	  memoized.cache = new (memoize.Cache || MapCache);
	  return memoized;
	}
	
	// Assign cache to `_.memoize`.
	memoize.Cache = MapCache;
	
	/**
	 * 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);
	}
	
	/**
	 * 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;
	
	/**
	 * 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) {
	  // The use of `Object#toString` avoids issues with the `typeof` operator
	  // in Safari 8-9 which returns 'object' for typed array and other constructors.
	  var tag = isObject(value) ? objectToString.call(value) : '';
	  return tag == funcTag || tag == genTag;
	}
	
	/**
	 * 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 && (type == 'object' || type == 'function');
	}
	
	/**
	 * 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 && typeof value == 'object';
	}
	
	/**
	 * 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) && objectToString.call(value) == symbolTag);
	}
	
	/**
	 * 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 process.
	 * @returns {string} Returns the string.
	 * @example
	 *
	 * _.toString(null);
	 * // => ''
	 *
	 * _.toString(-0);
	 * // => '-0'
	 *
	 * _.toString([1, 2, 3]);
	 * // => '1,2,3'
	 */
	function toString(value) {
	  return value == null ? '' : baseToString(value);
	}
	
	/**
	 * Gets the value at `path` of `object`. If the resolved value is
	 * `undefined`, the `defaultValue` is returned in its place.
	 *
	 * @static
	 * @memberOf _
	 * @since 3.7.0
	 * @category Object
	 * @param {Object} object The object to query.
	 * @param {Array|string} path The path of the property to get.
	 * @param {*} [defaultValue] The value returned for `undefined` resolved values.
	 * @returns {*} Returns the resolved value.
	 * @example
	 *
	 * var object = { 'a': [{ 'b': { 'c': 3 } }] };
	 *
	 * _.get(object, 'a[0].b.c');
	 * // => 3
	 *
	 * _.get(object, ['a', '0', 'b', 'c']);
	 * // => 3
	 *
	 * _.get(object, 'a.b.c', 'default');
	 * // => 'default'
	 */
	function get(object, path, defaultValue) {
	  var result = object == null ? undefined : baseGet(object, path);
	  return result === undefined ? defaultValue : result;
	}
	
	module.exports = get;
	
	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))

/***/ }),
/* 578 */
/***/ (function(module, exports) {

	/**
	 * lodash (Custom Build) <https://lodash.com/>
	 * Build: `lodash modularize exports="npm" -o ./`
	 * Copyright jQuery Foundation and other contributors <https://jquery.org/>
	 * Released under MIT license <https://lodash.com/license>
	 * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
	 * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
	 */
	
	/** Used as references for various `Number` constants. */
	var MAX_SAFE_INTEGER = 9007199254740991;
	
	/** `Object#toString` result references. */
	var argsTag = '[object Arguments]',
	    funcTag = '[object Function]',
	    genTag = '[object GeneratorFunction]';
	
	/** 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 objectToString = objectProto.toString;
	
	/** 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
	 */
	function isArguments(value) {
	  // Safari 8.1 makes `arguments.callee` enumerable in strict mode.
	  return isArrayLikeObject(value) && hasOwnProperty.call(value, 'callee') &&
	    (!propertyIsEnumerable.call(value, 'callee') || objectToString.call(value) == argsTag);
	}
	
	/**
	 * 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);
	}
	
	/**
	 * This method is like `_.isArrayLike` except that it also checks if `value`
	 * is an object.
	 *
	 * @static
	 * @memberOf _
	 * @since 4.0.0
	 * @category Lang
	 * @param {*} value The value to check.
	 * @returns {boolean} Returns `true` if `value` is an array-like object,
	 *  else `false`.
	 * @example
	 *
	 * _.isArrayLikeObject([1, 2, 3]);
	 * // => true
	 *
	 * _.isArrayLikeObject(document.body.children);
	 * // => true
	 *
	 * _.isArrayLikeObject('abc');
	 * // => false
	 *
	 * _.isArrayLikeObject(_.noop);
	 * // => false
	 */
	function isArrayLikeObject(value) {
	  return isObjectLike(value) && isArrayLike(value);
	}
	
	/**
	 * 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) {
	  // The use of `Object#toString` avoids issues with the `typeof` operator
	  // in Safari 8-9 which returns 'object' for typed array and other constructors.
	  var tag = isObject(value) ? objectToString.call(value) : '';
	  return tag == funcTag || tag == genTag;
	}
	
	/**
	 * 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;
	}
	
	/**
	 * 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 && (type == 'object' || type == 'function');
	}
	
	/**
	 * 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 && typeof value == 'object';
	}
	
	module.exports = isArguments;


/***/ }),
/* 579 */
/***/ (function(module, exports) {

	/**
	 * lodash 3.0.4 (Custom Build) <https://lodash.com/>
	 * Build: `lodash modern modularize exports="npm" -o ./`
	 * Copyright 2012-2015 The Dojo Foundation <http://dojofoundation.org/>
	 * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
	 * Copyright 2009-2015 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
	 * Available under MIT license <https://lodash.com/license>
	 */
	
	/** `Object#toString` result references. */
	var arrayTag = '[object Array]',
	    funcTag = '[object Function]';
	
	/** Used to detect host constructors (Safari > 5). */
	var reIsHostCtor = /^\[object .+?Constructor\]$/;
	
	/**
	 * Checks if `value` is object-like.
	 *
	 * @private
	 * @param {*} value The value to check.
	 * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
	 */
	function isObjectLike(value) {
	  return !!value && typeof value == 'object';
	}
	
	/** Used for native method references. */
	var objectProto = Object.prototype;
	
	/** Used to resolve the decompiled source of functions. */
	var fnToString = Function.prototype.toString;
	
	/** Used to check objects for own properties. */
	var hasOwnProperty = objectProto.hasOwnProperty;
	
	/**
	 * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)
	 * of values.
	 */
	var objToString = objectProto.toString;
	
	/** Used to detect if a method is native. */
	var reIsNative = RegExp('^' +
	  fnToString.call(hasOwnProperty).replace(/[\\^$.*+?()[\]{}|]/g, '\\$&')
	  .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
	);
	
	/* Native method references for those with the same name as other `lodash` methods. */
	var nativeIsArray = getNative(Array, 'isArray');
	
	/**
	 * Used as the [maximum length](http://ecma-international.org/ecma-262/6.0/#sec-number.max_safe_integer)
	 * of an array-like value.
	 */
	var MAX_SAFE_INTEGER = 9007199254740991;
	
	/**
	 * 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 = object == null ? undefined : object[key];
	  return isNative(value) ? value : undefined;
	}
	
	/**
	 * Checks if `value` is a valid array-like length.
	 *
	 * **Note:** This function is based on [`ToLength`](http://ecma-international.org/ecma-262/6.0/#sec-tolength).
	 *
	 * @private
	 * @param {*} value The value to check.
	 * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
	 */
	function isLength(value) {
	  return typeof value == 'number' && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
	}
	
	/**
	 * Checks if `value` is classified as an `Array` object.
	 *
	 * @static
	 * @memberOf _
	 * @category Lang
	 * @param {*} value The value to check.
	 * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
	 * @example
	 *
	 * _.isArray([1, 2, 3]);
	 * // => true
	 *
	 * _.isArray(function() { return arguments; }());
	 * // => false
	 */
	var isArray = nativeIsArray || function(value) {
	  return isObjectLike(value) && isLength(value.length) && objToString.call(value) == arrayTag;
	};
	
	/**
	 * Checks if `value` is classified as a `Function` object.
	 *
	 * @static
	 * @memberOf _
	 * @category Lang
	 * @param {*} value The value to check.
	 * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.
	 * @example
	 *
	 * _.isFunction(_);
	 * // => true
	 *
	 * _.isFunction(/abc/);
	 * // => false
	 */
	function isFunction(value) {
	  // The use of `Object#toString` avoids issues with the `typeof` operator
	  // in older versions of Chrome and Safari which return 'function' for regexes
	  // and Safari 8 equivalents which return 'object' for typed array constructors.
	  return isObject(value) && objToString.call(value) == funcTag;
	}
	
	/**
	 * Checks if `value` is the [language type](https://es5.github.io/#x8) of `Object`.
	 * (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
	 *
	 * @static
	 * @memberOf _
	 * @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(1);
	 * // => false
	 */
	function isObject(value) {
	  // Avoid a V8 JIT bug in Chrome 19-20.
	  // See https://code.google.com/p/v8/issues/detail?id=2291 for more details.
	  var type = typeof value;
	  return !!value && (type == 'object' || type == 'function');
	}
	
	/**
	 * Checks if `value` is a native function.
	 *
	 * @static
	 * @memberOf _
	 * @category Lang
	 * @param {*} value The value to check.
	 * @returns {boolean} Returns `true` if `value` is a native function, else `false`.
	 * @example
	 *
	 * _.isNative(Array.prototype.push);
	 * // => true
	 *
	 * _.isNative(_);
	 * // => false
	 */
	function isNative(value) {
	  if (value == null) {
	    return false;
	  }
	  if (isFunction(value)) {
	    return reIsNative.test(fnToString.call(value));
	  }
	  return isObjectLike(value) && reIsHostCtor.test(value);
	}
	
	module.exports = isArray;


/***/ }),
/* 580 */
/***/ (function(module, exports) {

	/* WEBPACK VAR INJECTION */(function(global) {/**
	 * lodash (Custom Build) <https://lodash.com/>
	 * Build: `lodash modularize exports="npm" -o ./`
	 * Copyright jQuery Foundation and other contributors <https://jquery.org/>
	 * Released under MIT license <https://lodash.com/license>
	 * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
	 * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
	 */
	
	/** Used as the `TypeError` message for "Functions" methods. */
	var FUNC_ERROR_TEXT = 'Expected a function';
	
	/** Used as references for various `Number` constants. */
	var NAN = 0 / 0;
	
	/** `Object#toString` result references. */
	var symbolTag = '[object Symbol]';
	
	/** 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;
	
	/** Detect free variable `global` from Node.js. */
	var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;
	
	/** 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')();
	
	/** 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 objectToString = objectProto.toString;
	
	/* Built-in method references for those with the same name as other `lodash` methods. */
	var nativeMax = Math.max,
	    nativeMin = Math.min;
	
	/**
	 * Gets the timestamp of the number of milliseconds that have elapsed since
	 * the Unix epoch (1 January 1970 00:00:00 UTC).
	 *
	 * @static
	 * @memberOf _
	 * @since 2.4.0
	 * @category Date
	 * @returns {number} Returns the timestamp.
	 * @example
	 *
	 * _.defer(function(stamp) {
	 *   console.log(_.now() - stamp);
	 * }, _.now());
	 * // => Logs the number of milliseconds it took for the deferred invocation.
	 */
	var now = function() {
	  return root.Date.now();
	};
	
	/**
	 * Creates a debounced function that delays invoking `func` until after `wait`
	 * milliseconds have elapsed since the last time the debounced function was
	 * invoked. The debounced function comes with a `cancel` method to cancel
	 * delayed `func` invocations and a `flush` method to immediately invoke them.
	 * Provide `options` to indicate whether `func` should be invoked on the
	 * leading and/or trailing edge of the `wait` timeout. The `func` is invoked
	 * with the last arguments provided to the debounced function. Subsequent
	 * calls to the debounced function return the result of the last `func`
	 * invocation.
	 *
	 * **Note:** If `leading` and `trailing` options are `true`, `func` is
	 * invoked on the trailing edge of the timeout only if the debounced function
	 * is invoked more than once during the `wait` timeout.
	 *
	 * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
	 * until to the next tick, similar to `setTimeout` with a timeout of `0`.
	 *
	 * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
	 * for details over the differences between `_.debounce` and `_.throttle`.
	 *
	 * @static
	 * @memberOf _
	 * @since 0.1.0
	 * @category Function
	 * @param {Function} func The function to debounce.
	 * @param {number} [wait=0] The number of milliseconds to delay.
	 * @param {Object} [options={}] The options object.
	 * @param {boolean} [options.leading=false]
	 *  Specify invoking on the leading edge of the timeout.
	 * @param {number} [options.maxWait]
	 *  The maximum time `func` is allowed to be delayed before it's invoked.
	 * @param {boolean} [options.trailing=true]
	 *  Specify invoking on the trailing edge of the timeout.
	 * @returns {Function} Returns the new debounced function.
	 * @example
	 *
	 * // Avoid costly calculations while the window size is in flux.
	 * jQuery(window).on('resize', _.debounce(calculateLayout, 150));
	 *
	 * // Invoke `sendMail` when clicked, debouncing subsequent calls.
	 * jQuery(element).on('click', _.debounce(sendMail, 300, {
	 *   'leading': true,
	 *   'trailing': false
	 * }));
	 *
	 * // Ensure `batchLog` is invoked once after 1 second of debounced calls.
	 * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });
	 * var source = new EventSource('/stream');
	 * jQuery(source).on('message', debounced);
	 *
	 * // Cancel the trailing debounced invocation.
	 * jQuery(window).on('popstate', debounced.cancel);
	 */
	function debounce(func, wait, options) {
	  var lastArgs,
	      lastThis,
	      maxWait,
	      result,
	      timerId,
	      lastCallTime,
	      lastInvokeTime = 0,
	      leading = false,
	      maxing = false,
	      trailing = true;
	
	  if (typeof func != 'function') {
	    throw new TypeError(FUNC_ERROR_TEXT);
	  }
	  wait = toNumber(wait) || 0;
	  if (isObject(options)) {
	    leading = !!options.leading;
	    maxing = 'maxWait' in options;
	    maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;
	    trailing = 'trailing' in options ? !!options.trailing : trailing;
	  }
	
	  function invokeFunc(time) {
	    var args = lastArgs,
	        thisArg = lastThis;
	
	    lastArgs = lastThis = undefined;
	    lastInvokeTime = time;
	    result = func.apply(thisArg, args);
	    return result;
	  }
	
	  function leadingEdge(time) {
	    // Reset any `maxWait` timer.
	    lastInvokeTime = time;
	    // Start the timer for the trailing edge.
	    timerId = setTimeout(timerExpired, wait);
	    // Invoke the leading edge.
	    return leading ? invokeFunc(time) : result;
	  }
	
	  function remainingWait(time) {
	    var timeSinceLastCall = time - lastCallTime,
	        timeSinceLastInvoke = time - lastInvokeTime,
	        result = wait - timeSinceLastCall;
	
	    return maxing ? nativeMin(result, maxWait - timeSinceLastInvoke) : result;
	  }
	
	  function shouldInvoke(time) {
	    var timeSinceLastCall = time - lastCallTime,
	        timeSinceLastInvoke = time - lastInvokeTime;
	
	    // Either this is the first call, activity has stopped and we're at the
	    // trailing edge, the system time has gone backwards and we're treating
	    // it as the trailing edge, or we've hit the `maxWait` limit.
	    return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||
	      (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));
	  }
	
	  function timerExpired() {
	    var time = now();
	    if (shouldInvoke(time)) {
	      return trailingEdge(time);
	    }
	    // Restart the timer.
	    timerId = setTimeout(timerExpired, remainingWait(time));
	  }
	
	  function trailingEdge(time) {
	    timerId = undefined;
	
	    // Only invoke if we have `lastArgs` which means `func` has been
	    // debounced at least once.
	    if (trailing && lastArgs) {
	      return invokeFunc(time);
	    }
	    lastArgs = lastThis = undefined;
	    return result;
	  }
	
	  function cancel() {
	    if (timerId !== undefined) {
	      clearTimeout(timerId);
	    }
	    lastInvokeTime = 0;
	    lastArgs = lastCallTime = lastThis = timerId = undefined;
	  }
	
	  function flush() {
	    return timerId === undefined ? result : trailingEdge(now());
	  }
	
	  function debounced() {
	    var time = now(),
	        isInvoking = shouldInvoke(time);
	
	    lastArgs = arguments;
	    lastThis = this;
	    lastCallTime = time;
	
	    if (isInvoking) {
	      if (timerId === undefined) {
	        return leadingEdge(lastCallTime);
	      }
	      if (maxing) {
	        // Handle invocations in a tight loop.
	        timerId = setTimeout(timerExpired, wait);
	        return invokeFunc(lastCallTime);
	      }
	    }
	    if (timerId === undefined) {
	      timerId = setTimeout(timerExpired, wait);
	    }
	    return result;
	  }
	  debounced.cancel = cancel;
	  debounced.flush = flush;
	  return debounced;
	}
	
	/**
	 * Creates a throttled function that only invokes `func` at most once per
	 * every `wait` milliseconds. The throttled function comes with a `cancel`
	 * method to cancel delayed `func` invocations and a `flush` method to
	 * immediately invoke them. Provide `options` to indicate whether `func`
	 * should be invoked on the leading and/or trailing edge of the `wait`
	 * timeout. The `func` is invoked with the last arguments provided to the
	 * throttled function. Subsequent calls to the throttled function return the
	 * result of the last `func` invocation.
	 *
	 * **Note:** If `leading` and `trailing` options are `true`, `func` is
	 * invoked on the trailing edge of the timeout only if the throttled function
	 * is invoked more than once during the `wait` timeout.
	 *
	 * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
	 * until to the next tick, similar to `setTimeout` with a timeout of `0`.
	 *
	 * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
	 * for details over the differences between `_.throttle` and `_.debounce`.
	 *
	 * @static
	 * @memberOf _
	 * @since 0.1.0
	 * @category Function
	 * @param {Function} func The function to throttle.
	 * @param {number} [wait=0] The number of milliseconds to throttle invocations to.
	 * @param {Object} [options={}] The options object.
	 * @param {boolean} [options.leading=true]
	 *  Specify invoking on the leading edge of the timeout.
	 * @param {boolean} [options.trailing=true]
	 *  Specify invoking on the trailing edge of the timeout.
	 * @returns {Function} Returns the new throttled function.
	 * @example
	 *
	 * // Avoid excessively updating the position while scrolling.
	 * jQuery(window).on('scroll', _.throttle(updatePosition, 100));
	 *
	 * // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes.
	 * var throttled = _.throttle(renewToken, 300000, { 'trailing': false });
	 * jQuery(element).on('click', throttled);
	 *
	 * // Cancel the trailing throttled invocation.
	 * jQuery(window).on('popstate', throttled.cancel);
	 */
	function throttle(func, wait, options) {
	  var leading = true,
	      trailing = true;
	
	  if (typeof func != 'function') {
	    throw new TypeError(FUNC_ERROR_TEXT);
	  }
	  if (isObject(options)) {
	    leading = 'leading' in options ? !!options.leading : leading;
	    trailing = 'trailing' in options ? !!options.trailing : trailing;
	  }
	  return debounce(func, wait, {
	    'leading': leading,
	    'maxWait': wait,
	    'trailing': trailing
	  });
	}
	
	/**
	 * 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 && (type == 'object' || type == 'function');
	}
	
	/**
	 * 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 && typeof value == 'object';
	}
	
	/**
	 * 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) && objectToString.call(value) == symbolTag);
	}
	
	/**
	 * 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 = throttle;
	
	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))

/***/ }),
/* 581 */
/***/ (function(module, exports, __webpack_require__) {

	/* WEBPACK VAR INJECTION */(function(global, module) {/**
	 * lodash (Custom Build) <https://lodash.com/>
	 * Build: `lodash modularize exports="npm" -o ./`
	 * Copyright jQuery Foundation and other contributors <https://jquery.org/>
	 * Released under MIT license <https://lodash.com/license>
	 * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
	 * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
	 */
	
	/** Used as the size to enable large array optimizations. */
	var LARGE_ARRAY_SIZE = 200;
	
	/** Used as the `TypeError` message for "Functions" methods. */
	var FUNC_ERROR_TEXT = 'Expected a function';
	
	/** Used to stand-in for `undefined` hash values. */
	var HASH_UNDEFINED = '__lodash_hash_undefined__';
	
	/** Used to compose bitmasks for comparison styles. */
	var UNORDERED_COMPARE_FLAG = 1,
	    PARTIAL_COMPARE_FLAG = 2;
	
	/** Used as references for various `Number` constants. */
	var INFINITY = 1 / 0,
	    MAX_SAFE_INTEGER = 9007199254740991;
	
	/** `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]',
	    promiseTag = '[object Promise]',
	    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 match property names within property paths. */
	var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,
	    reIsPlainProp = /^\w*$/,
	    reLeadingDot = /^\./,
	    rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
	
	/**
	 * Used to match `RegExp`
	 * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
	 */
	var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
	
	/** Used to match backslashes in property paths. */
	var reEscapeChar = /\\(\\)?/g;
	
	/** Used to detect host constructors (Safari). */
	var reIsHostCtor = /^\[object .+?Constructor\]$/;
	
	/** Used to detect unsigned integer values. */
	var reIsUint = /^(?:0|[1-9]\d*)$/;
	
	/** 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;
	
	/** Detect free variable `global` from Node.js. */
	var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;
	
	/** 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')();
	
	/** 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('util');
	  } catch (e) {}
	}());
	
	/* Node.js helper references. */
	var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
	
	/**
	 * A specialized version of `_.includes` for arrays without support for
	 * specifying an index to search from.
	 *
	 * @private
	 * @param {Array} [array] The array to inspect.
	 * @param {*} target The value to search for.
	 * @returns {boolean} Returns `true` if `target` is found, else `false`.
	 */
	function arrayIncludes(array, value) {
	  var length = array ? array.length : 0;
	  return !!length && baseIndexOf(array, value, 0) > -1;
	}
	
	/**
	 * This function is like `arrayIncludes` except that it accepts a comparator.
	 *
	 * @private
	 * @param {Array} [array] The array to inspect.
	 * @param {*} target The value to search for.
	 * @param {Function} comparator The comparator invoked per element.
	 * @returns {boolean} Returns `true` if `target` is found, else `false`.
	 */
	function arrayIncludesWith(array, value, comparator) {
	  var index = -1,
	      length = array ? array.length : 0;
	
	  while (++index < length) {
	    if (comparator(value, array[index])) {
	      return true;
	    }
	  }
	  return false;
	}
	
	/**
	 * A specialized version of `_.some` 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 {boolean} Returns `true` if any element passes the predicate check,
	 *  else `false`.
	 */
	function arraySome(array, predicate) {
	  var index = -1,
	      length = array ? array.length : 0;
	
	  while (++index < length) {
	    if (predicate(array[index], index, array)) {
	      return true;
	    }
	  }
	  return false;
	}
	
	/**
	 * 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;
	}
	
	/**
	 * 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) {
	  if (value !== value) {
	    return baseFindIndex(array, baseIsNaN, fromIndex);
	  }
	  var index = fromIndex - 1,
	      length = array.length;
	
	  while (++index < length) {
	    if (array[index] === value) {
	      return index;
	    }
	  }
	  return -1;
	}
	
	/**
	 * 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;
	}
	
	/**
	 * The base implementation of `_.property` without support for deep paths.
	 *
	 * @private
	 * @param {string} key The key of the property to get.
	 * @returns {Function} Returns the new accessor function.
	 */
	function baseProperty(key) {
	  return function(object) {
	    return object == null ? undefined : object[key];
	  };
	}
	
	/**
	 * 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;
	}
	
	/**
	 * 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);
	  };
	}
	
	/**
	 * Checks if a cache value for `key` exists.
	 *
	 * @private
	 * @param {Object} cache The cache to query.
	 * @param {string} key The key of the entry to check.
	 * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
	 */
	function cacheHas(cache, key) {
	  return cache.has(key);
	}
	
	/**
	 * 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];
	}
	
	/**
	 * Checks if `value` is a host object in IE < 9.
	 *
	 * @private
	 * @param {*} value The value to check.
	 * @returns {boolean} Returns `true` if `value` is a host object, else `false`.
	 */
	function isHostObject(value) {
	  // Many host objects are `Object` objects that can coerce to strings
	  // despite having improperly defined `toString` methods.
	  var result = false;
	  if (value != null && typeof value.toString != 'function') {
	    try {
	      result = !!(value + '');
	    } catch (e) {}
	  }
	  return result;
	}
	
	/**
	 * 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;
	}
	
	/**
	 * 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));
	  };
	}
	
	/**
	 * 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;
	}
	
	/** Used for built-in method references. */
	var arrayProto = Array.prototype,
	    funcProto = Function.prototype,
	    objectProto = Object.prototype;
	
	/** Used to detect overreaching core-js shims. */
	var coreJsData = root['__core-js_shared__'];
	
	/** 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) : '';
	}());
	
	/** 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 resolve the
	 * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
	 * of values.
	 */
	var objectToString = objectProto.toString;
	
	/** Used to detect if a method is native. */
	var reIsNative = RegExp('^' +
	  funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&')
	  .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
	);
	
	/** Built-in value references. */
	var Symbol = root.Symbol,
	    Uint8Array = root.Uint8Array,
	    propertyIsEnumerable = objectProto.propertyIsEnumerable,
	    splice = arrayProto.splice;
	
	/* Built-in method references for those with the same name as other `lodash` methods. */
	var nativeKeys = overArg(Object.keys, Object);
	
	/* Built-in method references that are verified to be native. */
	var DataView = getNative(root, 'DataView'),
	    Map = getNative(root, 'Map'),
	    Promise = getNative(root, 'Promise'),
	    Set = getNative(root, 'Set'),
	    WeakMap = getNative(root, 'WeakMap'),
	    nativeCreate = getNative(Object, 'create');
	
	/** Used to detect maps, sets, and weakmaps. */
	var dataViewCtorString = toSource(DataView),
	    mapCtorString = toSource(Map),
	    promiseCtorString = toSource(Promise),
	    setCtorString = toSource(Set),
	    weakMapCtorString = toSource(WeakMap);
	
	/** Used to convert symbols to primitives and strings. */
	var symbolProto = Symbol ? Symbol.prototype : undefined,
	    symbolValueOf = symbolProto ? symbolProto.valueOf : undefined,
	    symbolToString = symbolProto ? symbolProto.toString : undefined;
	
	/**
	 * Creates a hash object.
	 *
	 * @private
	 * @constructor
	 * @param {Array} [entries] The key-value pairs to cache.
	 */
	function Hash(entries) {
	  var index = -1,
	      length = entries ? entries.length : 0;
	
	  this.clear();
	  while (++index < length) {
	    var entry = entries[index];
	    this.set(entry[0], entry[1]);
	  }
	}
	
	/**
	 * Removes all key-value entries from the hash.
	 *
	 * @private
	 * @name clear
	 * @memberOf Hash
	 */
	function hashClear() {
	  this.__data__ = nativeCreate ? nativeCreate(null) : {};
	}
	
	/**
	 * 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) {
	  return this.has(key) && delete this.__data__[key];
	}
	
	/**
	 * 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;
	}
	
	/**
	 * 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);
	}
	
	/**
	 * 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__;
	  data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;
	  return this;
	}
	
	// Add methods to `Hash`.
	Hash.prototype.clear = hashClear;
	Hash.prototype['delete'] = hashDelete;
	Hash.prototype.get = hashGet;
	Hash.prototype.has = hashHas;
	Hash.prototype.set = hashSet;
	
	/**
	 * Creates an list cache object.
	 *
	 * @private
	 * @constructor
	 * @param {Array} [entries] The key-value pairs to cache.
	 */
	function ListCache(entries) {
	  var index = -1,
	      length = entries ? entries.length : 0;
	
	  this.clear();
	  while (++index < length) {
	    var entry = entries[index];
	    this.set(entry[0], entry[1]);
	  }
	}
	
	/**
	 * Removes all key-value entries from the list cache.
	 *
	 * @private
	 * @name clear
	 * @memberOf ListCache
	 */
	function listCacheClear() {
	  this.__data__ = [];
	}
	
	/**
	 * 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);
	  }
	  return true;
	}
	
	/**
	 * 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];
	}
	
	/**
	 * 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;
	}
	
	/**
	 * 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) {
	    data.push([key, value]);
	  } else {
	    data[index][1] = value;
	  }
	  return this;
	}
	
	// Add methods to `ListCache`.
	ListCache.prototype.clear = listCacheClear;
	ListCache.prototype['delete'] = listCacheDelete;
	ListCache.prototype.get = listCacheGet;
	ListCache.prototype.has = listCacheHas;
	ListCache.prototype.set = listCacheSet;
	
	/**
	 * 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 ? entries.length : 0;
	
	  this.clear();
	  while (++index < length) {
	    var entry = entries[index];
	    this.set(entry[0], entry[1]);
	  }
	}
	
	/**
	 * Removes all key-value entries from the map.
	 *
	 * @private
	 * @name clear
	 * @memberOf MapCache
	 */
	function mapCacheClear() {
	  this.__data__ = {
	    'hash': new Hash,
	    'map': new (Map || ListCache),
	    'string': new Hash
	  };
	}
	
	/**
	 * 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) {
	  return getMapData(this, key)['delete'](key);
	}
	
	/**
	 * 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);
	}
	
	/**
	 * 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);
	}
	
	/**
	 * 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) {
	  getMapData(this, key).set(key, value);
	  return this;
	}
	
	// Add methods to `MapCache`.
	MapCache.prototype.clear = mapCacheClear;
	MapCache.prototype['delete'] = mapCacheDelete;
	MapCache.prototype.get = mapCacheGet;
	MapCache.prototype.has = mapCacheHas;
	MapCache.prototype.set = mapCacheSet;
	
	/**
	 *
	 * Creates an array cache object to store unique values.
	 *
	 * @private
	 * @constructor
	 * @param {Array} [values] The values to cache.
	 */
	function SetCache(values) {
	  var index = -1,
	      length = values ? values.length : 0;
	
	  this.__data__ = new MapCache;
	  while (++index < length) {
	    this.add(values[index]);
	  }
	}
	
	/**
	 * Adds `value` to the array cache.
	 *
	 * @private
	 * @name add
	 * @memberOf SetCache
	 * @alias push
	 * @param {*} value The value to cache.
	 * @returns {Object} Returns the cache instance.
	 */
	function setCacheAdd(value) {
	  this.__data__.set(value, HASH_UNDEFINED);
	  return this;
	}
	
	/**
	 * Checks if `value` is in the array cache.
	 *
	 * @private
	 * @name has
	 * @memberOf SetCache
	 * @param {*} value The value to search for.
	 * @returns {number} Returns `true` if `value` is found, else `false`.
	 */
	function setCacheHas(value) {
	  return this.__data__.has(value);
	}
	
	// Add methods to `SetCache`.
	SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
	SetCache.prototype.has = setCacheHas;
	
	/**
	 * Creates a stack cache object to store key-value pairs.
	 *
	 * @private
	 * @constructor
	 * @param {Array} [entries] The key-value pairs to cache.
	 */
	function Stack(entries) {
	  this.__data__ = new ListCache(entries);
	}
	
	/**
	 * Removes all key-value entries from the stack.
	 *
	 * @private
	 * @name clear
	 * @memberOf Stack
	 */
	function stackClear() {
	  this.__data__ = new ListCache;
	}
	
	/**
	 * 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) {
	  return this.__data__['delete'](key);
	}
	
	/**
	 * 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);
	}
	
	/**
	 * 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);
	}
	
	/**
	 * 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 cache = this.__data__;
	  if (cache instanceof ListCache) {
	    var pairs = cache.__data__;
	    if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {
	      pairs.push([key, value]);
	      return this;
	    }
	    cache = this.__data__ = new MapCache(pairs);
	  }
	  cache.set(key, value);
	  return this;
	}
	
	// Add methods to `Stack`.
	Stack.prototype.clear = stackClear;
	Stack.prototype['delete'] = stackDelete;
	Stack.prototype.get = stackGet;
	Stack.prototype.has = stackHas;
	Stack.prototype.set = stackSet;
	
	/**
	 * 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) {
	  // Safari 8.1 makes `arguments.callee` enumerable in strict mode.
	  // Safari 9 makes `arguments.length` enumerable in strict mode.
	  var result = (isArray(value) || isArguments(value))
	    ? baseTimes(value.length, String)
	    : [];
	
	  var length = result.length,
	      skipIndexes = !!length;
	
	  for (var key in value) {
	    if ((inherited || hasOwnProperty.call(value, key)) &&
	        !(skipIndexes && (key == 'length' || isIndex(key, length)))) {
	      result.push(key);
	    }
	  }
	  return result;
	}
	
	/**
	 * 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;
	}
	
	/**
	 * 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 = isKey(path, object) ? [path] : castPath(path);
	
	  var index = 0,
	      length = path.length;
	
	  while (object != null && index < length) {
	    object = object[toKey(path[index++])];
	  }
	  return (index && index == length) ? object : undefined;
	}
	
	/**
	 * The base implementation of `getTag`.
	 *
	 * @private
	 * @param {*} value The value to query.
	 * @returns {string} Returns the `toStringTag`.
	 */
	function baseGetTag(value) {
	  return objectToString.call(value);
	}
	
	/**
	 * The base implementation of `_.hasIn` without support for deep paths.
	 *
	 * @private
	 * @param {Object} [object] The object to query.
	 * @param {Array|string} key The key to check.
	 * @returns {boolean} Returns `true` if `key` exists, else `false`.
	 */
	function baseHasIn(object, key) {
	  return object != null && key in Object(object);
	}
	
	/**
	 * The base implementation of `_.isEqual` which supports partial comparisons
	 * and tracks traversed objects.
	 *
	 * @private
	 * @param {*} value The value to compare.
	 * @param {*} other The other value to compare.
	 * @param {Function} [customizer] The function to customize comparisons.
	 * @param {boolean} [bitmask] The bitmask of comparison flags.
	 *  The bitmask may be composed of the following flags:
	 *     1 - Unordered comparison
	 *     2 - Partial comparison
	 * @param {Object} [stack] Tracks traversed `value` and `other` objects.
	 * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
	 */
	function baseIsEqual(value, other, customizer, bitmask, stack) {
	  if (value === other) {
	    return true;
	  }
	  if (value == null || other == null || (!isObject(value) && !isObjectLike(other))) {
	    return value !== value && other !== other;
	  }
	  return baseIsEqualDeep(value, other, baseIsEqual, customizer, bitmask, stack);
	}
	
	/**
	 * A specialized version of `baseIsEqual` for arrays and objects which performs
	 * deep comparisons and tracks traversed objects enabling objects with circular
	 * references to be compared.
	 *
	 * @private
	 * @param {Object} object The object to compare.
	 * @param {Object} other The other object to compare.
	 * @param {Function} equalFunc The function to determine equivalents of values.
	 * @param {Function} [customizer] The function to customize comparisons.
	 * @param {number} [bitmask] The bitmask of comparison flags. See `baseIsEqual`
	 *  for more details.
	 * @param {Object} [stack] Tracks traversed `object` and `other` objects.
	 * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
	 */
	function baseIsEqualDeep(object, other, equalFunc, customizer, bitmask, stack) {
	  var objIsArr = isArray(object),
	      othIsArr = isArray(other),
	      objTag = arrayTag,
	      othTag = arrayTag;
	
	  if (!objIsArr) {
	    objTag = getTag(object);
	    objTag = objTag == argsTag ? objectTag : objTag;
	  }
	  if (!othIsArr) {
	    othTag = getTag(other);
	    othTag = othTag == argsTag ? objectTag : othTag;
	  }
	  var objIsObj = objTag == objectTag && !isHostObject(object),
	      othIsObj = othTag == objectTag && !isHostObject(other),
	      isSameTag = objTag == othTag;
	
	  if (isSameTag && !objIsObj) {
	    stack || (stack = new Stack);
	    return (objIsArr || isTypedArray(object))
	      ? equalArrays(object, other, equalFunc, customizer, bitmask, stack)
	      : equalByTag(object, other, objTag, equalFunc, customizer, bitmask, stack);
	  }
	  if (!(bitmask & PARTIAL_COMPARE_FLAG)) {
	    var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),
	        othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');
	
	    if (objIsWrapped || othIsWrapped) {
	      var objUnwrapped = objIsWrapped ? object.value() : object,
	          othUnwrapped = othIsWrapped ? other.value() : other;
	
	      stack || (stack = new Stack);
	      return equalFunc(objUnwrapped, othUnwrapped, customizer, bitmask, stack);
	    }
	  }
	  if (!isSameTag) {
	    return false;
	  }
	  stack || (stack = new Stack);
	  return equalObjects(object, other, equalFunc, customizer, bitmask, stack);
	}
	
	/**
	 * The base implementation of `_.isMatch` without support for iteratee shorthands.
	 *
	 * @private
	 * @param {Object} object The object to inspect.
	 * @param {Object} source The object of property values to match.
	 * @param {Array} matchData The property names, values, and compare flags to match.
	 * @param {Function} [customizer] The function to customize comparisons.
	 * @returns {boolean} Returns `true` if `object` is a match, else `false`.
	 */
	function baseIsMatch(object, source, matchData, customizer) {
	  var index = matchData.length,
	      length = index,
	      noCustomizer = !customizer;
	
	  if (object == null) {
	    return !length;
	  }
	  object = Object(object);
	  while (index--) {
	    var data = matchData[index];
	    if ((noCustomizer && data[2])
	          ? data[1] !== object[data[0]]
	          : !(data[0] in object)
	        ) {
	      return false;
	    }
	  }
	  while (++index < length) {
	    data = matchData[index];
	    var key = data[0],
	        objValue = object[key],
	        srcValue = data[1];
	
	    if (noCustomizer && data[2]) {
	      if (objValue === undefined && !(key in object)) {
	        return false;
	      }
	    } else {
	      var stack = new Stack;
	      if (customizer) {
	        var result = customizer(objValue, srcValue, key, object, source, stack);
	      }
	      if (!(result === undefined
	            ? baseIsEqual(srcValue, objValue, customizer, UNORDERED_COMPARE_FLAG | PARTIAL_COMPARE_FLAG, stack)
	            : result
	          )) {
	        return false;
	      }
	    }
	  }
	  return true;
	}
	
	/**
	 * 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) || isHostObject(value)) ? reIsNative : reIsHostCtor;
	  return pattern.test(toSource(value));
	}
	
	/**
	 * 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[objectToString.call(value)];
	}
	
	/**
	 * The base implementation of `_.iteratee`.
	 *
	 * @private
	 * @param {*} [value=_.identity] The value to convert to an iteratee.
	 * @returns {Function} Returns the iteratee.
	 */
	function baseIteratee(value) {
	  // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9.
	  // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details.
	  if (typeof value == 'function') {
	    return value;
	  }
	  if (value == null) {
	    return identity;
	  }
	  if (typeof value == 'object') {
	    return isArray(value)
	      ? baseMatchesProperty(value[0], value[1])
	      : baseMatches(value);
	  }
	  return property(value);
	}
	
	/**
	 * 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;
	}
	
	/**
	 * The base implementation of `_.matches` which doesn't clone `source`.
	 *
	 * @private
	 * @param {Object} source The object of property values to match.
	 * @returns {Function} Returns the new spec function.
	 */
	function baseMatches(source) {
	  var matchData = getMatchData(source);
	  if (matchData.length == 1 && matchData[0][2]) {
	    return matchesStrictComparable(matchData[0][0], matchData[0][1]);
	  }
	  return function(object) {
	    return object === source || baseIsMatch(object, source, matchData);
	  };
	}
	
	/**
	 * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`.
	 *
	 * @private
	 * @param {string} path The path of the property to get.
	 * @param {*} srcValue The value to match.
	 * @returns {Function} Returns the new spec function.
	 */
	function baseMatchesProperty(path, srcValue) {
	  if (isKey(path) && isStrictComparable(srcValue)) {
	    return matchesStrictComparable(toKey(path), srcValue);
	  }
	  return function(object) {
	    var objValue = get(object, path);
	    return (objValue === undefined && objValue === srcValue)
	      ? hasIn(object, path)
	      : baseIsEqual(srcValue, objValue, undefined, UNORDERED_COMPARE_FLAG | PARTIAL_COMPARE_FLAG);
	  };
	}
	
	/**
	 * A specialized version of `baseProperty` which supports deep paths.
	 *
	 * @private
	 * @param {Array|string} path The path of the property to get.
	 * @returns {Function} Returns the new accessor function.
	 */
	function basePropertyDeep(path) {
	  return function(object) {
	    return baseGet(object, path);
	  };
	}
	
	/**
	 * 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 (isSymbol(value)) {
	    return symbolToString ? symbolToString.call(value) : '';
	  }
	  var result = (value + '');
	  return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
	}
	
	/**
	 * The base implementation of `_.uniqBy` without support for iteratee shorthands.
	 *
	 * @private
	 * @param {Array} array The array to inspect.
	 * @param {Function} [iteratee] The iteratee invoked per element.
	 * @param {Function} [comparator] The comparator invoked per element.
	 * @returns {Array} Returns the new duplicate free array.
	 */
	function baseUniq(array, iteratee, comparator) {
	  var index = -1,
	      includes = arrayIncludes,
	      length = array.length,
	      isCommon = true,
	      result = [],
	      seen = result;
	
	  if (comparator) {
	    isCommon = false;
	    includes = arrayIncludesWith;
	  }
	  else if (length >= LARGE_ARRAY_SIZE) {
	    var set = iteratee ? null : createSet(array);
	    if (set) {
	      return setToArray(set);
	    }
	    isCommon = false;
	    includes = cacheHas;
	    seen = new SetCache;
	  }
	  else {
	    seen = iteratee ? [] : result;
	  }
	  outer:
	  while (++index < length) {
	    var value = array[index],
	        computed = iteratee ? iteratee(value) : value;
	
	    value = (comparator || value !== 0) ? value : 0;
	    if (isCommon && computed === computed) {
	      var seenIndex = seen.length;
	      while (seenIndex--) {
	        if (seen[seenIndex] === computed) {
	          continue outer;
	        }
	      }
	      if (iteratee) {
	        seen.push(computed);
	      }
	      result.push(value);
	    }
	    else if (!includes(seen, computed, comparator)) {
	      if (seen !== result) {
	        seen.push(computed);
	      }
	      result.push(value);
	    }
	  }
	  return result;
	}
	
	/**
	 * Casts `value` to a path array if it's not one.
	 *
	 * @private
	 * @param {*} value The value to inspect.
	 * @returns {Array} Returns the cast property path array.
	 */
	function castPath(value) {
	  return isArray(value) ? value : stringToPath(value);
	}
	
	/**
	 * Creates a set object of `values`.
	 *
	 * @private
	 * @param {Array} values The values to add to the set.
	 * @returns {Object} Returns the new set.
	 */
	var createSet = !(Set && (1 / setToArray(new Set([,-0]))[1]) == INFINITY) ? noop : function(values) {
	  return new Set(values);
	};
	
	/**
	 * A specialized version of `baseIsEqualDeep` for arrays with support for
	 * partial deep comparisons.
	 *
	 * @private
	 * @param {Array} array The array to compare.
	 * @param {Array} other The other array to compare.
	 * @param {Function} equalFunc The function to determine equivalents of values.
	 * @param {Function} customizer The function to customize comparisons.
	 * @param {number} bitmask The bitmask of comparison flags. See `baseIsEqual`
	 *  for more details.
	 * @param {Object} stack Tracks traversed `array` and `other` objects.
	 * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.
	 */
	function equalArrays(array, other, equalFunc, customizer, bitmask, stack) {
	  var isPartial = bitmask & PARTIAL_COMPARE_FLAG,
	      arrLength = array.length,
	      othLength = other.length;
	
	  if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
	    return false;
	  }
	  // Assume cyclic values are equal.
	  var stacked = stack.get(array);
	  if (stacked && stack.get(other)) {
	    return stacked == other;
	  }
	  var index = -1,
	      result = true,
	      seen = (bitmask & UNORDERED_COMPARE_FLAG) ? new SetCache : undefined;
	
	  stack.set(array, other);
	  stack.set(other, array);
	
	  // Ignore non-index properties.
	  while (++index < arrLength) {
	    var arrValue = array[index],
	        othValue = other[index];
	
	    if (customizer) {
	      var compared = isPartial
	        ? customizer(othValue, arrValue, index, other, array, stack)
	        : customizer(arrValue, othValue, index, array, other, stack);
	    }
	    if (compared !== undefined) {
	      if (compared) {
	        continue;
	      }
	      result = false;
	      break;
	    }
	    // Recursively compare arrays (susceptible to call stack limits).
	    if (seen) {
	      if (!arraySome(other, function(othValue, othIndex) {
	            if (!seen.has(othIndex) &&
	                (arrValue === othValue || equalFunc(arrValue, othValue, customizer, bitmask, stack))) {
	              return seen.add(othIndex);
	            }
	          })) {
	        result = false;
	        break;
	      }
	    } else if (!(
	          arrValue === othValue ||
	            equalFunc(arrValue, othValue, customizer, bitmask, stack)
	        )) {
	      result = false;
	      break;
	    }
	  }
	  stack['delete'](array);
	  stack['delete'](other);
	  return result;
	}
	
	/**
	 * A specialized version of `baseIsEqualDeep` for comparing objects of
	 * the same `toStringTag`.
	 *
	 * **Note:** This function only supports comparing values with tags of
	 * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.
	 *
	 * @private
	 * @param {Object} object The object to compare.
	 * @param {Object} other The other object to compare.
	 * @param {string} tag The `toStringTag` of the objects to compare.
	 * @param {Function} equalFunc The function to determine equivalents of values.
	 * @param {Function} customizer The function to customize comparisons.
	 * @param {number} bitmask The bitmask of comparison flags. See `baseIsEqual`
	 *  for more details.
	 * @param {Object} stack Tracks traversed `object` and `other` objects.
	 * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
	 */
	function equalByTag(object, other, tag, equalFunc, customizer, bitmask, stack) {
	  switch (tag) {
	    case dataViewTag:
	      if ((object.byteLength != other.byteLength) ||
	          (object.byteOffset != other.byteOffset)) {
	        return false;
	      }
	      object = object.buffer;
	      other = other.buffer;
	
	    case arrayBufferTag:
	      if ((object.byteLength != other.byteLength) ||
	          !equalFunc(new Uint8Array(object), new Uint8Array(other))) {
	        return false;
	      }
	      return true;
	
	    case boolTag:
	    case dateTag:
	    case numberTag:
	      // Coerce booleans to `1` or `0` and dates to milliseconds.
	      // Invalid dates are coerced to `NaN`.
	      return eq(+object, +other);
	
	    case errorTag:
	      return object.name == other.name && object.message == other.message;
	
	    case regexpTag:
	    case stringTag:
	      // Coerce regexes to strings and treat strings, primitives and objects,
	      // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring
	      // for more details.
	      return object == (other + '');
	
	    case mapTag:
	      var convert = mapToArray;
	
	    case setTag:
	      var isPartial = bitmask & PARTIAL_COMPARE_FLAG;
	      convert || (convert = setToArray);
	
	      if (object.size != other.size && !isPartial) {
	        return false;
	      }
	      // Assume cyclic values are equal.
	      var stacked = stack.get(object);
	      if (stacked) {
	        return stacked == other;
	      }
	      bitmask |= UNORDERED_COMPARE_FLAG;
	
	      // Recursively compare objects (susceptible to call stack limits).
	      stack.set(object, other);
	      var result = equalArrays(convert(object), convert(other), equalFunc, customizer, bitmask, stack);
	      stack['delete'](object);
	      return result;
	
	    case symbolTag:
	      if (symbolValueOf) {
	        return symbolValueOf.call(object) == symbolValueOf.call(other);
	      }
	  }
	  return false;
	}
	
	/**
	 * A specialized version of `baseIsEqualDeep` for objects with support for
	 * partial deep comparisons.
	 *
	 * @private
	 * @param {Object} object The object to compare.
	 * @param {Object} other The other object to compare.
	 * @param {Function} equalFunc The function to determine equivalents of values.
	 * @param {Function} customizer The function to customize comparisons.
	 * @param {number} bitmask The bitmask of comparison flags. See `baseIsEqual`
	 *  for more details.
	 * @param {Object} stack Tracks traversed `object` and `other` objects.
	 * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
	 */
	function equalObjects(object, other, equalFunc, customizer, bitmask, stack) {
	  var isPartial = bitmask & PARTIAL_COMPARE_FLAG,
	      objProps = keys(object),
	      objLength = objProps.length,
	      othProps = keys(other),
	      othLength = othProps.length;
	
	  if (objLength != othLength && !isPartial) {
	    return false;
	  }
	  var index = objLength;
	  while (index--) {
	    var key = objProps[index];
	    if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {
	      return false;
	    }
	  }
	  // Assume cyclic values are equal.
	  var stacked = stack.get(object);
	  if (stacked && stack.get(other)) {
	    return stacked == other;
	  }
	  var result = true;
	  stack.set(object, other);
	  stack.set(other, object);
	
	  var skipCtor = isPartial;
	  while (++index < objLength) {
	    key = objProps[index];
	    var objValue = object[key],
	        othValue = other[key];
	
	    if (customizer) {
	      var compared = isPartial
	        ? customizer(othValue, objValue, key, other, object, stack)
	        : customizer(objValue, othValue, key, object, other, stack);
	    }
	    // Recursively compare objects (susceptible to call stack limits).
	    if (!(compared === undefined
	          ? (objValue === othValue || equalFunc(objValue, othValue, customizer, bitmask, stack))
	          : compared
	        )) {
	      result = false;
	      break;
	    }
	    skipCtor || (skipCtor = key == 'constructor');
	  }
	  if (result && !skipCtor) {
	    var objCtor = object.constructor,
	        othCtor = other.constructor;
	
	    // Non `Object` object instances with different constructors are not equal.
	    if (objCtor != othCtor &&
	        ('constructor' in object && 'constructor' in other) &&
	        !(typeof objCtor == 'function' && objCtor instanceof objCtor &&
	          typeof othCtor == 'function' && othCtor instanceof othCtor)) {
	      result = false;
	    }
	  }
	  stack['delete'](object);
	  stack['delete'](other);
	  return result;
	}
	
	/**
	 * 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;
	}
	
	/**
	 * Gets the property names, values, and compare flags of `object`.
	 *
	 * @private
	 * @param {Object} object The object to query.
	 * @returns {Array} Returns the match data of `object`.
	 */
	function getMatchData(object) {
	  var result = keys(object),
	      length = result.length;
	
	  while (length--) {
	    var key = result[length],
	        value = object[key];
	
	    result[length] = [key, value, isStrictComparable(value)];
	  }
	  return result;
	}
	
	/**
	 * 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;
	}
	
	/**
	 * 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,
	// for data views in Edge < 14, and promises in Node.js.
	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 = objectToString.call(value),
	        Ctor = result == objectTag ? value.constructor : undefined,
	        ctorString = Ctor ? toSource(Ctor) : undefined;
	
	    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;
	  };
	}
	
	/**
	 * Checks if `path` exists on `object`.
	 *
	 * @private
	 * @param {Object} object The object to query.
	 * @param {Array|string} path The path to check.
	 * @param {Function} hasFunc The function to check properties.
	 * @returns {boolean} Returns `true` if `path` exists, else `false`.
	 */
	function hasPath(object, path, hasFunc) {
	  path = isKey(path, object) ? [path] : castPath(path);
	
	  var result,
	      index = -1,
	      length = path.length;
	
	  while (++index < length) {
	    var key = toKey(path[index]);
	    if (!(result = object != null && hasFunc(object, key))) {
	      break;
	    }
	    object = object[key];
	  }
	  if (result) {
	    return result;
	  }
	  var length = object ? object.length : 0;
	  return !!length && isLength(length) && isIndex(key, length) &&
	    (isArray(object) || isArguments(object));
	}
	
	/**
	 * 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);
	}
	
	/**
	 * 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));
	}
	
	/**
	 * 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);
	}
	
	/**
	 * 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);
	}
	
	/**
	 * 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;
	}
	
	/**
	 * Checks if `value` is suitable for strict equality comparisons, i.e. `===`.
	 *
	 * @private
	 * @param {*} value The value to check.
	 * @returns {boolean} Returns `true` if `value` if suitable for strict
	 *  equality comparisons, else `false`.
	 */
	function isStrictComparable(value) {
	  return value === value && !isObject(value);
	}
	
	/**
	 * A specialized version of `matchesProperty` for source values suitable
	 * for strict equality comparisons, i.e. `===`.
	 *
	 * @private
	 * @param {string} key The key of the property to get.
	 * @param {*} srcValue The value to match.
	 * @returns {Function} Returns the new spec function.
	 */
	function matchesStrictComparable(key, srcValue) {
	  return function(object) {
	    if (object == null) {
	      return false;
	    }
	    return object[key] === srcValue &&
	      (srcValue !== undefined || (key in Object(object)));
	  };
	}
	
	/**
	 * Converts `string` to a property path array.
	 *
	 * @private
	 * @param {string} string The string to convert.
	 * @returns {Array} Returns the property path array.
	 */
	var stringToPath = memoize(function(string) {
	  string = toString(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;
	});
	
	/**
	 * 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;
	}
	
	/**
	 * Converts `func` to its source code.
	 *
	 * @private
	 * @param {Function} func The function to process.
	 * @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 '';
	}
	
	/**
	 * This method is like `_.uniq` except that it accepts `iteratee` which is
	 * invoked for each element in `array` to generate the criterion by which
	 * uniqueness is computed. The iteratee is invoked with one argument: (value).
	 *
	 * @static
	 * @memberOf _
	 * @since 4.0.0
	 * @category Array
	 * @param {Array} array The array to inspect.
	 * @param {Function} [iteratee=_.identity]
	 *  The iteratee invoked per element.
	 * @returns {Array} Returns the new duplicate free array.
	 * @example
	 *
	 * _.uniqBy([2.1, 1.2, 2.3], Math.floor);
	 * // => [2.1, 1.2]
	 *
	 * // The `_.property` iteratee shorthand.
	 * _.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');
	 * // => [{ 'x': 1 }, { 'x': 2 }]
	 */
	function uniqBy(array, iteratee) {
	  return (array && array.length)
	    ? baseUniq(array, baseIteratee(iteratee, 2))
	    : [];
	}
	
	/**
	 * 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 `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 && 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);
	    return result;
	  };
	  memoized.cache = new (memoize.Cache || MapCache);
	  return memoized;
	}
	
	// Assign cache to `_.memoize`.
	memoize.Cache = MapCache;
	
	/**
	 * 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);
	}
	
	/**
	 * 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
	 */
	function isArguments(value) {
	  // Safari 8.1 makes `arguments.callee` enumerable in strict mode.
	  return isArrayLikeObject(value) && hasOwnProperty.call(value, 'callee') &&
	    (!propertyIsEnumerable.call(value, 'callee') || objectToString.call(value) == argsTag);
	}
	
	/**
	 * 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;
	
	/**
	 * 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);
	}
	
	/**
	 * This method is like `_.isArrayLike` except that it also checks if `value`
	 * is an object.
	 *
	 * @static
	 * @memberOf _
	 * @since 4.0.0
	 * @category Lang
	 * @param {*} value The value to check.
	 * @returns {boolean} Returns `true` if `value` is an array-like object,
	 *  else `false`.
	 * @example
	 *
	 * _.isArrayLikeObject([1, 2, 3]);
	 * // => true
	 *
	 * _.isArrayLikeObject(document.body.children);
	 * // => true
	 *
	 * _.isArrayLikeObject('abc');
	 * // => false
	 *
	 * _.isArrayLikeObject(_.noop);
	 * // => false
	 */
	function isArrayLikeObject(value) {
	  return isObjectLike(value) && isArrayLike(value);
	}
	
	/**
	 * 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) {
	  // The use of `Object#toString` avoids issues with the `typeof` operator
	  // in Safari 8-9 which returns 'object' for typed array and other constructors.
	  var tag = isObject(value) ? objectToString.call(value) : '';
	  return tag == funcTag || tag == genTag;
	}
	
	/**
	 * 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;
	}
	
	/**
	 * 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 && (type == 'object' || type == 'function');
	}
	
	/**
	 * 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 && typeof value == 'object';
	}
	
	/**
	 * 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) && objectToString.call(value) == symbolTag);
	}
	
	/**
	 * 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;
	
	/**
	 * 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 process.
	 * @returns {string} Returns the string.
	 * @example
	 *
	 * _.toString(null);
	 * // => ''
	 *
	 * _.toString(-0);
	 * // => '-0'
	 *
	 * _.toString([1, 2, 3]);
	 * // => '1,2,3'
	 */
	function toString(value) {
	  return value == null ? '' : baseToString(value);
	}
	
	/**
	 * Gets the value at `path` of `object`. If the resolved value is
	 * `undefined`, the `defaultValue` is returned in its place.
	 *
	 * @static
	 * @memberOf _
	 * @since 3.7.0
	 * @category Object
	 * @param {Object} object The object to query.
	 * @param {Array|string} path The path of the property to get.
	 * @param {*} [defaultValue] The value returned for `undefined` resolved values.
	 * @returns {*} Returns the resolved value.
	 * @example
	 *
	 * var object = { 'a': [{ 'b': { 'c': 3 } }] };
	 *
	 * _.get(object, 'a[0].b.c');
	 * // => 3
	 *
	 * _.get(object, ['a', '0', 'b', 'c']);
	 * // => 3
	 *
	 * _.get(object, 'a.b.c', 'default');
	 * // => 'default'
	 */
	function get(object, path, defaultValue) {
	  var result = object == null ? undefined : baseGet(object, path);
	  return result === undefined ? defaultValue : result;
	}
	
	/**
	 * Checks if `path` is a direct or inherited property of `object`.
	 *
	 * @static
	 * @memberOf _
	 * @since 4.0.0
	 * @category Object
	 * @param {Object} object The object to query.
	 * @param {Array|string} path The path to check.
	 * @returns {boolean} Returns `true` if `path` exists, else `false`.
	 * @example
	 *
	 * var object = _.create({ 'a': _.create({ 'b': 2 }) });
	 *
	 * _.hasIn(object, 'a');
	 * // => true
	 *
	 * _.hasIn(object, 'a.b');
	 * // => true
	 *
	 * _.hasIn(object, ['a', 'b']);
	 * // => true
	 *
	 * _.hasIn(object, 'b');
	 * // => false
	 */
	function hasIn(object, path) {
	  return object != null && hasPath(object, path, baseHasIn);
	}
	
	/**
	 * 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);
	}
	
	/**
	 * 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;
	}
	
	/**
	 * This method returns `undefined`.
	 *
	 * @static
	 * @memberOf _
	 * @since 2.3.0
	 * @category Util
	 * @example
	 *
	 * _.times(2, _.noop);
	 * // => [undefined, undefined]
	 */
	function noop() {
	  // No operation performed.
	}
	
	/**
	 * Creates a function that returns the value at `path` of a given object.
	 *
	 * @static
	 * @memberOf _
	 * @since 2.4.0
	 * @category Util
	 * @param {Array|string} path The path of the property to get.
	 * @returns {Function} Returns the new accessor function.
	 * @example
	 *
	 * var objects = [
	 *   { 'a': { 'b': 2 } },
	 *   { 'a': { 'b': 1 } }
	 * ];
	 *
	 * _.map(objects, _.property('a.b'));
	 * // => [2, 1]
	 *
	 * _.map(_.sortBy(objects, _.property(['a', 'b'])), 'a.b');
	 * // => [1, 2]
	 */
	function property(path) {
	  return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path);
	}
	
	module.exports = uniqBy;
	
	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()), __webpack_require__(98)(module)))

/***/ }),
/* 582 */
/***/ (function(module, exports, __webpack_require__) {

	var getNative = __webpack_require__(52),
	    root = __webpack_require__(43);
	
	/* Built-in method references that are verified to be native. */
	var DataView = getNative(root, 'DataView');
	
	module.exports = DataView;


/***/ }),
/* 583 */
/***/ (function(module, exports, __webpack_require__) {

	var hashClear = __webpack_require__(612),
	    hashDelete = __webpack_require__(613),
	    hashGet = __webpack_require__(614),
	    hashHas = __webpack_require__(615),
	    hashSet = __webpack_require__(616);
	
	/**
	 * 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;


/***/ }),
/* 584 */
/***/ (function(module, exports, __webpack_require__) {

	var listCacheClear = __webpack_require__(622),
	    listCacheDelete = __webpack_require__(623),
	    listCacheGet = __webpack_require__(624),
	    listCacheHas = __webpack_require__(625),
	    listCacheSet = __webpack_require__(626);
	
	/**
	 * 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;


/***/ }),
/* 585 */
/***/ (function(module, exports, __webpack_require__) {

	var mapCacheClear = __webpack_require__(627),
	    mapCacheDelete = __webpack_require__(628),
	    mapCacheGet = __webpack_require__(629),
	    mapCacheHas = __webpack_require__(630),
	    mapCacheSet = __webpack_require__(631);
	
	/**
	 * 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;


/***/ }),
/* 586 */
/***/ (function(module, exports, __webpack_require__) {

	var getNative = __webpack_require__(52),
	    root = __webpack_require__(43);
	
	/* Built-in method references that are verified to be native. */
	var Promise = getNative(root, 'Promise');
	
	module.exports = Promise;


/***/ }),
/* 587 */
/***/ (function(module, exports, __webpack_require__) {

	var getNative = __webpack_require__(52),
	    root = __webpack_require__(43);
	
	/* Built-in method references that are verified to be native. */
	var Set = getNative(root, 'Set');
	
	module.exports = Set;


/***/ }),
/* 588 */
/***/ (function(module, exports, __webpack_require__) {

	var getNative = __webpack_require__(52),
	    root = __webpack_require__(43);
	
	/* Built-in method references that are verified to be native. */
	var WeakMap = getNative(root, 'WeakMap');
	
	module.exports = WeakMap;


/***/ }),
/* 589 */
/***/ (function(module, exports, __webpack_require__) {

	var baseTimes = __webpack_require__(600),
	    isArguments = __webpack_require__(235),
	    isArray = __webpack_require__(65),
	    isBuffer = __webpack_require__(642),
	    isIndex = __webpack_require__(137),
	    isTypedArray = __webpack_require__(644);
	
	/** 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;


/***/ }),
/* 590 */
/***/ (function(module, exports) {

	/**
	 * Converts an ASCII `string` to an array.
	 *
	 * @private
	 * @param {string} string The string to convert.
	 * @returns {Array} Returns the converted array.
	 */
	function asciiToArray(string) {
	  return string.split('');
	}
	
	module.exports = asciiToArray;


/***/ }),
/* 591 */
/***/ (function(module, exports, __webpack_require__) {

	var baseAssignValue = __webpack_require__(592),
	    eq = __webpack_require__(233);
	
	/** 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;


/***/ }),
/* 592 */
/***/ (function(module, exports, __webpack_require__) {

	var defineProperty = __webpack_require__(606);
	
	/**
	 * 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;


/***/ }),
/* 593 */
/***/ (function(module, exports, __webpack_require__) {

	var castPath = __webpack_require__(136),
	    toKey = __webpack_require__(138);
	
	/**
	 * 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;


/***/ }),
/* 594 */
/***/ (function(module, exports) {

	/** 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 `_.has` without support for deep paths.
	 *
	 * @private
	 * @param {Object} [object] The object to query.
	 * @param {Array|string} key The key to check.
	 * @returns {boolean} Returns `true` if `key` exists, else `false`.
	 */
	function baseHas(object, key) {
	  return object != null && hasOwnProperty.call(object, key);
	}
	
	module.exports = baseHas;


/***/ }),
/* 595 */
/***/ (function(module, exports, __webpack_require__) {

	var baseGetTag = __webpack_require__(64),
	    isObjectLike = __webpack_require__(76);
	
	/** `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;


/***/ }),
/* 596 */
/***/ (function(module, exports, __webpack_require__) {

	var isFunction = __webpack_require__(237),
	    isMasked = __webpack_require__(619),
	    isObject = __webpack_require__(141),
	    toSource = __webpack_require__(232);
	
	/**
	 * 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;


/***/ }),
/* 597 */
/***/ (function(module, exports, __webpack_require__) {

	var baseGetTag = __webpack_require__(64),
	    isLength = __webpack_require__(140),
	    isObjectLike = __webpack_require__(76);
	
	/** `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;


/***/ }),
/* 598 */
/***/ (function(module, exports, __webpack_require__) {

	var isPrototype = __webpack_require__(620),
	    nativeKeys = __webpack_require__(634);
	
	/** 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;


/***/ }),
/* 599 */
/***/ (function(module, exports, __webpack_require__) {

	var assignValue = __webpack_require__(591),
	    castPath = __webpack_require__(136),
	    isIndex = __webpack_require__(137),
	    isObject = __webpack_require__(141),
	    toKey = __webpack_require__(138);
	
	/**
	 * The base implementation of `_.set`.
	 *
	 * @private
	 * @param {Object} object The object to modify.
	 * @param {Array|string} path The path of the property to set.
	 * @param {*} value The value to set.
	 * @param {Function} [customizer] The function to customize path creation.
	 * @returns {Object} Returns `object`.
	 */
	function baseSet(object, path, value, customizer) {
	  if (!isObject(object)) {
	    return object;
	  }
	  path = castPath(path, object);
	
	  var index = -1,
	      length = path.length,
	      lastIndex = length - 1,
	      nested = object;
	
	  while (nested != null && ++index < length) {
	    var key = toKey(path[index]),
	        newValue = value;
	
	    if (index != lastIndex) {
	      var objValue = nested[key];
	      newValue = customizer ? customizer(objValue, key, nested) : undefined;
	      if (newValue === undefined) {
	        newValue = isObject(objValue)
	          ? objValue
	          : (isIndex(path[index + 1]) ? [] : {});
	      }
	    }
	    assignValue(nested, key, newValue);
	    nested = nested[key];
	  }
	  return object;
	}
	
	module.exports = baseSet;


/***/ }),
/* 600 */
/***/ (function(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;


/***/ }),
/* 601 */
/***/ (function(module, exports, __webpack_require__) {

	var Symbol = __webpack_require__(92),
	    arrayMap = __webpack_require__(230),
	    isArray = __webpack_require__(65),
	    isSymbol = __webpack_require__(142);
	
	/** 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;


/***/ }),
/* 602 */
/***/ (function(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;


/***/ }),
/* 603 */
/***/ (function(module, exports, __webpack_require__) {

	var arrayMap = __webpack_require__(230);
	
	/**
	 * 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;


/***/ }),
/* 604 */
/***/ (function(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;


/***/ }),
/* 605 */
/***/ (function(module, exports, __webpack_require__) {

	var root = __webpack_require__(43);
	
	/** Used to detect overreaching core-js shims. */
	var coreJsData = root['__core-js_shared__'];
	
	module.exports = coreJsData;


/***/ }),
/* 606 */
/***/ (function(module, exports, __webpack_require__) {

	var getNative = __webpack_require__(52);
	
	var defineProperty = (function() {
	  try {
	    var func = getNative(Object, 'defineProperty');
	    func({}, '', {});
	    return func;
	  } catch (e) {}
	}());
	
	module.exports = defineProperty;


/***/ }),
/* 607 */
/***/ (function(module, exports, __webpack_require__) {

	var Symbol = __webpack_require__(92);
	
	/** 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;


/***/ }),
/* 608 */
/***/ (function(module, exports, __webpack_require__) {

	var DataView = __webpack_require__(582),
	    Map = __webpack_require__(229),
	    Promise = __webpack_require__(586),
	    Set = __webpack_require__(587),
	    WeakMap = __webpack_require__(588),
	    baseGetTag = __webpack_require__(64),
	    toSource = __webpack_require__(232);
	
	/** `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;


/***/ }),
/* 609 */
/***/ (function(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;


/***/ }),
/* 610 */
/***/ (function(module, exports, __webpack_require__) {

	var castPath = __webpack_require__(136),
	    isArguments = __webpack_require__(235),
	    isArray = __webpack_require__(65),
	    isIndex = __webpack_require__(137),
	    isLength = __webpack_require__(140),
	    toKey = __webpack_require__(138);
	
	/**
	 * Checks if `path` exists on `object`.
	 *
	 * @private
	 * @param {Object} object The object to query.
	 * @param {Array|string} path The path to check.
	 * @param {Function} hasFunc The function to check properties.
	 * @returns {boolean} Returns `true` if `path` exists, else `false`.
	 */
	function hasPath(object, path, hasFunc) {
	  path = castPath(path, object);
	
	  var index = -1,
	      length = path.length,
	      result = false;
	
	  while (++index < length) {
	    var key = toKey(path[index]);
	    if (!(result = object != null && hasFunc(object, key))) {
	      break;
	    }
	    object = object[key];
	  }
	  if (result || ++index != length) {
	    return result;
	  }
	  length = object == null ? 0 : object.length;
	  return !!length && isLength(length) && isIndex(key, length) &&
	    (isArray(object) || isArguments(object));
	}
	
	module.exports = hasPath;


/***/ }),
/* 611 */
/***/ (function(module, exports) {

	/** Used to compose unicode character classes. */
	var rsAstralRange = '\\ud800-\\udfff',
	    rsComboMarksRange = '\\u0300-\\u036f',
	    reComboHalfMarksRange = '\\ufe20-\\ufe2f',
	    rsComboSymbolsRange = '\\u20d0-\\u20ff',
	    rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange,
	    rsVarRange = '\\ufe0e\\ufe0f';
	
	/** Used to compose unicode capture groups. */
	var rsZWJ = '\\u200d';
	
	/** Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */
	var reHasUnicode = RegExp('[' + rsZWJ + rsAstralRange  + rsComboRange + rsVarRange + ']');
	
	/**
	 * Checks if `string` contains Unicode symbols.
	 *
	 * @private
	 * @param {string} string The string to inspect.
	 * @returns {boolean} Returns `true` if a symbol is found, else `false`.
	 */
	function hasUnicode(string) {
	  return reHasUnicode.test(string);
	}
	
	module.exports = hasUnicode;


/***/ }),
/* 612 */
/***/ (function(module, exports, __webpack_require__) {

	var nativeCreate = __webpack_require__(95);
	
	/**
	 * 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;


/***/ }),
/* 613 */
/***/ (function(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;


/***/ }),
/* 614 */
/***/ (function(module, exports, __webpack_require__) {

	var nativeCreate = __webpack_require__(95);
	
	/** 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;


/***/ }),
/* 615 */
/***/ (function(module, exports, __webpack_require__) {

	var nativeCreate = __webpack_require__(95);
	
	/** 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;


/***/ }),
/* 616 */
/***/ (function(module, exports, __webpack_require__) {

	var nativeCreate = __webpack_require__(95);
	
	/** 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;


/***/ }),
/* 617 */
/***/ (function(module, exports, __webpack_require__) {

	var isArray = __webpack_require__(65),
	    isSymbol = __webpack_require__(142);
	
	/** 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;


/***/ }),
/* 618 */
/***/ (function(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;


/***/ }),
/* 619 */
/***/ (function(module, exports, __webpack_require__) {

	var coreJsData = __webpack_require__(605);
	
	/** 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;


/***/ }),
/* 620 */
/***/ (function(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;


/***/ }),
/* 621 */
/***/ (function(module, exports) {

	/**
	 * Converts `iterator` to an array.
	 *
	 * @private
	 * @param {Object} iterator The iterator to convert.
	 * @returns {Array} Returns the converted array.
	 */
	function iteratorToArray(iterator) {
	  var data,
	      result = [];
	
	  while (!(data = iterator.next()).done) {
	    result.push(data.value);
	  }
	  return result;
	}
	
	module.exports = iteratorToArray;


/***/ }),
/* 622 */
/***/ (function(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;


/***/ }),
/* 623 */
/***/ (function(module, exports, __webpack_require__) {

	var assocIndexOf = __webpack_require__(93);
	
	/** 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;


/***/ }),
/* 624 */
/***/ (function(module, exports, __webpack_require__) {

	var assocIndexOf = __webpack_require__(93);
	
	/**
	 * 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;


/***/ }),
/* 625 */
/***/ (function(module, exports, __webpack_require__) {

	var assocIndexOf = __webpack_require__(93);
	
	/**
	 * 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;


/***/ }),
/* 626 */
/***/ (function(module, exports, __webpack_require__) {

	var assocIndexOf = __webpack_require__(93);
	
	/**
	 * 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;


/***/ }),
/* 627 */
/***/ (function(module, exports, __webpack_require__) {

	var Hash = __webpack_require__(583),
	    ListCache = __webpack_require__(584),
	    Map = __webpack_require__(229);
	
	/**
	 * 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;


/***/ }),
/* 628 */
/***/ (function(module, exports, __webpack_require__) {

	var getMapData = __webpack_require__(94);
	
	/**
	 * 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;


/***/ }),
/* 629 */
/***/ (function(module, exports, __webpack_require__) {

	var getMapData = __webpack_require__(94);
	
	/**
	 * 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;


/***/ }),
/* 630 */
/***/ (function(module, exports, __webpack_require__) {

	var getMapData = __webpack_require__(94);
	
	/**
	 * 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;


/***/ }),
/* 631 */
/***/ (function(module, exports, __webpack_require__) {

	var getMapData = __webpack_require__(94);
	
	/**
	 * 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;


/***/ }),
/* 632 */
/***/ (function(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;


/***/ }),
/* 633 */
/***/ (function(module, exports, __webpack_require__) {

	var memoize = __webpack_require__(646);
	
	/** 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;


/***/ }),
/* 634 */
/***/ (function(module, exports, __webpack_require__) {

	var overArg = __webpack_require__(637);
	
	/* Built-in method references for those with the same name as other `lodash` methods. */
	var nativeKeys = overArg(Object.keys, Object);
	
	module.exports = nativeKeys;


/***/ }),
/* 635 */
/***/ (function(module, exports, __webpack_require__) {

	/* WEBPACK VAR INJECTION */(function(module) {var freeGlobal = __webpack_require__(231);
	
	/** 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 {
	    // Use `util.types` for Node.js 10+.
	    var types = freeModule && freeModule.require && freeModule.require('util').types;
	
	    if (types) {
	      return types;
	    }
	
	    // Legacy `process.binding('util')` for Node.js < 10.
	    return freeProcess && freeProcess.binding && freeProcess.binding('util');
	  } catch (e) {}
	}());
	
	module.exports = nodeUtil;
	
	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(98)(module)))

/***/ }),
/* 636 */
/***/ (function(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;


/***/ }),
/* 637 */
/***/ (function(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;


/***/ }),
/* 638 */
/***/ (function(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;


/***/ }),
/* 639 */
/***/ (function(module, exports, __webpack_require__) {

	var asciiToArray = __webpack_require__(590),
	    hasUnicode = __webpack_require__(611),
	    unicodeToArray = __webpack_require__(641);
	
	/**
	 * Converts `string` to an array.
	 *
	 * @private
	 * @param {string} string The string to convert.
	 * @returns {Array} Returns the converted array.
	 */
	function stringToArray(string) {
	  return hasUnicode(string)
	    ? unicodeToArray(string)
	    : asciiToArray(string);
	}
	
	module.exports = stringToArray;


/***/ }),
/* 640 */
/***/ (function(module, exports, __webpack_require__) {

	var memoizeCapped = __webpack_require__(633);
	
	/** Used to match property names within property paths. */
	var 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 (string.charCodeAt(0) === 46 /* . */) {
	    result.push('');
	  }
	  string.replace(rePropName, function(match, number, quote, subString) {
	    result.push(quote ? subString.replace(reEscapeChar, '$1') : (number || match));
	  });
	  return result;
	});
	
	module.exports = stringToPath;


/***/ }),
/* 641 */
/***/ (function(module, exports) {

	/** Used to compose unicode character classes. */
	var rsAstralRange = '\\ud800-\\udfff',
	    rsComboMarksRange = '\\u0300-\\u036f',
	    reComboHalfMarksRange = '\\ufe20-\\ufe2f',
	    rsComboSymbolsRange = '\\u20d0-\\u20ff',
	    rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange,
	    rsVarRange = '\\ufe0e\\ufe0f';
	
	/** Used to compose unicode capture groups. */
	var rsAstral = '[' + rsAstralRange + ']',
	    rsCombo = '[' + rsComboRange + ']',
	    rsFitz = '\\ud83c[\\udffb-\\udfff]',
	    rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')',
	    rsNonAstral = '[^' + rsAstralRange + ']',
	    rsRegional = '(?:\\ud83c[\\udde6-\\uddff]){2}',
	    rsSurrPair = '[\\ud800-\\udbff][\\udc00-\\udfff]',
	    rsZWJ = '\\u200d';
	
	/** Used to compose unicode regexes. */
	var reOptMod = rsModifier + '?',
	    rsOptVar = '[' + rsVarRange + ']?',
	    rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*',
	    rsSeq = rsOptVar + reOptMod + rsOptJoin,
	    rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')';
	
	/** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */
	var reUnicode = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g');
	
	/**
	 * Converts a Unicode `string` to an array.
	 *
	 * @private
	 * @param {string} string The string to convert.
	 * @returns {Array} Returns the converted array.
	 */
	function unicodeToArray(string) {
	  return string.match(reUnicode) || [];
	}
	
	module.exports = unicodeToArray;


/***/ }),
/* 642 */
/***/ (function(module, exports, __webpack_require__) {

	/* WEBPACK VAR INJECTION */(function(module) {var root = __webpack_require__(43),
	    stubFalse = __webpack_require__(647);
	
	/** 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;
	
	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(98)(module)))

/***/ }),
/* 643 */
/***/ (function(module, exports, __webpack_require__) {

	var baseGetTag = __webpack_require__(64),
	    isArray = __webpack_require__(65),
	    isObjectLike = __webpack_require__(76);
	
	/** `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;


/***/ }),
/* 644 */
/***/ (function(module, exports, __webpack_require__) {

	var baseIsTypedArray = __webpack_require__(597),
	    baseUnary = __webpack_require__(602),
	    nodeUtil = __webpack_require__(635);
	
	/* 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;


/***/ }),
/* 645 */
/***/ (function(module, exports, __webpack_require__) {

	var arrayLikeKeys = __webpack_require__(589),
	    baseKeys = __webpack_require__(598),
	    isArrayLike = __webpack_require__(236);
	
	/**
	 * 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;


/***/ }),
/* 646 */
/***/ (function(module, exports, __webpack_require__) {

	var MapCache = __webpack_require__(585);
	
	/** 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;


/***/ }),
/* 647 */
/***/ (function(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;


/***/ }),
/* 648 */
/***/ (function(module, exports, __webpack_require__) {

	var Symbol = __webpack_require__(92),
	    copyArray = __webpack_require__(604),
	    getTag = __webpack_require__(608),
	    isArrayLike = __webpack_require__(236),
	    isString = __webpack_require__(643),
	    iteratorToArray = __webpack_require__(621),
	    mapToArray = __webpack_require__(632),
	    setToArray = __webpack_require__(638),
	    stringToArray = __webpack_require__(639),
	    values = __webpack_require__(650);
	
	/** `Object#toString` result references. */
	var mapTag = '[object Map]',
	    setTag = '[object Set]';
	
	/** Built-in value references. */
	var symIterator = Symbol ? Symbol.iterator : undefined;
	
	/**
	 * Converts `value` to an array.
	 *
	 * @static
	 * @since 0.1.0
	 * @memberOf _
	 * @category Lang
	 * @param {*} value The value to convert.
	 * @returns {Array} Returns the converted array.
	 * @example
	 *
	 * _.toArray({ 'a': 1, 'b': 2 });
	 * // => [1, 2]
	 *
	 * _.toArray('abc');
	 * // => ['a', 'b', 'c']
	 *
	 * _.toArray(1);
	 * // => []
	 *
	 * _.toArray(null);
	 * // => []
	 */
	function toArray(value) {
	  if (!value) {
	    return [];
	  }
	  if (isArrayLike(value)) {
	    return isString(value) ? stringToArray(value) : copyArray(value);
	  }
	  if (symIterator && value[symIterator]) {
	    return iteratorToArray(value[symIterator]());
	  }
	  var tag = getTag(value),
	      func = tag == mapTag ? mapToArray : (tag == setTag ? setToArray : values);
	
	  return func(value);
	}
	
	module.exports = toArray;


/***/ }),
/* 649 */
/***/ (function(module, exports, __webpack_require__) {

	var baseToString = __webpack_require__(601);
	
	/**
	 * 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;


/***/ }),
/* 650 */
/***/ (function(module, exports, __webpack_require__) {

	var baseValues = __webpack_require__(603),
	    keys = __webpack_require__(645);
	
	/**
	 * 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;


/***/ }),
/* 651 */
/***/ (function(module, exports, __webpack_require__) {

	//! moment.js locale configuration
	
	;(function (global, factory) {
	    true ? factory(__webpack_require__(13)) :
	   typeof define === 'function' && define.amd ? define(['../moment'], factory) :
	   factory(global.moment)
	}(this, (function (moment) { 'use strict';
	
	
	    var zhCn = moment.defineLocale('zh-cn', {
	        months : '一月_二月_三月_四月_五月_六月_七月_八月_九月_十月_十一月_十二月'.split('_'),
	        monthsShort : '1月_2月_3月_4月_5月_6月_7月_8月_9月_10月_11月_12月'.split('_'),
	        weekdays : '星期日_星期一_星期二_星期三_星期四_星期五_星期六'.split('_'),
	        weekdaysShort : '周日_周一_周二_周三_周四_周五_周六'.split('_'),
	        weekdaysMin : '日_一_二_三_四_五_六'.split('_'),
	        longDateFormat : {
	            LT : 'HH:mm',
	            LTS : 'HH:mm:ss',
	            L : 'YYYY/MM/DD',
	            LL : 'YYYY年M月D日',
	            LLL : 'YYYY年M月D日Ah点mm分',
	            LLLL : 'YYYY年M月D日ddddAh点mm分',
	            l : 'YYYY/M/D',
	            ll : 'YYYY年M月D日',
	            lll : 'YYYY年M月D日 HH:mm',
	            llll : 'YYYY年M月D日dddd HH:mm'
	        },
	        meridiemParse: /凌晨|早上|上午|中午|下午|晚上/,
	        meridiemHour: function (hour, meridiem) {
	            if (hour === 12) {
	                hour = 0;
	            }
	            if (meridiem === '凌晨' || meridiem === '早上' ||
	                    meridiem === '上午') {
	                return hour;
	            } else if (meridiem === '下午' || meridiem === '晚上') {
	                return hour + 12;
	            } else {
	                // '中午'
	                return hour >= 11 ? hour : hour + 12;
	            }
	        },
	        meridiem : function (hour, minute, isLower) {
	            var hm = hour * 100 + minute;
	            if (hm < 600) {
	                return '凌晨';
	            } else if (hm < 900) {
	                return '早上';
	            } else if (hm < 1130) {
	                return '上午';
	            } else if (hm < 1230) {
	                return '中午';
	            } else if (hm < 1800) {
	                return '下午';
	            } else {
	                return '晚上';
	            }
	        },
	        calendar : {
	            sameDay : '[今天]LT',
	            nextDay : '[明天]LT',
	            nextWeek : '[下]ddddLT',
	            lastDay : '[昨天]LT',
	            lastWeek : '[上]ddddLT',
	            sameElse : 'L'
	        },
	        dayOfMonthOrdinalParse: /\d{1,2}(日|月|周)/,
	        ordinal : function (number, period) {
	            switch (period) {
	                case 'd':
	                case 'D':
	                case 'DDD':
	                    return number + '日';
	                case 'M':
	                    return number + '月';
	                case 'w':
	                case 'W':
	                    return number + '周';
	                default:
	                    return number;
	            }
	        },
	        relativeTime : {
	            future : '%s内',
	            past : '%s前',
	            s : '几秒',
	            ss : '%d 秒',
	            m : '1 分钟',
	            mm : '%d 分钟',
	            h : '1 小时',
	            hh : '%d 小时',
	            d : '1 天',
	            dd : '%d 天',
	            M : '1 个月',
	            MM : '%d 个月',
	            y : '1 年',
	            yy : '%d 年'
	        },
	        week : {
	            // GB/T 7408-1994《数据元和交换格式·信息交换·日期和时间表示法》与ISO 8601:1988等效
	            dow : 1, // Monday is the first day of the week.
	            doy : 4  // The week that contains Jan 4th is the first week of the year.
	        }
	    });
	
	    return zhCn;
	
	})));


/***/ }),
/* 652 */
/***/ (function(module, exports) {

	// shim for using process in browser
	var process = module.exports = {};
	
	// cached from whatever global is present so that test runners that stub it
	// don't break things.  But we need to wrap it in a try catch in case it is
	// wrapped in strict mode code which doesn't define any globals.  It's inside a
	// function because try/catches deoptimize in certain engines.
	
	var cachedSetTimeout;
	var cachedClearTimeout;
	
	function defaultSetTimout() {
	    throw new Error('setTimeout has not been defined');
	}
	function defaultClearTimeout () {
	    throw new Error('clearTimeout has not been defined');
	}
	(function () {
	    try {
	        if (typeof setTimeout === 'function') {
	            cachedSetTimeout = setTimeout;
	        } else {
	            cachedSetTimeout = defaultSetTimout;
	        }
	    } catch (e) {
	        cachedSetTimeout = defaultSetTimout;
	    }
	    try {
	        if (typeof clearTimeout === 'function') {
	            cachedClearTimeout = clearTimeout;
	        } else {
	            cachedClearTimeout = defaultClearTimeout;
	        }
	    } catch (e) {
	        cachedClearTimeout = defaultClearTimeout;
	    }
	} ())
	function runTimeout(fun) {
	    if (cachedSetTimeout === setTimeout) {
	        //normal enviroments in sane situations
	        return setTimeout(fun, 0);
	    }
	    // if setTimeout wasn't available but was latter defined
	    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
	        cachedSetTimeout = setTimeout;
	        return setTimeout(fun, 0);
	    }
	    try {
	        // when when somebody has screwed with setTimeout but no I.E. maddness
	        return cachedSetTimeout(fun, 0);
	    } catch(e){
	        try {
	            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
	            return cachedSetTimeout.call(null, fun, 0);
	        } catch(e){
	            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
	            return cachedSetTimeout.call(this, fun, 0);
	        }
	    }
	
	
	}
	function runClearTimeout(marker) {
	    if (cachedClearTimeout === clearTimeout) {
	        //normal enviroments in sane situations
	        return clearTimeout(marker);
	    }
	    // if clearTimeout wasn't available but was latter defined
	    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
	        cachedClearTimeout = clearTimeout;
	        return clearTimeout(marker);
	    }
	    try {
	        // when when somebody has screwed with setTimeout but no I.E. maddness
	        return cachedClearTimeout(marker);
	    } catch (e){
	        try {
	            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
	            return cachedClearTimeout.call(null, marker);
	        } catch (e){
	            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
	            // Some versions of I.E. have different rules for clearTimeout vs setTimeout
	            return cachedClearTimeout.call(this, marker);
	        }
	    }
	
	
	
	}
	var queue = [];
	var draining = false;
	var currentQueue;
	var queueIndex = -1;
	
	function cleanUpNextTick() {
	    if (!draining || !currentQueue) {
	        return;
	    }
	    draining = false;
	    if (currentQueue.length) {
	        queue = currentQueue.concat(queue);
	    } else {
	        queueIndex = -1;
	    }
	    if (queue.length) {
	        drainQueue();
	    }
	}
	
	function drainQueue() {
	    if (draining) {
	        return;
	    }
	    var timeout = runTimeout(cleanUpNextTick);
	    draining = true;
	
	    var len = queue.length;
	    while(len) {
	        currentQueue = queue;
	        queue = [];
	        while (++queueIndex < len) {
	            if (currentQueue) {
	                currentQueue[queueIndex].run();
	            }
	        }
	        queueIndex = -1;
	        len = queue.length;
	    }
	    currentQueue = null;
	    draining = false;
	    runClearTimeout(timeout);
	}
	
	process.nextTick = function (fun) {
	    var args = new Array(arguments.length - 1);
	    if (arguments.length > 1) {
	        for (var i = 1; i < arguments.length; i++) {
	            args[i - 1] = arguments[i];
	        }
	    }
	    queue.push(new Item(fun, args));
	    if (queue.length === 1 && !draining) {
	        runTimeout(drainQueue);
	    }
	};
	
	// v8 likes predictible objects
	function Item(fun, array) {
	    this.fun = fun;
	    this.array = array;
	}
	Item.prototype.run = function () {
	    this.fun.apply(null, this.array);
	};
	process.title = 'browser';
	process.browser = true;
	process.env = {};
	process.argv = [];
	process.version = ''; // empty string to avoid regexp issues
	process.versions = {};
	
	function noop() {}
	
	process.on = noop;
	process.addListener = noop;
	process.once = noop;
	process.off = noop;
	process.removeListener = noop;
	process.removeAllListeners = noop;
	process.emit = noop;
	process.prependListener = noop;
	process.prependOnceListener = noop;
	
	process.listeners = function (name) { return [] }
	
	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; };


/***/ }),
/* 653 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 */
	
	'use strict';
	
	if (true) {
	  var invariant = __webpack_require__(12);
	  var warning = __webpack_require__(135);
	  var ReactPropTypesSecret = __webpack_require__(239);
	  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 {?Function} getStack Returns the component stack.
	 * @private
	 */
	function checkPropTypes(typeSpecs, values, location, componentName, getStack) {
	  if (true) {
	    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.
	          invariant(typeof typeSpecs[typeSpecName] === 'function', '%s: %s type `%s` is invalid; it must be a function, usually from ' + 'the `prop-types` package, but received `%s`.', componentName || 'React class', location, typeSpecName, typeof typeSpecs[typeSpecName]);
	          error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);
	        } catch (ex) {
	          error = ex;
	        }
	        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', location, typeSpecName, typeof error);
	        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 stack = getStack ? getStack() : '';
	
	          warning(false, 'Failed %s type: %s%s', location, error.message, stack != null ? stack : '');
	        }
	      }
	    }
	  }
	}
	
	module.exports = checkPropTypes;


/***/ }),
/* 654 */
/***/ (function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 */
	
	'use strict';
	
	var emptyFunction = __webpack_require__(75);
	var invariant = __webpack_require__(12);
	var warning = __webpack_require__(135);
	var assign = __webpack_require__(18);
	
	var ReactPropTypesSecret = __webpack_require__(239);
	var checkPropTypes = __webpack_require__(653);
	
	module.exports = function(isValidElement, throwOnDirectAccess) {
	  /* 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;
	    }
	  }
	
	  /**
	   * 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>>';
	
	  // Important!
	  // Keep this list in sync with production version in `./factoryWithThrowingShims.js`.
	  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,
	    exact: createStrictShapeTypeChecker,
	  };
	
	  /**
	   * 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 (true) {
	      var manualPropTypeCallCache = {};
	      var manualPropTypeWarningCount = 0;
	    }
	    function checkType(isRequired, props, propName, componentName, location, propFullName, secret) {
	      componentName = componentName || ANONYMOUS;
	      propFullName = propFullName || propName;
	
	      if (secret !== ReactPropTypesSecret) {
	        if (throwOnDirectAccess) {
	          // New behavior only for users of `prop-types` package
	          invariant(
	            false,
	            'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +
	            'Use `PropTypes.checkPropTypes()` to call them. ' +
	            'Read more at http://fb.me/use-check-prop-types'
	          );
	        } else if (("development") !== 'production' && typeof console !== 'undefined') {
	          // Old behavior for people using React.PropTypes
	          var cacheKey = componentName + ':' + propName;
	          if (
	            !manualPropTypeCallCache[cacheKey] &&
	            // Avoid spamming the console because they are often not actionable except for lib authors
	            manualPropTypeWarningCount < 3
	          ) {
	            warning(
	              false,
	              'You are manually calling a React.PropTypes validation ' +
	              'function for the `%s` prop on `%s`. This is deprecated ' +
	              'and will throw in the standalone `prop-types` package. ' +
	              '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
	            );
	            manualPropTypeCallCache[cacheKey] = true;
	            manualPropTypeWarningCount++;
	          }
	        }
	      }
	      if (props[propName] == null) {
	        if (isRequired) {
	          if (props[propName] === null) {
	            return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required ' + ('in `' + componentName + '`, but its value is `null`.'));
	          }
	          return new PropTypeError('The ' + location + ' `' + 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) {
	        // `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 ' + location + ' `' + propFullName + '` of type ' + ('`' + preciseType + '` supplied to `' + componentName + '`, expected ') + ('`' + expectedType + '`.'));
	      }
	      return null;
	    }
	    return createChainableTypeChecker(validate);
	  }
	
	  function createAnyTypeChecker() {
	    return createChainableTypeChecker(emptyFunction.thatReturnsNull);
	  }
	
	  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 propType = getPropType(propValue);
	        return new PropTypeError('Invalid ' + location + ' `' + 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 (!isValidElement(propValue)) {
	        var propType = getPropType(propValue);
	        return new PropTypeError('Invalid ' + location + ' `' + 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 expectedClassName = expectedClass.name || ANONYMOUS;
	        var actualClassName = getClassName(props[propName]);
	        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + actualClassName + '` supplied to `' + componentName + '`, expected ') + ('instance of `' + expectedClassName + '`.'));
	      }
	      return null;
	    }
	    return createChainableTypeChecker(validate);
	  }
	
	  function createEnumTypeChecker(expectedValues) {
	    if (!Array.isArray(expectedValues)) {
	       true ? 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 valuesString = JSON.stringify(expectedValues);
	      return new PropTypeError('Invalid ' + location + ' `' + 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') {
	        return new PropTypeError('Invalid ' + location + ' `' + 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)) {
	       true ? warning(false, 'Invalid argument supplied to oneOfType, expected an instance of array.') : void 0;
	      return emptyFunction.thatReturnsNull;
	    }
	
	    for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
	      var checker = arrayOfTypeCheckers[i];
	      if (typeof checker !== 'function') {
	        warning(
	          false,
	          'Invalid argument supplied to oneOfType. Expected an array of check functions, but ' +
	          'received %s at index %s.',
	          getPostfixForTypeWarning(checker),
	          i
	        );
	        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;
	        }
	      }
	
	      return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`.'));
	    }
	    return createChainableTypeChecker(validate);
	  }
	
	  function createNodeChecker() {
	    function validate(props, propName, componentName, location, propFullName) {
	      if (!isNode(props[propName])) {
	        return new PropTypeError('Invalid ' + location + ' `' + 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') {
	        return new PropTypeError('Invalid ' + location + ' `' + 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 createStrictShapeTypeChecker(shapeTypes) {
	    function validate(props, propName, componentName, location, propFullName) {
	      var propValue = props[propName];
	      var propType = getPropType(propValue);
	      if (propType !== 'object') {
	        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));
	      }
	      // We need to check all keys in case some are required but missing from
	      // props.
	      var allKeys = assign({}, props[propName], shapeTypes);
	      for (var key in allKeys) {
	        var checker = shapeTypes[key];
	        if (!checker) {
	          return new PropTypeError(
	            'Invalid ' + location + ' `' + propFullName + '` key `' + key + '` supplied to `' + componentName + '`.' +
	            '\nBad object: ' + JSON.stringify(props[propName], null, '  ') +
	            '\nValid keys: ' +  JSON.stringify(Object.keys(shapeTypes), null, '  ')
	          );
	        }
	        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 || 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) {
	    if (typeof propValue === 'undefined' || propValue === null) {
	      return '' + propValue;
	    }
	    var propType = getPropType(propValue);
	    if (propType === 'object') {
	      if (propValue instanceof Date) {
	        return 'date';
	      } else if (propValue instanceof RegExp) {
	        return 'regexp';
	      }
	    }
	    return propType;
	  }
	
	  // Returns a string that is postfixed to a warning about an invalid type.
	  // For example, "undefined" or "of type array"
	  function getPostfixForTypeWarning(value) {
	    var type = getPreciseType(value);
	    switch (type) {
	      case 'array':
	      case 'object':
	        return 'an ' + type;
	      case 'boolean':
	      case 'date':
	      case 'regexp':
	        return 'a ' + type;
	      default:
	        return type;
	    }
	  }
	
	  // Returns class name of the object, if any.
	  function getClassName(propValue) {
	    if (!propValue.constructor || !propValue.constructor.name) {
	      return ANONYMOUS;
	    }
	    return propValue.constructor.name;
	  }
	
	  ReactPropTypes.checkPropTypes = checkPropTypes;
	  ReactPropTypes.PropTypes = ReactPropTypes;
	
	  return ReactPropTypes;
	};


/***/ }),
/* 655 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	exports.__esModule = true;
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _reactDom = __webpack_require__(10);
	
	var _reactDom2 = _interopRequireDefault(_reactDom);
	
	var _domAlign = __webpack_require__(473);
	
	var _domAlign2 = _interopRequireDefault(_domAlign);
	
	var _addEventListener = __webpack_require__(34);
	
	var _addEventListener2 = _interopRequireDefault(_addEventListener);
	
	var _shallowequal = __webpack_require__(45);
	
	var _shallowequal2 = _interopRequireDefault(_shallowequal);
	
	var _isWindow = __webpack_require__(657);
	
	var _isWindow2 = _interopRequireDefault(_isWindow);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function buffer(fn, ms) {
	  var timer = void 0;
	
	  function clear() {
	    if (timer) {
	      clearTimeout(timer);
	      timer = null;
	    }
	  }
	
	  function bufferFn() {
	    clear();
	    timer = setTimeout(fn, ms);
	  }
	
	  bufferFn.clear = clear;
	
	  return bufferFn;
	}
	
	var Align = function (_Component) {
	  (0, _inherits3['default'])(Align, _Component);
	
	  function Align() {
	    var _temp, _this, _ret;
	
	    (0, _classCallCheck3['default'])(this, Align);
	
	    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
	      args[_key] = arguments[_key];
	    }
	
	    return _ret = (_temp = (_this = (0, _possibleConstructorReturn3['default'])(this, _Component.call.apply(_Component, [this].concat(args))), _this), _this.forceAlign = function () {
	      var props = _this.props;
	      if (!props.disabled) {
	        var source = _reactDom2['default'].findDOMNode(_this);
	        props.onAlign(source, (0, _domAlign2['default'])(source, props.target(), props.align));
	      }
	    }, _temp), (0, _possibleConstructorReturn3['default'])(_this, _ret);
	  }
	
	  Align.prototype.componentDidMount = function componentDidMount() {
	    var props = this.props;
	    // if parent ref not attached .... use document.getElementById
	    this.forceAlign();
	    if (!props.disabled && props.monitorWindowResize) {
	      this.startMonitorWindowResize();
	    }
	  };
	
	  Align.prototype.componentDidUpdate = function componentDidUpdate(prevProps) {
	    var reAlign = false;
	    var props = this.props;
	
	    if (!props.disabled) {
	      if (prevProps.disabled || !(0, _shallowequal2['default'])(prevProps.align, props.align)) {
	        reAlign = true;
	      } else {
	        var lastTarget = prevProps.target();
	        var currentTarget = props.target();
	        if ((0, _isWindow2['default'])(lastTarget) && (0, _isWindow2['default'])(currentTarget)) {
	          reAlign = false;
	        } else if (lastTarget !== currentTarget) {
	          reAlign = true;
	        }
	      }
	    }
	
	    if (reAlign) {
	      this.forceAlign();
	    }
	
	    if (props.monitorWindowResize && !props.disabled) {
	      this.startMonitorWindowResize();
	    } else {
	      this.stopMonitorWindowResize();
	    }
	  };
	
	  Align.prototype.componentWillUnmount = function componentWillUnmount() {
	    this.stopMonitorWindowResize();
	  };
	
	  Align.prototype.startMonitorWindowResize = function startMonitorWindowResize() {
	    if (!this.resizeHandler) {
	      this.bufferMonitor = buffer(this.forceAlign, this.props.monitorBufferTime);
	      this.resizeHandler = (0, _addEventListener2['default'])(window, 'resize', this.bufferMonitor);
	    }
	  };
	
	  Align.prototype.stopMonitorWindowResize = function stopMonitorWindowResize() {
	    if (this.resizeHandler) {
	      this.bufferMonitor.clear();
	      this.resizeHandler.remove();
	      this.resizeHandler = null;
	    }
	  };
	
	  Align.prototype.render = function render() {
	    var _props = this.props,
	        childrenProps = _props.childrenProps,
	        children = _props.children;
	
	    var child = _react2['default'].Children.only(children);
	    if (childrenProps) {
	      var newProps = {};
	      for (var prop in childrenProps) {
	        if (childrenProps.hasOwnProperty(prop)) {
	          newProps[prop] = this.props[childrenProps[prop]];
	        }
	      }
	      return _react2['default'].cloneElement(child, newProps);
	    }
	    return child;
	  };
	
	  return Align;
	}(_react.Component);
	
	Align.propTypes = {
	  childrenProps: _propTypes2['default'].object,
	  align: _propTypes2['default'].object.isRequired,
	  target: _propTypes2['default'].func,
	  onAlign: _propTypes2['default'].func,
	  monitorBufferTime: _propTypes2['default'].number,
	  monitorWindowResize: _propTypes2['default'].bool,
	  disabled: _propTypes2['default'].bool,
	  children: _propTypes2['default'].any
	};
	Align.defaultProps = {
	  target: function target() {
	    return window;
	  },
	  onAlign: function onAlign() {},
	  monitorBufferTime: 50,
	  monitorWindowResize: false,
	  disabled: false
	};
	exports['default'] = Align;
	module.exports = exports['default'];

/***/ }),
/* 656 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	exports.__esModule = true;
	
	var _Align = __webpack_require__(655);
	
	var _Align2 = _interopRequireDefault(_Align);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	exports['default'] = _Align2['default']; // export this package's api
	
	module.exports = exports['default'];

/***/ }),
/* 657 */
/***/ (function(module, exports) {

	"use strict";
	
	exports.__esModule = true;
	exports["default"] = isWindow;
	function isWindow(obj) {
	  /* eslint no-eq-null: 0 */
	  /* eslint eqeqeq: 0 */
	  return obj != null && obj == obj.window;
	}
	module.exports = exports['default'];

/***/ }),
/* 658 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _typeof2 = __webpack_require__(21);
	
	var _typeof3 = _interopRequireDefault(_typeof2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _reactDom = __webpack_require__(10);
	
	var _reactDom2 = _interopRequireDefault(_reactDom);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _cssAnimation = __webpack_require__(122);
	
	var _cssAnimation2 = _interopRequireDefault(_cssAnimation);
	
	var _util = __webpack_require__(240);
	
	var _util2 = _interopRequireDefault(_util);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var transitionMap = {
	  enter: 'transitionEnter',
	  appear: 'transitionAppear',
	  leave: 'transitionLeave'
	};
	
	var AnimateChild = function (_React$Component) {
	  (0, _inherits3['default'])(AnimateChild, _React$Component);
	
	  function AnimateChild() {
	    (0, _classCallCheck3['default'])(this, AnimateChild);
	    return (0, _possibleConstructorReturn3['default'])(this, (AnimateChild.__proto__ || Object.getPrototypeOf(AnimateChild)).apply(this, arguments));
	  }
	
	  (0, _createClass3['default'])(AnimateChild, [{
	    key: 'componentWillUnmount',
	    value: function componentWillUnmount() {
	      this.stop();
	    }
	  }, {
	    key: 'componentWillEnter',
	    value: function componentWillEnter(done) {
	      if (_util2['default'].isEnterSupported(this.props)) {
	        this.transition('enter', done);
	      } else {
	        done();
	      }
	    }
	  }, {
	    key: 'componentWillAppear',
	    value: function componentWillAppear(done) {
	      if (_util2['default'].isAppearSupported(this.props)) {
	        this.transition('appear', done);
	      } else {
	        done();
	      }
	    }
	  }, {
	    key: 'componentWillLeave',
	    value: function componentWillLeave(done) {
	      if (_util2['default'].isLeaveSupported(this.props)) {
	        this.transition('leave', done);
	      } else {
	        // always sync, do not interupt with react component life cycle
	        // update hidden -> animate hidden ->
	        // didUpdate -> animate leave -> unmount (if animate is none)
	        done();
	      }
	    }
	  }, {
	    key: 'transition',
	    value: function transition(animationType, finishCallback) {
	      var _this2 = this;
	
	      var node = _reactDom2['default'].findDOMNode(this);
	      var props = this.props;
	      var transitionName = props.transitionName;
	      var nameIsObj = (typeof transitionName === 'undefined' ? 'undefined' : (0, _typeof3['default'])(transitionName)) === 'object';
	      this.stop();
	      var end = function end() {
	        _this2.stopper = null;
	        finishCallback();
	      };
	      if ((_cssAnimation.isCssAnimationSupported || !props.animation[animationType]) && transitionName && props[transitionMap[animationType]]) {
	        var name = nameIsObj ? transitionName[animationType] : transitionName + '-' + animationType;
	        var activeName = name + '-active';
	        if (nameIsObj && transitionName[animationType + 'Active']) {
	          activeName = transitionName[animationType + 'Active'];
	        }
	        this.stopper = (0, _cssAnimation2['default'])(node, {
	          name: name,
	          active: activeName
	        }, end);
	      } else {
	        this.stopper = props.animation[animationType](node, end);
	      }
	    }
	  }, {
	    key: 'stop',
	    value: function stop() {
	      var stopper = this.stopper;
	      if (stopper) {
	        this.stopper = null;
	        stopper.stop();
	      }
	    }
	  }, {
	    key: 'render',
	    value: function render() {
	      return this.props.children;
	    }
	  }]);
	  return AnimateChild;
	}(_react2['default'].Component);
	
	AnimateChild.propTypes = {
	  children: _propTypes2['default'].any
	};
	exports['default'] = AnimateChild;
	module.exports = exports['default'];

/***/ }),
/* 659 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.toArrayChildren = toArrayChildren;
	exports.findChildInChildrenByKey = findChildInChildrenByKey;
	exports.findShownChildInChildrenByKey = findShownChildInChildrenByKey;
	exports.findHiddenChildInChildrenByKey = findHiddenChildInChildrenByKey;
	exports.isSameChildren = isSameChildren;
	exports.mergeChildren = mergeChildren;
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function toArrayChildren(children) {
	  var ret = [];
	  _react2['default'].Children.forEach(children, function (child) {
	    ret.push(child);
	  });
	  return ret;
	}
	
	function findChildInChildrenByKey(children, key) {
	  var ret = null;
	  if (children) {
	    children.forEach(function (child) {
	      if (ret) {
	        return;
	      }
	      if (child && child.key === key) {
	        ret = child;
	      }
	    });
	  }
	  return ret;
	}
	
	function findShownChildInChildrenByKey(children, key, showProp) {
	  var ret = null;
	  if (children) {
	    children.forEach(function (child) {
	      if (child && child.key === key && child.props[showProp]) {
	        if (ret) {
	          throw new Error('two child with same key for <rc-animate> children');
	        }
	        ret = child;
	      }
	    });
	  }
	  return ret;
	}
	
	function findHiddenChildInChildrenByKey(children, key, showProp) {
	  var found = 0;
	  if (children) {
	    children.forEach(function (child) {
	      if (found) {
	        return;
	      }
	      found = child && child.key === key && !child.props[showProp];
	    });
	  }
	  return found;
	}
	
	function isSameChildren(c1, c2, showProp) {
	  var same = c1.length === c2.length;
	  if (same) {
	    c1.forEach(function (child, index) {
	      var child2 = c2[index];
	      if (child && child2) {
	        if (child && !child2 || !child && child2) {
	          same = false;
	        } else if (child.key !== child2.key) {
	          same = false;
	        } else if (showProp && child.props[showProp] !== child2.props[showProp]) {
	          same = false;
	        }
	      }
	    });
	  }
	  return same;
	}
	
	function mergeChildren(prev, next) {
	  var ret = [];
	
	  // For each key of `next`, the list of keys to insert before that key in
	  // the combined list
	  var nextChildrenPending = {};
	  var pendingChildren = [];
	  prev.forEach(function (child) {
	    if (child && findChildInChildrenByKey(next, child.key)) {
	      if (pendingChildren.length) {
	        nextChildrenPending[child.key] = pendingChildren;
	        pendingChildren = [];
	      }
	    } else {
	      pendingChildren.push(child);
	    }
	  });
	
	  next.forEach(function (child) {
	    if (child && nextChildrenPending.hasOwnProperty(child.key)) {
	      ret = ret.concat(nextChildrenPending[child.key]);
	    }
	    ret.push(child);
	  });
	
	  ret = ret.concat(pendingChildren);
	
	  return ret;
	}

/***/ }),
/* 660 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _reactDom = __webpack_require__(10);
	
	var _reactDom2 = _interopRequireDefault(_reactDom);
	
	var _createReactClass = __webpack_require__(14);
	
	var _createReactClass2 = _interopRequireDefault(_createReactClass);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _KeyCode = __webpack_require__(29);
	
	var _KeyCode2 = _interopRequireDefault(_KeyCode);
	
	var _DateTable = __webpack_require__(143);
	
	var _DateTable2 = _interopRequireDefault(_DateTable);
	
	var _CalendarHeader = __webpack_require__(243);
	
	var _CalendarHeader2 = _interopRequireDefault(_CalendarHeader);
	
	var _CalendarFooter = __webpack_require__(663);
	
	var _CalendarFooter2 = _interopRequireDefault(_CalendarFooter);
	
	var _CalendarMixin = __webpack_require__(144);
	
	var _CalendarMixin2 = _interopRequireDefault(_CalendarMixin);
	
	var _CommonMixin = __webpack_require__(96);
	
	var _CommonMixin2 = _interopRequireDefault(_CommonMixin);
	
	var _DateInput = __webpack_require__(248);
	
	var _DateInput2 = _interopRequireDefault(_DateInput);
	
	var _util = __webpack_require__(44);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function noop() {}
	
	function goStartMonth() {
	  var next = this.state.value.clone();
	  next.startOf('month');
	  this.setValue(next);
	}
	
	function goEndMonth() {
	  var next = this.state.value.clone();
	  next.endOf('month');
	  this.setValue(next);
	}
	
	function goTime(direction, unit) {
	  var next = this.state.value.clone();
	  next.add(direction, unit);
	  this.setValue(next);
	}
	
	function goMonth(direction) {
	  return goTime.call(this, direction, 'months');
	}
	
	function goYear(direction) {
	  return goTime.call(this, direction, 'years');
	}
	
	function goWeek(direction) {
	  return goTime.call(this, direction, 'weeks');
	}
	
	function goDay(direction) {
	  return goTime.call(this, direction, 'days');
	}
	
	var Calendar = (0, _createReactClass2['default'])({
	  displayName: 'Calendar',
	
	  propTypes: {
	    disabledDate: _propTypes2['default'].func,
	    disabledTime: _propTypes2['default'].any,
	    value: _propTypes2['default'].object,
	    selectedValue: _propTypes2['default'].object,
	    defaultValue: _propTypes2['default'].object,
	    className: _propTypes2['default'].string,
	    locale: _propTypes2['default'].object,
	    showWeekNumber: _propTypes2['default'].bool,
	    style: _propTypes2['default'].object,
	    showToday: _propTypes2['default'].bool,
	    showDateInput: _propTypes2['default'].bool,
	    visible: _propTypes2['default'].bool,
	    onSelect: _propTypes2['default'].func,
	    onOk: _propTypes2['default'].func,
	    showOk: _propTypes2['default'].bool,
	    prefixCls: _propTypes2['default'].string,
	    onKeyDown: _propTypes2['default'].func,
	    timePicker: _propTypes2['default'].element,
	    dateInputPlaceholder: _propTypes2['default'].any,
	    onClear: _propTypes2['default'].func,
	    onChange: _propTypes2['default'].func,
	    renderFooter: _propTypes2['default'].func,
	    renderSidebar: _propTypes2['default'].func
	  },
	
	  mixins: [_CommonMixin2['default'], _CalendarMixin2['default']],
	
	  getDefaultProps: function getDefaultProps() {
	    return {
	      showToday: true,
	      showDateInput: true,
	      timePicker: null,
	      onOk: noop
	    };
	  },
	  getInitialState: function getInitialState() {
	    return {
	      showTimePicker: false
	    };
	  },
	  onKeyDown: function onKeyDown(event) {
	    if (event.target.nodeName.toLowerCase() === 'input') {
	      return undefined;
	    }
	    var keyCode = event.keyCode;
	    // mac
	    var ctrlKey = event.ctrlKey || event.metaKey;
	    var disabledDate = this.props.disabledDate;
	    var value = this.state.value;
	
	    switch (keyCode) {
	      case _KeyCode2['default'].DOWN:
	        goWeek.call(this, 1);
	        event.preventDefault();
	        return 1;
	      case _KeyCode2['default'].UP:
	        goWeek.call(this, -1);
	        event.preventDefault();
	        return 1;
	      case _KeyCode2['default'].LEFT:
	        if (ctrlKey) {
	          goYear.call(this, -1);
	        } else {
	          goDay.call(this, -1);
	        }
	        event.preventDefault();
	        return 1;
	      case _KeyCode2['default'].RIGHT:
	        if (ctrlKey) {
	          goYear.call(this, 1);
	        } else {
	          goDay.call(this, 1);
	        }
	        event.preventDefault();
	        return 1;
	      case _KeyCode2['default'].HOME:
	        goStartMonth.call(this);
	        event.preventDefault();
	        return 1;
	      case _KeyCode2['default'].END:
	        goEndMonth.call(this);
	        event.preventDefault();
	        return 1;
	      case _KeyCode2['default'].PAGE_DOWN:
	        goMonth.call(this, 1);
	        event.preventDefault();
	        return 1;
	      case _KeyCode2['default'].PAGE_UP:
	        goMonth.call(this, -1);
	        event.preventDefault();
	        return 1;
	      case _KeyCode2['default'].ENTER:
	        if (!disabledDate || !disabledDate(value)) {
	          this.onSelect(value, {
	            source: 'keyboard'
	          });
	        }
	        event.preventDefault();
	        return 1;
	      default:
	        this.props.onKeyDown(event);
	        return 1;
	    }
	  },
	  onClear: function onClear() {
	    this.onSelect(null);
	    this.props.onClear();
	  },
	  onOk: function onOk() {
	    var selectedValue = this.state.selectedValue;
	
	    if (this.isAllowedDate(selectedValue)) {
	      this.props.onOk(selectedValue);
	    }
	  },
	  onDateInputChange: function onDateInputChange(value) {
	    this.onSelect(value, {
	      source: 'dateInput'
	    });
	  },
	  onDateTableSelect: function onDateTableSelect(value) {
	    var timePicker = this.props.timePicker;
	    var selectedValue = this.state.selectedValue;
	
	    if (!selectedValue && timePicker) {
	      var timePickerDefaultValue = timePicker.props.defaultValue;
	      if (timePickerDefaultValue) {
	        (0, _util.syncTime)(timePickerDefaultValue, value);
	      }
	    }
	    this.onSelect(value);
	  },
	  onToday: function onToday() {
	    var value = this.state.value;
	
	    var now = (0, _util.getTodayTime)(value);
	    this.onSelect(now, {
	      source: 'todayButton'
	    });
	  },
	  getRootDOMNode: function getRootDOMNode() {
	    return _reactDom2['default'].findDOMNode(this);
	  },
	  openTimePicker: function openTimePicker() {
	    this.setState({
	      showTimePicker: true
	    });
	  },
	  closeTimePicker: function closeTimePicker() {
	    this.setState({
	      showTimePicker: false
	    });
	  },
	  render: function render() {
	    var props = this.props;
	    var locale = props.locale,
	        prefixCls = props.prefixCls,
	        disabledDate = props.disabledDate,
	        dateInputPlaceholder = props.dateInputPlaceholder,
	        timePicker = props.timePicker,
	        disabledTime = props.disabledTime;
	
	    var state = this.state;
	    var value = state.value,
	        selectedValue = state.selectedValue,
	        showTimePicker = state.showTimePicker;
	
	    var disabledTimeConfig = showTimePicker && disabledTime && timePicker ? (0, _util.getTimeConfig)(selectedValue, disabledTime) : null;
	
	    var timePickerEle = null;
	
	    if (timePicker && showTimePicker) {
	      var timePickerProps = (0, _extends3['default'])({
	        showHour: true,
	        showSecond: true,
	        showMinute: true
	      }, timePicker.props, disabledTimeConfig, {
	        onChange: this.onDateInputChange,
	        value: selectedValue,
	        disabledTime: disabledTime
	      });
	
	      if (timePicker.props.defaultValue !== undefined) {
	        timePickerProps.defaultOpenValue = timePicker.props.defaultValue;
	      }
	
	      timePickerEle = _react2['default'].cloneElement(timePicker, timePickerProps);
	    }
	
	    var dateInputElement = props.showDateInput ? _react2['default'].createElement(_DateInput2['default'], {
	      format: this.getFormat(),
	      key: 'date-input',
	      value: value,
	      locale: locale,
	      placeholder: dateInputPlaceholder,
	      showClear: true,
	      disabledTime: disabledTime,
	      disabledDate: disabledDate,
	      onClear: this.onClear,
	      prefixCls: prefixCls,
	      selectedValue: selectedValue,
	      onChange: this.onDateInputChange
	    }) : null;
	    var children = [props.renderSidebar(), _react2['default'].createElement(
	      'div',
	      { className: prefixCls + '-panel', key: 'panel' },
	      dateInputElement,
	      _react2['default'].createElement(
	        'div',
	        { className: prefixCls + '-date-panel' },
	        _react2['default'].createElement(_CalendarHeader2['default'], {
	          locale: locale,
	          onValueChange: this.setValue,
	          value: value,
	          showTimePicker: showTimePicker,
	          prefixCls: prefixCls
	        }),
	        timePicker && showTimePicker ? _react2['default'].createElement(
	          'div',
	          { className: prefixCls + '-time-picker' },
	          _react2['default'].createElement(
	            'div',
	            { className: prefixCls + '-time-picker-panel' },
	            timePickerEle
	          )
	        ) : null,
	        _react2['default'].createElement(
	          'div',
	          { className: prefixCls + '-body' },
	          _react2['default'].createElement(_DateTable2['default'], {
	            locale: locale,
	            value: value,
	            selectedValue: selectedValue,
	            prefixCls: prefixCls,
	            dateRender: props.dateRender,
	            onSelect: this.onDateTableSelect,
	            disabledDate: disabledDate,
	            showWeekNumber: props.showWeekNumber
	          })
	        ),
	        _react2['default'].createElement(_CalendarFooter2['default'], {
	          showOk: props.showOk,
	          renderFooter: props.renderFooter,
	          locale: locale,
	          prefixCls: prefixCls,
	          showToday: props.showToday,
	          disabledTime: disabledTime,
	          showTimePicker: showTimePicker,
	          showDateInput: props.showDateInput,
	          timePicker: timePicker,
	          selectedValue: selectedValue,
	          value: value,
	          disabledDate: disabledDate,
	          okDisabled: !this.isAllowedDate(selectedValue),
	          onOk: this.onOk,
	          onSelect: this.onSelect,
	          onToday: this.onToday,
	          onOpenTimePicker: this.openTimePicker,
	          onCloseTimePicker: this.closeTimePicker
	        })
	      )
	    )];
	
	    return this.renderRoot({
	      children: children,
	      className: props.showWeekNumber ? prefixCls + '-week-number' : ''
	    });
	  }
	});
	
	exports['default'] = Calendar;
	module.exports = exports['default'];

/***/ }),
/* 661 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _createReactClass = __webpack_require__(14);
	
	var _createReactClass2 = _interopRequireDefault(_createReactClass);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _DateTable = __webpack_require__(143);
	
	var _DateTable2 = _interopRequireDefault(_DateTable);
	
	var _MonthTable = __webpack_require__(252);
	
	var _MonthTable2 = _interopRequireDefault(_MonthTable);
	
	var _CalendarMixin = __webpack_require__(144);
	
	var _CalendarMixin2 = _interopRequireDefault(_CalendarMixin);
	
	var _CommonMixin = __webpack_require__(96);
	
	var _CommonMixin2 = _interopRequireDefault(_CommonMixin);
	
	var _CalendarHeader = __webpack_require__(667);
	
	var _CalendarHeader2 = _interopRequireDefault(_CalendarHeader);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var FullCalendar = (0, _createReactClass2['default'])({
	  displayName: 'FullCalendar',
	
	  propTypes: {
	    defaultType: _propTypes2['default'].string,
	    type: _propTypes2['default'].string,
	    prefixCls: _propTypes2['default'].string,
	    locale: _propTypes2['default'].object,
	    onTypeChange: _propTypes2['default'].func,
	    fullscreen: _propTypes2['default'].bool,
	    monthCellRender: _propTypes2['default'].func,
	    dateCellRender: _propTypes2['default'].func,
	    showTypeSwitch: _propTypes2['default'].bool,
	    Select: _propTypes2['default'].func.isRequired,
	    headerComponents: _propTypes2['default'].array,
	    headerComponent: _propTypes2['default'].object, // The whole header component
	    headerRender: _propTypes2['default'].func,
	    showHeader: _propTypes2['default'].bool,
	    disabledDate: _propTypes2['default'].func
	  },
	  mixins: [_CommonMixin2['default'], _CalendarMixin2['default']],
	  getDefaultProps: function getDefaultProps() {
	    return {
	      defaultType: 'date',
	      fullscreen: false,
	      showTypeSwitch: true,
	      showHeader: true,
	      onTypeChange: function onTypeChange() {}
	    };
	  },
	  getInitialState: function getInitialState() {
	    var type = void 0;
	    if ('type' in this.props) {
	      type = this.props.type;
	    } else {
	      type = this.props.defaultType;
	    }
	    return {
	      type: type
	    };
	  },
	  componentWillReceiveProps: function componentWillReceiveProps(nextProps) {
	    if ('type' in nextProps) {
	      this.setState({
	        type: nextProps.type
	      });
	    }
	  },
	  onMonthSelect: function onMonthSelect(value) {
	    this.onSelect(value, {
	      target: 'month'
	    });
	  },
	  setType: function setType(type) {
	    if (!('type' in this.props)) {
	      this.setState({
	        type: type
	      });
	    }
	    this.props.onTypeChange(type);
	  },
	  render: function render() {
	    var props = this.props;
	    var locale = props.locale,
	        prefixCls = props.prefixCls,
	        fullscreen = props.fullscreen,
	        showHeader = props.showHeader,
	        headerComponent = props.headerComponent,
	        headerRender = props.headerRender,
	        disabledDate = props.disabledDate;
	    var _state = this.state,
	        value = _state.value,
	        type = _state.type;
	
	
	    var header = null;
	    if (showHeader) {
	      if (headerRender) {
	        header = headerRender(value, type, locale);
	      } else {
	        var TheHeader = headerComponent || _CalendarHeader2['default'];
	        header = _react2['default'].createElement(TheHeader, (0, _extends3['default'])({
	          key: 'calendar-header'
	        }, props, {
	          prefixCls: prefixCls + '-full',
	          type: type,
	          value: value,
	          onTypeChange: this.setType,
	          onValueChange: this.setValue
	        }));
	      }
	    }
	
	    var table = type === 'date' ? _react2['default'].createElement(_DateTable2['default'], {
	      dateRender: props.dateCellRender,
	      contentRender: props.dateCellContentRender,
	      locale: locale,
	      prefixCls: prefixCls,
	      onSelect: this.onSelect,
	      value: value,
	      disabledDate: disabledDate
	    }) : _react2['default'].createElement(_MonthTable2['default'], {
	      cellRender: props.monthCellRender,
	      contentRender: props.monthCellContentRender,
	      locale: locale,
	      onSelect: this.onMonthSelect,
	      prefixCls: prefixCls + '-month-panel',
	      value: value,
	      disabledDate: disabledDate
	    });
	
	    var children = [header, _react2['default'].createElement(
	      'div',
	      { key: 'calendar-body', className: prefixCls + '-calendar-body' },
	      table
	    )];
	
	    var className = [prefixCls + '-full'];
	
	    if (fullscreen) {
	      className.push(prefixCls + '-fullscreen');
	    }
	
	    return this.renderRoot({
	      children: children,
	      className: className.join(' ')
	    });
	  }
	});
	
	exports['default'] = FullCalendar;
	module.exports = exports['default'];

/***/ }),
/* 662 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _toConsumableArray2 = __webpack_require__(31);
	
	var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);
	
	var _slicedToArray2 = __webpack_require__(186);
	
	var _slicedToArray3 = _interopRequireDefault(_slicedToArray2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _createReactClass = __webpack_require__(14);
	
	var _createReactClass2 = _interopRequireDefault(_createReactClass);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _moment = __webpack_require__(13);
	
	var _moment2 = _interopRequireDefault(_moment);
	
	var _classnames2 = __webpack_require__(8);
	
	var _classnames3 = _interopRequireDefault(_classnames2);
	
	var _CalendarPart = __webpack_require__(669);
	
	var _CalendarPart2 = _interopRequireDefault(_CalendarPart);
	
	var _TodayButton = __webpack_require__(246);
	
	var _TodayButton2 = _interopRequireDefault(_TodayButton);
	
	var _OkButton = __webpack_require__(244);
	
	var _OkButton2 = _interopRequireDefault(_OkButton);
	
	var _TimePickerButton = __webpack_require__(245);
	
	var _TimePickerButton2 = _interopRequireDefault(_TimePickerButton);
	
	var _CommonMixin = __webpack_require__(96);
	
	var _CommonMixin2 = _interopRequireDefault(_CommonMixin);
	
	var _util = __webpack_require__(44);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function noop() {}
	
	function isEmptyArray(arr) {
	  return Array.isArray(arr) && (arr.length === 0 || arr.every(function (i) {
	    return !i;
	  }));
	}
	
	function getValueFromSelectedValue(selectedValue) {
	  var _selectedValue = (0, _slicedToArray3['default'])(selectedValue, 2),
	      start = _selectedValue[0],
	      end = _selectedValue[1];
	
	  var newEnd = end && end.isSame(start, 'month') ? end.clone().add(1, 'month') : end;
	  return [start, newEnd];
	}
	
	function normalizeAnchor(props, init) {
	  var selectedValue = props.selectedValue || init && props.defaultSelectedValue;
	  var value = props.value || init && props.defaultValue;
	  var normalizedValue = value ? getValueFromSelectedValue(value) : getValueFromSelectedValue(selectedValue);
	  return !isEmptyArray(normalizedValue) ? normalizedValue : init && [(0, _moment2['default'])(), (0, _moment2['default'])().add(1, 'months')];
	}
	
	function generateOptions(length) {
	  var arr = [];
	  for (var value = 0; value < length; value++) {
	    arr.push(value);
	  }
	  return arr;
	}
	
	function onInputSelect(direction, value) {
	  if (!value) {
	    return;
	  }
	  var originalValue = this.state.selectedValue;
	  var selectedValue = originalValue.concat();
	  var index = direction === 'left' ? 0 : 1;
	  selectedValue[index] = value;
	  if (selectedValue[0] && this.compare(selectedValue[0], selectedValue[1]) > 0) {
	    selectedValue[1 - index] = this.state.showTimePicker ? selectedValue[index] : undefined;
	  }
	  this.fireSelectValueChange(selectedValue);
	}
	
	var RangeCalendar = (0, _createReactClass2['default'])({
	  displayName: 'RangeCalendar',
	
	  propTypes: {
	    prefixCls: _propTypes2['default'].string,
	    dateInputPlaceholder: _propTypes2['default'].any,
	    defaultValue: _propTypes2['default'].any,
	    value: _propTypes2['default'].any,
	    hoverValue: _propTypes2['default'].any,
	    timePicker: _propTypes2['default'].any,
	    showOk: _propTypes2['default'].bool,
	    showToday: _propTypes2['default'].bool,
	    defaultSelectedValue: _propTypes2['default'].array,
	    selectedValue: _propTypes2['default'].array,
	    onOk: _propTypes2['default'].func,
	    showClear: _propTypes2['default'].bool,
	    locale: _propTypes2['default'].object,
	    onChange: _propTypes2['default'].func,
	    onSelect: _propTypes2['default'].func,
	    onValueChange: _propTypes2['default'].func,
	    onHoverChange: _propTypes2['default'].func,
	    format: _propTypes2['default'].oneOfType([_propTypes2['default'].object, _propTypes2['default'].string]),
	    onClear: _propTypes2['default'].func,
	    type: _propTypes2['default'].any,
	    disabledDate: _propTypes2['default'].func,
	    disabledTime: _propTypes2['default'].func
	  },
	
	  mixins: [_CommonMixin2['default']],
	
	  getDefaultProps: function getDefaultProps() {
	    return {
	      type: 'both',
	      defaultSelectedValue: [],
	      onValueChange: noop,
	      onHoverChange: noop,
	      disabledTime: noop,
	      showToday: true
	    };
	  },
	  getInitialState: function getInitialState() {
	    var props = this.props;
	    var selectedValue = props.selectedValue || props.defaultSelectedValue;
	    var value = normalizeAnchor(props, 1);
	    return {
	      selectedValue: selectedValue,
	      prevSelectedValue: selectedValue,
	      firstSelectedValue: null,
	      hoverValue: props.hoverValue || [],
	      value: value,
	      showTimePicker: false,
	      isStartMonthYearPanelShow: false,
	      isEndMonthYearPanelShow: false
	    };
	  },
	  componentWillReceiveProps: function componentWillReceiveProps(nextProps) {
	    var newState = {};
	    if ('value' in nextProps) {
	      newState.value = normalizeAnchor(nextProps, 0);
	      this.setState(newState);
	    }
	    if ('hoverValue' in nextProps) {
	      this.setState({ hoverValue: nextProps.hoverValue });
	    }
	    if ('selectedValue' in nextProps) {
	      newState.selectedValue = nextProps.selectedValue;
	      newState.prevSelectedValue = nextProps.selectedValue;
	      this.setState(newState);
	    }
	  },
	  onDatePanelEnter: function onDatePanelEnter() {
	    if (this.hasSelectedValue()) {
	      this.fireHoverValueChange(this.state.selectedValue.concat());
	    }
	  },
	  onDatePanelLeave: function onDatePanelLeave() {
	    if (this.hasSelectedValue()) {
	      this.fireHoverValueChange([]);
	    }
	  },
	  onSelect: function onSelect(value) {
	    var type = this.props.type;
	    var _state = this.state,
	        selectedValue = _state.selectedValue,
	        prevSelectedValue = _state.prevSelectedValue,
	        firstSelectedValue = _state.firstSelectedValue;
	
	    var nextSelectedValue = void 0;
	    if (type === 'both') {
	      if (!firstSelectedValue) {
	        (0, _util.syncTime)(prevSelectedValue[0], value);
	        nextSelectedValue = [value];
	      } else if (this.compare(firstSelectedValue, value) < 0) {
	        (0, _util.syncTime)(prevSelectedValue[1], value);
	        nextSelectedValue = [firstSelectedValue, value];
	      } else {
	        (0, _util.syncTime)(prevSelectedValue[0], value);
	        (0, _util.syncTime)(prevSelectedValue[1], firstSelectedValue);
	        nextSelectedValue = [value, firstSelectedValue];
	      }
	    } else if (type === 'start') {
	      (0, _util.syncTime)(prevSelectedValue[0], value);
	      var endValue = selectedValue[1];
	      nextSelectedValue = endValue && this.compare(endValue, value) > 0 ? [value, endValue] : [value];
	    } else {
	      // type === 'end'
	      var startValue = selectedValue[0];
	      if (startValue && this.compare(startValue, value) <= 0) {
	        (0, _util.syncTime)(prevSelectedValue[1], value);
	        nextSelectedValue = [startValue, value];
	      } else {
	        (0, _util.syncTime)(prevSelectedValue[0], value);
	        nextSelectedValue = [value];
	      }
	    }
	
	    this.fireSelectValueChange(nextSelectedValue);
	  },
	  onDayHover: function onDayHover(value) {
	    var hoverValue = [];
	    var _state2 = this.state,
	        selectedValue = _state2.selectedValue,
	        firstSelectedValue = _state2.firstSelectedValue;
	    var type = this.props.type;
	
	    if (type === 'start' && selectedValue[1]) {
	      hoverValue = this.compare(value, selectedValue[1]) < 0 ? [value, selectedValue[1]] : [value];
	    } else if (type === 'end' && selectedValue[0]) {
	      hoverValue = this.compare(value, selectedValue[0]) > 0 ? [selectedValue[0], value] : [];
	    } else {
	      if (!firstSelectedValue) {
	        return;
	      }
	      hoverValue = this.compare(value, firstSelectedValue) < 0 ? [value, firstSelectedValue] : [firstSelectedValue, value];
	    }
	    this.fireHoverValueChange(hoverValue);
	  },
	  onToday: function onToday() {
	    var startValue = (0, _util.getTodayTime)(this.state.value[0]);
	    var endValue = startValue.clone().add(1, 'months');
	    this.setState({ value: [startValue, endValue] });
	  },
	  onOpenTimePicker: function onOpenTimePicker() {
	    this.setState({
	      showTimePicker: true
	    });
	  },
	  onCloseTimePicker: function onCloseTimePicker() {
	    this.setState({
	      showTimePicker: false
	    });
	  },
	  onOk: function onOk() {
	    var selectedValue = this.state.selectedValue;
	
	    if (this.isAllowedDateAndTime(selectedValue)) {
	      this.props.onOk(this.state.selectedValue);
	    }
	  },
	  onStartInputSelect: function onStartInputSelect() {
	    for (var _len = arguments.length, oargs = Array(_len), _key = 0; _key < _len; _key++) {
	      oargs[_key] = arguments[_key];
	    }
	
	    var args = ['left'].concat(oargs);
	    return onInputSelect.apply(this, args);
	  },
	  onEndInputSelect: function onEndInputSelect() {
	    for (var _len2 = arguments.length, oargs = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
	      oargs[_key2] = arguments[_key2];
	    }
	
	    var args = ['right'].concat(oargs);
	    return onInputSelect.apply(this, args);
	  },
	  onStartValueChange: function onStartValueChange(leftValue) {
	    var value = [].concat((0, _toConsumableArray3['default'])(this.state.value));
	    value[0] = leftValue;
	    return this.fireValueChange(value);
	  },
	  onEndValueChange: function onEndValueChange(rightValue) {
	    var value = [].concat((0, _toConsumableArray3['default'])(this.state.value));
	    value[1] = rightValue;
	    return this.fireValueChange(value);
	  },
	  onStartPanelChange: function onStartPanelChange(_ref) {
	    var showMonthPanel = _ref.showMonthPanel,
	        showYearPanel = _ref.showYearPanel;
	
	    this.setState({ isStartMonthYearPanelShow: showMonthPanel || showYearPanel });
	  },
	  onEndPanelChange: function onEndPanelChange(_ref2) {
	    var showMonthPanel = _ref2.showMonthPanel,
	        showYearPanel = _ref2.showYearPanel;
	
	    this.setState({ isEndMonthYearPanelShow: showMonthPanel || showYearPanel });
	  },
	  getStartValue: function getStartValue() {
	    var value = this.state.value[0];
	    var selectedValue = this.state.selectedValue;
	    // keep selectedTime when select date
	    if (selectedValue[0] && this.props.timePicker) {
	      value = value.clone();
	      (0, _util.syncTime)(selectedValue[0], value);
	    }
	    if (this.state.showTimePicker && selectedValue[0]) {
	      return selectedValue[0];
	    }
	    return value;
	  },
	  getEndValue: function getEndValue() {
	    var _state3 = this.state,
	        value = _state3.value,
	        selectedValue = _state3.selectedValue,
	        showTimePicker = _state3.showTimePicker;
	
	    var endValue = value[1] ? value[1].clone() : value[0].clone().add(1, 'month');
	    // keep selectedTime when select date
	    if (selectedValue[1] && this.props.timePicker) {
	      (0, _util.syncTime)(selectedValue[1], endValue);
	    }
	    if (showTimePicker) {
	      return selectedValue[1] ? selectedValue[1] : this.getStartValue();
	    }
	    return endValue;
	  },
	
	  // get disabled hours for second picker
	  getEndDisableTime: function getEndDisableTime() {
	    var _state4 = this.state,
	        selectedValue = _state4.selectedValue,
	        value = _state4.value;
	
	    var startValue = selectedValue && selectedValue[0] || value[0].clone();
	    // if startTime and endTime is same day..
	    // the second time picker will not able to pick time before first time picker
	    if (!selectedValue[1] || startValue.isSame(selectedValue[1], 'day')) {
	      var hours = startValue.hour();
	      var minutes = startValue.minute();
	      var second = startValue.second();
	      var _disabledHours = generateOptions(hours);
	      var _disabledMinutes = generateOptions(minutes);
	      var _disabledSeconds = generateOptions(second);
	      return {
	        disabledHours: function disabledHours() {
	          return _disabledHours;
	        },
	        disabledMinutes: function disabledMinutes(hour) {
	          if (hour === hours) {
	            return _disabledMinutes;
	          }
	          return [];
	        },
	        disabledSeconds: function disabledSeconds(hour, minute) {
	          if (hour === hours && minute === minutes) {
	            return _disabledSeconds;
	          }
	          return [];
	        }
	      };
	    }
	    return null;
	  },
	  isAllowedDateAndTime: function isAllowedDateAndTime(selectedValue) {
	    return (0, _util.isAllowedDate)(selectedValue[0], this.props.disabledDate, this.disabledStartTime) && (0, _util.isAllowedDate)(selectedValue[1], this.props.disabledDate, this.disabledEndTime);
	  },
	  hasSelectedValue: function hasSelectedValue() {
	    var selectedValue = this.state.selectedValue;
	
	    return !!selectedValue[1] && !!selectedValue[0];
	  },
	  compare: function compare(v1, v2) {
	    if (this.props.timePicker) {
	      return v1.diff(v2);
	    }
	    return v1.diff(v2, 'days');
	  },
	  fireSelectValueChange: function fireSelectValueChange(selectedValue, direct) {
	    var timePicker = this.props.timePicker;
	    var prevSelectedValue = this.state.prevSelectedValue;
	
	    if (timePicker && timePicker.props.defaultValue) {
	      var timePickerDefaultValue = timePicker.props.defaultValue;
	      if (!prevSelectedValue[0] && selectedValue[0]) {
	        (0, _util.syncTime)(timePickerDefaultValue[0], selectedValue[0]);
	      }
	      if (!prevSelectedValue[1] && selectedValue[1]) {
	        (0, _util.syncTime)(timePickerDefaultValue[1], selectedValue[1]);
	      }
	    }
	
	    if (!('selectedValue' in this.props)) {
	      this.setState({
	        selectedValue: selectedValue
	      });
	    }
	
	    // 尚未选择过时间，直接输入的话
	    if (!this.state.selectedValue[0] || !this.state.selectedValue[1]) {
	      var startValue = selectedValue[0] || (0, _moment2['default'])();
	      var endValue = selectedValue[1] || startValue.clone().add(1, 'months');
	      this.setState({
	        selectedValue: selectedValue,
	        value: getValueFromSelectedValue([startValue, endValue])
	      });
	    }
	
	    if (selectedValue[0] && !selectedValue[1]) {
	      this.setState({ firstSelectedValue: selectedValue[0] });
	      this.fireHoverValueChange(selectedValue.concat());
	    }
	    this.props.onChange(selectedValue);
	    if (direct || selectedValue[0] && selectedValue[1]) {
	      this.setState({
	        prevSelectedValue: selectedValue,
	        firstSelectedValue: null
	      });
	      this.fireHoverValueChange([]);
	      this.props.onSelect(selectedValue);
	    }
	  },
	  fireValueChange: function fireValueChange(value) {
	    var props = this.props;
	    if (!('value' in props)) {
	      this.setState({
	        value: value
	      });
	    }
	    props.onValueChange(value);
	  },
	  fireHoverValueChange: function fireHoverValueChange(hoverValue) {
	    var props = this.props;
	    if (!('hoverValue' in props)) {
	      this.setState({ hoverValue: hoverValue });
	    }
	    props.onHoverChange(hoverValue);
	  },
	  clear: function clear() {
	    this.fireSelectValueChange([], true);
	    this.props.onClear();
	  },
	  disabledStartTime: function disabledStartTime(time) {
	    return this.props.disabledTime(time, 'start');
	  },
	  disabledEndTime: function disabledEndTime(time) {
	    return this.props.disabledTime(time, 'end');
	  },
	  disabledStartMonth: function disabledStartMonth(month) {
	    var value = this.state.value;
	
	    return month.isSameOrAfter(value[1], 'month');
	  },
	  disabledEndMonth: function disabledEndMonth(month) {
	    var value = this.state.value;
	
	    return month.isSameOrBefore(value[0], 'month');
	  },
	  render: function render() {
	    var _className, _classnames;
	
	    var props = this.props;
	    var state = this.state;
	    var showTimePicker = state.showTimePicker,
	        isStartMonthYearPanelShow = state.isStartMonthYearPanelShow,
	        isEndMonthYearPanelShow = state.isEndMonthYearPanelShow;
	    var prefixCls = props.prefixCls,
	        dateInputPlaceholder = props.dateInputPlaceholder,
	        timePicker = props.timePicker,
	        showOk = props.showOk,
	        locale = props.locale,
	        showClear = props.showClear,
	        showToday = props.showToday,
	        type = props.type;
	    var hoverValue = state.hoverValue,
	        selectedValue = state.selectedValue;
	
	    var className = (_className = {}, (0, _defineProperty3['default'])(_className, props.className, !!props.className), (0, _defineProperty3['default'])(_className, prefixCls, 1), (0, _defineProperty3['default'])(_className, prefixCls + '-hidden', !props.visible), (0, _defineProperty3['default'])(_className, prefixCls + '-range', 1), (0, _defineProperty3['default'])(_className, prefixCls + '-show-time-picker', showTimePicker), (0, _defineProperty3['default'])(_className, prefixCls + '-week-number', props.showWeekNumber), _className);
	    var classes = (0, _classnames3['default'])(className);
	    var newProps = {
	      selectedValue: state.selectedValue,
	      onSelect: this.onSelect,
	      onDayHover: type === 'start' && selectedValue[1] || type === 'end' && selectedValue[0] || !!hoverValue.length ? this.onDayHover : undefined
	    };
	
	    var placeholder1 = void 0;
	    var placeholder2 = void 0;
	
	    if (dateInputPlaceholder) {
	      if (Array.isArray(dateInputPlaceholder)) {
	        var _dateInputPlaceholder = (0, _slicedToArray3['default'])(dateInputPlaceholder, 2);
	
	        placeholder1 = _dateInputPlaceholder[0];
	        placeholder2 = _dateInputPlaceholder[1];
	      } else {
	        placeholder1 = placeholder2 = dateInputPlaceholder;
	      }
	    }
	    var showOkButton = showOk === true || showOk !== false && !!timePicker;
	    var cls = (0, _classnames3['default'])((_classnames = {}, (0, _defineProperty3['default'])(_classnames, prefixCls + '-footer', true), (0, _defineProperty3['default'])(_classnames, prefixCls + '-range-bottom', true), (0, _defineProperty3['default'])(_classnames, prefixCls + '-footer-show-ok', showOkButton), _classnames));
	
	    var startValue = this.getStartValue();
	    var endValue = this.getEndValue();
	    var todayTime = (0, _util.getTodayTime)(startValue);
	    var thisMonth = todayTime.month();
	    var thisYear = todayTime.year();
	    var isTodayInView = startValue.year() === thisYear && startValue.month() === thisMonth || endValue.year() === thisYear && endValue.month() === thisMonth;
	    var nextMonthOfStart = startValue.clone().add(1, 'months');
	    var isClosestMonths = nextMonthOfStart.year() === endValue.year() && nextMonthOfStart.month() === endValue.month();
	    return _react2['default'].createElement(
	      'div',
	      {
	        ref: this.saveRoot,
	        className: classes,
	        style: props.style,
	        tabIndex: '0'
	      },
	      props.renderSidebar(),
	      _react2['default'].createElement(
	        'div',
	        { className: prefixCls + '-panel' },
	        showClear && selectedValue[0] && selectedValue[1] ? _react2['default'].createElement('a', {
	          className: prefixCls + '-clear-btn',
	          role: 'button',
	          title: locale.clear,
	          onClick: this.clear
	        }) : null,
	        _react2['default'].createElement(
	          'div',
	          {
	            className: prefixCls + '-date-panel',
	            onMouseLeave: type !== 'both' ? this.onDatePanelLeave : undefined,
	            onMouseEnter: type !== 'both' ? this.onDatePanelEnter : undefined
	          },
	          _react2['default'].createElement(_CalendarPart2['default'], (0, _extends3['default'])({}, props, newProps, {
	            hoverValue: hoverValue,
	            direction: 'left',
	            disabledTime: this.disabledStartTime,
	            disabledMonth: this.disabledStartMonth,
	            format: this.getFormat(),
	            value: startValue,
	            placeholder: placeholder1,
	            onInputSelect: this.onStartInputSelect,
	            onValueChange: this.onStartValueChange,
	            onPanelChange: this.onStartPanelChange,
	            timePicker: timePicker,
	            showTimePicker: showTimePicker,
	            enablePrev: true,
	            enableNext: !isClosestMonths || isEndMonthYearPanelShow
	          })),
	          _react2['default'].createElement(
	            'span',
	            { className: prefixCls + '-range-middle' },
	            '~'
	          ),
	          _react2['default'].createElement(_CalendarPart2['default'], (0, _extends3['default'])({}, props, newProps, {
	            hoverValue: hoverValue,
	            direction: 'right',
	            format: this.getFormat(),
	            timePickerDisabledTime: this.getEndDisableTime(),
	            placeholder: placeholder2,
	            value: endValue,
	            onInputSelect: this.onEndInputSelect,
	            onValueChange: this.onEndValueChange,
	            onPanelChange: this.onEndPanelChange,
	            timePicker: timePicker,
	            showTimePicker: showTimePicker,
	            disabledTime: this.disabledEndTime,
	            disabledMonth: this.disabledEndMonth,
	            enablePrev: !isClosestMonths || isStartMonthYearPanelShow,
	            enableNext: true
	          }))
	        ),
	        _react2['default'].createElement(
	          'div',
	          { className: cls },
	          props.renderFooter(),
	          showToday || props.timePicker || showOkButton ? _react2['default'].createElement(
	            'div',
	            { className: prefixCls + '-footer-btn' },
	            showToday ? _react2['default'].createElement(_TodayButton2['default'], (0, _extends3['default'])({}, props, {
	              disabled: isTodayInView,
	              value: state.value[0],
	              onToday: this.onToday,
	              text: locale.backToToday
	            })) : null,
	            props.timePicker ? _react2['default'].createElement(_TimePickerButton2['default'], (0, _extends3['default'])({}, props, {
	              showTimePicker: showTimePicker,
	              onOpenTimePicker: this.onOpenTimePicker,
	              onCloseTimePicker: this.onCloseTimePicker,
	              timePickerDisabled: !this.hasSelectedValue() || hoverValue.length
	            })) : null,
	            showOkButton ? _react2['default'].createElement(_OkButton2['default'], (0, _extends3['default'])({}, props, {
	              onOk: this.onOk,
	              okDisabled: !this.isAllowedDateAndTime(selectedValue) || !this.hasSelectedValue() || hoverValue.length
	            })) : null
	          ) : null
	        )
	      )
	    );
	  }
	});
	
	exports['default'] = RangeCalendar;
	module.exports = exports['default'];

/***/ }),
/* 663 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _reactDom = __webpack_require__(10);
	
	var _reactDom2 = _interopRequireDefault(_reactDom);
	
	var _createReactClass = __webpack_require__(14);
	
	var _createReactClass2 = _interopRequireDefault(_createReactClass);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _mapSelf = __webpack_require__(282);
	
	var _mapSelf2 = _interopRequireDefault(_mapSelf);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _TodayButton = __webpack_require__(246);
	
	var _TodayButton2 = _interopRequireDefault(_TodayButton);
	
	var _OkButton = __webpack_require__(244);
	
	var _OkButton2 = _interopRequireDefault(_OkButton);
	
	var _TimePickerButton = __webpack_require__(245);
	
	var _TimePickerButton2 = _interopRequireDefault(_TimePickerButton);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var CalendarFooter = (0, _createReactClass2['default'])({
	  displayName: 'CalendarFooter',
	
	  propTypes: {
	    prefixCls: _propTypes2['default'].string,
	    showDateInput: _propTypes2['default'].bool,
	    disabledTime: _propTypes2['default'].any,
	    timePicker: _propTypes2['default'].element,
	    selectedValue: _propTypes2['default'].any,
	    showOk: _propTypes2['default'].bool,
	    onSelect: _propTypes2['default'].func,
	    value: _propTypes2['default'].object,
	    renderFooter: _propTypes2['default'].func,
	    defaultValue: _propTypes2['default'].object
	  },
	
	  onSelect: function onSelect(value) {
	    this.props.onSelect(value);
	  },
	  getRootDOMNode: function getRootDOMNode() {
	    return _reactDom2['default'].findDOMNode(this);
	  },
	  render: function render() {
	    var props = this.props;
	    var value = props.value,
	        prefixCls = props.prefixCls,
	        showOk = props.showOk,
	        timePicker = props.timePicker,
	        renderFooter = props.renderFooter;
	
	    var footerEl = null;
	    var extraFooter = renderFooter();
	    if (props.showToday || timePicker || extraFooter) {
	      var _cx;
	
	      var nowEl = void 0;
	      if (props.showToday) {
	        nowEl = _react2['default'].createElement(_TodayButton2['default'], (0, _extends3['default'])({}, props, { value: value }));
	      }
	      var okBtn = void 0;
	      if (showOk === true || showOk !== false && !!props.timePicker) {
	        okBtn = _react2['default'].createElement(_OkButton2['default'], props);
	      }
	      var timePickerBtn = void 0;
	      if (!!props.timePicker) {
	        timePickerBtn = _react2['default'].createElement(_TimePickerButton2['default'], props);
	      }
	
	      var footerBtn = void 0;
	      if (nowEl || timePickerBtn || okBtn) {
	        footerBtn = _react2['default'].createElement(
	          'span',
	          { className: prefixCls + '-footer-btn' },
	          (0, _mapSelf2['default'])([nowEl, timePickerBtn, okBtn])
	        );
	      }
	      var cls = (0, _classnames2['default'])((_cx = {}, (0, _defineProperty3['default'])(_cx, prefixCls + '-footer', true), (0, _defineProperty3['default'])(_cx, prefixCls + '-footer-show-ok', okBtn), _cx));
	      footerEl = _react2['default'].createElement(
	        'div',
	        { className: cls },
	        extraFooter,
	        footerBtn
	      );
	    }
	    return footerEl;
	  }
	});
	
	exports['default'] = CalendarFooter;
	module.exports = exports['default'];

/***/ }),
/* 664 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _createReactClass = __webpack_require__(14);
	
	var _createReactClass2 = _interopRequireDefault(_createReactClass);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _DateConstants = __webpack_require__(247);
	
	var _DateConstants2 = _interopRequireDefault(_DateConstants);
	
	var _util = __webpack_require__(44);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function isSameDay(one, two) {
	  return one && two && one.isSame(two, 'day');
	}
	
	function beforeCurrentMonthYear(current, today) {
	  if (current.year() < today.year()) {
	    return 1;
	  }
	  return current.year() === today.year() && current.month() < today.month();
	}
	
	function afterCurrentMonthYear(current, today) {
	  if (current.year() > today.year()) {
	    return 1;
	  }
	  return current.year() === today.year() && current.month() > today.month();
	}
	
	function getIdFromDate(date) {
	  return 'rc-calendar-' + date.year() + '-' + date.month() + '-' + date.date();
	}
	
	var DateTBody = (0, _createReactClass2['default'])({
	  displayName: 'DateTBody',
	
	  propTypes: {
	    contentRender: _propTypes2['default'].func,
	    dateRender: _propTypes2['default'].func,
	    disabledDate: _propTypes2['default'].func,
	    prefixCls: _propTypes2['default'].string,
	    selectedValue: _propTypes2['default'].oneOfType([_propTypes2['default'].object, _propTypes2['default'].arrayOf(_propTypes2['default'].object)]),
	    value: _propTypes2['default'].object,
	    hoverValue: _propTypes2['default'].any,
	    showWeekNumber: _propTypes2['default'].bool
	  },
	
	  getDefaultProps: function getDefaultProps() {
	    return {
	      hoverValue: []
	    };
	  },
	  render: function render() {
	    var props = this.props;
	    var contentRender = props.contentRender,
	        prefixCls = props.prefixCls,
	        selectedValue = props.selectedValue,
	        value = props.value,
	        showWeekNumber = props.showWeekNumber,
	        dateRender = props.dateRender,
	        disabledDate = props.disabledDate,
	        hoverValue = props.hoverValue;
	
	    var iIndex = void 0;
	    var jIndex = void 0;
	    var current = void 0;
	    var dateTable = [];
	    var today = (0, _util.getTodayTime)(value);
	    var cellClass = prefixCls + '-cell';
	    var weekNumberCellClass = prefixCls + '-week-number-cell';
	    var dateClass = prefixCls + '-date';
	    var todayClass = prefixCls + '-today';
	    var selectedClass = prefixCls + '-selected-day';
	    var selectedDateClass = prefixCls + '-selected-date'; // do not move with mouse operation
	    var inRangeClass = prefixCls + '-in-range-cell';
	    var lastMonthDayClass = prefixCls + '-last-month-cell';
	    var nextMonthDayClass = prefixCls + '-next-month-btn-day';
	    var disabledClass = prefixCls + '-disabled-cell';
	    var firstDisableClass = prefixCls + '-disabled-cell-first-of-row';
	    var lastDisableClass = prefixCls + '-disabled-cell-last-of-row';
	    var month1 = value.clone();
	    month1.date(1);
	    var day = month1.day();
	    var lastMonthDiffDay = (day + 7 - value.localeData().firstDayOfWeek()) % 7;
	    // calculate last month
	    var lastMonth1 = month1.clone();
	    lastMonth1.add(0 - lastMonthDiffDay, 'days');
	    var passed = 0;
	    for (iIndex = 0; iIndex < _DateConstants2['default'].DATE_ROW_COUNT; iIndex++) {
	      for (jIndex = 0; jIndex < _DateConstants2['default'].DATE_COL_COUNT; jIndex++) {
	        current = lastMonth1;
	        if (passed) {
	          current = current.clone();
	          current.add(passed, 'days');
	        }
	        dateTable.push(current);
	        passed++;
	      }
	    }
	    var tableHtml = [];
	    passed = 0;
	
	    for (iIndex = 0; iIndex < _DateConstants2['default'].DATE_ROW_COUNT; iIndex++) {
	      var _cx;
	
	      var isCurrentWeek = void 0;
	      var weekNumberCell = void 0;
	      var isActiveWeek = false;
	      var dateCells = [];
	      if (showWeekNumber) {
	        weekNumberCell = _react2['default'].createElement(
	          'td',
	          {
	            key: dateTable[passed].week(),
	            role: 'gridcell',
	            className: weekNumberCellClass
	          },
	          dateTable[passed].week()
	        );
	      }
	      for (jIndex = 0; jIndex < _DateConstants2['default'].DATE_COL_COUNT; jIndex++) {
	        var next = null;
	        var last = null;
	        current = dateTable[passed];
	        if (jIndex < _DateConstants2['default'].DATE_COL_COUNT - 1) {
	          next = dateTable[passed + 1];
	        }
	        if (jIndex > 0) {
	          last = dateTable[passed - 1];
	        }
	        var cls = cellClass;
	        var disabled = false;
	        var selected = false;
	
	        if (isSameDay(current, today)) {
	          cls += ' ' + todayClass;
	          isCurrentWeek = true;
	        }
	
	        var isBeforeCurrentMonthYear = beforeCurrentMonthYear(current, value);
	        var isAfterCurrentMonthYear = afterCurrentMonthYear(current, value);
	
	        if (selectedValue && Array.isArray(selectedValue)) {
	          var rangeValue = hoverValue.length ? hoverValue : selectedValue;
	          if (!isBeforeCurrentMonthYear && !isAfterCurrentMonthYear) {
	            var startValue = rangeValue[0];
	            var endValue = rangeValue[1];
	            if (startValue) {
	              if (isSameDay(current, startValue)) {
	                selected = true;
	                isActiveWeek = true;
	              }
	            }
	            if (startValue && endValue) {
	              if (isSameDay(current, endValue)) {
	                selected = true;
	                isActiveWeek = true;
	              } else if (current.isAfter(startValue, 'day') && current.isBefore(endValue, 'day')) {
	                cls += ' ' + inRangeClass;
	              }
	            }
	          }
	        } else if (isSameDay(current, value)) {
	          // keyboard change value, highlight works
	          selected = true;
	          isActiveWeek = true;
	        }
	
	        if (isSameDay(current, selectedValue)) {
	          cls += ' ' + selectedDateClass;
	        }
	
	        if (isBeforeCurrentMonthYear) {
	          cls += ' ' + lastMonthDayClass;
	        }
	        if (isAfterCurrentMonthYear) {
	          cls += ' ' + nextMonthDayClass;
	        }
	
	        if (disabledDate) {
	          if (disabledDate(current, value)) {
	            disabled = true;
	
	            if (!last || !disabledDate(last, value)) {
	              cls += ' ' + firstDisableClass;
	            }
	
	            if (!next || !disabledDate(next, value)) {
	              cls += ' ' + lastDisableClass;
	            }
	          }
	        }
	
	        if (selected) {
	          cls += ' ' + selectedClass;
	        }
	
	        if (disabled) {
	          cls += ' ' + disabledClass;
	        }
	
	        var dateHtml = void 0;
	        if (dateRender) {
	          dateHtml = dateRender(current, value);
	        } else {
	          var content = contentRender ? contentRender(current, value) : current.date();
	          dateHtml = _react2['default'].createElement(
	            'div',
	            {
	              key: getIdFromDate(current),
	              className: dateClass,
	              'aria-selected': selected,
	              'aria-disabled': disabled
	            },
	            content
	          );
	        }
	
	        dateCells.push(_react2['default'].createElement(
	          'td',
	          {
	            key: passed,
	            onClick: disabled ? undefined : props.onSelect.bind(null, current),
	            onMouseEnter: disabled ? undefined : props.onDayHover && props.onDayHover.bind(null, current) || undefined,
	            role: 'gridcell',
	            title: (0, _util.getTitleString)(current), className: cls
	          },
	          dateHtml
	        ));
	
	        passed++;
	      }
	
	      tableHtml.push(_react2['default'].createElement(
	        'tr',
	        {
	          key: iIndex,
	          role: 'row',
	          className: (0, _classnames2['default'])((_cx = {}, (0, _defineProperty3['default'])(_cx, prefixCls + '-current-week', isCurrentWeek), (0, _defineProperty3['default'])(_cx, prefixCls + '-active-week', isActiveWeek), _cx))
	        },
	        weekNumberCell,
	        dateCells
	      ));
	    }
	    return _react2['default'].createElement(
	      'tbody',
	      { className: prefixCls + '-tbody' },
	      tableHtml
	    );
	  }
	});
	
	exports['default'] = DateTBody;
	module.exports = exports['default'];

/***/ }),
/* 665 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _DateConstants = __webpack_require__(247);
	
	var _DateConstants2 = _interopRequireDefault(_DateConstants);
	
	var _moment = __webpack_require__(13);
	
	var _moment2 = _interopRequireDefault(_moment);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var DateTHead = function (_React$Component) {
	  (0, _inherits3['default'])(DateTHead, _React$Component);
	
	  function DateTHead() {
	    (0, _classCallCheck3['default'])(this, DateTHead);
	    return (0, _possibleConstructorReturn3['default'])(this, (DateTHead.__proto__ || Object.getPrototypeOf(DateTHead)).apply(this, arguments));
	  }
	
	  (0, _createClass3['default'])(DateTHead, [{
	    key: 'render',
	    value: function render() {
	      var props = this.props;
	      var value = props.value;
	      var localeData = value.localeData();
	      var prefixCls = props.prefixCls;
	      var veryShortWeekdays = [];
	      var weekDays = [];
	      var firstDayOfWeek = localeData.firstDayOfWeek();
	      var showWeekNumberEl = void 0;
	      var now = (0, _moment2['default'])();
	      for (var dateColIndex = 0; dateColIndex < _DateConstants2['default'].DATE_COL_COUNT; dateColIndex++) {
	        var index = (firstDayOfWeek + dateColIndex) % _DateConstants2['default'].DATE_COL_COUNT;
	        now.day(index);
	        veryShortWeekdays[dateColIndex] = localeData.weekdaysMin(now);
	        weekDays[dateColIndex] = localeData.weekdaysShort(now);
	      }
	
	      if (props.showWeekNumber) {
	        showWeekNumberEl = _react2['default'].createElement(
	          'th',
	          {
	            role: 'columnheader',
	            className: prefixCls + '-column-header ' + prefixCls + '-week-number-header'
	          },
	          _react2['default'].createElement(
	            'span',
	            { className: prefixCls + '-column-header-inner' },
	            'x'
	          )
	        );
	      }
	      var weekDaysEls = weekDays.map(function (day, xindex) {
	        return _react2['default'].createElement(
	          'th',
	          {
	            key: xindex,
	            role: 'columnheader',
	            title: day,
	            className: prefixCls + '-column-header'
	          },
	          _react2['default'].createElement(
	            'span',
	            { className: prefixCls + '-column-header-inner' },
	            veryShortWeekdays[xindex]
	          )
	        );
	      });
	      return _react2['default'].createElement(
	        'thead',
	        null,
	        _react2['default'].createElement(
	          'tr',
	          { role: 'row' },
	          showWeekNumberEl,
	          weekDaysEls
	        )
	      );
	    }
	  }]);
	  return DateTHead;
	}(_react2['default'].Component);
	
	exports['default'] = DateTHead;
	module.exports = exports['default'];

/***/ }),
/* 666 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var ROW = 4;
	var COL = 3;
	
	
	function goYear(direction) {
	  var next = this.state.value.clone();
	  next.add(direction, 'years');
	  this.setState({
	    value: next
	  });
	}
	
	function chooseDecade(year, event) {
	  var next = this.state.value.clone();
	  next.year(year);
	  next.month(this.state.value.month());
	  this.props.onSelect(next);
	  event.preventDefault();
	}
	
	var DecadePanel = function (_React$Component) {
	  (0, _inherits3['default'])(DecadePanel, _React$Component);
	
	  function DecadePanel(props) {
	    (0, _classCallCheck3['default'])(this, DecadePanel);
	
	    var _this = (0, _possibleConstructorReturn3['default'])(this, (DecadePanel.__proto__ || Object.getPrototypeOf(DecadePanel)).call(this, props));
	
	    _this.state = {
	      value: props.value || props.defaultValue
	    };
	
	    // bind methods
	    _this.prefixCls = props.rootPrefixCls + '-decade-panel';
	    _this.nextCentury = goYear.bind(_this, 100);
	    _this.previousCentury = goYear.bind(_this, -100);
	    return _this;
	  }
	
	  (0, _createClass3['default'])(DecadePanel, [{
	    key: 'render',
	    value: function render() {
	      var _this2 = this;
	
	      var value = this.state.value;
	      var locale = this.props.locale;
	      var currentYear = value.year();
	      var startYear = parseInt(currentYear / 100, 10) * 100;
	      var preYear = startYear - 10;
	      var endYear = startYear + 99;
	      var decades = [];
	      var index = 0;
	      var prefixCls = this.prefixCls;
	
	      for (var rowIndex = 0; rowIndex < ROW; rowIndex++) {
	        decades[rowIndex] = [];
	        for (var colIndex = 0; colIndex < COL; colIndex++) {
	          var startDecade = preYear + index * 10;
	          var endDecade = preYear + index * 10 + 9;
	          decades[rowIndex][colIndex] = {
	            startDecade: startDecade,
	            endDecade: endDecade
	          };
	          index++;
	        }
	      }
	
	      var decadesEls = decades.map(function (row, decadeIndex) {
	        var tds = row.map(function (decadeData) {
	          var _classNameMap;
	
	          var dStartDecade = decadeData.startDecade;
	          var dEndDecade = decadeData.endDecade;
	          var isLast = dStartDecade < startYear;
	          var isNext = dEndDecade > endYear;
	          var classNameMap = (_classNameMap = {}, (0, _defineProperty3['default'])(_classNameMap, prefixCls + '-cell', 1), (0, _defineProperty3['default'])(_classNameMap, prefixCls + '-selected-cell', dStartDecade <= currentYear && currentYear <= dEndDecade), (0, _defineProperty3['default'])(_classNameMap, prefixCls + '-last-century-cell', isLast), (0, _defineProperty3['default'])(_classNameMap, prefixCls + '-next-century-cell', isNext), _classNameMap);
	          var content = dStartDecade + '-' + dEndDecade;
	          var clickHandler = void 0;
	          if (isLast) {
	            clickHandler = _this2.previousCentury;
	          } else if (isNext) {
	            clickHandler = _this2.nextCentury;
	          } else {
	            clickHandler = chooseDecade.bind(_this2, dStartDecade);
	          }
	          return _react2['default'].createElement(
	            'td',
	            {
	              key: dStartDecade,
	              onClick: clickHandler,
	              role: 'gridcell',
	              className: (0, _classnames2['default'])(classNameMap)
	            },
	            _react2['default'].createElement(
	              'a',
	              {
	                className: prefixCls + '-decade'
	              },
	              content
	            )
	          );
	        });
	        return _react2['default'].createElement(
	          'tr',
	          { key: decadeIndex, role: 'row' },
	          tds
	        );
	      });
	
	      return _react2['default'].createElement(
	        'div',
	        { className: this.prefixCls },
	        _react2['default'].createElement(
	          'div',
	          { className: prefixCls + '-header' },
	          _react2['default'].createElement('a', {
	            className: prefixCls + '-prev-century-btn',
	            role: 'button',
	            onClick: this.previousCentury,
	            title: locale.previousCentury
	          }),
	          _react2['default'].createElement(
	            'div',
	            { className: prefixCls + '-century' },
	            startYear,
	            '-',
	            endYear
	          ),
	          _react2['default'].createElement('a', {
	            className: prefixCls + '-next-century-btn',
	            role: 'button',
	            onClick: this.nextCentury,
	            title: locale.nextCentury
	          })
	        ),
	        _react2['default'].createElement(
	          'div',
	          { className: prefixCls + '-body' },
	          _react2['default'].createElement(
	            'table',
	            { className: prefixCls + '-table', cellSpacing: '0', role: 'grid' },
	            _react2['default'].createElement(
	              'tbody',
	              { className: prefixCls + '-tbody' },
	              decadesEls
	            )
	          )
	        )
	      );
	    }
	  }]);
	  return DecadePanel;
	}(_react2['default'].Component);
	
	exports['default'] = DecadePanel;
	
	
	DecadePanel.propTypes = {
	  locale: _propTypes2['default'].object,
	  value: _propTypes2['default'].object,
	  defaultValue: _propTypes2['default'].object,
	  rootPrefixCls: _propTypes2['default'].string
	};
	
	DecadePanel.defaultProps = {
	  onSelect: function onSelect() {}
	};
	module.exports = exports['default'];

/***/ }),
/* 667 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _util = __webpack_require__(44);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function noop() {}
	
	var CalendarHeader = function (_Component) {
	  (0, _inherits3['default'])(CalendarHeader, _Component);
	
	  function CalendarHeader() {
	    (0, _classCallCheck3['default'])(this, CalendarHeader);
	    return (0, _possibleConstructorReturn3['default'])(this, (CalendarHeader.__proto__ || Object.getPrototypeOf(CalendarHeader)).apply(this, arguments));
	  }
	
	  (0, _createClass3['default'])(CalendarHeader, [{
	    key: 'onYearChange',
	    value: function onYearChange(year) {
	      var newValue = this.props.value.clone();
	      newValue.year(parseInt(year, 10));
	      this.props.onValueChange(newValue);
	    }
	  }, {
	    key: 'onMonthChange',
	    value: function onMonthChange(month) {
	      var newValue = this.props.value.clone();
	      newValue.month(parseInt(month, 10));
	      this.props.onValueChange(newValue);
	    }
	  }, {
	    key: 'yearSelectElement',
	    value: function yearSelectElement(year) {
	      var _props = this.props,
	          yearSelectOffset = _props.yearSelectOffset,
	          yearSelectTotal = _props.yearSelectTotal,
	          prefixCls = _props.prefixCls,
	          Select = _props.Select;
	
	      var start = year - yearSelectOffset;
	      var end = start + yearSelectTotal;
	
	      var options = [];
	      for (var index = start; index < end; index++) {
	        options.push(_react2['default'].createElement(
	          Select.Option,
	          { key: '' + index },
	          index
	        ));
	      }
	      return _react2['default'].createElement(
	        Select,
	        {
	          className: prefixCls + '-header-year-select',
	          onChange: this.onYearChange.bind(this),
	          dropdownStyle: { zIndex: 2000 },
	          dropdownMenuStyle: { maxHeight: 250, overflow: 'auto', fontSize: 12 },
	          optionLabelProp: 'children',
	          value: String(year),
	          showSearch: false
	        },
	        options
	      );
	    }
	  }, {
	    key: 'monthSelectElement',
	    value: function monthSelectElement(month) {
	      var props = this.props;
	      var t = props.value.clone();
	      var prefixCls = props.prefixCls;
	
	      var options = [];
	      var Select = props.Select;
	
	      for (var index = 0; index < 12; index++) {
	        t.month(index);
	        options.push(_react2['default'].createElement(
	          Select.Option,
	          { key: '' + index },
	          (0, _util.getMonthName)(t)
	        ));
	      }
	
	      return _react2['default'].createElement(
	        Select,
	        {
	          className: prefixCls + '-header-month-select',
	          dropdownStyle: { zIndex: 2000 },
	          dropdownMenuStyle: { maxHeight: 250, overflow: 'auto', overflowX: 'hidden', fontSize: 12 },
	          optionLabelProp: 'children',
	          value: String(month),
	          showSearch: false,
	          onChange: this.onMonthChange.bind(this)
	        },
	        options
	      );
	    }
	  }, {
	    key: 'changeTypeToDate',
	    value: function changeTypeToDate() {
	      this.props.onTypeChange('date');
	    }
	  }, {
	    key: 'changeTypeToMonth',
	    value: function changeTypeToMonth() {
	      this.props.onTypeChange('month');
	    }
	  }, {
	    key: 'render',
	    value: function render() {
	      var _props2 = this.props,
	          value = _props2.value,
	          locale = _props2.locale,
	          prefixCls = _props2.prefixCls,
	          type = _props2.type,
	          showTypeSwitch = _props2.showTypeSwitch,
	          headerComponents = _props2.headerComponents;
	
	      var year = value.year();
	      var month = value.month();
	      var yearSelect = this.yearSelectElement(year);
	      var monthSelect = type === 'month' ? null : this.monthSelectElement(month);
	      var switchCls = prefixCls + '-header-switcher';
	      var typeSwitcher = showTypeSwitch ? _react2['default'].createElement(
	        'span',
	        { className: switchCls },
	        type === 'date' ? _react2['default'].createElement(
	          'span',
	          { className: switchCls + '-focus' },
	          locale.month
	        ) : _react2['default'].createElement(
	          'span',
	          {
	            onClick: this.changeTypeToDate.bind(this),
	            className: switchCls + '-normal'
	          },
	          locale.month
	        ),
	        type === 'month' ? _react2['default'].createElement(
	          'span',
	          { className: switchCls + '-focus' },
	          locale.year
	        ) : _react2['default'].createElement(
	          'span',
	          {
	            onClick: this.changeTypeToMonth.bind(this),
	            className: switchCls + '-normal'
	          },
	          locale.year
	        )
	      ) : null;
	
	      return _react2['default'].createElement(
	        'div',
	        { className: prefixCls + '-header' },
	        typeSwitcher,
	        monthSelect,
	        yearSelect,
	        headerComponents
	      );
	    }
	  }]);
	  return CalendarHeader;
	}(_react.Component);
	
	CalendarHeader.propTypes = {
	  value: _propTypes2['default'].object,
	  locale: _propTypes2['default'].object,
	  yearSelectOffset: _propTypes2['default'].number,
	  yearSelectTotal: _propTypes2['default'].number,
	  onValueChange: _propTypes2['default'].func,
	  onTypeChange: _propTypes2['default'].func,
	  Select: _propTypes2['default'].func,
	  prefixCls: _propTypes2['default'].string,
	  type: _propTypes2['default'].string,
	  showTypeSwitch: _propTypes2['default'].bool,
	  headerComponents: _propTypes2['default'].array
	};
	CalendarHeader.defaultProps = {
	  yearSelectOffset: 10,
	  yearSelectTotal: 20,
	  onValueChange: noop,
	  onTypeChange: noop
	};
	
	exports['default'] = CalendarHeader;
	module.exports = exports['default'];

/***/ }),
/* 668 */
/***/ (function(module, exports) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	var autoAdjustOverflow = {
	  adjustX: 1,
	  adjustY: 1
	};
	
	var targetOffset = [0, 0];
	
	var placements = {
	  bottomLeft: {
	    points: ['tl', 'tl'],
	    overflow: autoAdjustOverflow,
	    offset: [0, -3],
	    targetOffset: targetOffset
	  },
	  bottomRight: {
	    points: ['tr', 'tr'],
	    overflow: autoAdjustOverflow,
	    offset: [0, -3],
	    targetOffset: targetOffset
	  },
	  topRight: {
	    points: ['br', 'br'],
	    overflow: autoAdjustOverflow,
	    offset: [0, 3],
	    targetOffset: targetOffset
	  },
	  topLeft: {
	    points: ['bl', 'bl'],
	    overflow: autoAdjustOverflow,
	    offset: [0, 3],
	    targetOffset: targetOffset
	  }
	};
	
	exports['default'] = placements;
	module.exports = exports['default'];

/***/ }),
/* 669 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _createReactClass = __webpack_require__(14);
	
	var _createReactClass2 = _interopRequireDefault(_createReactClass);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _CalendarHeader = __webpack_require__(243);
	
	var _CalendarHeader2 = _interopRequireDefault(_CalendarHeader);
	
	var _DateTable = __webpack_require__(143);
	
	var _DateTable2 = _interopRequireDefault(_DateTable);
	
	var _DateInput = __webpack_require__(248);
	
	var _DateInput2 = _interopRequireDefault(_DateInput);
	
	var _index = __webpack_require__(44);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var CalendarPart = (0, _createReactClass2['default'])({
	  displayName: 'CalendarPart',
	
	  propTypes: {
	    prefixCls: _propTypes2['default'].string,
	    value: _propTypes2['default'].any,
	    hoverValue: _propTypes2['default'].any,
	    selectedValue: _propTypes2['default'].any,
	    direction: _propTypes2['default'].any,
	    locale: _propTypes2['default'].any,
	    showTimePicker: _propTypes2['default'].bool,
	    format: _propTypes2['default'].any,
	    placeholder: _propTypes2['default'].any,
	    disabledDate: _propTypes2['default'].any,
	    timePicker: _propTypes2['default'].any,
	    disabledTime: _propTypes2['default'].any,
	    onInputSelect: _propTypes2['default'].func,
	    timePickerDisabledTime: _propTypes2['default'].object,
	    enableNext: _propTypes2['default'].any,
	    enablePrev: _propTypes2['default'].any
	  },
	  render: function render() {
	    var props = this.props;
	    var prefixCls = props.prefixCls,
	        value = props.value,
	        hoverValue = props.hoverValue,
	        selectedValue = props.selectedValue,
	        direction = props.direction,
	        locale = props.locale,
	        format = props.format,
	        placeholder = props.placeholder,
	        disabledDate = props.disabledDate,
	        timePicker = props.timePicker,
	        disabledTime = props.disabledTime,
	        timePickerDisabledTime = props.timePickerDisabledTime,
	        showTimePicker = props.showTimePicker,
	        onInputSelect = props.onInputSelect,
	        enablePrev = props.enablePrev,
	        enableNext = props.enableNext;
	
	    var shouldShowTimePicker = showTimePicker && timePicker;
	    var disabledTimeConfig = shouldShowTimePicker && disabledTime ? (0, _index.getTimeConfig)(selectedValue, disabledTime) : null;
	    var rangeClassName = prefixCls + '-range';
	    var newProps = {
	      locale: locale,
	      value: value,
	      prefixCls: prefixCls,
	      showTimePicker: showTimePicker
	    };
	    var index = direction === 'left' ? 0 : 1;
	    var timePickerEle = shouldShowTimePicker && _react2['default'].cloneElement(timePicker, (0, _extends3['default'])({
	      showHour: true,
	      showMinute: true,
	      showSecond: true
	    }, timePicker.props, disabledTimeConfig, timePickerDisabledTime, {
	      onChange: onInputSelect,
	      defaultOpenValue: value,
	      value: selectedValue[index]
	    }));
	    return _react2['default'].createElement(
	      'div',
	      { className: rangeClassName + '-part ' + rangeClassName + '-' + direction },
	      _react2['default'].createElement(_DateInput2['default'], {
	        format: format,
	        locale: locale,
	        prefixCls: prefixCls,
	        timePicker: timePicker,
	        disabledDate: disabledDate,
	        placeholder: placeholder,
	        disabledTime: disabledTime,
	        value: value,
	        showClear: false,
	        selectedValue: selectedValue[index],
	        onChange: onInputSelect
	      }),
	      _react2['default'].createElement(
	        'div',
	        { style: { outline: 'none' } },
	        _react2['default'].createElement(_CalendarHeader2['default'], (0, _extends3['default'])({}, newProps, {
	          enableNext: enableNext,
	          enablePrev: enablePrev,
	          onValueChange: props.onValueChange,
	          onPanelChange: props.onPanelChange,
	          disabledMonth: props.disabledMonth
	        })),
	        showTimePicker ? _react2['default'].createElement(
	          'div',
	          { className: prefixCls + '-time-picker' },
	          _react2['default'].createElement(
	            'div',
	            { className: prefixCls + '-time-picker-panel' },
	            timePickerEle
	          )
	        ) : null,
	        _react2['default'].createElement(
	          'div',
	          { className: prefixCls + '-body' },
	          _react2['default'].createElement(_DateTable2['default'], (0, _extends3['default'])({}, newProps, {
	            hoverValue: hoverValue,
	            selectedValue: selectedValue,
	            dateRender: props.dateRender,
	            onSelect: props.onSelect,
	            onDayHover: props.onDayHover,
	            disabledDate: disabledDate,
	            showWeekNumber: props.showWeekNumber
	          }))
	        )
	      )
	    );
	  }
	});
	
	exports['default'] = CalendarPart;
	module.exports = exports['default'];

/***/ }),
/* 670 */
/***/ (function(module, exports, __webpack_require__) {

	'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 _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _rcTrigger = __webpack_require__(53);
	
	var _rcTrigger2 = _interopRequireDefault(_rcTrigger);
	
	var _Menus = __webpack_require__(671);
	
	var _Menus2 = _interopRequireDefault(_Menus);
	
	var _KeyCode = __webpack_require__(29);
	
	var _KeyCode2 = _interopRequireDefault(_KeyCode);
	
	var _arrayTreeFilter = __webpack_require__(99);
	
	var _arrayTreeFilter2 = _interopRequireDefault(_arrayTreeFilter);
	
	var _arrays = __webpack_require__(803);
	
	var _arrays2 = _interopRequireDefault(_arrays);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
	
	function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return 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 _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
	
	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) : _defaults(subClass, superClass); }
	
	var BUILT_IN_PLACEMENTS = {
	  bottomLeft: {
	    points: ['tl', 'bl'],
	    offset: [0, 4],
	    overflow: {
	      adjustX: 1,
	      adjustY: 1
	    }
	  },
	  topLeft: {
	    points: ['bl', 'tl'],
	    offset: [0, -4],
	    overflow: {
	      adjustX: 1,
	      adjustY: 1
	    }
	  },
	  bottomRight: {
	    points: ['tr', 'br'],
	    offset: [0, 4],
	    overflow: {
	      adjustX: 1,
	      adjustY: 1
	    }
	  },
	  topRight: {
	    points: ['br', 'tr'],
	    offset: [0, -4],
	    overflow: {
	      adjustX: 1,
	      adjustY: 1
	    }
	  }
	};
	
	var Cascader = function (_Component) {
	  _inherits(Cascader, _Component);
	
	  function Cascader(props) {
	    _classCallCheck(this, Cascader);
	
	    var _this = _possibleConstructorReturn(this, _Component.call(this, props));
	
	    _this.setPopupVisible = function (popupVisible) {
	      if (!('popupVisible' in _this.props)) {
	        _this.setState({ popupVisible: popupVisible });
	      }
	      // sync activeValue with value when panel open
	      if (popupVisible && !_this.state.visible) {
	        _this.setState({
	          activeValue: _this.state.value
	        });
	      }
	      _this.props.onPopupVisibleChange(popupVisible);
	    };
	
	    _this.handleChange = function (options, setProps, e) {
	      if (e.type !== 'keydown' || e.keyCode === _KeyCode2["default"].ENTER) {
	        _this.props.onChange(options.map(function (o) {
	          return o.value;
	        }), options);
	        _this.setPopupVisible(setProps.visible);
	      }
	    };
	
	    _this.handlePopupVisibleChange = function (popupVisible) {
	      _this.setPopupVisible(popupVisible);
	    };
	
	    _this.handleMenuSelect = function (targetOption, menuIndex, e) {
	      if (e && e.preventDefault) {
	        e.preventDefault();
	      }
	      // Keep focused state for keyboard support
	      var triggerNode = _this.refs.trigger.getRootDomNode();
	      if (triggerNode && triggerNode.focus) {
	        triggerNode.focus();
	      }
	      var _this$props = _this.props,
	          changeOnSelect = _this$props.changeOnSelect,
	          loadData = _this$props.loadData,
	          expandTrigger = _this$props.expandTrigger;
	
	      if (!targetOption || targetOption.disabled) {
	        return;
	      }
	      var activeValue = _this.state.activeValue;
	
	      activeValue = activeValue.slice(0, menuIndex + 1);
	      activeValue[menuIndex] = targetOption.value;
	      var activeOptions = _this.getActiveOptions(activeValue);
	      if (targetOption.isLeaf === false && !targetOption.children && loadData) {
	        if (changeOnSelect) {
	          _this.handleChange(activeOptions, { visible: true }, e);
	        }
	        _this.setState({ activeValue: activeValue });
	        loadData(activeOptions);
	        return;
	      }
	      var newState = {};
	      if (!targetOption.children || !targetOption.children.length) {
	        _this.handleChange(activeOptions, { visible: false }, e);
	        // set value to activeValue when select leaf option
	        newState.value = activeValue;
	        // add e.type judgement to prevent `onChange` being triggered by mouseEnter
	      } else if (changeOnSelect && (e.type === 'click' || e.type === 'keydown')) {
	        if (expandTrigger === 'hover') {
	          _this.handleChange(activeOptions, { visible: false }, e);
	        } else {
	          _this.handleChange(activeOptions, { visible: true }, e);
	        }
	        // set value to activeValue on every select
	        newState.value = activeValue;
	      }
	      newState.activeValue = activeValue;
	      //  not change the value by keyboard
	      if ('value' in _this.props || e.type === 'keydown' && e.keyCode !== _KeyCode2["default"].ENTER) {
	        delete newState.value;
	      }
	      _this.setState(newState);
	    };
	
	    _this.handleKeyDown = function (e) {
	      var children = _this.props.children;
	      // https://github.com/ant-design/ant-design/issues/6717
	      // Don't bind keyboard support when children specify the onKeyDown
	
	      if (children && children.props.onKeyDown) {
	        children.props.onKeyDown(e);
	        return;
	      }
	      var activeValue = [].concat(_toConsumableArray(_this.state.activeValue));
	      var currentLevel = activeValue.length - 1 < 0 ? 0 : activeValue.length - 1;
	      var currentOptions = _this.getCurrentLevelOptions();
	      var currentIndex = currentOptions.map(function (o) {
	        return o.value;
	      }).indexOf(activeValue[currentLevel]);
	      if (e.keyCode !== _KeyCode2["default"].DOWN && e.keyCode !== _KeyCode2["default"].UP && e.keyCode !== _KeyCode2["default"].LEFT && e.keyCode !== _KeyCode2["default"].RIGHT && e.keyCode !== _KeyCode2["default"].ENTER && e.keyCode !== _KeyCode2["default"].BACKSPACE && e.keyCode !== _KeyCode2["default"].ESC) {
	        return;
	      }
	      // Press any keys above to reopen menu
	      if (!_this.state.popupVisible && e.keyCode !== _KeyCode2["default"].BACKSPACE && e.keyCode !== _KeyCode2["default"].ESC) {
	        _this.setPopupVisible(true);
	        return;
	      }
	      if (e.keyCode === _KeyCode2["default"].DOWN || e.keyCode === _KeyCode2["default"].UP) {
	        var nextIndex = currentIndex;
	        if (nextIndex !== -1) {
	          if (e.keyCode === _KeyCode2["default"].DOWN) {
	            nextIndex += 1;
	            nextIndex = nextIndex >= currentOptions.length ? 0 : nextIndex;
	          } else {
	            nextIndex -= 1;
	            nextIndex = nextIndex < 0 ? currentOptions.length - 1 : nextIndex;
	          }
	        } else {
	          nextIndex = 0;
	        }
	        activeValue[currentLevel] = currentOptions[nextIndex].value;
	      } else if (e.keyCode === _KeyCode2["default"].LEFT || e.keyCode === _KeyCode2["default"].BACKSPACE) {
	        activeValue.splice(activeValue.length - 1, 1);
	      } else if (e.keyCode === _KeyCode2["default"].RIGHT) {
	        if (currentOptions[currentIndex] && currentOptions[currentIndex].children) {
	          activeValue.push(currentOptions[currentIndex].children[0].value);
	        }
	      } else if (e.keyCode === _KeyCode2["default"].ESC) {
	        _this.setPopupVisible(false);
	        return;
	      }
	      if (!activeValue || activeValue.length === 0) {
	        _this.setPopupVisible(false);
	      }
	      var activeOptions = _this.getActiveOptions(activeValue);
	      var targetOption = activeOptions[activeOptions.length - 1];
	      _this.handleMenuSelect(targetOption, activeOptions.length - 1, e);
	
	      if (_this.props.onKeyDown) {
	        _this.props.onKeyDown(e);
	      }
	    };
	
	    var initialValue = [];
	    if ('value' in props) {
	      initialValue = props.value || [];
	    } else if ('defaultValue' in props) {
	      initialValue = props.defaultValue || [];
	    }
	
	    _this.state = {
	      popupVisible: props.popupVisible,
	      activeValue: initialValue,
	      value: initialValue
	    };
	    return _this;
	  }
	
	  Cascader.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {
	    if ('value' in nextProps && !(0, _arrays2["default"])(this.props.value, nextProps.value)) {
	      var newValues = {
	        value: nextProps.value || [],
	        activeValue: nextProps.value || []
	      };
	      // allow activeValue diff from value
	      // https://github.com/ant-design/ant-design/issues/2767
	      if ('loadData' in nextProps) {
	        delete newValues.activeValue;
	      }
	      this.setState(newValues);
	    }
	    if ('popupVisible' in nextProps) {
	      this.setState({
	        popupVisible: nextProps.popupVisible
	      });
	    }
	  };
	
	  Cascader.prototype.getPopupDOMNode = function getPopupDOMNode() {
	    return this.refs.trigger.getPopupDomNode();
	  };
	
	  Cascader.prototype.getCurrentLevelOptions = function getCurrentLevelOptions() {
	    var options = this.props.options;
	    var _state$activeValue = this.state.activeValue,
	        activeValue = _state$activeValue === undefined ? [] : _state$activeValue;
	
	    var result = (0, _arrayTreeFilter2["default"])(options, function (o, level) {
	      return o.value === activeValue[level];
	    });
	    if (result[result.length - 2]) {
	      return result[result.length - 2].children;
	    }
	    return [].concat(_toConsumableArray(options)).filter(function (o) {
	      return !o.disabled;
	    });
	  };
	
	  Cascader.prototype.getActiveOptions = function getActiveOptions(activeValue) {
	    return (0, _arrayTreeFilter2["default"])(this.props.options, function (o, level) {
	      return o.value === activeValue[level];
	    });
	  };
	
	  Cascader.prototype.render = function render() {
	    var _props = this.props,
	        prefixCls = _props.prefixCls,
	        transitionName = _props.transitionName,
	        popupClassName = _props.popupClassName,
	        options = _props.options,
	        disabled = _props.disabled,
	        builtinPlacements = _props.builtinPlacements,
	        popupPlacement = _props.popupPlacement,
	        children = _props.children,
	        restProps = _objectWithoutProperties(_props, ['prefixCls', 'transitionName', 'popupClassName', 'options', 'disabled', 'builtinPlacements', 'popupPlacement', 'children']);
	    // Did not show popup when there is no options
	
	
	    var menus = _react2["default"].createElement('div', null);
	    var emptyMenuClassName = '';
	    if (options && options.length > 0) {
	      menus = _react2["default"].createElement(_Menus2["default"], _extends({}, this.props, {
	        value: this.state.value,
	        activeValue: this.state.activeValue,
	        onSelect: this.handleMenuSelect,
	        visible: this.state.popupVisible
	      }));
	    } else {
	      emptyMenuClassName = ' ' + prefixCls + '-menus-empty';
	    }
	    return _react2["default"].createElement(
	      _rcTrigger2["default"],
	      _extends({
	        ref: 'trigger'
	      }, restProps, {
	        options: options,
	        disabled: disabled,
	        popupPlacement: popupPlacement,
	        builtinPlacements: builtinPlacements,
	        popupTransitionName: transitionName,
	        action: disabled ? [] : ['click'],
	        popupVisible: disabled ? false : this.state.popupVisible,
	        onPopupVisibleChange: this.handlePopupVisibleChange,
	        prefixCls: prefixCls + '-menus',
	        popupClassName: popupClassName + emptyMenuClassName,
	        popup: menus
	      }),
	      (0, _react.cloneElement)(children, {
	        onKeyDown: this.handleKeyDown,
	        tabIndex: disabled ? undefined : 0
	      })
	    );
	  };
	
	  return Cascader;
	}(_react.Component);
	
	Cascader.defaultProps = {
	  options: [],
	  onChange: function onChange() {},
	  onPopupVisibleChange: function onPopupVisibleChange() {},
	
	  disabled: false,
	  transitionName: '',
	  prefixCls: 'rc-cascader',
	  popupClassName: '',
	  popupPlacement: 'bottomLeft',
	  builtinPlacements: BUILT_IN_PLACEMENTS,
	  expandTrigger: 'click'
	};
	
	Cascader.propTypes = {
	  value: _propTypes2["default"].array,
	  defaultValue: _propTypes2["default"].array,
	  options: _propTypes2["default"].array.isRequired,
	  onChange: _propTypes2["default"].func,
	  onPopupVisibleChange: _propTypes2["default"].func,
	  popupVisible: _propTypes2["default"].bool,
	  disabled: _propTypes2["default"].bool,
	  transitionName: _propTypes2["default"].string,
	  popupClassName: _propTypes2["default"].string,
	  popupPlacement: _propTypes2["default"].string,
	  prefixCls: _propTypes2["default"].string,
	  dropdownMenuColumnStyle: _propTypes2["default"].object,
	  builtinPlacements: _propTypes2["default"].object,
	  loadData: _propTypes2["default"].func,
	  changeOnSelect: _propTypes2["default"].bool,
	  children: _propTypes2["default"].node,
	  onKeyDown: _propTypes2["default"].func,
	  expandTrigger: _propTypes2["default"].string
	};
	
	exports["default"] = Cascader;
	module.exports = exports['default'];

/***/ }),
/* 671 */
/***/ (function(module, exports, __webpack_require__) {

	'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 _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _arrayTreeFilter = __webpack_require__(99);
	
	var _arrayTreeFilter2 = _interopRequireDefault(_arrayTreeFilter);
	
	var _reactDom = __webpack_require__(10);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
	
	function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(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) : _defaults(subClass, superClass); }
	
	var Menus = function (_React$Component) {
	  _inherits(Menus, _React$Component);
	
	  function Menus() {
	    _classCallCheck(this, Menus);
	
	    return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	  }
	
	  Menus.prototype.componentDidMount = function componentDidMount() {
	    this.scrollActiveItemToView();
	  };
	
	  Menus.prototype.componentDidUpdate = function componentDidUpdate(prevProps) {
	    if (!prevProps.visible && this.props.visible) {
	      this.scrollActiveItemToView();
	    }
	  };
	
	  Menus.prototype.getOption = function getOption(option, menuIndex) {
	    var _props = this.props,
	        prefixCls = _props.prefixCls,
	        expandTrigger = _props.expandTrigger;
	
	    var onSelect = this.props.onSelect.bind(this, option, menuIndex);
	    var expandProps = {
	      onClick: onSelect
	    };
	    var menuItemCls = prefixCls + '-menu-item';
	    var hasChildren = option.children && option.children.length > 0;
	    if (hasChildren || option.isLeaf === false) {
	      menuItemCls += ' ' + prefixCls + '-menu-item-expand';
	    }
	    if (expandTrigger === 'hover' && hasChildren) {
	      expandProps = {
	        onMouseEnter: this.delayOnSelect.bind(this, onSelect),
	        onMouseLeave: this.delayOnSelect.bind(this),
	        onClick: onSelect
	      };
	    }
	    if (this.isActiveOption(option, menuIndex)) {
	      menuItemCls += ' ' + prefixCls + '-menu-item-active';
	      expandProps.ref = 'activeItem' + menuIndex;
	    }
	    if (option.disabled) {
	      menuItemCls += ' ' + prefixCls + '-menu-item-disabled';
	    }
	    if (option.loading) {
	      menuItemCls += ' ' + prefixCls + '-menu-item-loading';
	    }
	    var title = '';
	    if (option.title) {
	      title = option.title;
	    } else if (typeof option.label === 'string') {
	      title = option.label;
	    }
	    return _react2["default"].createElement(
	      'li',
	      _extends({
	        key: option.value,
	        className: menuItemCls,
	        title: title
	      }, expandProps),
	      option.label
	    );
	  };
	
	  Menus.prototype.getActiveOptions = function getActiveOptions(values) {
	    var activeValue = values || this.props.activeValue;
	    var options = this.props.options;
	    return (0, _arrayTreeFilter2["default"])(options, function (o, level) {
	      return o.value === activeValue[level];
	    });
	  };
	
	  Menus.prototype.getShowOptions = function getShowOptions() {
	    var options = this.props.options;
	
	    var result = this.getActiveOptions().map(function (activeOption) {
	      return activeOption.children;
	    }).filter(function (activeOption) {
	      return !!activeOption;
	    });
	    result.unshift(options);
	    return result;
	  };
	
	  Menus.prototype.delayOnSelect = function delayOnSelect(onSelect) {
	    var _this2 = this;
	
	    for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
	      args[_key - 1] = arguments[_key];
	    }
	
	    if (this.delayTimer) {
	      clearTimeout(this.delayTimer);
	      this.delayTimer = null;
	    }
	    if (typeof onSelect === 'function') {
	      this.delayTimer = setTimeout(function () {
	        onSelect(args);
	        _this2.delayTimer = null;
	      }, 150);
	    }
	  };
	
	  Menus.prototype.scrollActiveItemToView = function scrollActiveItemToView() {
	    // scroll into view
	    var optionsLength = this.getShowOptions().length;
	    for (var i = 0; i < optionsLength; i++) {
	      var itemComponent = this.refs['activeItem' + i];
	      if (itemComponent) {
	        var target = (0, _reactDom.findDOMNode)(itemComponent);
	        target.parentNode.scrollTop = target.offsetTop;
	      }
	    }
	  };
	
	  Menus.prototype.isActiveOption = function isActiveOption(option, menuIndex) {
	    var _props$activeValue = this.props.activeValue,
	        activeValue = _props$activeValue === undefined ? [] : _props$activeValue;
	
	    return activeValue[menuIndex] === option.value;
	  };
	
	  Menus.prototype.render = function render() {
	    var _this3 = this;
	
	    var _props2 = this.props,
	        prefixCls = _props2.prefixCls,
	        dropdownMenuColumnStyle = _props2.dropdownMenuColumnStyle;
	
	    return _react2["default"].createElement(
	      'div',
	      null,
	      this.getShowOptions().map(function (options, menuIndex) {
	        return _react2["default"].createElement(
	          'ul',
	          { className: prefixCls + '-menu', key: menuIndex, style: dropdownMenuColumnStyle },
	          options.map(function (option) {
	            return _this3.getOption(option, menuIndex);
	          })
	        );
	      })
	    );
	  };
	
	  return Menus;
	}(_react2["default"].Component);
	
	Menus.defaultProps = {
	  options: [],
	  value: [],
	  activeValue: [],
	  onSelect: function onSelect() {},
	
	  prefixCls: 'rc-cascader-menus',
	  visible: false,
	  expandTrigger: 'click'
	};
	
	Menus.propTypes = {
	  value: _propTypes2["default"].array,
	  activeValue: _propTypes2["default"].array,
	  options: _propTypes2["default"].array.isRequired,
	  prefixCls: _propTypes2["default"].string,
	  expandTrigger: _propTypes2["default"].string,
	  onSelect: _propTypes2["default"].func,
	  visible: _propTypes2["default"].bool,
	  dropdownMenuColumnStyle: _propTypes2["default"].object
	};
	
	exports["default"] = Menus;
	module.exports = exports['default'];

/***/ }),
/* 672 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _Cascader = __webpack_require__(670);
	
	var _Cascader2 = _interopRequireDefault(_Cascader);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
	
	exports["default"] = _Cascader2["default"]; // export this package's api
	
	module.exports = exports['default'];

/***/ }),
/* 673 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _objectWithoutProperties2 = __webpack_require__(20);
	
	var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _PureRenderMixin = __webpack_require__(78);
	
	var _PureRenderMixin2 = _interopRequireDefault(_PureRenderMixin);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var Checkbox = function (_React$Component) {
	  (0, _inherits3['default'])(Checkbox, _React$Component);
	
	  function Checkbox(props) {
	    (0, _classCallCheck3['default'])(this, Checkbox);
	
	    var _this = (0, _possibleConstructorReturn3['default'])(this, (Checkbox.__proto__ || Object.getPrototypeOf(Checkbox)).call(this, props));
	
	    _initialiseProps.call(_this);
	
	    var checked = 'checked' in props ? props.checked : props.defaultChecked;
	
	    _this.state = {
	      checked: checked
	    };
	    return _this;
	  }
	
	  (0, _createClass3['default'])(Checkbox, [{
	    key: 'componentWillReceiveProps',
	    value: function componentWillReceiveProps(nextProps) {
	      if ('checked' in nextProps) {
	        this.setState({
	          checked: nextProps.checked
	        });
	      }
	    }
	  }, {
	    key: 'shouldComponentUpdate',
	    value: function shouldComponentUpdate() {
	      for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
	        args[_key] = arguments[_key];
	      }
	
	      return _PureRenderMixin2['default'].shouldComponentUpdate.apply(this, args);
	    }
	  }, {
	    key: 'render',
	    value: function render() {
	      var _classNames;
	
	      var _props = this.props,
	          prefixCls = _props.prefixCls,
	          className = _props.className,
	          style = _props.style,
	          name = _props.name,
	          type = _props.type,
	          disabled = _props.disabled,
	          readOnly = _props.readOnly,
	          tabIndex = _props.tabIndex,
	          onClick = _props.onClick,
	          onFocus = _props.onFocus,
	          onBlur = _props.onBlur,
	          others = (0, _objectWithoutProperties3['default'])(_props, ['prefixCls', 'className', 'style', 'name', 'type', 'disabled', 'readOnly', 'tabIndex', 'onClick', 'onFocus', 'onBlur']);
	
	
	      var globalProps = Object.keys(others).reduce(function (prev, key) {
	        if (key.substr(0, 5) === 'aria-' || key.substr(0, 5) === 'data-' || key === 'role') {
	          prev[key] = others[key];
	        }
	        return prev;
	      }, {});
	
	      var checked = this.state.checked;
	
	      var classString = (0, _classnames2['default'])(prefixCls, className, (_classNames = {}, (0, _defineProperty3['default'])(_classNames, prefixCls + '-checked', checked), (0, _defineProperty3['default'])(_classNames, prefixCls + '-disabled', disabled), _classNames));
	
	      return _react2['default'].createElement(
	        'span',
	        { className: classString, style: style },
	        _react2['default'].createElement('input', (0, _extends3['default'])({
	          name: name,
	          type: type,
	          readOnly: readOnly,
	          disabled: disabled,
	          tabIndex: tabIndex,
	          className: prefixCls + '-input',
	          checked: !!checked,
	          onClick: onClick,
	          onFocus: onFocus,
	          onBlur: onBlur,
	          onChange: this.handleChange
	        }, globalProps)),
	        _react2['default'].createElement('span', { className: prefixCls + '-inner' })
	      );
	    }
	  }]);
	  return Checkbox;
	}(_react2['default'].Component);
	
	Checkbox.propTypes = {
	  prefixCls: _propTypes2['default'].string,
	  className: _propTypes2['default'].string,
	  style: _propTypes2['default'].object,
	  name: _propTypes2['default'].string,
	  type: _propTypes2['default'].string,
	  defaultChecked: _propTypes2['default'].oneOfType([_propTypes2['default'].number, _propTypes2['default'].bool]),
	  checked: _propTypes2['default'].oneOfType([_propTypes2['default'].number, _propTypes2['default'].bool]),
	  disabled: _propTypes2['default'].bool,
	  onFocus: _propTypes2['default'].func,
	  onBlur: _propTypes2['default'].func,
	  onChange: _propTypes2['default'].func,
	  onClick: _propTypes2['default'].func,
	  tabIndex: _propTypes2['default'].string,
	  readOnly: _propTypes2['default'].bool
	};
	Checkbox.defaultProps = {
	  prefixCls: 'rc-checkbox',
	  className: '',
	  style: {},
	  type: 'checkbox',
	  defaultChecked: false,
	  onFocus: function onFocus() {},
	  onBlur: function onBlur() {},
	  onChange: function onChange() {}
	};
	
	var _initialiseProps = function _initialiseProps() {
	  var _this2 = this;
	
	  this.handleChange = function (e) {
	    var props = _this2.props;
	
	    if (props.disabled) {
	      return;
	    }
	    if (!('checked' in props)) {
	      _this2.setState({
	        checked: e.target.checked
	      });
	    }
	    props.onChange({
	      target: (0, _extends3['default'])({}, props, {
	        checked: e.target.checked
	      }),
	      stopPropagation: function stopPropagation() {
	        e.stopPropagation();
	      },
	      preventDefault: function preventDefault() {
	        e.preventDefault();
	      }
	    });
	  };
	};
	
	exports['default'] = Checkbox;
	module.exports = exports['default'];

/***/ }),
/* 674 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _Panel = __webpack_require__(675);
	
	var _Panel2 = _interopRequireDefault(_Panel);
	
	var _openAnimationFactory = __webpack_require__(678);
	
	var _openAnimationFactory2 = _interopRequireDefault(_openAnimationFactory);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	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 _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
	
	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 toArray(activeKey) {
	  var currentActiveKey = activeKey;
	  if (!Array.isArray(currentActiveKey)) {
	    currentActiveKey = currentActiveKey ? [currentActiveKey] : [];
	  }
	  return currentActiveKey;
	}
	
	var Collapse = function (_Component) {
	  _inherits(Collapse, _Component);
	
	  function Collapse(props) {
	    _classCallCheck(this, Collapse);
	
	    var _this = _possibleConstructorReturn(this, (Collapse.__proto__ || Object.getPrototypeOf(Collapse)).call(this, props));
	
	    var _this$props = _this.props,
	        activeKey = _this$props.activeKey,
	        defaultActiveKey = _this$props.defaultActiveKey;
	
	    var currentActiveKey = defaultActiveKey;
	    if ('activeKey' in _this.props) {
	      currentActiveKey = activeKey;
	    }
	
	    _this.state = {
	      openAnimation: _this.props.openAnimation || (0, _openAnimationFactory2['default'])(_this.props.prefixCls),
	      activeKey: toArray(currentActiveKey)
	    };
	    return _this;
	  }
	
	  _createClass(Collapse, [{
	    key: 'componentWillReceiveProps',
	    value: function componentWillReceiveProps(nextProps) {
	      if ('activeKey' in nextProps) {
	        this.setState({
	          activeKey: toArray(nextProps.activeKey)
	        });
	      }
	      if ('openAnimation' in nextProps) {
	        this.setState({
	          openAnimation: nextProps.openAnimation
	        });
	      }
	    }
	  }, {
	    key: 'onClickItem',
	    value: function onClickItem(key) {
	      var activeKey = this.state.activeKey;
	      if (this.props.accordion) {
	        activeKey = activeKey[0] === key ? [] : [key];
	      } else {
	        activeKey = [].concat(_toConsumableArray(activeKey));
	        var index = activeKey.indexOf(key);
	        var isActive = index > -1;
	        if (isActive) {
	          // remove active state
	          activeKey.splice(index, 1);
	        } else {
	          activeKey.push(key);
	        }
	      }
	      this.setActiveKey(activeKey);
	    }
	  }, {
	    key: 'getItems',
	    value: function getItems() {
	      var _this2 = this;
	
	      var activeKey = this.state.activeKey;
	      var _props = this.props,
	          prefixCls = _props.prefixCls,
	          accordion = _props.accordion,
	          destroyInactivePanel = _props.destroyInactivePanel;
	
	      var newChildren = [];
	
	      _react.Children.forEach(this.props.children, function (child, index) {
	        if (!child) return;
	        // If there is no key provide, use the panel order as default key
	        var key = child.key || String(index);
	        var _child$props = child.props,
	            header = _child$props.header,
	            headerClass = _child$props.headerClass,
	            disabled = _child$props.disabled;
	
	        var isActive = false;
	        if (accordion) {
	          isActive = activeKey[0] === key;
	        } else {
	          isActive = activeKey.indexOf(key) > -1;
	        }
	
	        var props = {
	          key: key,
	          header: header,
	          headerClass: headerClass,
	          isActive: isActive,
	          prefixCls: prefixCls,
	          destroyInactivePanel: destroyInactivePanel,
	          openAnimation: _this2.state.openAnimation,
	          children: child.props.children,
	          onItemClick: disabled ? null : function () {
	            return _this2.onClickItem(key);
	          }
	        };
	
	        newChildren.push(_react2['default'].cloneElement(child, props));
	      });
	
	      return newChildren;
	    }
	  }, {
	    key: 'setActiveKey',
	    value: function setActiveKey(activeKey) {
	      if (!('activeKey' in this.props)) {
	        this.setState({ activeKey: activeKey });
	      }
	      this.props.onChange(this.props.accordion ? activeKey[0] : activeKey);
	    }
	  }, {
	    key: 'render',
	    value: function render() {
	      var _classNames;
	
	      var _props2 = this.props,
	          prefixCls = _props2.prefixCls,
	          className = _props2.className,
	          style = _props2.style;
	
	      var collapseClassName = (0, _classnames2['default'])((_classNames = {}, _defineProperty(_classNames, prefixCls, true), _defineProperty(_classNames, className, !!className), _classNames));
	      return _react2['default'].createElement(
	        'div',
	        { className: collapseClassName, style: style },
	        this.getItems()
	      );
	    }
	  }]);
	
	  return Collapse;
	}(_react.Component);
	
	Collapse.propTypes = {
	  children: _propTypes2['default'].any,
	  prefixCls: _propTypes2['default'].string,
	  activeKey: _propTypes2['default'].oneOfType([_propTypes2['default'].string, _propTypes2['default'].arrayOf(_propTypes2['default'].string)]),
	  defaultActiveKey: _propTypes2['default'].oneOfType([_propTypes2['default'].string, _propTypes2['default'].arrayOf(_propTypes2['default'].string)]),
	  openAnimation: _propTypes2['default'].object,
	  onChange: _propTypes2['default'].func,
	  accordion: _propTypes2['default'].bool,
	  className: _propTypes2['default'].string,
	  style: _propTypes2['default'].object,
	  destroyInactivePanel: _propTypes2['default'].bool
	};
	
	Collapse.defaultProps = {
	  prefixCls: 'rc-collapse',
	  onChange: function onChange() {},
	
	  accordion: false,
	  destroyInactivePanel: false
	};
	
	Collapse.Panel = _Panel2['default'];
	
	exports['default'] = Collapse;
	module.exports = exports['default'];

/***/ }),
/* 675 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _PanelContent = __webpack_require__(676);
	
	var _PanelContent2 = _interopRequireDefault(_PanelContent);
	
	var _rcAnimate = __webpack_require__(22);
	
	var _rcAnimate2 = _interopRequireDefault(_rcAnimate);
	
	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 CollapsePanel = function (_Component) {
	  _inherits(CollapsePanel, _Component);
	
	  function CollapsePanel() {
	    _classCallCheck(this, CollapsePanel);
	
	    return _possibleConstructorReturn(this, (CollapsePanel.__proto__ || Object.getPrototypeOf(CollapsePanel)).apply(this, arguments));
	  }
	
	  _createClass(CollapsePanel, [{
	    key: 'handleItemClick',
	    value: function handleItemClick() {
	      if (this.props.onItemClick) {
	        this.props.onItemClick();
	      }
	    }
	  }, {
	    key: 'render',
	    value: function render() {
	      var _classNames2;
	
	      var _props = this.props,
	          className = _props.className,
	          id = _props.id,
	          style = _props.style,
	          prefixCls = _props.prefixCls,
	          header = _props.header,
	          headerClass = _props.headerClass,
	          children = _props.children,
	          isActive = _props.isActive,
	          showArrow = _props.showArrow,
	          destroyInactivePanel = _props.destroyInactivePanel,
	          disabled = _props.disabled;
	
	      var headerCls = (0, _classnames2['default'])(prefixCls + '-header', _defineProperty({}, headerClass, headerClass));
	      var itemCls = (0, _classnames2['default'])((_classNames2 = {}, _defineProperty(_classNames2, prefixCls + '-item', true), _defineProperty(_classNames2, prefixCls + '-item-active', isActive), _defineProperty(_classNames2, prefixCls + '-item-disabled', disabled), _classNames2), className);
	      return _react2['default'].createElement(
	        'div',
	        { className: itemCls, style: style, id: id, role: 'tablist' },
	        _react2['default'].createElement(
	          'div',
	          {
	            className: headerCls,
	            onClick: this.handleItemClick.bind(this),
	            role: 'tab',
	            'aria-expanded': isActive
	          },
	          showArrow && _react2['default'].createElement('i', { className: 'arrow' }),
	          header
	        ),
	        _react2['default'].createElement(
	          _rcAnimate2['default'],
	          {
	            showProp: 'isActive',
	            exclusive: true,
	            component: '',
	            animation: this.props.openAnimation
	          },
	          _react2['default'].createElement(
	            _PanelContent2['default'],
	            {
	              prefixCls: prefixCls,
	              isActive: isActive,
	              destroyInactivePanel: destroyInactivePanel
	            },
	            children
	          )
	        )
	      );
	    }
	  }]);
	
	  return CollapsePanel;
	}(_react.Component);
	
	CollapsePanel.propTypes = {
	  className: _propTypes2['default'].oneOfType([_propTypes2['default'].string, _propTypes2['default'].object]),
	  id: _propTypes2['default'].string,
	  children: _propTypes2['default'].any,
	  openAnimation: _propTypes2['default'].object,
	  prefixCls: _propTypes2['default'].string,
	  header: _propTypes2['default'].oneOfType([_propTypes2['default'].string, _propTypes2['default'].number, _propTypes2['default'].node]),
	  headerClass: _propTypes2['default'].string,
	  showArrow: _propTypes2['default'].bool,
	  isActive: _propTypes2['default'].bool,
	  onItemClick: _propTypes2['default'].func,
	  style: _propTypes2['default'].object,
	  destroyInactivePanel: _propTypes2['default'].bool,
	  disabled: _propTypes2['default'].bool
	};
	
	CollapsePanel.defaultProps = {
	  showArrow: true,
	  isActive: false,
	  destroyInactivePanel: false,
	  onItemClick: function onItemClick() {},
	
	  headerClass: ''
	};
	
	exports['default'] = CollapsePanel;
	module.exports = exports['default'];

/***/ }),
/* 676 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _classnames2 = __webpack_require__(8);
	
	var _classnames3 = _interopRequireDefault(_classnames2);
	
	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 PanelContent = function (_Component) {
	  _inherits(PanelContent, _Component);
	
	  function PanelContent() {
	    _classCallCheck(this, PanelContent);
	
	    return _possibleConstructorReturn(this, (PanelContent.__proto__ || Object.getPrototypeOf(PanelContent)).apply(this, arguments));
	  }
	
	  _createClass(PanelContent, [{
	    key: 'shouldComponentUpdate',
	    value: function shouldComponentUpdate(nextProps) {
	      return this.props.isActive || nextProps.isActive;
	    }
	  }, {
	    key: 'render',
	    value: function render() {
	      var _classnames;
	
	      this._isActived = this._isActived || this.props.isActive;
	      if (!this._isActived) {
	        return null;
	      }
	      var _props = this.props,
	          prefixCls = _props.prefixCls,
	          isActive = _props.isActive,
	          children = _props.children,
	          destroyInactivePanel = _props.destroyInactivePanel;
	
	      var contentCls = (0, _classnames3['default'])((_classnames = {}, _defineProperty(_classnames, prefixCls + '-content', true), _defineProperty(_classnames, prefixCls + '-content-active', isActive), _defineProperty(_classnames, prefixCls + '-content-inactive', !isActive), _classnames));
	      var child = !isActive && destroyInactivePanel ? null : _react2['default'].createElement(
	        'div',
	        { className: prefixCls + '-content-box' },
	        children
	      );
	      return _react2['default'].createElement(
	        'div',
	        {
	          className: contentCls,
	          role: 'tabpanel'
	        },
	        child
	      );
	    }
	  }]);
	
	  return PanelContent;
	}(_react.Component);
	
	PanelContent.propTypes = {
	  prefixCls: _propTypes2['default'].string,
	  isActive: _propTypes2['default'].bool,
	  children: _propTypes2['default'].any,
	  destroyInactivePanel: _propTypes2['default'].bool
	};
	
	exports['default'] = PanelContent;
	module.exports = exports['default'];

/***/ }),
/* 677 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.Panel = undefined;
	
	var _Collapse = __webpack_require__(674);
	
	var _Collapse2 = _interopRequireDefault(_Collapse);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	exports['default'] = _Collapse2['default'];
	var Panel = exports.Panel = _Collapse2['default'].Panel;

/***/ }),
/* 678 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _cssAnimation = __webpack_require__(122);
	
	var _cssAnimation2 = _interopRequireDefault(_cssAnimation);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function animate(node, show, transitionName, done) {
	  var height = void 0;
	  return (0, _cssAnimation2['default'])(node, transitionName, {
	    start: function start() {
	      if (!show) {
	        node.style.height = node.offsetHeight + 'px';
	      } else {
	        height = node.offsetHeight;
	        node.style.height = 0;
	      }
	    },
	    active: function active() {
	      node.style.height = (show ? height : 0) + 'px';
	    },
	    end: function end() {
	      node.style.height = '';
	      done();
	    }
	  });
	}
	
	function animation(prefixCls) {
	  return {
	    enter: function enter(node, done) {
	      return animate(node, true, prefixCls + '-anim', done);
	    },
	    leave: function leave(node, done) {
	      return animate(node, false, prefixCls + '-anim', done);
	    }
	  };
	}
	
	exports['default'] = animation;
	module.exports = exports['default'];

/***/ }),
/* 679 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _reactDom = __webpack_require__(10);
	
	var _reactDom2 = _interopRequireDefault(_reactDom);
	
	var _KeyCode = __webpack_require__(29);
	
	var _KeyCode2 = _interopRequireDefault(_KeyCode);
	
	var _rcAnimate = __webpack_require__(22);
	
	var _rcAnimate2 = _interopRequireDefault(_rcAnimate);
	
	var _LazyRenderBox = __webpack_require__(681);
	
	var _LazyRenderBox2 = _interopRequireDefault(_LazyRenderBox);
	
	var _getScrollBarSize = __webpack_require__(789);
	
	var _getScrollBarSize2 = _interopRequireDefault(_getScrollBarSize);
	
	var _objectAssign = __webpack_require__(18);
	
	var _objectAssign2 = _interopRequireDefault(_objectAssign);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var uuid = 0;
	var openCount = 0;
	/* eslint react/no-is-mounted:0 */
	function noop() {}
	function getScroll(w, top) {
	    var ret = w['page' + (top ? 'Y' : 'X') + 'Offset'];
	    var method = 'scroll' + (top ? 'Top' : 'Left');
	    if (typeof ret !== 'number') {
	        var d = w.document;
	        ret = d.documentElement[method];
	        if (typeof ret !== 'number') {
	            ret = d.body[method];
	        }
	    }
	    return ret;
	}
	function setTransformOrigin(node, value) {
	    var style = node.style;
	    ['Webkit', 'Moz', 'Ms', 'ms'].forEach(function (prefix) {
	        style[prefix + 'TransformOrigin'] = value;
	    });
	    style['transformOrigin'] = value;
	}
	function offset(el) {
	    var rect = el.getBoundingClientRect();
	    var pos = {
	        left: rect.left,
	        top: rect.top
	    };
	    var doc = el.ownerDocument;
	    var w = doc.defaultView || doc.parentWindow;
	    pos.left += getScroll(w);
	    pos.top += getScroll(w, true);
	    return pos;
	}
	
	var Dialog = function (_React$Component) {
	    (0, _inherits3['default'])(Dialog, _React$Component);
	
	    function Dialog() {
	        (0, _classCallCheck3['default'])(this, Dialog);
	
	        var _this = (0, _possibleConstructorReturn3['default'])(this, (Dialog.__proto__ || Object.getPrototypeOf(Dialog)).apply(this, arguments));
	
	        _this.onAnimateLeave = function () {
	            // need demo?
	            // https://github.com/react-component/dialog/pull/28
	            if (_this.refs.wrap) {
	                _this.refs.wrap.style.display = 'none';
	            }
	            _this.inTransition = false;
	            _this.removeScrollingEffect();
	            _this.props.afterClose();
	        };
	        _this.onMaskClick = function (e) {
	            // android trigger click on open (fastclick??)
	            if (Date.now() - _this.openTime < 300) {
	                return;
	            }
	            if (e.target === e.currentTarget) {
	                _this.close(e);
	            }
	        };
	        _this.onKeyDown = function (e) {
	            var props = _this.props;
	            if (props.keyboard && e.keyCode === _KeyCode2['default'].ESC) {
	                _this.close(e);
	            }
	            // keep focus inside dialog
	            if (props.visible) {
	                if (e.keyCode === _KeyCode2['default'].TAB) {
	                    var activeElement = document.activeElement;
	                    var dialogRoot = _this.refs.wrap;
	                    var sentinel = _this.refs.sentinel;
	                    if (e.shiftKey) {
	                        if (activeElement === dialogRoot) {
	                            sentinel.focus();
	                        }
	                    } else if (activeElement === _this.refs.sentinel) {
	                        dialogRoot.focus();
	                    }
	                }
	            }
	        };
	        _this.getDialogElement = function () {
	            var props = _this.props;
	            var closable = props.closable;
	            var prefixCls = props.prefixCls;
	            var dest = {};
	            if (props.width !== undefined) {
	                dest.width = props.width;
	            }
	            if (props.height !== undefined) {
	                dest.height = props.height;
	            }
	            var footer = void 0;
	            if (props.footer) {
	                footer = _react2['default'].createElement("div", { className: prefixCls + '-footer', ref: "footer" }, props.footer);
	            }
	            var header = void 0;
	            if (props.title) {
	                header = _react2['default'].createElement("div", { className: prefixCls + '-header', ref: "header" }, _react2['default'].createElement("div", { className: prefixCls + '-title', id: _this.titleId }, props.title));
	            }
	            var closer = void 0;
	            if (closable) {
	                closer = _react2['default'].createElement("button", { onClick: _this.close, "aria-label": "Close", className: prefixCls + '-close' }, _react2['default'].createElement("span", { className: prefixCls + '-close-x' }));
	            }
	            var style = (0, _objectAssign2['default'])({}, props.style, dest);
	            var transitionName = _this.getTransitionName();
	            var dialogElement = _react2['default'].createElement(_LazyRenderBox2['default'], { key: "dialog-element", role: "document", ref: "dialog", style: style, className: prefixCls + ' ' + (props.className || ''), visible: props.visible }, _react2['default'].createElement("div", { className: prefixCls + '-content' }, closer, header, _react2['default'].createElement("div", (0, _extends3['default'])({ className: prefixCls + '-body', style: props.bodyStyle, ref: "body" }, props.bodyProps), props.children), footer), _react2['default'].createElement("div", { tabIndex: 0, ref: "sentinel", style: { width: 0, height: 0, overflow: 'hidden' } }, "sentinel"));
	            return _react2['default'].createElement(_rcAnimate2['default'], { key: "dialog", showProp: "visible", onLeave: _this.onAnimateLeave, transitionName: transitionName, component: "", transitionAppear: true }, dialogElement);
	        };
	        _this.getZIndexStyle = function () {
	            var style = {};
	            var props = _this.props;
	            if (props.zIndex !== undefined) {
	                style.zIndex = props.zIndex;
	            }
	            return style;
	        };
	        _this.getWrapStyle = function () {
	            return (0, _objectAssign2['default'])({}, _this.getZIndexStyle(), _this.props.wrapStyle);
	        };
	        _this.getMaskStyle = function () {
	            return (0, _objectAssign2['default'])({}, _this.getZIndexStyle(), _this.props.maskStyle);
	        };
	        _this.getMaskElement = function () {
	            var props = _this.props;
	            var maskElement = void 0;
	            if (props.mask) {
	                var maskTransition = _this.getMaskTransitionName();
	                maskElement = _react2['default'].createElement(_LazyRenderBox2['default'], (0, _extends3['default'])({ style: _this.getMaskStyle(), key: "mask", className: props.prefixCls + '-mask', hiddenClassName: props.prefixCls + '-mask-hidden', visible: props.visible }, props.maskProps));
	                if (maskTransition) {
	                    maskElement = _react2['default'].createElement(_rcAnimate2['default'], { key: "mask", showProp: "visible", transitionAppear: true, component: "", transitionName: maskTransition }, maskElement);
	                }
	            }
	            return maskElement;
	        };
	        _this.getMaskTransitionName = function () {
	            var props = _this.props;
	            var transitionName = props.maskTransitionName;
	            var animation = props.maskAnimation;
	            if (!transitionName && animation) {
	                transitionName = props.prefixCls + '-' + animation;
	            }
	            return transitionName;
	        };
	        _this.getTransitionName = function () {
	            var props = _this.props;
	            var transitionName = props.transitionName;
	            var animation = props.animation;
	            if (!transitionName && animation) {
	                transitionName = props.prefixCls + '-' + animation;
	            }
	            return transitionName;
	        };
	        _this.getElement = function (part) {
	            return _this.refs[part];
	        };
	        _this.setScrollbar = function () {
	            if (_this.bodyIsOverflowing && _this.scrollbarWidth !== undefined) {
	                document.body.style.paddingRight = _this.scrollbarWidth + 'px';
	            }
	        };
	        _this.addScrollingEffect = function () {
	            openCount++;
	            if (openCount !== 1) {
	                return;
	            }
	            _this.checkScrollbar();
	            _this.setScrollbar();
	            document.body.style.overflow = 'hidden';
	            // this.adjustDialog();
	        };
	        _this.removeScrollingEffect = function () {
	            openCount--;
	            if (openCount !== 0) {
	                return;
	            }
	            document.body.style.overflow = '';
	            _this.resetScrollbar();
	            // this.resetAdjustments();
	        };
	        _this.close = function (e) {
	            _this.props.onClose(e);
	        };
	        _this.checkScrollbar = function () {
	            var fullWindowWidth = window.innerWidth;
	            if (!fullWindowWidth) {
	                var documentElementRect = document.documentElement.getBoundingClientRect();
	                fullWindowWidth = documentElementRect.right - Math.abs(documentElementRect.left);
	            }
	            _this.bodyIsOverflowing = document.body.clientWidth < fullWindowWidth;
	            if (_this.bodyIsOverflowing) {
	                _this.scrollbarWidth = (0, _getScrollBarSize2['default'])();
	            }
	        };
	        _this.resetScrollbar = function () {
	            document.body.style.paddingRight = '';
	        };
	        _this.adjustDialog = function () {
	            if (_this.refs.wrap && _this.scrollbarWidth !== undefined) {
	                var modalIsOverflowing = _this.refs.wrap.scrollHeight > document.documentElement.clientHeight;
	                _this.refs.wrap.style.paddingLeft = (!_this.bodyIsOverflowing && modalIsOverflowing ? _this.scrollbarWidth : '') + 'px';
	                _this.refs.wrap.style.paddingRight = (_this.bodyIsOverflowing && !modalIsOverflowing ? _this.scrollbarWidth : '') + 'px';
	            }
	        };
	        _this.resetAdjustments = function () {
	            if (_this.refs.wrap) {
	                _this.refs.wrap.style.paddingLeft = _this.refs.wrap.style.paddingLeft = '';
	            }
	        };
	        return _this;
	    }
	
	    (0, _createClass3['default'])(Dialog, [{
	        key: 'componentWillMount',
	        value: function componentWillMount() {
	            this.inTransition = false;
	            this.titleId = 'rcDialogTitle' + uuid++;
	        }
	    }, {
	        key: 'componentDidMount',
	        value: function componentDidMount() {
	            this.componentDidUpdate({});
	        }
	    }, {
	        key: 'componentDidUpdate',
	        value: function componentDidUpdate(prevProps) {
	            var props = this.props;
	            var mousePosition = this.props.mousePosition;
	            if (props.visible) {
	                // first show
	                if (!prevProps.visible) {
	                    this.openTime = Date.now();
	                    this.lastOutSideFocusNode = document.activeElement;
	                    this.addScrollingEffect();
	                    this.refs.wrap.focus();
	                    var dialogNode = _reactDom2['default'].findDOMNode(this.refs.dialog);
	                    if (mousePosition) {
	                        var elOffset = offset(dialogNode);
	                        setTransformOrigin(dialogNode, mousePosition.x - elOffset.left + 'px ' + (mousePosition.y - elOffset.top) + 'px');
	                    } else {
	                        setTransformOrigin(dialogNode, '');
	                    }
	                }
	            } else if (prevProps.visible) {
	                this.inTransition = true;
	                if (props.mask && this.lastOutSideFocusNode) {
	                    try {
	                        this.lastOutSideFocusNode.focus();
	                    } catch (e) {
	                        this.lastOutSideFocusNode = null;
	                    }
	                    this.lastOutSideFocusNode = null;
	                }
	            }
	        }
	    }, {
	        key: 'componentWillUnmount',
	        value: function componentWillUnmount() {
	            if (this.props.visible || this.inTransition) {
	                this.removeScrollingEffect();
	            }
	        }
	    }, {
	        key: 'render',
	        value: function render() {
	            var props = this.props;
	            var prefixCls = props.prefixCls,
	                maskClosable = props.maskClosable;
	
	            var style = this.getWrapStyle();
	            // clear hide display
	            // and only set display after async anim, not here for hide
	            if (props.visible) {
	                style.display = null;
	            }
	            return _react2['default'].createElement("div", null, this.getMaskElement(), _react2['default'].createElement("div", (0, _extends3['default'])({ tabIndex: -1, onKeyDown: this.onKeyDown, className: prefixCls + '-wrap ' + (props.wrapClassName || ''), ref: "wrap", onClick: maskClosable ? this.onMaskClick : undefined, role: "dialog", "aria-labelledby": props.title ? this.titleId : null, style: style }, props.wrapProps), this.getDialogElement()));
	        }
	    }]);
	    return Dialog;
	}(_react2['default'].Component);
	
	exports['default'] = Dialog;
	
	Dialog.defaultProps = {
	    afterClose: noop,
	    className: '',
	    mask: true,
	    visible: false,
	    keyboard: true,
	    closable: true,
	    maskClosable: true,
	    prefixCls: 'rc-dialog',
	    onClose: noop
	};
	module.exports = exports['default'];

/***/ }),
/* 680 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _createReactClass = __webpack_require__(14);
	
	var _createReactClass2 = _interopRequireDefault(_createReactClass);
	
	var _Dialog = __webpack_require__(679);
	
	var _Dialog2 = _interopRequireDefault(_Dialog);
	
	var _getContainerRenderMixin = __webpack_require__(284);
	
	var _getContainerRenderMixin2 = _interopRequireDefault(_getContainerRenderMixin);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var DialogWrap = (0, _createReactClass2['default'])({
	    displayName: 'DialogWrap',
	    mixins: [(0, _getContainerRenderMixin2['default'])({
	        isVisible: function isVisible(instance) {
	            return instance.props.visible;
	        },
	
	        autoDestroy: false,
	        getComponent: function getComponent(instance, extra) {
	            return _react2['default'].createElement(_Dialog2['default'], (0, _extends3['default'])({}, instance.props, extra, { key: "dialog" }));
	        },
	        getContainer: function getContainer(instance) {
	            if (instance.props.getContainer) {
	                return instance.props.getContainer();
	            }
	            var container = document.createElement('div');
	            document.body.appendChild(container);
	            return container;
	        }
	    })],
	    getDefaultProps: function getDefaultProps() {
	        return {
	            visible: false
	        };
	    },
	    shouldComponentUpdate: function shouldComponentUpdate(_ref) {
	        var visible = _ref.visible;
	
	        return !!(this.props.visible || visible);
	    },
	    componentWillUnmount: function componentWillUnmount() {
	        if (this.props.visible) {
	            this.renderComponent({
	                afterClose: this.removeContainer,
	                onClose: function onClose() {},
	
	                visible: false
	            });
	        } else {
	            this.removeContainer();
	        }
	    },
	    getElement: function getElement(part) {
	        return this._component.getElement(part);
	    },
	    render: function render() {
	        return null;
	    }
	});
	exports['default'] = DialogWrap;
	module.exports = exports['default'];

/***/ }),
/* 681 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _objectAssign = __webpack_require__(18);
	
	var _objectAssign2 = _interopRequireDefault(_objectAssign);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var LazyRenderBox = function (_React$Component) {
	    (0, _inherits3['default'])(LazyRenderBox, _React$Component);
	
	    function LazyRenderBox() {
	        (0, _classCallCheck3['default'])(this, LazyRenderBox);
	        return (0, _possibleConstructorReturn3['default'])(this, (LazyRenderBox.__proto__ || Object.getPrototypeOf(LazyRenderBox)).apply(this, arguments));
	    }
	
	    (0, _createClass3['default'])(LazyRenderBox, [{
	        key: 'shouldComponentUpdate',
	        value: function shouldComponentUpdate(nextProps) {
	            return !!nextProps.hiddenClassName || !!nextProps.visible;
	        }
	    }, {
	        key: 'render',
	        value: function render() {
	            var className = this.props.className;
	            if (!!this.props.hiddenClassName && !this.props.visible) {
	                className += ' ' + this.props.hiddenClassName;
	            }
	            var props = (0, _objectAssign2['default'])({}, this.props);
	            delete props.hiddenClassName;
	            delete props.visible;
	            props.className = className;
	            return _react2['default'].createElement("div", (0, _extends3['default'])({}, props));
	        }
	    }]);
	    return LazyRenderBox;
	}(_react2['default'].Component);
	
	exports['default'] = LazyRenderBox;
	module.exports = exports['default'];

/***/ }),
/* 682 */
/***/ (function(module, exports, __webpack_require__) {

	'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 _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _reactDom = __webpack_require__(10);
	
	var _reactDom2 = _interopRequireDefault(_reactDom);
	
	var _rcTrigger = __webpack_require__(53);
	
	var _rcTrigger2 = _interopRequireDefault(_rcTrigger);
	
	var _placements = __webpack_require__(684);
	
	var _placements2 = _interopRequireDefault(_placements);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
	
	function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return 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) : _defaults(subClass, superClass); }
	
	var Dropdown = function (_Component) {
	  _inherits(Dropdown, _Component);
	
	  function Dropdown(props) {
	    _classCallCheck(this, Dropdown);
	
	    var _this = _possibleConstructorReturn(this, _Component.call(this, props));
	
	    _initialiseProps.call(_this);
	
	    if ('visible' in props) {
	      _this.state = {
	        visible: props.visible
	      };
	    } else {
	      _this.state = {
	        visible: props.defaultVisible
	      };
	    }
	    return _this;
	  }
	
	  Dropdown.prototype.componentWillReceiveProps = function componentWillReceiveProps(_ref) {
	    var visible = _ref.visible;
	
	    if (visible !== undefined) {
	      this.setState({
	        visible: visible
	      });
	    }
	  };
	
	  Dropdown.prototype.getMenuElement = function getMenuElement() {
	    var _props = this.props,
	        overlay = _props.overlay,
	        prefixCls = _props.prefixCls;
	
	    var extraOverlayProps = {
	      prefixCls: prefixCls + '-menu',
	      onClick: this.onClick
	    };
	    if (typeof overlay.type === 'string') {
	      delete extraOverlayProps.prefixCls;
	    }
	    return _react2["default"].cloneElement(overlay, extraOverlayProps);
	  };
	
	  Dropdown.prototype.getPopupDomNode = function getPopupDomNode() {
	    return this.refs.trigger.getPopupDomNode();
	  };
	
	  Dropdown.prototype.render = function render() {
	    var _props2 = this.props,
	        prefixCls = _props2.prefixCls,
	        children = _props2.children,
	        transitionName = _props2.transitionName,
	        animation = _props2.animation,
	        align = _props2.align,
	        placement = _props2.placement,
	        getPopupContainer = _props2.getPopupContainer,
	        showAction = _props2.showAction,
	        hideAction = _props2.hideAction,
	        overlayClassName = _props2.overlayClassName,
	        overlayStyle = _props2.overlayStyle,
	        trigger = _props2.trigger,
	        otherProps = _objectWithoutProperties(_props2, ['prefixCls', 'children', 'transitionName', 'animation', 'align', 'placement', 'getPopupContainer', 'showAction', 'hideAction', 'overlayClassName', 'overlayStyle', 'trigger']);
	
	    return _react2["default"].createElement(
	      _rcTrigger2["default"],
	      _extends({}, otherProps, {
	        prefixCls: prefixCls,
	        ref: 'trigger',
	        popupClassName: overlayClassName,
	        popupStyle: overlayStyle,
	        builtinPlacements: _placements2["default"],
	        action: trigger,
	        showAction: showAction,
	        hideAction: hideAction,
	        popupPlacement: placement,
	        popupAlign: align,
	        popupTransitionName: transitionName,
	        popupAnimation: animation,
	        popupVisible: this.state.visible,
	        afterPopupVisibleChange: this.afterVisibleChange,
	        popup: this.getMenuElement(),
	        onPopupVisibleChange: this.onVisibleChange,
	        getPopupContainer: getPopupContainer
	      }),
	      children
	    );
	  };
	
	  return Dropdown;
	}(_react.Component);
	
	Dropdown.propTypes = {
	  minOverlayWidthMatchTrigger: _propTypes2["default"].bool,
	  onVisibleChange: _propTypes2["default"].func,
	  onOverlayClick: _propTypes2["default"].func,
	  prefixCls: _propTypes2["default"].string,
	  children: _propTypes2["default"].any,
	  transitionName: _propTypes2["default"].string,
	  overlayClassName: _propTypes2["default"].string,
	  animation: _propTypes2["default"].any,
	  align: _propTypes2["default"].object,
	  overlayStyle: _propTypes2["default"].object,
	  placement: _propTypes2["default"].string,
	  overlay: _propTypes2["default"].node,
	  trigger: _propTypes2["default"].array,
	  showAction: _propTypes2["default"].array,
	  hideAction: _propTypes2["default"].array,
	  getPopupContainer: _propTypes2["default"].func,
	  visible: _propTypes2["default"].bool,
	  defaultVisible: _propTypes2["default"].bool
	};
	Dropdown.defaultProps = {
	  minOverlayWidthMatchTrigger: true,
	  prefixCls: 'rc-dropdown',
	  trigger: ['hover'],
	  showAction: [],
	  hideAction: [],
	  overlayClassName: '',
	  overlayStyle: {},
	  defaultVisible: false,
	  onVisibleChange: function onVisibleChange() {},
	
	  placement: 'bottomLeft'
	};
	
	var _initialiseProps = function _initialiseProps() {
	  var _this2 = this;
	
	  this.onClick = function (e) {
	    var props = _this2.props;
	    var overlayProps = props.overlay.props;
	    // do no call onVisibleChange, if you need click to hide, use onClick and control visible
	    if (!('visible' in props)) {
	      _this2.setState({
	        visible: false
	      });
	    }
	    if (props.onOverlayClick) {
	      props.onOverlayClick(e);
	    }
	    if (overlayProps.onClick) {
	      overlayProps.onClick(e);
	    }
	  };
	
	  this.onVisibleChange = function (visible) {
	    var props = _this2.props;
	    if (!('visible' in props)) {
	      _this2.setState({
	        visible: visible
	      });
	    }
	    props.onVisibleChange(visible);
	  };
	
	  this.afterVisibleChange = function (visible) {
	    if (visible && _this2.props.minOverlayWidthMatchTrigger) {
	      var overlayNode = _this2.getPopupDomNode();
	      var rootNode = _reactDom2["default"].findDOMNode(_this2);
	      if (rootNode && overlayNode && rootNode.offsetWidth > overlayNode.offsetWidth) {
	        overlayNode.style.width = rootNode.offsetWidth + 'px';
	        if (_this2.refs.trigger && _this2.refs.trigger._component && _this2.refs.trigger._component.alignInstance) {
	          _this2.refs.trigger._component.alignInstance.forceAlign();
	        }
	      }
	    }
	  };
	};
	
	exports["default"] = Dropdown;
	module.exports = exports['default'];

/***/ }),
/* 683 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _Dropdown = __webpack_require__(682);
	
	var _Dropdown2 = _interopRequireDefault(_Dropdown);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
	
	exports["default"] = _Dropdown2["default"];
	module.exports = exports['default'];

/***/ }),
/* 684 */
/***/ (function(module, exports) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	var autoAdjustOverflow = {
	  adjustX: 1,
	  adjustY: 1
	};
	
	var targetOffset = [0, 0];
	
	var placements = exports.placements = {
	  topLeft: {
	    points: ['bl', 'tl'],
	    overflow: autoAdjustOverflow,
	    offset: [0, -4],
	    targetOffset: targetOffset
	  },
	  topCenter: {
	    points: ['bc', 'tc'],
	    overflow: autoAdjustOverflow,
	    offset: [0, -4],
	    targetOffset: targetOffset
	  },
	  topRight: {
	    points: ['br', 'tr'],
	    overflow: autoAdjustOverflow,
	    offset: [0, -4],
	    targetOffset: targetOffset
	  },
	  bottomLeft: {
	    points: ['tl', 'bl'],
	    overflow: autoAdjustOverflow,
	    offset: [0, 4],
	    targetOffset: targetOffset
	  },
	  bottomCenter: {
	    points: ['tc', 'bc'],
	    overflow: autoAdjustOverflow,
	    offset: [0, 4],
	    targetOffset: targetOffset
	  },
	  bottomRight: {
	    points: ['tr', 'br'],
	    overflow: autoAdjustOverflow,
	    offset: [0, 4],
	    targetOffset: targetOffset
	  }
	};
	
	exports["default"] = placements;

/***/ }),
/* 685 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _immutable = __webpack_require__(11);
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	var ConfigStore = function () {
	    function ConfigStore() {
	        _classCallCheck(this, ConfigStore);
	
	        this._store = (0, _immutable.Map)();
	    }
	
	    ConfigStore.prototype.set = function set(key, value) {
	        this._store = this._store.set(key, value);
	    };
	
	    ConfigStore.prototype.get = function get(key) {
	        return this._store.get(key);
	    };
	
	    return ConfigStore;
	}();
	
	exports["default"] = ConfigStore;
	module.exports = exports['default'];

/***/ }),
/* 686 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	exports["default"] = customHTML2Content;
	
	var _draftJs = __webpack_require__(41);
	
	var _toArray = __webpack_require__(648);
	
	var _toArray2 = _interopRequireDefault(_toArray);
	
	var _immutable = __webpack_require__(11);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
	
	function compose() {
	    for (var _len = arguments.length, argument = Array(_len), _key = 0; _key < _len; _key++) {
	        argument[_key] = arguments[_key];
	    }
	
	    var args = arguments;
	    var start = args.length - 1;
	    return function () {
	        var i = start;
	        var result = args[start].apply(this, arguments);
	        while (i--) {
	            result = args[i].call(this, result);
	        }return result;
	    };
	}
	;
	/*
	 * Helpers
	 */
	// Prepares img meta data object based on img attributes
	var getBlockSpecForElement = function getBlockSpecForElement(imgElement) {
	    return {
	        contentType: 'image',
	        src: imgElement.getAttribute('src'),
	        width: imgElement.getAttribute('width'),
	        height: imgElement.getAttribute('height'),
	        align: imgElement.style.cssFloat
	    };
	};
	// Wraps meta data in HTML element which is 'understandable' by Draft, I used <blockquote />.
	var wrapBlockSpec = function wrapBlockSpec(blockSpec) {
	    if (blockSpec == null) {
	        return null;
	    }
	    var tempEl = document.createElement('blockquote');
	    // stringify meta data and insert it as text content of temp HTML element. We will later extract
	    // and parse it.
	    tempEl.innerText = JSON.stringify(blockSpec);
	    return tempEl;
	};
	// Replaces <img> element with our temp element
	var replaceElement = function replaceElement(oldEl, newEl) {
	    if (!(newEl instanceof HTMLElement)) {
	        return;
	    }
	    var parentNode = oldEl.parentNode;
	    return parentNode.replaceChild(newEl, oldEl);
	};
	var elementToBlockSpecElement = compose(wrapBlockSpec, getBlockSpecForElement);
	var imgReplacer = function imgReplacer(imgElement) {
	    return replaceElement(imgElement, elementToBlockSpecElement(imgElement));
	};
	// creates ContentBlock based on provided spec
	var createContentBlock = function createContentBlock(blockData, contentState) {
	    var key = blockData.key,
	        type = blockData.type,
	        text = blockData.text,
	        data = blockData.data,
	        inlineStyles = blockData.inlineStyles,
	        entityData = blockData.entityData;
	
	    var blockSpec = {
	        type: type != null ? type : 'unstyled',
	        text: text != null ? text : '',
	        key: key != null ? key : (0, _draftJs.genKey)(),
	        data: null,
	        characterList: (0, _immutable.List)([])
	    };
	    if (data) {
	        blockSpec.data = (0, _immutable.fromJS)(data);
	    }
	    if (inlineStyles || entityData) {
	        var entityKey = void 0;
	        if (entityData) {
	            var _type = entityData.type,
	                mutability = entityData.mutability,
	                _data = entityData.data;
	
	            contentState.createEntity(_type, mutability, _data);
	            entityKey = contentState.getLastCreatedEntityKey();
	        } else {
	            entityKey = null;
	        }
	        var style = (0, _immutable.OrderedSet)(inlineStyles || []);
	        var charData = _draftJs.CharacterMetadata.create({ style: style, entityKey: entityKey });
	        blockSpec.characterList = (0, _immutable.List)((0, _immutable.Repeat)(charData, text.length));
	    }
	    return new _draftJs.ContentBlock(blockSpec);
	};
	// takes HTML string and returns DraftJS ContentState
	function customHTML2Content(HTML, contentState) {
	    var tempDoc = new DOMParser().parseFromString(HTML, 'text/html');
	    // replace all <img /> with <blockquote /> elements
	    (0, _toArray2["default"])(tempDoc.querySelectorAll('img')).forEach(imgReplacer);
	    // use DraftJS converter to do initial conversion. I don't provide DOMBuilder and
	    // blockRenderMap arguments here since it should fall back to its default ones, which are fine
	
	    var _convertFromHTML = (0, _draftJs.convertFromHTML)(tempDoc.body.innerHTML),
	        contentBlocks = _convertFromHTML.contentBlocks;
	    // now replace <blockquote /> ContentBlocks with 'atomic' ones
	
	
	    contentBlocks = contentBlocks.reduce(function (contentBlocks, block) {
	        if (block.getType() !== 'blockquote') {
	            return contentBlocks.concat(block);
	        }
	        var image = JSON.parse(block.getText());
	        contentState.createEntity('IMAGE-ENTITY', 'IMMUTABLE', image);
	        var entityKey = contentState.getLastCreatedEntityKey();
	        var charData = _draftJs.CharacterMetadata.create({ entity: entityKey });
	        // const blockSpec = Object.assign({ type: 'atomic', text: ' ' }, { entityData })
	        // const atomicBlock = createContentBlock(blockSpec)
	        // const spacerBlock = createContentBlock({});
	        var fragmentArray = [new _draftJs.ContentBlock({
	            key: (0, _draftJs.genKey)(),
	            type: 'image-block',
	            text: ' ',
	            characterList: (0, _immutable.List)((0, _immutable.Repeat)(charData, charData.count()))
	        }), new _draftJs.ContentBlock({
	            key: (0, _draftJs.genKey)(),
	            type: 'unstyled',
	            text: '',
	            characterList: (0, _immutable.List)()
	        })];
	        return contentBlocks.concat(fragmentArray);
	    }, []);
	    // console.log('>> customHTML2Content contentBlocks', contentBlocks);
	    tempDoc = null;
	    return _draftJs.BlockMapBuilder.createFromArray(contentBlocks);
	}
	module.exports = exports['default'];

/***/ }),
/* 687 */
/***/ (function(module, exports) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	exports.encodeContent = encodeContent;
	exports.decodeContent = decodeContent;
	exports["default"] = exportText;
	function encodeContent(text) {
	    return text.split('&').join('&amp;').split('<').join('&lt;').split('>').join('&gt;').split('\xA0').join('&nbsp;').split('\n').join('<br />' + '\n');
	}
	function decodeContent(text) {
	    return text.split('<br />' + '\n').join('\n');
	}
	function exportText(editorState) {
	    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : { encode: false };
	
	    var content = editorState.getCurrentContent();
	    var blockMap = content.getBlockMap();
	    var encode = options.encode;
	
	    return blockMap.map(function (block) {
	        var resultText = '';
	        var lastPosition = 0;
	        var text = block.getText();
	        block.findEntityRanges(function (character) {
	            return !!character.getEntity();
	        }, function (start, end) {
	            var key = block.getEntityAt(start);
	            var entityData = content.getEntity(key).getData();
	            resultText += text.slice(lastPosition, start);
	            resultText += entityData && entityData["export"] ? entityData["export"](entityData) : text.slice(start, end);
	            lastPosition = end;
	        });
	        resultText += text.slice(lastPosition);
	        return encode ? encodeContent(resultText) : resultText;
	    }).join(encode ? '<br />\n' : '\n');
	}

/***/ }),
/* 688 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	exports.DEFAULT_INLINE_STYLE = exports.DEFAULT_ELEMENT = exports.EMPTY_SET = undefined;
	
	var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
	
	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"] = GetHTML;
	
	var _draftJs = __webpack_require__(41);
	
	var _immutable = __webpack_require__(11);
	
	var _isUnitlessNumber = __webpack_require__(689);
	
	var _isUnitlessNumber2 = _interopRequireDefault(_isUnitlessNumber);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
	
	var EMPTY_SET = exports.EMPTY_SET = (0, _immutable.OrderedSet)();
	var DEFAULT_ELEMENT = exports.DEFAULT_ELEMENT = 'span';
	var DEFAULT_INLINE_STYLE = exports.DEFAULT_INLINE_STYLE = _draftJs.DefaultDraftInlineStyle;
	function encodeContent(text) {
	    return text.split('&').join('&amp;').split('<').join('&lt;').split('>').join('&gt;').split('\xA0').join('&nbsp;').split('\n').join('<br >' + '\n');
	}
	function encodeAttr(text) {
	    return text.split('&').join('&amp;').split('<').join('&lt;').split('>').join('&gt;').split('"').join('&quot;');
	}
	var VENDOR_PREFIX = /^(moz|ms|o|webkit)-/;
	var NUMERIC_STRING = /^\d+$/;
	var UPPERCASE_PATTERN = /([A-Z])/g;
	// Lifted from: https://github.com/facebook/react/blob/master/src/renderers/dom/shared/CSSPropertyOperations.js
	function processStyleName(name) {
	    return name.replace(UPPERCASE_PATTERN, '-$1').toLowerCase().replace(VENDOR_PREFIX, '-$1-');
	}
	// Lifted from: https://github.com/facebook/react/blob/master/src/renderers/dom/shared/dangerousStyleValue.js
	function processStyleValue(name, value) {
	    var isNumeric = void 0;
	    if (typeof value === 'string') {
	        isNumeric = NUMERIC_STRING.test(value);
	    } else {
	        isNumeric = true;
	        value = String(value);
	    }
	    if (!isNumeric || value === '0' || _isUnitlessNumber2["default"][name] === true) {
	        return value;
	    } else {
	        return value + 'px';
	    }
	}
	function getStyleText(styleObject) {
	    if (!styleObject) {
	        return '';
	    }
	    return Object.keys(styleObject).map(function (name) {
	        var styleName = processStyleName(name);
	        var styleValue = processStyleValue(name, styleObject[name]);
	        return styleName + ':' + styleValue;
	    }).join(';');
	}
	function getEntityContent(contentState, entityKey, content) {
	    if (entityKey) {
	        var entity = contentState.getEntity(entityKey);
	        var entityData = entity.getData();
	        if (entityData && entityData["export"]) {
	            return entityData["export"](content, entityData);
	        }
	    }
	    return content;
	}
	function GetHTML(configStore) {
	    return function exportHtml(editorState) {
	        var contentState = editorState.getCurrentContent();
	        var blockMap = contentState.getBlockMap();
	        var customStyleMap = configStore.get('customStyleMap') || {};
	        var customBlockRenderMap = configStore.get('blockRenderMap') || {};
	        var customStyleFn = configStore.get('customStyleFn');
	        var toHTMLList = configStore.get('toHTMLList');
	        _extends(customStyleMap, DEFAULT_INLINE_STYLE);
	        return blockMap.map(function (block) {
	            var resultText = '<div>';
	            var closeTag = '</div>';
	            var lastPosition = 0;
	            var text = block.getText();
	            var blockType = block.getType();
	            var blockRender = customBlockRenderMap.get(blockType);
	            if (blockRender) {
	                var element = typeof blockRender.element === 'function' ? blockRender.elementTag || 'div' : 'div';
	                resultText = '<' + (element || 'div') + ' style="' + getStyleText(customBlockRenderMap.get(blockType).style || {}) + '">';
	                closeTag = '</' + (element || 'div') + '>';
	            }
	            var charMetaList = block.getCharacterList();
	            var charEntity = null;
	            var prevCharEntity = null;
	            var ranges = [];
	            var rangeStart = 0;
	            for (var i = 0, len = text.length; i < len; i++) {
	                prevCharEntity = charEntity;
	                var meta = charMetaList.get(i);
	                charEntity = meta ? meta.getEntity() : null;
	                if (i > 0 && charEntity !== prevCharEntity) {
	                    ranges.push([prevCharEntity, getStyleRanges(text.slice(rangeStart, i), charMetaList.slice(rangeStart, i))]);
	                    rangeStart = i;
	                }
	            }
	            ranges.push([charEntity, getStyleRanges(text.slice(rangeStart), charMetaList.slice(rangeStart))]);
	            ranges.map(function (_ref) {
	                var _ref2 = _slicedToArray(_ref, 2),
	                    entityKey = _ref2[0],
	                    stylePieces = _ref2[1];
	
	                var element = DEFAULT_ELEMENT;
	                var rawContent = stylePieces.map(function (_ref3) {
	                    var _ref4 = _slicedToArray(_ref3, 1),
	                        text = _ref4[0];
	
	                    return text;
	                }).join('');
	                var content = stylePieces.map(function (_ref5) {
	                    var _ref6 = _slicedToArray(_ref5, 2),
	                        text = _ref6[0],
	                        styleSet = _ref6[1];
	
	                    var encodedContent = encodeContent(text);
	                    if (styleSet.size) {
	                        var inlineStyle = {};
	                        styleSet.forEach(function (item) {
	                            if (customStyleMap.hasOwnProperty(item)) {
	                                var currentStyle = customStyleMap[item];
	                                inlineStyle = _extends(inlineStyle, currentStyle);
	                            }
	                        });
	                        var customedStyle = customStyleFn(styleSet);
	                        inlineStyle = _extends(inlineStyle, customedStyle);
	                        return '<span style="' + getStyleText(inlineStyle) + '">' + encodedContent + '</span>';
	                    }
	                    return '<span>' + encodedContent + '</span>';
	                }).join('');
	                if (entityKey) {
	                    var entity = contentState.getEntity(entityKey);
	                    var entityData = entity.getData();
	                    if (entityData && entityData["export"]) {
	                        resultText += entityData["export"](content, entityData);
	                    } else {
	                        var HTMLText = '';
	                        toHTMLList.forEach(function (toHTML) {
	                            var text = toHTML(rawContent, entity, contentState);
	                            if (text) {
	                                HTMLText = text;
	                            }
	                        });
	                        if (HTMLText) {
	                            resultText += HTMLText;
	                        }
	                    }
	                } else {
	                    resultText += content;
	                }
	            });
	            resultText += closeTag;
	            return resultText;
	        }).join('\n');
	    };
	}
	function getStyleRanges(text, charMetaList) {
	    var charStyle = EMPTY_SET;
	    var prevCharStyle = EMPTY_SET;
	    var ranges = [];
	    var rangeStart = 0;
	    for (var i = 0, len = text.length; i < len; i++) {
	        prevCharStyle = charStyle;
	        var meta = charMetaList.get(i);
	        charStyle = meta ? meta.getStyle() : EMPTY_SET;
	        if (i > 0 && !(0, _immutable.is)(charStyle, prevCharStyle)) {
	            ranges.push([text.slice(rangeStart, i), prevCharStyle]);
	            rangeStart = i;
	        }
	    }
	    ranges.push([text.slice(rangeStart), charStyle]);
	    return ranges;
	}

/***/ }),
/* 689 */
/***/ (function(module, exports) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	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
	};
	function prefixKey(prefix, key) {
	    return prefix + key.charAt(0).toUpperCase() + key.substring(1);
	}
	var prefixes = ['Webkit', 'ms', 'Moz', 'O'];
	Object.keys(isUnitlessNumber).forEach(function (prop) {
	    prefixes.forEach(function (prefix) {
	        isUnitlessNumber[prefixKey(prefix, prop)] = isUnitlessNumber[prop];
	    });
	});
	exports["default"] = isUnitlessNumber;
	module.exports = exports['default'];

/***/ }),
/* 690 */
/***/ (function(module, exports, __webpack_require__) {

	/* WEBPACK VAR INJECTION */(function(clearImmediate, setImmediate) {'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 _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _draftJs = __webpack_require__(41);
	
	var _immutable = __webpack_require__(11);
	
	__webpack_require__(155);
	
	var _Toolbar = __webpack_require__(693);
	
	var _ConfigStore = __webpack_require__(685);
	
	var _ConfigStore2 = _interopRequireDefault(_ConfigStore);
	
	var _getHTML = __webpack_require__(688);
	
	var _getHTML2 = _interopRequireDefault(_getHTML);
	
	var _exportText = __webpack_require__(687);
	
	var _exportText2 = _interopRequireDefault(_exportText);
	
	var _customHTML2Content = __webpack_require__(686);
	
	var _customHTML2Content2 = _interopRequireDefault(_customHTML2Content);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
	
	function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(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) : _defaults(subClass, superClass); }
	
	var hasCommandModifier = _draftJs.KeyBindingUtil.hasCommandModifier;
	
	function noop() {}
	;
	var defaultPluginConfig = {};
	var focusDummyStyle = {
	    width: 0,
	    opacity: 0,
	    border: 0,
	    position: 'absolute',
	    left: 0,
	    top: 0
	};
	var toolbar = (0, _Toolbar.createToolbar)();
	var configStore = new _ConfigStore2["default"]();
	
	var EditorCore = function (_React$Component) {
	    _inherits(EditorCore, _React$Component);
	
	    function EditorCore(props) {
	        _classCallCheck(this, EditorCore);
	
	        var _this = _possibleConstructorReturn(this, _React$Component.call(this, props));
	
	        _this.cancelForceUpdateImmediate = function () {
	            clearImmediate(_this.forceUpdateImmediate);
	            _this.forceUpdateImmediate = null;
	        };
	        _this.handlePastedText = function (text, html) {
	            var editorState = _this.state.editorState;
	
	            if (html) {
	                var contentState = editorState.getCurrentContent();
	                var selection = editorState.getSelection();
	                var fragment = (0, _customHTML2Content2["default"])(html, contentState);
	                var pastedContent = _draftJs.Modifier.replaceWithFragment(contentState, selection, fragment);
	                var newContent = pastedContent.merge({
	                    selectionBefore: selection,
	                    selectionAfter: pastedContent.getSelectionAfter().set('hasFocus', true)
	                });
	                _this.setEditorState(_draftJs.EditorState.push(editorState, newContent, 'insert-fragment'), true);
	                return 'handled';
	            }
	            return 'not-handled';
	        };
	        _this.plugins = (0, _immutable.List)((0, _immutable.List)(props.plugins).flatten(true));
	        var editorState = void 0;
	        if (props.value !== undefined) {
	            if (props.value instanceof _draftJs.EditorState) {
	                editorState = props.value || _draftJs.EditorState.createEmpty();
	            } else {
	                editorState = _draftJs.EditorState.createEmpty();
	            }
	        } else {
	            editorState = _draftJs.EditorState.createEmpty();
	        }
	        editorState = _this.generatorDefaultValue(editorState);
	        _this.state = {
	            plugins: _this.reloadPlugins(),
	            editorState: editorState,
	            customStyleMap: {},
	            customBlockStyleMap: {},
	            compositeDecorator: null
	        };
	        if (props.value !== undefined) {
	            _this.controlledMode = true;
	            console.warn('this component is in controllred mode');
	        }
	        return _this;
	    }
	
	    EditorCore.ToEditorState = function ToEditorState(text) {
	        var createEmptyContentState = _draftJs.ContentState.createFromText((0, _exportText.decodeContent)(text) || '');
	        var editorState = _draftJs.EditorState.createWithContent(createEmptyContentState);
	        return _draftJs.EditorState.forceSelection(editorState, createEmptyContentState.getSelectionAfter());
	    };
	
	    EditorCore.prototype.Reset = function Reset() {
	        var defaultValue = this.props.defaultValue;
	
	        var contentState = defaultValue ? defaultValue.getCurrentContent() : _draftJs.ContentState.createFromText('');
	        var updatedEditorState = _draftJs.EditorState.push(this.state.editorState, contentState, 'remove-range');
	        this.setEditorState(_draftJs.EditorState.forceSelection(updatedEditorState, contentState.getSelectionBefore()));
	    };
	
	    EditorCore.prototype.SetText = function SetText(text) {
	        var createTextContentState = _draftJs.ContentState.createFromText(text || '');
	        var editorState = _draftJs.EditorState.push(this.state.editorState, createTextContentState, 'change-block-data');
	        this.setEditorState(_draftJs.EditorState.moveFocusToEnd(editorState), true);
	    };
	
	    EditorCore.prototype.getChildContext = function getChildContext() {
	        return {
	            getEditorState: this.getEditorState,
	            setEditorState: this.setEditorState
	        };
	    };
	
	    EditorCore.prototype.reloadPlugins = function reloadPlugins() {
	        var _this2 = this;
	
	        return this.plugins && this.plugins.size ? this.plugins.map(function (plugin) {
	            //　如果插件有 callbacks 方法,则认为插件已经加载。
	            if (plugin.callbacks) {
	                return plugin;
	            }
	            // 如果插件有 constructor 方法,则构造插件
	            if (plugin.hasOwnProperty('constructor')) {
	                var pluginConfig = _extends(_this2.props.pluginConfig, plugin.config || {}, defaultPluginConfig);
	                return plugin.constructor(pluginConfig);
	            }
	            // else 无效插件
	            console.warn('>> 插件: [', plugin.name, '] 无效。插件或许已经过期。');
	            return false;
	        }).filter(function (plugin) {
	            return plugin;
	        }).toArray() : [];
	    };
	
	    EditorCore.prototype.componentWillMount = function componentWillMount() {
	        var plugins = this.initPlugins().concat([toolbar]);
	        var customStyleMap = {};
	        var customBlockStyleMap = {};
	        var customBlockRenderMap = (0, _immutable.Map)(_draftJs.DefaultDraftBlockRenderMap);
	        var toHTMLList = (0, _immutable.List)([]);
	        // initialize compositeDecorator
	        var compositeDecorator = new _draftJs.CompositeDecorator(plugins.filter(function (plugin) {
	            return plugin.decorators !== undefined;
	        }).map(function (plugin) {
	            return plugin.decorators;
	        }).reduce(function (prev, curr) {
	            return prev.concat(curr);
	        }, []));
	        // initialize Toolbar
	        var toolbarPlugins = (0, _immutable.List)(plugins.filter(function (plugin) {
	            return !!plugin.component && plugin.name !== 'toolbar';
	        }));
	        // load inline styles...
	        plugins.forEach(function (plugin) {
	            var styleMap = plugin.styleMap,
	                blockStyleMap = plugin.blockStyleMap,
	                blockRenderMap = plugin.blockRenderMap,
	                toHtml = plugin.toHtml;
	
	            if (styleMap) {
	                for (var key in styleMap) {
	                    if (styleMap.hasOwnProperty(key)) {
	                        customStyleMap[key] = styleMap[key];
	                    }
	                }
	            }
	            if (blockStyleMap) {
	                for (var _key in blockStyleMap) {
	                    if (blockStyleMap.hasOwnProperty(_key)) {
	                        customBlockStyleMap[_key] = blockStyleMap[_key];
	                        customBlockRenderMap = customBlockRenderMap.set(_key, {
	                            element: null
	                        });
	                    }
	                }
	            }
	            if (toHtml) {
	                toHTMLList = toHTMLList.push(toHtml);
	            }
	            if (blockRenderMap) {
	                for (var _key2 in blockRenderMap) {
	                    if (blockRenderMap.hasOwnProperty(_key2)) {
	                        customBlockRenderMap = customBlockRenderMap.set(_key2, blockRenderMap[_key2]);
	                    }
	                }
	            }
	        });
	        configStore.set('customStyleMap', customStyleMap);
	        configStore.set('customBlockStyleMap', customBlockStyleMap);
	        configStore.set('blockRenderMap', customBlockRenderMap);
	        configStore.set('customStyleFn', this.customStyleFn.bind(this));
	        configStore.set('toHTMLList', toHTMLList);
	        this.setState({
	            toolbarPlugins: toolbarPlugins,
	            compositeDecorator: compositeDecorator
	        });
	        this.setEditorState(_draftJs.EditorState.set(this.state.editorState, { decorator: compositeDecorator }));
	    };
	
	    EditorCore.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {
	        if (this.forceUpdateImmediate) {
	            this.cancelForceUpdateImmediate();
	        }
	        if (this.controlledMode) {
	            var decorators = nextProps.value.getDecorator();
	            var editorState = decorators ? nextProps.value : _draftJs.EditorState.set(nextProps.value, { decorator: this.state.compositeDecorator });
	            this.setState({
	                editorState: editorState
	            });
	        }
	    };
	
	    EditorCore.prototype.componentWillUnmount = function componentWillUnmount() {
	        this.cancelForceUpdateImmediate();
	    };
	    //  处理　value　
	
	
	    EditorCore.prototype.generatorDefaultValue = function generatorDefaultValue(editorState) {
	        var defaultValue = this.props.defaultValue;
	
	        if (defaultValue) {
	            return defaultValue;
	        }
	        return editorState;
	    };
	
	    EditorCore.prototype.getStyleMap = function getStyleMap() {
	        return configStore.get('customStyleMap');
	    };
	
	    EditorCore.prototype.setStyleMap = function setStyleMap(customStyleMap) {
	        configStore.set('customStyleMap', customStyleMap);
	        this.render();
	    };
	
	    EditorCore.prototype.initPlugins = function initPlugins() {
	        var _this3 = this;
	
	        var enableCallbacks = ['focus', 'getEditorState', 'setEditorState', 'getStyleMap', 'setStyleMap'];
	        return this.getPlugins().map(function (plugin) {
	            enableCallbacks.forEach(function (callbackName) {
	                if (plugin.callbacks.hasOwnProperty(callbackName)) {
	                    plugin.callbacks[callbackName] = _this3[callbackName].bind(_this3);
	                }
	            });
	            return plugin;
	        });
	    };
	
	    EditorCore.prototype.focusEditor = function focusEditor(ev) {
	        this.refs.editor.focus(ev);
	        if (this.props.readOnly) {
	            this._focusDummy.focus();
	        }
	        if (this.props.onFocus) {
	            this.props.onFocus(ev);
	        }
	    };
	
	    EditorCore.prototype.focus = function focus(ev) {
	        var _this4 = this;
	
	        if (!ev || !ev.nativeEvent || !ev.nativeEvent.target) {
	            return;
	        }
	        var event = ev.nativeEvent;
	        if (document.activeElement && document.activeElement.getAttribute('contenteditable') === 'true') {
	            return;
	        }
	        if (event.target === this._editorWrapper) {
	            var editorState = this.state.editorState;
	
	            var selection = editorState.getSelection();
	            if (!selection.getHasFocus()) {
	                if (selection.isCollapsed()) {
	                    return this.setState({
	                        editorState: _draftJs.EditorState.moveFocusToEnd(editorState)
	                    }, function () {
	                        _this4.focusEditor(ev);
	                    });
	                }
	            }
	        }
	        this.focusEditor(ev);
	    };
	
	    EditorCore.prototype.getPlugins = function getPlugins() {
	        return this.state.plugins.slice();
	    };
	
	    EditorCore.prototype.getEventHandler = function getEventHandler() {
	        var _this5 = this;
	
	        var enabledEvents = ['onUpArrow', 'onDownArrow', 'handleReturn', 'onFocus', 'onBlur', 'onTab', 'handlePastedText'];
	        var eventHandler = {};
	        enabledEvents.forEach(function (event) {
	            eventHandler[event] = _this5.generatorEventHandler(event);
	        });
	        return eventHandler;
	    };
	
	    EditorCore.prototype.getEditorState = function getEditorState() {
	        var needFocus = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
	
	        if (needFocus) {
	            this.refs.editor.focus();
	        }
	        return this.state.editorState;
	    };
	
	    EditorCore.prototype.setEditorState = function setEditorState(editorState) {
	        var _this6 = this;
	
	        var focusEditor = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
	
	        var newEditorState = editorState;
	        this.getPlugins().forEach(function (plugin) {
	            if (plugin.onChange) {
	                var updatedEditorState = plugin.onChange(newEditorState);
	                if (updatedEditorState) {
	                    newEditorState = updatedEditorState;
	                }
	            }
	        });
	        if (this.props.onChange) {
	            this.props.onChange(newEditorState);
	            // close this issue https://github.com/ant-design/ant-design/issues/5788
	            // when onChange not take any effect
	            // `<Editor />` won't rerender cause no props is changed.
	            // add an timeout here,
	            // if props.onChange not trigger componentWillReceiveProps,
	            // we will force render Editor with previous editorState,
	            if (this.controlledMode) {
	                this.forceUpdateImmediate = setImmediate(function () {
	                    return _this6.setState({
	                        editorState: new _draftJs.EditorState(_this6.state.editorState.getImmutable())
	                    });
	                });
	            }
	        }
	        if (!this.controlledMode) {
	            this.setState({ editorState: newEditorState }, focusEditor ? function () {
	                return setImmediate(function () {
	                    return _this6.refs.editor.focus();
	                });
	            } : noop);
	        }
	    };
	
	    EditorCore.prototype.handleKeyBinding = function handleKeyBinding(ev) {
	        if (this.props.onKeyDown) {
	            ev.ctrlKey = hasCommandModifier(ev);
	            var keyDownResult = this.props.onKeyDown(ev);
	            if (keyDownResult) {
	                return keyDownResult;
	            }
	            return (0, _draftJs.getDefaultKeyBinding)(ev);
	        }
	        return (0, _draftJs.getDefaultKeyBinding)(ev);
	    };
	
	    EditorCore.prototype.handleKeyCommand = function handleKeyCommand(command) {
	        if (this.props.multiLines) {
	            return this.eventHandle('handleKeyBinding', command);
	        }
	        return command === 'split-block' ? 'handled' : 'not-handled';
	    };
	
	    EditorCore.prototype.getBlockStyle = function getBlockStyle(contentBlock) {
	        var customBlockStyleMap = configStore.get('customBlockStyleMap');
	        var type = contentBlock.getType();
	        if (customBlockStyleMap.hasOwnProperty(type)) {
	            return customBlockStyleMap[type];
	        }
	    };
	
	    EditorCore.prototype.blockRendererFn = function blockRendererFn(contentBlock) {
	        var blockRenderResult = null;
	        this.getPlugins().forEach(function (plugin) {
	            if (plugin.blockRendererFn) {
	                var result = plugin.blockRendererFn(contentBlock);
	                if (result) {
	                    blockRenderResult = result;
	                }
	            }
	        });
	        return blockRenderResult;
	    };
	
	    EditorCore.prototype.eventHandle = function eventHandle(eventName) {
	        var _props;
	
	        var plugins = this.getPlugins();
	
	        for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key3 = 1; _key3 < _len; _key3++) {
	            args[_key3 - 1] = arguments[_key3];
	        }
	
	        for (var i = 0; i < plugins.length; i++) {
	            var plugin = plugins[i];
	            if (plugin.callbacks[eventName] && typeof plugin.callbacks[eventName] === 'function') {
	                var _plugin$callbacks;
	
	                var result = (_plugin$callbacks = plugin.callbacks)[eventName].apply(_plugin$callbacks, args);
	                if (result === true) {
	                    return 'handled';
	                }
	            }
	        }
	        return this.props.hasOwnProperty(eventName) && (_props = this.props)[eventName].apply(_props, args) === true ? 'handled' : 'not-handled';
	    };
	
	    EditorCore.prototype.generatorEventHandler = function generatorEventHandler(eventName) {
	        var _this7 = this;
	
	        return function () {
	            for (var _len2 = arguments.length, args = Array(_len2), _key4 = 0; _key4 < _len2; _key4++) {
	                args[_key4] = arguments[_key4];
	            }
	
	            return _this7.eventHandle.apply(_this7, [eventName].concat(args));
	        };
	    };
	
	    EditorCore.prototype.customStyleFn = function customStyleFn(styleSet) {
	        if (styleSet.size === 0) {
	            return {};
	        }
	        var plugins = this.getPlugins();
	        var resultStyle = {};
	        for (var i = 0; i < plugins.length; i++) {
	            if (plugins[i].customStyleFn) {
	                var styled = plugins[i].customStyleFn(styleSet);
	                if (styled) {
	                    _extends(resultStyle, styled);
	                }
	            }
	        }
	        return resultStyle;
	    };
	
	    EditorCore.prototype.render = function render() {
	        var _this8 = this;
	
	        var _props2 = this.props,
	            prefixCls = _props2.prefixCls,
	            toolbars = _props2.toolbars,
	            style = _props2.style,
	            readOnly = _props2.readOnly;
	        var _state = this.state,
	            editorState = _state.editorState,
	            toolbarPlugins = _state.toolbarPlugins;
	
	        var customStyleMap = configStore.get('customStyleMap');
	        var blockRenderMap = configStore.get('blockRenderMap');
	        var eventHandler = this.getEventHandler();
	        var Toolbar = toolbar.component;
	        return _react2["default"].createElement(
	            'div',
	            { style: style, className: prefixCls + '-editor ' + (readOnly ? 'readonly' : ''), onClick: this.focus.bind(this) },
	            _react2["default"].createElement(Toolbar, { editorState: editorState, prefixCls: prefixCls, className: prefixCls + '-toolbar', plugins: toolbarPlugins, toolbars: toolbars }),
	            _react2["default"].createElement(
	                'div',
	                { className: prefixCls + '-editor-wrapper', ref: function ref(ele) {
	                        return _this8._editorWrapper = ele;
	                    }, style: style, onClick: function onClick(ev) {
	                        return ev.preventDefault();
	                    } },
	                _react2["default"].createElement(_draftJs.Editor, _extends({}, this.props, eventHandler, { ref: 'editor', customStyleMap: customStyleMap, customStyleFn: this.customStyleFn.bind(this), editorState: editorState, handleKeyCommand: this.handleKeyCommand.bind(this), keyBindingFn: this.handleKeyBinding.bind(this), onChange: this.setEditorState.bind(this), blockStyleFn: this.getBlockStyle.bind(this), blockRenderMap: blockRenderMap, handlePastedText: this.handlePastedText, blockRendererFn: this.blockRendererFn.bind(this) })),
	                readOnly ? _react2["default"].createElement('input', { style: focusDummyStyle, ref: function ref(ele) {
	                        return _this8._focusDummy = ele;
	                    }, onBlur: eventHandler.onBlur }) : null,
	                this.props.children
	            )
	        );
	    };
	
	    return EditorCore;
	}(_react2["default"].Component);
	
	EditorCore.GetText = _exportText2["default"];
	EditorCore.GetHTML = (0, _getHTML2["default"])(configStore);
	EditorCore.defaultProps = {
	    multiLines: true,
	    plugins: [],
	    prefixCls: 'rc-editor-core',
	    pluginConfig: {},
	    toolbars: [],
	    spilitLine: 'enter'
	};
	EditorCore.childContextTypes = {
	    getEditorState: _propTypes2["default"].func,
	    setEditorState: _propTypes2["default"].func
	};
	exports["default"] = EditorCore;
	module.exports = exports['default'];
	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(287).clearImmediate, __webpack_require__(287).setImmediate))

/***/ }),
/* 691 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _immutable = __webpack_require__(11);
	
	var _ToolbarLine = __webpack_require__(692);
	
	var _ToolbarLine2 = _interopRequireDefault(_ToolbarLine);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
	
	function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(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) : _defaults(subClass, superClass); }
	
	function noop() {}
	
	var Toolbar = function (_React$Component) {
	    _inherits(Toolbar, _React$Component);
	
	    function Toolbar(props) {
	        _classCallCheck(this, Toolbar);
	
	        var _this = _possibleConstructorReturn(this, _React$Component.call(this, props));
	
	        var map = {};
	        props.plugins.forEach(function (plugin) {
	            map[plugin.name] = plugin;
	        });
	        _this.pluginsMap = (0, _immutable.Map)(map);
	        _this.state = {
	            editorState: props.editorState,
	            toolbars: []
	        };
	        return _this;
	    }
	
	    Toolbar.prototype.renderToolbarItem = function renderToolbarItem(pluginName, idx) {
	        var element = this.pluginsMap.get(pluginName);
	        if (element && element.component) {
	            var component = element.component;
	
	            var props = {
	                key: 'toolbar-item-' + idx,
	                onClick: component.props ? component.props.onClick : noop
	            };
	            if (_react2["default"].isValidElement(component)) {
	                return _react2["default"].cloneElement(component, props);
	            }
	            return _react2["default"].createElement(component, props);
	        }
	        return null;
	    };
	
	    Toolbar.prototype.conpomentWillReceiveProps = function conpomentWillReceiveProps(nextProps) {
	        this.render();
	    };
	
	    Toolbar.prototype.render = function render() {
	        var _this2 = this;
	
	        var _props = this.props,
	            toolbars = _props.toolbars,
	            prefixCls = _props.prefixCls;
	
	        return _react2["default"].createElement(
	            'div',
	            { className: prefixCls + '-toolbar' },
	            toolbars.map(function (toolbar, idx) {
	                var children = _react2["default"].Children.map(toolbar, _this2.renderToolbarItem.bind(_this2));
	                return _react2["default"].createElement(
	                    _ToolbarLine2["default"],
	                    { key: 'toolbar-' + idx },
	                    children
	                );
	            })
	        );
	    };
	
	    return Toolbar;
	}(_react2["default"].Component);
	
	exports["default"] = Toolbar;
	module.exports = exports['default'];

/***/ }),
/* 692 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
	
	function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(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) : _defaults(subClass, superClass); }
	
	var ToolbarLine = function (_React$Component) {
	    _inherits(ToolbarLine, _React$Component);
	
	    function ToolbarLine() {
	        _classCallCheck(this, ToolbarLine);
	
	        return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	    }
	
	    ToolbarLine.prototype.render = function render() {
	        return _react2["default"].createElement(
	            'div',
	            null,
	            this.props.children
	        );
	    };
	
	    return ToolbarLine;
	}(_react2["default"].Component);
	
	exports["default"] = ToolbarLine;
	module.exports = exports['default'];

/***/ }),
/* 693 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	exports.createToolbar = createToolbar;
	
	var _Toolbar = __webpack_require__(691);
	
	var _Toolbar2 = _interopRequireDefault(_Toolbar);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
	
	function noop(args) {}
	;
	function createToolbar() {
	    var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
	
	    function editorStateChange(editorState) {
	        // console.log('>> editorStateChange', editorState);
	    }
	    var callbacks = {
	        onChange: editorStateChange,
	        onUpArrow: noop,
	        onDownArrow: noop,
	        getEditorState: noop,
	        setEditorState: noop,
	        handleReturn: noop
	    };
	    return {
	        name: 'toolbar',
	        decorators: [],
	        callbacks: callbacks,
	        onChange: function onChange(editorState) {
	            return callbacks.onChange ? callbacks.onChange(editorState) : editorState;
	        },
	
	        component: _Toolbar2["default"]
	    };
	}

/***/ }),
/* 694 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _EditorCore = __webpack_require__(690);
	
	var _EditorCore2 = _interopRequireDefault(_EditorCore);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
	
	var EditorCorePublic = {
	    EditorCore: _EditorCore2["default"],
	    GetText: _EditorCore2["default"].GetText,
	    GetHTML: _EditorCore2["default"].GetHTML,
	    toEditorState: _EditorCore2["default"].ToEditorState
	};
	exports["default"] = EditorCorePublic;
	module.exports = exports['default'];

/***/ }),
/* 695 */
/***/ (function(module, exports, __webpack_require__) {

	'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 _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _classnames2 = __webpack_require__(8);
	
	var _classnames3 = _interopRequireDefault(_classnames2);
	
	var _rcEditorCore = __webpack_require__(694);
	
	var _draftJs = __webpack_require__(41);
	
	var _createMention = __webpack_require__(703);
	
	var _createMention2 = _interopRequireDefault(_createMention);
	
	var _exportContent = __webpack_require__(145);
	
	var _exportContent2 = _interopRequireDefault(_exportContent);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
	
	function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return 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) : _defaults(subClass, superClass); }
	
	var Mention = function (_React$Component) {
	  _inherits(Mention, _React$Component);
	
	  function Mention(props) {
	    _classCallCheck(this, Mention);
	
	    var _this = _possibleConstructorReturn(this, _React$Component.call(this, props));
	
	    _this.onEditorChange = function (editorState) {
	      var selection = editorState.getSelection();
	      _this._decorator = editorState.getDecorator();
	      var content = editorState.getCurrentContent();
	
	      if (_this.props.onChange) {
	        _this.setState({
	          selection: selection
	        }, function () {
	          _this.props.onChange(content, (0, _exportContent2["default"])(content));
	        });
	      } else {
	        _this.setState({
	          editorState: editorState,
	          selection: selection
	        });
	      }
	    };
	
	    _this.onFocus = function (e) {
	      if (_this.props.onFocus) {
	        _this.props.onFocus(e);
	      }
	    };
	
	    _this.onBlur = function (e) {
	      if (_this.props.onBlur) {
	        _this.props.onBlur(e);
	      }
	    };
	
	    _this.reset = function () {
	      /*eslint-disable*/
	      _this._editor.Reset();
	      /*eslint-enable*/
	    };
	
	    _this.mention = (0, _createMention2["default"])({
	      prefix: _this.getPrefix(props),
	      tag: props.tag,
	      mode: props.mode,
	      mentionStyle: props.mentionStyle
	    });
	
	    _this.Suggestions = _this.mention.Suggestions;
	    _this.plugins = [_this.mention];
	
	    _this.state = {
	      suggestions: props.suggestions,
	      value: props.value && _draftJs.EditorState.createWithContent(props.value, new _draftJs.CompositeDecorator(_this.mention.decorators)),
	      selection: _draftJs.SelectionState.createEmpty()
	    };
	
	    if (typeof props.defaultValue === 'string') {
	      // eslint-disable-next-line
	      console.warn('The property `defaultValue` now allow `EditorState` only, see http://react-component.github.io/editor-mention/examples/defaultValue.html ');
	    }
	    if (props.value !== undefined) {
	      _this.controlledMode = true;
	    }
	    return _this;
	  }
	
	  Mention.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {
	    var suggestions = nextProps.suggestions;
	    var selection = this.state.selection;
	
	    var value = nextProps.value;
	    if (value && selection) {
	      value = _draftJs.EditorState.acceptSelection(_draftJs.EditorState.createWithContent(value, this._decorator), selection);
	    }
	    this.setState({
	      suggestions: suggestions,
	      value: value
	    });
	  };
	
	  Mention.prototype.getPrefix = function getPrefix() {
	    var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.props;
	
	    return Array.isArray(props.prefix) ? props.prefix : [props.prefix];
	  };
	
	  Mention.prototype.render = function render() {
	    var _classnames,
	        _this2 = this;
	
	    var _props = this.props,
	        prefixCls = _props.prefixCls,
	        style = _props.style,
	        tag = _props.tag,
	        multiLines = _props.multiLines,
	        suggestionStyle = _props.suggestionStyle,
	        placeholder = _props.placeholder,
	        defaultValue = _props.defaultValue,
	        className = _props.className,
	        notFoundContent = _props.notFoundContent,
	        getSuggestionContainer = _props.getSuggestionContainer,
	        readOnly = _props.readOnly,
	        disabled = _props.disabled;
	    var suggestions = this.state.suggestions;
	    var Suggestions = this.Suggestions;
	
	    var editorClass = (0, _classnames3["default"])(className, (_classnames = {}, _defineProperty(_classnames, prefixCls + '-wrapper', true), _defineProperty(_classnames, 'readonly', readOnly), _defineProperty(_classnames, 'disabled', disabled), _defineProperty(_classnames, 'multilines', multiLines), _classnames));
	    var editorProps = this.controlledMode ? { value: this.state.value } : {};
	    var defaultValueState = defaultValue && _draftJs.EditorState.createWithContent(typeof defaultValue === 'string' ? _draftJs.ContentState.createFromText(defaultValue) : defaultValue, this._decorator);
	    return _react2["default"].createElement(
	      'div',
	      { className: editorClass, style: style, ref: function ref(wrapper) {
	          return _this2._wrapper = wrapper;
	        } },
	      _react2["default"].createElement(
	        _rcEditorCore.EditorCore,
	        _extends({
	          ref: function ref(editor) {
	            return _this2._editor = editor;
	          },
	          prefixCls: prefixCls,
	          style: style,
	          multiLines: multiLines,
	          plugins: this.plugins,
	          defaultValue: defaultValueState,
	          placeholder: placeholder,
	          onFocus: this.onFocus,
	          onBlur: this.onBlur,
	          onChange: this.onEditorChange
	        }, editorProps, {
	          readOnly: readOnly || disabled
	        }),
	        _react2["default"].createElement(Suggestions, {
	          mode: tag ? 'immutable' : 'mutable',
	          prefix: this.getPrefix(),
	          prefixCls: prefixCls,
	          style: suggestionStyle,
	          notFoundContent: notFoundContent,
	          suggestions: suggestions,
	          getSuggestionContainer: getSuggestionContainer ? function () {
	            return getSuggestionContainer(_this2._wrapper);
	          } : null,
	          onSearchChange: this.props.onSearchChange,
	          onSelect: this.props.onSelect,
	          noRedup: this.props.noRedup
	        })
	      )
	    );
	  };
	
	  return Mention;
	}(_react2["default"].Component);
	
	Mention.propTypes = {
	  value: _propTypes2["default"].object,
	  suggestions: _propTypes2["default"].array,
	  prefix: _propTypes2["default"].oneOfType([_propTypes2["default"].string, _propTypes2["default"].arrayOf(_propTypes2["default"].string)]),
	  prefixCls: _propTypes2["default"].string,
	  tag: _propTypes2["default"].element,
	  style: _propTypes2["default"].object,
	  className: _propTypes2["default"].string,
	  onSearchChange: _propTypes2["default"].func,
	  onChange: _propTypes2["default"].func,
	  mode: _propTypes2["default"].string,
	  multiLines: _propTypes2["default"].bool,
	  suggestionStyle: _propTypes2["default"].object,
	  placeholder: _propTypes2["default"].string,
	  defaultValue: _propTypes2["default"].object,
	  notFoundContent: _propTypes2["default"].any,
	  position: _propTypes2["default"].string,
	  onFocus: _propTypes2["default"].func,
	  onBlur: _propTypes2["default"].func,
	  onSelect: _propTypes2["default"].func,
	  getSuggestionContainer: _propTypes2["default"].func,
	  noRedup: _propTypes2["default"].bool,
	  mentionStyle: _propTypes2["default"].object
	};
	Mention.controlledMode = false;
	
	
	Mention.defaultProps = {
	  prefixCls: 'rc-editor-mention',
	  prefix: '@',
	  mode: 'immutable',
	  suggestions: [],
	  multiLines: false,
	  className: '',
	  suggestionStyle: {},
	  notFoundContent: '无法找到',
	  position: 'absolute',
	  mentionStyle: {}
	};
	
	exports["default"] = Mention;
	module.exports = exports['default'];

/***/ }),
/* 696 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
	
	var MentionContent = function MentionContent(_ref) {
	  var children = _ref.children;
	  return _react2["default"].createElement(
	    'span',
	    { style: { backgroundColor: '#e6f3ff' } },
	    children
	  );
	};
	
	exports["default"] = MentionContent;
	module.exports = exports['default'];

/***/ }),
/* 697 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _getOffset = __webpack_require__(257);
	
	var _getOffset2 = _interopRequireDefault(_getOffset);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
	
	function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(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) : _defaults(subClass, superClass); }
	
	var SuggestionPortal = function (_React$Component) {
	  _inherits(SuggestionPortal, _React$Component);
	
	  function SuggestionPortal() {
	    var _temp, _this, _ret;
	
	    _classCallCheck(this, SuggestionPortal);
	
	    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
	      args[_key] = arguments[_key];
	    }
	
	    return _ret = (_temp = (_this = _possibleConstructorReturn(this, _React$Component.call.apply(_React$Component, [this].concat(args))), _this), _this.matchDecorates = function (props) {
	      var callbacks = props.callbacks,
	          suggestionRegex = props.suggestionRegex,
	          decoratedText = props.decoratedText;
	
	      var matches = suggestionRegex.exec(decoratedText);
	      _this.trigger = matches[2];
	      _this.updatePortalPosition(_this.props);
	      callbacks.setEditorState(callbacks.getEditorState());
	    }, _temp), _possibleConstructorReturn(_this, _ret);
	  }
	
	  SuggestionPortal.prototype.componentWillMount = function componentWillMount() {
	    this.matchDecorates(this.props);
	  };
	
	  SuggestionPortal.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {
	    if (nextProps.decoratedText !== this.props.decoratedText) {
	      this.matchDecorates(nextProps);
	    }
	    this.updatePortalPosition(nextProps);
	  };
	
	  SuggestionPortal.prototype.componentWillUnmount = function componentWillUnmount() {
	    var _props = this.props,
	        offsetKey = _props.offsetKey,
	        mentionStore = _props.mentionStore;
	
	    mentionStore.inActiveSuggestion({ offsetKey: offsetKey });
	  };
	
	  SuggestionPortal.prototype.updatePortalPosition = function updatePortalPosition(props) {
	    var _this2 = this;
	
	    var offsetKey = props.offsetKey,
	        mentionStore = props.mentionStore;
	
	    mentionStore.updateSuggestion({
	      offsetKey: offsetKey,
	      trigger: this.trigger,
	      position: function position() {
	        var element = _this2.searchPortal;
	        var rect = (0, _getOffset2["default"])(element);
	        return {
	          left: rect.left,
	          top: rect.top,
	          width: element.offsetWidth,
	          height: element.offsetHeight
	        };
	      }
	    });
	  };
	
	  SuggestionPortal.prototype.render = function render() {
	    var _this3 = this;
	
	    return _react2["default"].createElement(
	      'span',
	      { ref: function ref(node) {
	          _this3.searchPortal = node;
	        }, style: this.props.style },
	      this.props.children
	    );
	  };
	
	  return SuggestionPortal;
	}(_react2["default"].Component);
	
	SuggestionPortal.propTypes = {
	  offsetKey: _propTypes2["default"].any,
	  mentionStore: _propTypes2["default"].object,
	  decoratedText: _propTypes2["default"].string,
	  children: _propTypes2["default"].any,
	  callbacks: _propTypes2["default"].any,
	  suggestionRegex: _propTypes2["default"].any
	};
	exports["default"] = SuggestionPortal;
	module.exports = exports['default'];

/***/ }),
/* 698 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _reactDom = __webpack_require__(10);
	
	var _reactDom2 = _interopRequireDefault(_reactDom);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
	
	function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(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) : _defaults(subClass, superClass); }
	
	var SuggestionWrapper = function (_React$Component) {
	  _inherits(SuggestionWrapper, _React$Component);
	
	  function SuggestionWrapper() {
	    _classCallCheck(this, SuggestionWrapper);
	
	    return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	  }
	
	  SuggestionWrapper.prototype.componentDidMount = function componentDidMount() {
	    this.renderComponent();
	  };
	
	  SuggestionWrapper.prototype.componentDidUpdate = function componentDidUpdate() {
	    this.renderComponent();
	  };
	
	  SuggestionWrapper.prototype.renderComponent = function renderComponent() {
	    var instance = this.props.children;
	    var ready = this.props.renderReady;
	    _reactDom2["default"].unstable_renderSubtreeIntoContainer(this, instance, this.props.container, function callback() {
	      if (ready) {
	        ready.call(this);
	      }
	    });
	  };
	
	  SuggestionWrapper.prototype.render = function render() {
	    return null;
	  };
	
	  return SuggestionWrapper;
	}(_react2["default"].Component);
	
	exports["default"] = SuggestionWrapper;
	
	
	SuggestionWrapper.propTypes = {
	  children: _propTypes2["default"].any,
	  renderReady: _propTypes2["default"].func,
	  container: _propTypes2["default"].any
	};
	module.exports = exports['default'];

/***/ }),
/* 699 */
/***/ (function(module, exports, __webpack_require__) {

	'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 _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _DraftOffsetKey = __webpack_require__(71);
	
	var _rcAnimate = __webpack_require__(22);
	
	var _rcAnimate2 = _interopRequireDefault(_rcAnimate);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _domScrollIntoView = __webpack_require__(88);
	
	var _domScrollIntoView2 = _interopRequireDefault(_domScrollIntoView);
	
	var _Nav = __webpack_require__(255);
	
	var _Nav2 = _interopRequireDefault(_Nav);
	
	var _SuggestionWrapper = __webpack_require__(698);
	
	var _SuggestionWrapper2 = _interopRequireDefault(_SuggestionWrapper);
	
	var _insertMention = __webpack_require__(704);
	
	var _insertMention2 = _interopRequireDefault(_insertMention);
	
	var _clearMention = __webpack_require__(702);
	
	var _clearMention2 = _interopRequireDefault(_clearMention);
	
	var _getOffset = __webpack_require__(257);
	
	var _getOffset2 = _interopRequireDefault(_getOffset);
	
	var _getMentions = __webpack_require__(256);
	
	var _getMentions2 = _interopRequireDefault(_getMentions);
	
	var _getSearchWord2 = __webpack_require__(146);
	
	var _getSearchWord3 = _interopRequireDefault(_getSearchWord2);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
	
	function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return 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) : _defaults(subClass, superClass); }
	
	var isNotFalse = function isNotFalse(i) {
	  return i !== false;
	};
	
	var Suggestions = function (_React$Component) {
	  _inherits(Suggestions, _React$Component);
	
	  function Suggestions() {
	    _classCallCheck(this, Suggestions);
	
	    var _this = _possibleConstructorReturn(this, _React$Component.call(this));
	
	    _this.onEditorStateChange = function (editorState) {
	      var offset = _this.props.store.getOffset();
	      if (offset.size === 0) {
	        return editorState;
	      }
	      var selection = editorState.getSelection();
	      // 修复: 焦点移出再移入时, dropdown 会闪动一下
	      // 原因: https://github.com/facebook/draft-js/blob/67c5e69499e3b0c149ce83b004872afdf4180463/src/component/handlers/edit/editOnFocus.js#L33
	      // 此处强制 update 了一下,因此 onEditorStateChange 会 call 两次
	      if (!_this.props.callbacks.getEditorState().getSelection().getHasFocus() && selection.getHasFocus()) {
	        return editorState;
	      }
	
	      var _getSearchWord = (0, _getSearchWord3["default"])(editorState, selection),
	          word = _getSearchWord.word;
	
	      if (!word) {
	        _this.closeDropDown();
	        return editorState;
	      }
	      var selectionInsideMention = offset.map(function (_ref) {
	        var offsetKey = _ref.offsetKey;
	
	        var _decode = (0, _DraftOffsetKey.decode)(offsetKey),
	            blockKey = _decode.blockKey,
	            decoratorKey = _decode.decoratorKey,
	            leafKey = _decode.leafKey;
	
	        if (blockKey !== selection.anchorKey) {
	          return false;
	        }
	        var leaf = editorState.getBlockTree(blockKey).getIn([decoratorKey, 'leaves', leafKey]);
	        if (!leaf) {
	          return false;
	        }
	        var startKey = leaf.get('start');
	        var endKey = leaf.get('end');
	        // 处理只有一个 `@` 符号时的情况
	        if (!word) {
	          return false;
	        }
	        if (startKey === endKey - 1) {
	          return selection.anchorOffset >= startKey + 1 && selection.anchorOffset <= endKey ? offsetKey : false;
	        }
	        return selection.anchorOffset > startKey + 1 && selection.anchorOffset <= endKey ? offsetKey : false;
	      });
	
	      var selectionInText = selectionInsideMention.some(isNotFalse);
	      _this.activeOffsetKey = selectionInsideMention.find(isNotFalse);
	      var trigger = _this.props.store.getTrigger(_this.activeOffsetKey);
	
	      if (!selectionInText || !selection.getHasFocus()) {
	        _this.closeDropDown();
	        return editorState;
	      }
	
	      var searchValue = word.substring(trigger.length, word.length);
	      if (_this.lastSearchValue !== searchValue || _this.lastTrigger !== trigger) {
	        _this.lastSearchValue = searchValue;
	        _this.lastTrigger = trigger;
	        _this.props.onSearchChange(searchValue, trigger);
	      }
	      if (!_this.state.active) {
	        _this.openDropDown();
	      }
	      return editorState;
	    };
	
	    _this.onUpArrow = function (ev) {
	      ev.preventDefault();
	      if (_this.props.suggestions.length > 0) {
	        var newIndex = _this.state.focusedIndex - 1;
	        _this.setState({
	          focusedIndex: Math.max(newIndex, 0)
	        });
	      }
	    };
	
	    _this.onBlur = function (ev) {
	      ev.preventDefault();
	      _this.closeDropDown();
	    };
	
	    _this.onDownArrow = function (ev) {
	      ev.preventDefault();
	      var newIndex = _this.state.focusedIndex + 1;
	      _this.setState({
	        focusedIndex: newIndex >= _this.props.suggestions.length ? 0 : newIndex
	      });
	    };
	
	    _this.getContainer = function () {
	      var popupContainer = document.createElement('div');
	      var mountNode = void 0;
	      if (_this.props.getSuggestionContainer) {
	        mountNode = _this.props.getSuggestionContainer();
	        popupContainer.style.position = 'relative';
	      } else {
	        mountNode = document.body;
	      }
	      mountNode.appendChild(popupContainer);
	      return popupContainer;
	    };
	
	    _this.handleKeyBinding = function (command) {
	      return command === 'split-block';
	    };
	
	    _this.handleReturn = function (ev) {
	      ev.preventDefault();
	      var selectedSuggestion = _this.props.suggestions[_this.state.focusedIndex];
	      if (selectedSuggestion) {
	        if (_react2["default"].isValidElement(selectedSuggestion)) {
	          _this.onMentionSelect(selectedSuggestion.props.value, selectedSuggestion.props.data);
	        } else {
	          _this.onMentionSelect(selectedSuggestion);
	        }
	        _this.lastSearchValue = null;
	        _this.lastTrigger = null;
	        return true;
	      }
	      return false;
	    };
	
	    _this.renderReady = function () {
	      var container = _this.dropdownContainer;
	      if (!container) {
	        return;
	      }
	      var active = _this.state.active;
	      var activeOffsetKey = _this.activeOffsetKey;
	
	      var offset = _this.props.store.getOffset();
	      var dropDownPosition = offset.get(activeOffsetKey);
	      if (active && dropDownPosition) {
	        var dropDownStyle = _this.getPositionStyle(true, dropDownPosition.position());
	        Object.keys(dropDownStyle).forEach(function (key) {
	          container.style[key] = dropDownStyle[key];
	        });
	      }
	
	      if (!_this.focusItem) {
	        return;
	      }
	      (0, _domScrollIntoView2["default"])(_this.focusItem, container, {
	        onlyScrollIfNeeded: true
	      });
	    };
	
	    _this.getNavigations = function () {
	      var _this$props = _this.props,
	          prefixCls = _this$props.prefixCls,
	          suggestions = _this$props.suggestions;
	      var focusedIndex = _this.state.focusedIndex;
	
	      return suggestions.length ? _react2["default"].Children.map(suggestions, function (element, index) {
	        var focusItem = index === focusedIndex;
	        var ref = focusItem ? function (node) {
	          _this.focusItem = node;
	        } : null;
	        var mentionClass = (0, _classnames2["default"])(prefixCls + '-dropdown-item', {
	          focus: focusItem
	        });
	        if (_react2["default"].isValidElement(element)) {
	          return _react2["default"].cloneElement(element, {
	            className: mentionClass,
	            onMouseDown: function onMouseDown() {
	              return _this.onMentionSelect(element.props.value, element.props.data);
	            },
	            ref: ref
	          });
	        }
	        return _react2["default"].createElement(
	          _Nav2["default"],
	          {
	            ref: ref,
	            className: mentionClass,
	            onMouseDown: function onMouseDown() {
	              return _this.onMentionSelect(element);
	            }
	          },
	          element
	        );
	      }, _this) : _react2["default"].createElement(
	        'div',
	        { className: prefixCls + '-dropdown-notfound ' + prefixCls + '-dropdown-item' },
	        _this.props.notFoundContent
	      );
	    };
	
	    _this.state = {
	      isActive: false,
	      focusedIndex: 0,
	      container: false
	    };
	    return _this;
	  }
	
	  Suggestions.prototype.componentDidMount = function componentDidMount() {
	    this.props.callbacks.onChange = this.onEditorStateChange;
	  };
	
	  Suggestions.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {
	    if (nextProps.suggestions.length !== this.props.suggestions.length) {
	      this.setState({
	        focusedIndex: 0
	      });
	    }
	  };
	
	  Suggestions.prototype.onMentionSelect = function onMentionSelect(mention, data) {
	    var editorState = this.props.callbacks.getEditorState();
	    var _props = this.props,
	        store = _props.store,
	        onSelect = _props.onSelect;
	
	    var trigger = store.getTrigger(this.activeOffsetKey);
	    if (onSelect) {
	      onSelect(mention, data || mention);
	    }
	    if (this.props.noRedup) {
	      var mentions = (0, _getMentions2["default"])(editorState, trigger);
	      if (mentions.indexOf('' + trigger + mention) !== -1) {
	        // eslint-disable-next-line
	        console.warn('you have specified `noRedup` props but have duplicated mentions.');
	        this.closeDropDown();
	        this.props.callbacks.setEditorState((0, _clearMention2["default"])(editorState));
	        return;
	      }
	    }
	    this.props.callbacks.setEditorState((0, _insertMention2["default"])(editorState, '' + trigger + mention, data, this.props.mode), true);
	    this.closeDropDown();
	  };
	
	  Suggestions.prototype.getPositionStyle = function getPositionStyle(isActive, position) {
	    if (this.props.getSuggestionStyle) {
	      return this.props.getSuggestionStyle(isActive, position);
	    }
	    var container = this.props.getSuggestionContainer ? this.state.container : document.body;
	    var offset = (0, _getOffset2["default"])(container);
	    return position ? _extends({
	      position: 'absolute',
	      left: position.left - offset.left + 'px',
	      top: position.top - offset.top + 'px'
	    }, this.props.style) : {};
	  };
	
	  Suggestions.prototype.openDropDown = function openDropDown() {
	    this.props.callbacks.onUpArrow = this.onUpArrow;
	    this.props.callbacks.handleReturn = this.handleReturn;
	    this.props.callbacks.handleKeyBinding = this.handleKeyBinding;
	    this.props.callbacks.onDownArrow = this.onDownArrow;
	    this.props.callbacks.onBlur = this.onBlur;
	    this.setState({
	      active: true,
	      container: this.state.container || this.getContainer()
	    });
	  };
	
	  Suggestions.prototype.closeDropDown = function closeDropDown() {
	    this.props.callbacks.onUpArrow = null;
	    this.props.callbacks.handleReturn = null;
	    this.props.callbacks.handleKeyBinding = null;
	    this.props.callbacks.onDownArrow = null;
	    this.props.callbacks.onBlur = null;
	    this.setState({
	      active: false
	    });
	  };
	
	  Suggestions.prototype.render = function render() {
	    var _this2 = this;
	
	    var _props2 = this.props,
	        prefixCls = _props2.prefixCls,
	        className = _props2.className;
	    var _state = this.state,
	        container = _state.container,
	        active = _state.active;
	
	    var cls = (0, _classnames2["default"])(_extends(_defineProperty({}, prefixCls + '-dropdown', true), className));
	
	    var navigations = this.getNavigations();
	
	    return container ? _react2["default"].createElement(
	      _SuggestionWrapper2["default"],
	      { renderReady: this.renderReady, container: container },
	      _react2["default"].createElement(
	        _rcAnimate2["default"],
	        { transitionName: 'slide-up' },
	        active ? _react2["default"].createElement(
	          'div',
	          { className: cls, ref: function ref(node) {
	              _this2.dropdownContainer = node;
	            } },
	          navigations
	        ) : null
	      )
	    ) : null;
	  };
	
	  return Suggestions;
	}(_react2["default"].Component);
	
	exports["default"] = Suggestions;
	
	
	Suggestions.propTypes = {
	  callbacks: _propTypes2["default"].object,
	  suggestions: _propTypes2["default"].array,
	  store: _propTypes2["default"].object,
	  onSearchChange: _propTypes2["default"].func,
	  prefixCls: _propTypes2["default"].string,
	  mode: _propTypes2["default"].string,
	  style: _propTypes2["default"].object,
	  onSelect: _propTypes2["default"].func,
	  getSuggestionContainer: _propTypes2["default"].func,
	  notFoundContent: _propTypes2["default"].any,
	  getSuggestionStyle: _propTypes2["default"].func,
	  className: _propTypes2["default"].string,
	  noRedup: _propTypes2["default"].bool
	};
	module.exports = exports['default'];

/***/ }),
/* 700 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.getMentions = exports.toEditorState = exports.toString = exports.Nav = undefined;
	
	var _draftJs = __webpack_require__(41);
	
	var _Mention = __webpack_require__(695);
	
	var _Mention2 = _interopRequireDefault(_Mention);
	
	var _exportContent = __webpack_require__(145);
	
	var _exportContent2 = _interopRequireDefault(_exportContent);
	
	var _getMentions = __webpack_require__(256);
	
	var _getMentions2 = _interopRequireDefault(_getMentions);
	
	var _Nav = __webpack_require__(255);
	
	var _Nav2 = _interopRequireDefault(_Nav);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
	
	function toEditorState(text) {
	  return _draftJs.ContentState.createFromText(text);
	} // export this package's api
	
	
	_Mention2["default"].Nav = _Nav2["default"];
	_Mention2["default"].toString = _exportContent2["default"];
	_Mention2["default"].toEditorState = toEditorState;
	_Mention2["default"].getMentions = _getMentions2["default"];
	
	exports.Nav = _Nav2["default"];
	exports.toString = _exportContent2["default"];
	exports.toEditorState = toEditorState;
	exports.getMentions = _getMentions2["default"];
	exports["default"] = _Mention2["default"];

/***/ }),
/* 701 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _immutable = __webpack_require__(11);
	
	var offset = (0, _immutable.Map)(); /* eslint new-cap: [2, {capIsNewExceptions: ["Map"]}] */
	
	var mentionStore = {
	  offset: (0, _immutable.Map)(),
	  getOffset: function getOffset() {
	    return offset;
	  },
	  getTrigger: function getTrigger(offsetKey) {
	    var currentOffset = offset.get(offsetKey);
	    return currentOffset && currentOffset.trigger;
	  },
	  activeSuggestion: function activeSuggestion(_ref) {
	    var offsetKey = _ref.offsetKey;
	
	    offset = offset.set(offsetKey, {
	      offsetKey: offsetKey
	    });
	  },
	  inActiveSuggestion: function inActiveSuggestion(_ref2) {
	    var offsetKey = _ref2.offsetKey;
	
	    offset = offset["delete"](offsetKey);
	  },
	  updateSuggestion: function updateSuggestion(_ref3) {
	    var offsetKey = _ref3.offsetKey,
	        position = _ref3.position,
	        trigger = _ref3.trigger;
	
	    offset = offset.set(offsetKey, {
	      offsetKey: offsetKey,
	      position: position,
	      trigger: trigger
	    });
	  }
	};
	
	exports["default"] = mentionStore;
	module.exports = exports['default'];

/***/ }),
/* 702 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports["default"] = clearMention;
	
	var _draftJs = __webpack_require__(41);
	
	var _getSearchWord = __webpack_require__(146);
	
	var _getSearchWord2 = _interopRequireDefault(_getSearchWord);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
	
	function clearMention(editorState) {
	  var selection = editorState.getSelection();
	  var searchWord = (0, _getSearchWord2["default"])(editorState, selection);
	  var begin = searchWord.begin,
	      end = searchWord.end;
	
	  var replacedContent = _draftJs.Modifier.replaceText(editorState.getCurrentContent(), selection.merge({
	    anchorOffset: begin,
	    focusOffset: end
	  }), '', null);
	
	  var InsertSpaceContent = _draftJs.Modifier.insertText(replacedContent, replacedContent.getSelectionAfter(), ' ');
	
	  var newEditorState = _draftJs.EditorState.push(editorState, InsertSpaceContent, 'insert-mention');
	  return _draftJs.EditorState.forceSelection(newEditorState, InsertSpaceContent.getSelectionAfter());
	}
	module.exports = exports['default'];

/***/ }),
/* 703 */
/***/ (function(module, exports, __webpack_require__) {

	'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; };
	
	exports["default"] = createMention;
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _Suggestions2 = __webpack_require__(699);
	
	var _Suggestions3 = _interopRequireDefault(_Suggestions2);
	
	var _SuggestionPortal = __webpack_require__(697);
	
	var _SuggestionPortal2 = _interopRequireDefault(_SuggestionPortal);
	
	var _MentionContent = __webpack_require__(696);
	
	var _MentionContent2 = _interopRequireDefault(_MentionContent);
	
	var _mentionStore = __webpack_require__(701);
	
	var _mentionStore2 = _interopRequireDefault(_mentionStore);
	
	var _exportContent = __webpack_require__(145);
	
	var _exportContent2 = _interopRequireDefault(_exportContent);
	
	var _getRegExp = __webpack_require__(258);
	
	var _getRegExp2 = _interopRequireDefault(_getRegExp);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
	
	function findWithRegex(regex, contentBlock, callback) {
	  // Get the text from the contentBlock
	  var text = contentBlock.getText();
	  var matchArr = void 0;
	  var start = void 0; // eslint-disable-line
	  // Go through all matches in the text and return the indizes to the callback
	  while ((matchArr = regex.exec(text)) !== null) {
	    // eslint-disable-line
	    start = matchArr.index;
	    callback(start, start + matchArr[0].length);
	  }
	}
	
	function mentionContentStrategy(contentBlock, callback, contentState) {
	  contentBlock.findEntityRanges(function (character) {
	    var entityKey = character.getEntity();
	    return entityKey && contentState.getEntity(entityKey).getType() === 'mention';
	  }, callback);
	}
	
	function noop() {}
	
	var MentionContentComponent = function MentionContentComponent(props) {
	  var entityKey = props.entityKey,
	      tag = props.tag,
	      callbacks = props.callbacks;
	
	  var contentState = callbacks.getEditorState().getCurrentContent();
	  var data = contentState.getEntity(entityKey).getData();
	  return _react2["default"].createElement(tag, _extends({}, props, { data: data }));
	};
	
	function createMention() {
	  var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
	
	  var callbacks = {
	    onChange: noop,
	    onUpArrow: noop,
	    onDownArrow: noop,
	    getEditorState: noop,
	    setEditorState: noop,
	    handleReturn: noop,
	    onBlur: noop
	  };
	  var componentProps = {
	    callbacks: callbacks,
	    mentionStore: _mentionStore2["default"]
	  };
	  var suggestionRegex = (0, _getRegExp2["default"])(config.prefix);
	
	  var tag = config.tag || _MentionContent2["default"];
	  var decorators = [{
	    strategy: function strategy(contentBlock, callback) {
	      findWithRegex(suggestionRegex, contentBlock, callback);
	    },
	    component: function component(props) {
	      return _react2["default"].createElement(_SuggestionPortal2["default"], _extends({}, props, componentProps, {
	        style: config.mentionStyle,
	        suggestionRegex: (0, _getRegExp2["default"])(config.prefix)
	      }));
	    }
	  }];
	  if (config.mode !== 'immutable') {
	    decorators.unshift({
	      strategy: mentionContentStrategy,
	      component: function component(props) {
	        return _react2["default"].createElement(MentionContentComponent, _extends({ tag: tag }, props, { callbacks: callbacks }));
	      }
	    });
	  }
	
	  return {
	    name: 'mention',
	    Suggestions: function Suggestions(props) {
	      return _react2["default"].createElement(_Suggestions3["default"], _extends({}, props, componentProps, {
	        store: _mentionStore2["default"]
	      }));
	    },
	    decorators: decorators,
	    onChange: function onChange(editorState) {
	      return callbacks.onChange ? callbacks.onChange(editorState) : editorState;
	    },
	    callbacks: callbacks,
	    "export": _exportContent2["default"]
	  };
	}
	module.exports = exports['default'];

/***/ }),
/* 704 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports["default"] = insertMention;
	
	var _draftJs = __webpack_require__(41);
	
	var _getSearchWord = __webpack_require__(146);
	
	var _getSearchWord2 = _interopRequireDefault(_getSearchWord);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
	
	function insertMention(editorState, mention, data, mode) {
	  var entityMode = mode === 'immutable' ? 'IMMUTABLE' : 'MUTABLE';
	  var selection = editorState.getSelection();
	  var contentState = editorState.getCurrentContent();
	
	  contentState.createEntity('mention', entityMode, data || mention);
	  var searchWord = (0, _getSearchWord2["default"])(editorState, selection);
	  var begin = searchWord.begin,
	      end = searchWord.end;
	
	  var replacedContent = _draftJs.Modifier.replaceText(contentState, selection.merge({
	    anchorOffset: begin,
	    focusOffset: end
	  }), mention, null, contentState.getLastCreatedEntityKey());
	
	  var InsertSpaceContent = _draftJs.Modifier.insertText(replacedContent, replacedContent.getSelectionAfter(), ' ');
	
	  var newEditorState = _draftJs.EditorState.push(editorState, InsertSpaceContent, 'insert-mention');
	  return _draftJs.EditorState.forceSelection(newEditorState, InsertSpaceContent.getSelectionAfter());
	}
	module.exports = exports['default'];

/***/ }),
/* 705 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _reactDom = __webpack_require__(10);
	
	var _reactDom2 = _interopRequireDefault(_reactDom);
	
	var _domScrollIntoView = __webpack_require__(88);
	
	var _domScrollIntoView2 = _interopRequireDefault(_domScrollIntoView);
	
	var _has = __webpack_require__(139);
	
	var _has2 = _interopRequireDefault(_has);
	
	var _createBaseForm = __webpack_require__(259);
	
	var _createBaseForm2 = _interopRequireDefault(_createBaseForm);
	
	var _createForm = __webpack_require__(707);
	
	var _utils = __webpack_require__(147);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function computedStyle(el, prop) {
	  var getComputedStyle = window.getComputedStyle;
	  var style =
	  // If we have getComputedStyle
	  getComputedStyle ?
	  // Query it
	  // TODO: From CSS-Query notes, we might need (node, null) for FF
	  getComputedStyle(el) :
	
	  // Otherwise, we are in IE and use currentStyle
	  el.currentStyle;
	  if (style) {
	    return style[
	    // Switch to camelCase for CSSOM
	    // DEV: Grabbed from jQuery
	    // https://github.com/jquery/jquery/blob/1.9-stable/src/css.js#L191-L194
	    // https://github.com/jquery/jquery/blob/1.9-stable/src/core.js#L593-L597
	    prop.replace(/-(\w)/gi, function (word, letter) {
	      return letter.toUpperCase();
	    })];
	  }
	  return undefined;
	}
	
	function getScrollableContainer(n) {
	  var node = n;
	  var nodeName = void 0;
	  /* eslint no-cond-assign:0 */
	  while ((nodeName = node.nodeName.toLowerCase()) !== 'body') {
	    var overflowY = computedStyle(node, 'overflowY');
	    // https://stackoverflow.com/a/36900407/3040605
	    if (node !== n && (overflowY === 'auto' || overflowY === 'scroll') && node.scrollHeight > node.clientHeight) {
	      return node;
	    }
	    node = node.parentNode;
	  }
	  return nodeName === 'body' ? node.ownerDocument : node;
	}
	
	var mixin = {
	  getForm: function getForm() {
	    return (0, _extends3['default'])({}, _createForm.mixin.getForm.call(this), {
	      validateFieldsAndScroll: this.validateFieldsAndScroll
	    });
	  },
	  validateFieldsAndScroll: function validateFieldsAndScroll(ns, opt, cb) {
	    var _this = this;
	
	    var _getParams = (0, _utils.getParams)(ns, opt, cb),
	        names = _getParams.names,
	        callback = _getParams.callback,
	        options = _getParams.options;
	
	    var newCb = function newCb(error, values) {
	      if (error) {
	        var validNames = _this.fieldsStore.getValidFieldsName();
	        var firstNode = void 0;
	        var firstTop = void 0;
	        var _iteratorNormalCompletion = true;
	        var _didIteratorError = false;
	        var _iteratorError = undefined;
	
	        try {
	          for (var _iterator = validNames[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
	            var name = _step.value;
	
	            if ((0, _has2['default'])(error, name)) {
	              var instance = _this.getFieldInstance(name);
	              if (instance) {
	                var node = _reactDom2['default'].findDOMNode(instance);
	                var top = node.getBoundingClientRect().top;
	                if (firstTop === undefined || firstTop > top) {
	                  firstTop = top;
	                  firstNode = node;
	                }
	              }
	            }
	          }
	        } catch (err) {
	          _didIteratorError = true;
	          _iteratorError = err;
	        } finally {
	          try {
	            if (!_iteratorNormalCompletion && _iterator['return']) {
	              _iterator['return']();
	            }
	          } finally {
	            if (_didIteratorError) {
	              throw _iteratorError;
	            }
	          }
	        }
	
	        if (firstNode) {
	          var c = options.container || getScrollableContainer(firstNode);
	          (0, _domScrollIntoView2['default'])(firstNode, c, (0, _extends3['default'])({
	            onlyScrollIfNeeded: true
	          }, options.scroll));
	        }
	      }
	
	      if (typeof callback === 'function') {
	        callback(error, values);
	      }
	    };
	
	    return this.validateFields(names, options, newCb);
	  }
	};
	
	function createDOMForm(option) {
	  return (0, _createBaseForm2['default'])((0, _extends3['default'])({}, option), [mixin]);
	}
	
	exports['default'] = createDOMForm;
	module.exports = exports['default'];

/***/ }),
/* 706 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	exports['default'] = createFieldsStore;
	
	var _get = __webpack_require__(234);
	
	var _get2 = _interopRequireDefault(_get);
	
	var _has = __webpack_require__(139);
	
	var _has2 = _interopRequireDefault(_has);
	
	var _set = __webpack_require__(238);
	
	var _set2 = _interopRequireDefault(_set);
	
	var _utils = __webpack_require__(147);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var atom = {};
	
	var FieldsStore = function () {
	  function FieldsStore(fields) {
	    (0, _classCallCheck3['default'])(this, FieldsStore);
	
	    _initialiseProps.call(this);
	
	    this.fields = fields;
	    this.fieldsMeta = {};
	  }
	
	  (0, _createClass3['default'])(FieldsStore, [{
	    key: 'updateFields',
	    value: function updateFields(fields) {
	      (0, _extends3['default'])(this.fields, fields);
	    }
	  }, {
	    key: 'setFields',
	    value: function setFields(fields) {
	      var _this = this;
	
	      var fieldsMeta = this.fieldsMeta;
	      var nowFields = (0, _extends3['default'])({}, this.fields, fields);
	      var nowValues = {};
	      Object.keys(fieldsMeta).forEach(function (f) {
	        var _getNameIfNested = (0, _utils.getNameIfNested)(f),
	            name = _getNameIfNested.name,
	            isNested = _getNameIfNested.isNested;
	
	        if (isNested && fieldsMeta[name].exclusive) {
	          return;
	        }
	        nowValues[f] = _this.getValueFromFields(f, nowFields);
	      });
	      Object.keys(nowValues).forEach(function (f) {
	        var value = nowValues[f];
	        var fieldMeta = fieldsMeta[f];
	        if (fieldMeta && fieldMeta.normalize) {
	          var nowValue = fieldMeta.normalize(value, _this.getValueFromFields(f, _this.fields), nowValues);
	          if (nowValue !== value) {
	            nowFields[f] = (0, _extends3['default'])({}, nowFields[f], {
	              value: nowValue
	            });
	          }
	        }
	      });
	      this.fields = nowFields;
	    }
	  }, {
	    key: 'resetFields',
	    value: function resetFields(ns) {
	      var newFields = {};
	      var fields = this.fields;
	
	      var names = ns || Object.keys(fields);
	      names.forEach(function (name) {
	        var field = fields[name];
	        if (field && 'value' in field) {
	          newFields[name] = {};
	        }
	      });
	      return newFields;
	    }
	  }, {
	    key: 'getValueFromFieldsInternal',
	    value: function getValueFromFieldsInternal(name, fields) {
	      var field = fields[name];
	      if (field && 'value' in field) {
	        return field.value;
	      }
	      var fieldMeta = this.fieldsMeta[name];
	      return fieldMeta && fieldMeta.initialValue;
	    }
	  }, {
	    key: 'getValueFromFields',
	    value: function getValueFromFields(name, fields) {
	      var _this2 = this;
	
	      var fieldsMeta = this.fieldsMeta;
	
	      if (fieldsMeta[name] && fieldsMeta[name].virtual) {
	        var ret = {};
	        Object.keys(fieldsMeta).forEach(function (fieldKey) {
	          var nameIfNested = (0, _utils.getNameIfNested)(fieldKey);
	          if (nameIfNested.name === name && nameIfNested.isNested) {
	            (0, _set2['default'])(ret, fieldKey, _this2.getValueFromFieldsInternal(fieldKey, fields));
	          }
	        });
	        return ret[name];
	      }
	      return this.getValueFromFieldsInternal(name, fields);
	    }
	  }, {
	    key: 'getValidFieldsName',
	    value: function getValidFieldsName() {
	      var fieldsMeta = this.fieldsMeta;
	      return fieldsMeta ? Object.keys(fieldsMeta).filter(function (name) {
	        return !fieldsMeta[name].hidden;
	      }) : [];
	    }
	  }, {
	    key: 'getFieldValuePropValue',
	    value: function getFieldValuePropValue(fieldMeta) {
	      var exclusive = fieldMeta.exclusive,
	          leadingName = fieldMeta.leadingName,
	          name = fieldMeta.name,
	          getValueProps = fieldMeta.getValueProps,
	          valuePropName = fieldMeta.valuePropName;
	      var fieldsMeta = this.fieldsMeta;
	
	      var field = exclusive ? this.getField(leadingName) : this.getField(name);
	      var fieldValue = atom;
	      if (field && 'value' in field) {
	        fieldValue = field.value;
	      }
	      if (fieldValue === atom) {
	        fieldValue = exclusive ? fieldsMeta[leadingName].initialValue : fieldMeta.initialValue;
	      }
	      if (getValueProps) {
	        return getValueProps(fieldValue);
	      }
	      return (0, _defineProperty3['default'])({}, valuePropName, fieldValue);
	    }
	  }, {
	    key: 'getField',
	    value: function getField(name) {
	      return (0, _extends3['default'])({}, this.fields[name], {
	        name: name
	      });
	    }
	  }, {
	    key: 'getFieldMember',
	    value: function getFieldMember(name, member) {
	      return this.getField(name)[member];
	    }
	  }, {
	    key: 'getFieldMeta',
	    value: function getFieldMeta(name) {
	      if (!this.fieldsMeta[name]) {
	        this.fieldsMeta[name] = {};
	      }
	      return this.fieldsMeta[name];
	    }
	  }, {
	    key: 'setFieldMeta',
	    value: function setFieldMeta(name, meta) {
	      this.fieldsMeta[name] = meta;
	    }
	  }, {
	    key: 'clearField',
	    value: function clearField(name) {
	      delete this.fields[name];
	      delete this.fieldsMeta[name];
	    }
	  }]);
	  return FieldsStore;
	}();
	
	var _initialiseProps = function _initialiseProps() {
	  var _this3 = this;
	
	  this.getFieldsValue = function (names) {
	    var fields = names || (0, _utils.flatFieldNames)(_this3.getValidFieldsName());
	    var allValues = {};
	    fields.forEach(function (f) {
	      (0, _set2['default'])(allValues, f, _this3.getFieldValue(f));
	    });
	    return allValues;
	  };
	
	  this.getFieldValue = function (name) {
	    var fields = _this3.fields;
	
	    return _this3.getValueFromFields(name, fields);
	  };
	
	  this.getFieldsError = function (names) {
	    var fields = names || (0, _utils.flatFieldNames)(_this3.getValidFieldsName());
	    var allErrors = {};
	    fields.forEach(function (f) {
	      (0, _set2['default'])(allErrors, f, _this3.getFieldError(f));
	    });
	    return allErrors;
	  };
	
	  this.getFieldError = function (name) {
	    return (0, _utils.getErrorStrs)(_this3.getFieldMember(name, 'errors'));
	  };
	
	  this.setFieldsInitialValue = function (initialValues) {
	    var fieldsMeta = _this3.fieldsMeta;
	    var virtualPaths = (0, _utils.getVirtualPaths)(fieldsMeta);
	    Object.keys(initialValues).forEach(function (name) {
	      if (fieldsMeta[name] && fieldsMeta[name].virtual) {
	        for (var i = 0, len = virtualPaths[name].length; i < len; i++) {
	          var path = virtualPaths[name][i];
	          if ((0, _has2['default'])(initialValues, path)) {
	            fieldsMeta[path] = (0, _extends3['default'])({}, fieldsMeta[path], {
	              initialValue: (0, _get2['default'])(initialValues, path)
	            });
	          }
	        }
	      } else if (fieldsMeta[name]) {
	        fieldsMeta[name] = (0, _extends3['default'])({}, fieldsMeta[name], {
	          initialValue: initialValues[name]
	        });
	      }
	    });
	  };
	
	  this.isFieldValidating = function (name) {
	    return _this3.getFieldMember(name, 'validating');
	  };
	
	  this.isFieldsValidating = function (ns) {
	    var names = ns || _this3.getValidFieldsName();
	    return names.some(function (n) {
	      return _this3.isFieldValidating(n);
	    });
	  };
	
	  this.isFieldTouched = function (name) {
	    return _this3.getFieldMember(name, 'touched');
	  };
	
	  this.isFieldsTouched = function (ns) {
	    var names = ns || _this3.getValidFieldsName();
	    return names.some(function (n) {
	      return _this3.isFieldTouched(n);
	    });
	  };
	};
	
	function createFieldsStore(fields) {
	  return new FieldsStore(fields);
	}
	module.exports = exports['default'];

/***/ }),
/* 707 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.mixin = undefined;
	
	var _createBaseForm = __webpack_require__(259);
	
	var _createBaseForm2 = _interopRequireDefault(_createBaseForm);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var mixin = exports.mixin = {
	  getForm: function getForm() {
	    return {
	      getFieldsValue: this.fieldsStore.getFieldsValue,
	      getFieldValue: this.fieldsStore.getFieldValue,
	      getFieldInstance: this.getFieldInstance,
	      setFieldsValue: this.setFieldsValue,
	      setFields: this.setFields,
	      setFieldsInitialValue: this.fieldsStore.setFieldsInitialValue,
	      getFieldDecorator: this.getFieldDecorator,
	      getFieldProps: this.getFieldProps,
	      getFieldsError: this.fieldsStore.getFieldsError,
	      getFieldError: this.fieldsStore.getFieldError,
	      isFieldValidating: this.fieldsStore.isFieldValidating,
	      isFieldsValidating: this.fieldsStore.isFieldsValidating,
	      isFieldsTouched: this.fieldsStore.isFieldsTouched,
	      isFieldTouched: this.fieldsStore.isFieldTouched,
	      isSubmitting: this.isSubmitting,
	      submit: this.submit,
	      validateFields: this.validateFields,
	      resetFields: this.resetFields
	    };
	  }
	};
	
	function createForm(options) {
	  return (0, _createBaseForm2['default'])(options, [mixin]);
	}
	
	exports['default'] = createForm;

/***/ }),
/* 708 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _objectWithoutProperties2 = __webpack_require__(20);
	
	var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _rcTouchable = __webpack_require__(773);
	
	var _rcTouchable2 = _interopRequireDefault(_rcTouchable);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var InputHandler = function (_Component) {
	  (0, _inherits3['default'])(InputHandler, _Component);
	
	  function InputHandler() {
	    (0, _classCallCheck3['default'])(this, InputHandler);
	    return (0, _possibleConstructorReturn3['default'])(this, (InputHandler.__proto__ || Object.getPrototypeOf(InputHandler)).apply(this, arguments));
	  }
	
	  (0, _createClass3['default'])(InputHandler, [{
	    key: 'render',
	    value: function render() {
	      var _props = this.props,
	          prefixCls = _props.prefixCls,
	          disabled = _props.disabled,
	          otherProps = (0, _objectWithoutProperties3['default'])(_props, ['prefixCls', 'disabled']);
	
	      return _react2['default'].createElement(
	        _rcTouchable2['default'],
	        { disabled: disabled, activeClassName: prefixCls + '-handler-active' },
	        _react2['default'].createElement('span', otherProps)
	      );
	    }
	  }]);
	  return InputHandler;
	}(_react.Component);
	
	InputHandler.propTypes = {
	  prefixCls: _propTypes2['default'].string,
	  disabled: _propTypes2['default'].bool
	};
	
	exports['default'] = InputHandler;
	module.exports = exports['default'];

/***/ }),
/* 709 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _createReactClass = __webpack_require__(14);
	
	var _createReactClass2 = _interopRequireDefault(_createReactClass);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _mixin = __webpack_require__(710);
	
	var _mixin2 = _interopRequireDefault(_mixin);
	
	var _InputHandler = __webpack_require__(708);
	
	var _InputHandler2 = _interopRequireDefault(_InputHandler);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function noop() {}
	
	function preventDefault(e) {
	  e.preventDefault();
	}
	
	var InputNumber = (0, _createReactClass2['default'])({
	  displayName: 'InputNumber',
	
	  propTypes: {
	    focusOnUpDown: _propTypes2['default'].bool,
	    onChange: _propTypes2['default'].func,
	    onKeyDown: _propTypes2['default'].func,
	    onKeyUp: _propTypes2['default'].func,
	    prefixCls: _propTypes2['default'].string,
	    tabIndex: _propTypes2['default'].string,
	    disabled: _propTypes2['default'].bool,
	    onFocus: _propTypes2['default'].func,
	    onBlur: _propTypes2['default'].func,
	    readOnly: _propTypes2['default'].bool,
	    max: _propTypes2['default'].number,
	    min: _propTypes2['default'].number,
	    step: _propTypes2['default'].oneOfType([_propTypes2['default'].number, _propTypes2['default'].string]),
	    upHandler: _propTypes2['default'].node,
	    downHandler: _propTypes2['default'].node,
	    useTouch: _propTypes2['default'].bool,
	    formatter: _propTypes2['default'].func,
	    parser: _propTypes2['default'].func,
	    onMouseEnter: _propTypes2['default'].func,
	    onMouseLeave: _propTypes2['default'].func,
	    onMouseOver: _propTypes2['default'].func,
	    onMouseOut: _propTypes2['default'].func,
	    precision: _propTypes2['default'].number
	  },
	
	  mixins: [_mixin2['default']],
	
	  getDefaultProps: function getDefaultProps() {
	    return {
	      focusOnUpDown: true,
	      useTouch: false,
	      prefixCls: 'rc-input-number'
	    };
	  },
	  componentDidMount: function componentDidMount() {
	    this.componentDidUpdate();
	  },
	  componentWillUpdate: function componentWillUpdate() {
	    try {
	      this.start = this.refs.input.selectionStart;
	      this.end = this.refs.input.selectionEnd;
	    } catch (e) {
	      // Fix error in Chrome:
	      // Failed to read the 'selectionStart' property from 'HTMLInputElement'
	      // http://stackoverflow.com/q/21177489/3040605
	    }
	  },
	  componentDidUpdate: function componentDidUpdate() {
	    if (this.props.focusOnUpDown && this.state.focused) {
	      var selectionRange = this.refs.input.setSelectionRange;
	      if (selectionRange && typeof selectionRange === 'function' && this.start !== undefined && this.end !== undefined && this.start !== this.end) {
	        this.refs.input.setSelectionRange(this.start, this.end);
	      } else {
	        this.focus();
	      }
	    }
	  },
	  onKeyDown: function onKeyDown(e) {
	    if (e.keyCode === 38) {
	      var ratio = this.getRatio(e);
	      this.up(e, ratio);
	      this.stop();
	    } else if (e.keyCode === 40) {
	      var _ratio = this.getRatio(e);
	      this.down(e, _ratio);
	      this.stop();
	    }
	    var onKeyDown = this.props.onKeyDown;
	
	    if (onKeyDown) {
	      for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
	        args[_key - 1] = arguments[_key];
	      }
	
	      onKeyDown.apply(undefined, [e].concat(args));
	    }
	  },
	  onKeyUp: function onKeyUp(e) {
	    this.stop();
	    var onKeyUp = this.props.onKeyUp;
	
	    if (onKeyUp) {
	      for (var _len2 = arguments.length, args = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
	        args[_key2 - 1] = arguments[_key2];
	      }
	
	      onKeyUp.apply(undefined, [e].concat(args));
	    }
	  },
	  getRatio: function getRatio(e) {
	    var ratio = 1;
	    if (e.metaKey || e.ctrlKey) {
	      ratio = 0.1;
	    } else if (e.shiftKey) {
	      ratio = 10;
	    }
	    return ratio;
	  },
	  getValueFromEvent: function getValueFromEvent(e) {
	    return e.target.value;
	  },
	  focus: function focus() {
	    this.refs.input.focus();
	  },
	  formatWrapper: function formatWrapper(num) {
	    if (this.props.formatter) {
	      return this.props.formatter(num);
	    }
	    return num;
	  },
	  render: function render() {
	    var _classNames;
	
	    var props = (0, _extends3['default'])({}, this.props);
	    var prefixCls = props.prefixCls,
	        disabled = props.disabled,
	        readOnly = props.readOnly,
	        useTouch = props.useTouch;
	
	    var classes = (0, _classnames2['default'])((_classNames = {}, (0, _defineProperty3['default'])(_classNames, prefixCls, true), (0, _defineProperty3['default'])(_classNames, props.className, !!props.className), (0, _defineProperty3['default'])(_classNames, prefixCls + '-disabled', disabled), (0, _defineProperty3['default'])(_classNames, prefixCls + '-focused', this.state.focused), _classNames));
	    var upDisabledClass = '';
	    var downDisabledClass = '';
	    var value = this.state.value;
	
	    if (value) {
	      if (!isNaN(value)) {
	        var val = Number(value);
	        if (val >= props.max) {
	          upDisabledClass = prefixCls + '-handler-up-disabled';
	        }
	        if (val <= props.min) {
	          downDisabledClass = prefixCls + '-handler-down-disabled';
	        }
	      } else {
	        upDisabledClass = prefixCls + '-handler-up-disabled';
	        downDisabledClass = prefixCls + '-handler-down-disabled';
	      }
	    }
	
	    var editable = !props.readOnly && !props.disabled;
	
	    // focus state, show input value
	    // unfocus state, show valid value
	    var inputDisplayValue = void 0;
	    if (this.state.focused) {
	      inputDisplayValue = this.state.inputValue;
	    } else {
	      inputDisplayValue = this.toPrecisionAsStep(this.state.value);
	    }
	
	    if (inputDisplayValue === undefined || inputDisplayValue === null) {
	      inputDisplayValue = '';
	    }
	
	    var upEvents = void 0;
	    var downEvents = void 0;
	    if (useTouch) {
	      upEvents = {
	        onTouchStart: editable && !upDisabledClass ? this.up : noop,
	        onTouchEnd: this.stop
	      };
	      downEvents = {
	        onTouchStart: editable && !downDisabledClass ? this.down : noop,
	        onTouchEnd: this.stop
	      };
	    } else {
	      upEvents = {
	        onMouseDown: editable && !upDisabledClass ? this.up : noop,
	        onMouseUp: this.stop,
	        onMouseLeave: this.stop
	      };
	      downEvents = {
	        onMouseDown: editable && !downDisabledClass ? this.down : noop,
	        onMouseUp: this.stop,
	        onMouseLeave: this.stop
	      };
	    }
	    var inputDisplayValueFormat = this.formatWrapper(inputDisplayValue);
	    var isUpDisabled = !!upDisabledClass || disabled || readOnly;
	    var isDownDisabled = !!downDisabledClass || disabled || readOnly;
	    // ref for test
	    return _react2['default'].createElement(
	      'div',
	      {
	        className: classes,
	        style: props.style,
	        onMouseEnter: props.onMouseEnter,
	        onMouseLeave: props.onMouseLeave,
	        onMouseOver: props.onMouseOver,
	        onMouseOut: props.onMouseOut
	      },
	      _react2['default'].createElement(
	        'div',
	        { className: prefixCls + '-handler-wrap' },
	        _react2['default'].createElement(
	          _InputHandler2['default'],
	          (0, _extends3['default'])({
	            ref: 'up',
	            disabled: isUpDisabled,
	            prefixCls: prefixCls,
	            unselectable: 'unselectable'
	          }, upEvents, {
	            role: 'button',
	            'aria-label': 'Increase Value',
	            'aria-disabled': !!isUpDisabled,
	            className: prefixCls + '-handler ' + prefixCls + '-handler-up ' + upDisabledClass
	          }),
	          this.props.upHandler || _react2['default'].createElement('span', {
	            unselectable: 'unselectable',
	            className: prefixCls + '-handler-up-inner',
	            onClick: preventDefault
	          })
	        ),
	        _react2['default'].createElement(
	          _InputHandler2['default'],
	          (0, _extends3['default'])({
	            ref: 'down',
	            disabled: isDownDisabled,
	            prefixCls: prefixCls,
	            unselectable: 'unselectable'
	          }, downEvents, {
	            role: 'button',
	            'aria-label': 'Decrease Value',
	            'aria-disabled': !!isDownDisabled,
	            className: prefixCls + '-handler ' + prefixCls + '-handler-down ' + downDisabledClass
	          }),
	          this.props.downHandler || _react2['default'].createElement('span', {
	            unselectable: 'unselectable',
	            className: prefixCls + '-handler-down-inner',
	            onClick: preventDefault
	          })
	        )
	      ),
	      _react2['default'].createElement(
	        'div',
	        {
	          className: prefixCls + '-input-wrap',
	          role: 'spinbutton',
	          'aria-valuemin': props.min,
	          'aria-valuemax': props.max,
	          'aria-valuenow': value
	        },
	        _react2['default'].createElement('input', {
	          type: props.type,
	          placeholder: props.placeholder,
	          onClick: props.onClick,
	          className: prefixCls + '-input',
	          tabIndex: props.tabIndex,
	          autoComplete: 'off',
	          onFocus: this.onFocus,
	          onBlur: this.onBlur,
	          onKeyDown: editable ? this.onKeyDown : noop,
	          onKeyUp: editable ? this.onKeyUp : noop,
	          autoFocus: props.autoFocus,
	          maxLength: props.maxLength,
	          readOnly: props.readOnly,
	          disabled: props.disabled,
	          max: props.max,
	          min: props.min,
	          step: props.step,
	          name: props.name,
	          id: props.id,
	          onChange: this.onChange,
	          ref: 'input',
	          value: inputDisplayValueFormat
	        })
	      )
	    );
	  }
	});
	
	exports['default'] = InputNumber;
	module.exports = exports['default'];

/***/ }),
/* 710 */
/***/ (function(module, exports) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	function noop() {}
	
	function defaultParser(input) {
	  return input.replace(/[^\w\.-]+/g, '');
	}
	
	/**
	 * When click and hold on a button - the speed of auto changin the value.
	 */
	var SPEED = 200;
	
	/**
	 * When click and hold on a button - the delay before auto changin the value.
	 */
	var DELAY = 600;
	
	/**
	 * Max Safe Integer -- on IE this is not available, so manually set the number in that case.
	 * The reason this is used, instead of Infinity is because numbers above the MSI are unstable
	 */
	var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || Math.pow(2, 53) - 1;
	
	exports['default'] = {
	  getDefaultProps: function getDefaultProps() {
	    return {
	      max: MAX_SAFE_INTEGER,
	      min: -MAX_SAFE_INTEGER,
	      step: 1,
	      style: {},
	      onChange: noop,
	      onKeyDown: noop,
	      onFocus: noop,
	      onBlur: noop,
	      parser: defaultParser
	    };
	  },
	  getInitialState: function getInitialState() {
	    var value = void 0;
	    var props = this.props;
	    if ('value' in props) {
	      value = props.value;
	    } else {
	      value = props.defaultValue;
	    }
	    value = this.toNumber(value);
	    return {
	      inputValue: this.toPrecisionAsStep(value),
	      value: value,
	      focused: props.autoFocus
	    };
	  },
	  componentWillReceiveProps: function componentWillReceiveProps(nextProps) {
	    if ('value' in nextProps) {
	      var value = this.state.focused ? nextProps.value : this.getValidValue(nextProps.value);
	      this.setState({
	        value: value,
	        inputValue: this.inputting ? value : this.toPrecisionAsStep(value)
	      });
	    }
	  },
	  componentWillUnmount: function componentWillUnmount() {
	    this.stop();
	  },
	  onChange: function onChange(e) {
	    if (this.state.focused) {
	      this.inputting = true;
	    }
	    var input = this.props.parser(this.getValueFromEvent(e).trim());
	    this.setState({ inputValue: input });
	    this.props.onChange(this.toNumberWhenUserInput(input)); // valid number or invalid string
	  },
	  onFocus: function onFocus() {
	    var _props;
	
	    this.setState({
	      focused: true
	    });
	    (_props = this.props).onFocus.apply(_props, arguments);
	  },
	  onBlur: function onBlur(e) {
	    var _this = this;
	
	    for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
	      args[_key - 1] = arguments[_key];
	    }
	
	    this.inputting = false;
	    this.setState({
	      focused: false
	    });
	    var value = this.getCurrentValidValue(this.state.inputValue);
	    e.persist(); // fix https://github.com/react-component/input-number/issues/51
	    this.setValue(value, function () {
	      var _props2;
	
	      (_props2 = _this.props).onBlur.apply(_props2, [e].concat(args));
	    });
	  },
	  getCurrentValidValue: function getCurrentValidValue(value) {
	    var val = value;
	    if (val === '') {
	      val = '';
	    } else if (!this.isNotCompleteNumber(val)) {
	      val = this.getValidValue(val);
	    } else {
	      val = this.state.value;
	    }
	    return this.toNumber(val);
	  },
	  getValidValue: function getValidValue(value) {
	    var val = parseFloat(value, 10);
	    // https://github.com/ant-design/ant-design/issues/7358
	    if (isNaN(val)) {
	      return value;
	    }
	    if (val < this.props.min) {
	      val = this.props.min;
	    }
	    if (val > this.props.max) {
	      val = this.props.max;
	    }
	    return val;
	  },
	  setValue: function setValue(v, callback) {
	    // trigger onChange
	    var newValue = this.isNotCompleteNumber(parseFloat(v, 10)) ? undefined : parseFloat(v, 10);
	    var changed = newValue !== this.state.value || '' + newValue !== '' + this.state.inputValue; // https://github.com/ant-design/ant-design/issues/7363
	    if (!('value' in this.props)) {
	      this.setState({
	        value: newValue,
	        inputValue: this.toPrecisionAsStep(v)
	      }, callback);
	    } else {
	      // always set input value same as value
	      this.setState({
	        inputValue: this.toPrecisionAsStep(this.state.value)
	      }, callback);
	    }
	    if (changed) {
	      this.props.onChange(newValue);
	    }
	  },
	  getPrecision: function getPrecision(value) {
	    if ('precision' in this.props) {
	      return this.props.precision;
	    }
	    var valueString = value.toString();
	    if (valueString.indexOf('e-') >= 0) {
	      return parseInt(valueString.slice(valueString.indexOf('e-') + 2), 10);
	    }
	    var precision = 0;
	    if (valueString.indexOf('.') >= 0) {
	      precision = valueString.length - valueString.indexOf('.') - 1;
	    }
	    return precision;
	  },
	
	
	  // step={1.0} value={1.51}
	  // press +
	  // then value should be 2.51, rather than 2.5
	  // if this.props.precision is undefined
	  // https://github.com/react-component/input-number/issues/39
	  getMaxPrecision: function getMaxPrecision(currentValue) {
	    var ratio = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
	
	    if ('precision' in this.props) {
	      return this.props.precision;
	    }
	    var step = this.props.step;
	
	    var ratioPrecision = this.getPrecision(ratio);
	    var stepPrecision = this.getPrecision(step);
	    var currentValuePrecision = this.getPrecision(currentValue);
	    if (!currentValue) {
	      return ratioPrecision + stepPrecision;
	    }
	    return Math.max(currentValuePrecision, ratioPrecision + stepPrecision);
	  },
	  getPrecisionFactor: function getPrecisionFactor(currentValue) {
	    var ratio = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
	
	    var precision = this.getMaxPrecision(currentValue, ratio);
	    return Math.pow(10, precision);
	  },
	  toPrecisionAsStep: function toPrecisionAsStep(num) {
	    if (this.isNotCompleteNumber(num) || num === '') {
	      return num;
	    }
	    var precision = Math.abs(this.getMaxPrecision(num));
	    if (precision === 0) {
	      return num.toString();
	    }
	    if (!isNaN(precision)) {
	      return Number(num).toFixed(precision);
	    }
	    return num.toString();
	  },
	
	
	  // '1.' '1x' 'xx' '' => are not complete numbers
	  isNotCompleteNumber: function isNotCompleteNumber(num) {
	    return isNaN(num) || num === '' || num === null || num && num.toString().indexOf('.') === num.toString().length - 1;
	  },
	  toNumber: function toNumber(num) {
	    if (this.isNotCompleteNumber(num)) {
	      return num;
	    }
	    if ('precision' in this.props) {
	      return Number(Number(num).toFixed(this.props.precision));
	    }
	    return Number(num);
	  },
	
	
	  // '1.0' '1.00'  => may be a inputing number
	  toNumberWhenUserInput: function toNumberWhenUserInput(num) {
	    // num.length > 16 => prevent input large number will became Infinity
	    if ((/\.\d*0$/.test(num) || num.length > 16) && this.state.focused) {
	      return num;
	    }
	    return this.toNumber(num);
	  },
	  upStep: function upStep(val, rat) {
	    var _props3 = this.props,
	        step = _props3.step,
	        min = _props3.min;
	
	    var precisionFactor = this.getPrecisionFactor(val, rat);
	    var precision = Math.abs(this.getMaxPrecision(val, rat));
	    var result = void 0;
	    if (typeof val === 'number') {
	      result = ((precisionFactor * val + precisionFactor * step * rat) / precisionFactor).toFixed(precision);
	    } else {
	      result = min === -Infinity ? step : min;
	    }
	    return this.toNumber(result);
	  },
	  downStep: function downStep(val, rat) {
	    var _props4 = this.props,
	        step = _props4.step,
	        min = _props4.min;
	
	    var precisionFactor = this.getPrecisionFactor(val, rat);
	    var precision = Math.abs(this.getMaxPrecision(val, rat));
	    var result = void 0;
	    if (typeof val === 'number') {
	      result = ((precisionFactor * val - precisionFactor * step * rat) / precisionFactor).toFixed(precision);
	    } else {
	      result = min === -Infinity ? -step : min;
	    }
	    return this.toNumber(result);
	  },
	  step: function step(type, e) {
	    var ratio = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
	
	    if (e) {
	      e.preventDefault();
	    }
	    var props = this.props;
	    if (props.disabled) {
	      return;
	    }
	    var value = this.getCurrentValidValue(this.state.inputValue) || 0;
	    if (this.isNotCompleteNumber(value)) {
	      return;
	    }
	    var val = this[type + 'Step'](value, ratio);
	    if (val > props.max) {
	      val = props.max;
	    } else if (val < props.min) {
	      val = props.min;
	    }
	    this.setValue(val);
	    this.setState({
	      focused: true
	    });
	  },
	  stop: function stop() {
	    if (this.autoStepTimer) {
	      clearTimeout(this.autoStepTimer);
	    }
	  },
	  down: function down(e, ratio, recursive) {
	    var _this2 = this;
	
	    if (e.persist) {
	      e.persist();
	    }
	    this.stop();
	    this.step('down', e, ratio);
	    this.autoStepTimer = setTimeout(function () {
	      _this2.down(e, ratio, true);
	    }, recursive ? SPEED : DELAY);
	  },
	  up: function up(e, ratio, recursive) {
	    var _this3 = this;
	
	    if (e.persist) {
	      e.persist();
	    }
	    this.stop();
	    this.step('up', e, ratio);
	    this.autoStepTimer = setTimeout(function () {
	      _this3.up(e, ratio, true);
	    }, recursive ? SPEED : DELAY);
	  }
	};
	module.exports = exports['default'];

/***/ }),
/* 711 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _createReactClass = __webpack_require__(14);
	
	var _createReactClass2 = _interopRequireDefault(_createReactClass);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
	
	var DOMWrap = (0, _createReactClass2["default"])({
	  displayName: 'DOMWrap',
	
	  propTypes: {
	    tag: _propTypes2["default"].string,
	    hiddenClassName: _propTypes2["default"].string,
	    visible: _propTypes2["default"].bool
	  },
	
	  getDefaultProps: function getDefaultProps() {
	    return {
	      tag: 'div'
	    };
	  },
	  render: function render() {
	    var props = (0, _extends3["default"])({}, this.props);
	    if (!props.visible) {
	      props.className = props.className || '';
	      props.className += ' ' + props.hiddenClassName;
	    }
	    var Tag = props.tag;
	    delete props.tag;
	    delete props.hiddenClassName;
	    delete props.visible;
	    return _react2["default"].createElement(Tag, props);
	  }
	});
	
	exports["default"] = DOMWrap;
	module.exports = exports['default'];

/***/ }),
/* 712 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _createReactClass = __webpack_require__(14);
	
	var _createReactClass2 = _interopRequireDefault(_createReactClass);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
	
	var Divider = (0, _createReactClass2["default"])({
	  displayName: 'Divider',
	
	  propTypes: {
	    disabled: _propTypes2["default"].bool,
	    className: _propTypes2["default"].string,
	    rootPrefixCls: _propTypes2["default"].string
	  },
	
	  getDefaultProps: function getDefaultProps() {
	    return {
	      disabled: true
	    };
	  },
	  render: function render() {
	    var _props = this.props,
	        _props$className = _props.className,
	        className = _props$className === undefined ? '' : _props$className,
	        rootPrefixCls = _props.rootPrefixCls;
	
	    return _react2["default"].createElement('li', { className: className + ' ' + rootPrefixCls + '-item-divider' });
	  }
	});
	
	exports["default"] = Divider;
	module.exports = exports['default'];

/***/ }),
/* 713 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _createReactClass = __webpack_require__(14);
	
	var _createReactClass2 = _interopRequireDefault(_createReactClass);
	
	var _MenuMixin = __webpack_require__(260);
	
	var _MenuMixin2 = _interopRequireDefault(_MenuMixin);
	
	var _util = __webpack_require__(97);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
	
	// import React from 'react';
	var Menu = (0, _createReactClass2["default"])({
	  displayName: 'Menu',
	
	  propTypes: {
	    openSubMenuOnMouseEnter: _propTypes2["default"].bool,
	    closeSubMenuOnMouseLeave: _propTypes2["default"].bool,
	    selectedKeys: _propTypes2["default"].arrayOf(_propTypes2["default"].string),
	    defaultSelectedKeys: _propTypes2["default"].arrayOf(_propTypes2["default"].string),
	    defaultOpenKeys: _propTypes2["default"].arrayOf(_propTypes2["default"].string),
	    openKeys: _propTypes2["default"].arrayOf(_propTypes2["default"].string),
	    mode: _propTypes2["default"].string,
	    onClick: _propTypes2["default"].func,
	    onSelect: _propTypes2["default"].func,
	    onDeselect: _propTypes2["default"].func,
	    onDestroy: _propTypes2["default"].func,
	    openTransitionName: _propTypes2["default"].string,
	    openAnimation: _propTypes2["default"].oneOfType([_propTypes2["default"].string, _propTypes2["default"].object]),
	    level: _propTypes2["default"].number,
	    eventKey: _propTypes2["default"].string,
	    selectable: _propTypes2["default"].bool,
	    children: _propTypes2["default"].any
	  },
	
	  mixins: [_MenuMixin2["default"]],
	
	  getDefaultProps: function getDefaultProps() {
	    return {
	      openSubMenuOnMouseEnter: true,
	      closeSubMenuOnMouseLeave: true,
	      selectable: true,
	      onClick: _util.noop,
	      onSelect: _util.noop,
	      onOpenChange: _util.noop,
	      onDeselect: _util.noop,
	      defaultSelectedKeys: [],
	      defaultOpenKeys: []
	    };
	  },
	  getInitialState: function getInitialState() {
	    var props = this.props;
	    var selectedKeys = props.defaultSelectedKeys;
	    var openKeys = props.defaultOpenKeys;
	    if ('selectedKeys' in props) {
	      selectedKeys = props.selectedKeys || [];
	    }
	    if ('openKeys' in props) {
	      openKeys = props.openKeys || [];
	    }
	    return {
	      selectedKeys: selectedKeys,
	      openKeys: openKeys
	    };
	  },
	  componentWillReceiveProps: function componentWillReceiveProps(nextProps) {
	    var props = {};
	    if ('selectedKeys' in nextProps) {
	      props.selectedKeys = nextProps.selectedKeys || [];
	    }
	    if ('openKeys' in nextProps) {
	      props.openKeys = nextProps.openKeys || [];
	    }
	    this.setState(props);
	  },
	  onDestroy: function onDestroy(key) {
	    var state = this.state;
	    var props = this.props;
	    var selectedKeys = state.selectedKeys;
	    var openKeys = state.openKeys;
	    var index = selectedKeys.indexOf(key);
	    if (!('selectedKeys' in props) && index !== -1) {
	      selectedKeys.splice(index, 1);
	    }
	    index = openKeys.indexOf(key);
	    if (!('openKeys' in props) && index !== -1) {
	      openKeys.splice(index, 1);
	    }
	  },
	  onItemHover: function onItemHover(e) {
	    var item = e.item;
	    var _props = this.props,
	        mode = _props.mode,
	        closeSubMenuOnMouseLeave = _props.closeSubMenuOnMouseLeave;
	    var _e$openChanges = e.openChanges,
	        openChanges = _e$openChanges === undefined ? [] : _e$openChanges;
	    // special for top sub menu
	
	    if (mode !== 'inline' && !closeSubMenuOnMouseLeave && item.isSubMenu) {
	      var activeKey = this.state.activeKey;
	      var activeItem = this.getFlatInstanceArray().filter(function (c) {
	        return c && c.props.eventKey === activeKey;
	      })[0];
	      if (activeItem && activeItem.props.open) {
	        openChanges = openChanges.concat({
	          key: item.props.eventKey,
	          item: item,
	          originalEvent: e,
	          open: true
	        });
	      }
	    }
	    openChanges = openChanges.concat(this.getOpenChangesOnItemHover(e));
	    if (openChanges.length) {
	      this.onOpenChange(openChanges);
	    }
	  },
	  onSelect: function onSelect(selectInfo) {
	    var props = this.props;
	    if (props.selectable) {
	      // root menu
	      var selectedKeys = this.state.selectedKeys;
	      var selectedKey = selectInfo.key;
	      if (props.multiple) {
	        selectedKeys = selectedKeys.concat([selectedKey]);
	      } else {
	        selectedKeys = [selectedKey];
	      }
	      if (!('selectedKeys' in props)) {
	        this.setState({
	          selectedKeys: selectedKeys
	        });
	      }
	      props.onSelect((0, _extends3["default"])({}, selectInfo, {
	        selectedKeys: selectedKeys
	      }));
	    }
	  },
	  onClick: function onClick(e) {
	    this.props.onClick(e);
	  },
	  onOpenChange: function onOpenChange(e_) {
	    var props = this.props;
	    var openKeys = this.state.openKeys.concat();
	    var changed = false;
	    var processSingle = function processSingle(e) {
	      var oneChanged = false;
	      if (e.open) {
	        oneChanged = openKeys.indexOf(e.key) === -1;
	        if (oneChanged) {
	          openKeys.push(e.key);
	        }
	      } else {
	        var index = openKeys.indexOf(e.key);
	        oneChanged = index !== -1;
	        if (oneChanged) {
	          openKeys.splice(index, 1);
	        }
	      }
	      changed = changed || oneChanged;
	    };
	    if (Array.isArray(e_)) {
	      // batch change call
	      e_.forEach(processSingle);
	    } else {
	      processSingle(e_);
	    }
	    if (changed) {
	      if (!('openKeys' in this.props)) {
	        this.setState({ openKeys: openKeys });
	      }
	      props.onOpenChange(openKeys);
	    }
	  },
	  onDeselect: function onDeselect(selectInfo) {
	    var props = this.props;
	    if (props.selectable) {
	      var selectedKeys = this.state.selectedKeys.concat();
	      var selectedKey = selectInfo.key;
	      var index = selectedKeys.indexOf(selectedKey);
	      if (index !== -1) {
	        selectedKeys.splice(index, 1);
	      }
	      if (!('selectedKeys' in props)) {
	        this.setState({
	          selectedKeys: selectedKeys
	        });
	      }
	      props.onDeselect((0, _extends3["default"])({}, selectInfo, {
	        selectedKeys: selectedKeys
	      }));
	    }
	  },
	  getOpenTransitionName: function getOpenTransitionName() {
	    var props = this.props;
	    var transitionName = props.openTransitionName;
	    var animationName = props.openAnimation;
	    if (!transitionName && typeof animationName === 'string') {
	      transitionName = props.prefixCls + '-open-' + animationName;
	    }
	    return transitionName;
	  },
	  isInlineMode: function isInlineMode() {
	    return this.props.mode === 'inline';
	  },
	  lastOpenSubMenu: function lastOpenSubMenu() {
	    var lastOpen = [];
	    var openKeys = this.state.openKeys;
	
	    if (openKeys.length) {
	      lastOpen = this.getFlatInstanceArray().filter(function (c) {
	        return c && openKeys.indexOf(c.props.eventKey) !== -1;
	      });
	    }
	    return lastOpen[0];
	  },
	  renderMenuItem: function renderMenuItem(c, i, subIndex) {
	    if (!c) {
	      return null;
	    }
	    var state = this.state;
	    var extraProps = {
	      openKeys: state.openKeys,
	      selectedKeys: state.selectedKeys,
	      openSubMenuOnMouseEnter: this.props.openSubMenuOnMouseEnter
	    };
	    return this.renderCommonMenuItem(c, i, subIndex, extraProps);
	  },
	  render: function render() {
	    var props = (0, _extends3["default"])({}, this.props);
	    props.className += ' ' + props.prefixCls + '-root';
	    return this.renderRoot(props);
	  }
	});
	
	exports["default"] = Menu;
	module.exports = exports['default'];

/***/ }),
/* 714 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _createReactClass = __webpack_require__(14);
	
	var _createReactClass2 = _interopRequireDefault(_createReactClass);
	
	var _KeyCode = __webpack_require__(29);
	
	var _KeyCode2 = _interopRequireDefault(_KeyCode);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _util = __webpack_require__(97);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
	
	/* eslint react/no-is-mounted:0 */
	
	var MenuItem = (0, _createReactClass2["default"])({
	  displayName: 'MenuItem',
	
	  propTypes: {
	    rootPrefixCls: _propTypes2["default"].string,
	    eventKey: _propTypes2["default"].string,
	    active: _propTypes2["default"].bool,
	    children: _propTypes2["default"].any,
	    selectedKeys: _propTypes2["default"].array,
	    disabled: _propTypes2["default"].bool,
	    title: _propTypes2["default"].string,
	    onSelect: _propTypes2["default"].func,
	    onClick: _propTypes2["default"].func,
	    onDeselect: _propTypes2["default"].func,
	    parentMenu: _propTypes2["default"].object,
	    onItemHover: _propTypes2["default"].func,
	    onDestroy: _propTypes2["default"].func,
	    onMouseEnter: _propTypes2["default"].func,
	    onMouseLeave: _propTypes2["default"].func
	  },
	
	  getDefaultProps: function getDefaultProps() {
	    return {
	      onSelect: _util.noop,
	      onMouseEnter: _util.noop,
	      onMouseLeave: _util.noop
	    };
	  },
	  componentWillUnmount: function componentWillUnmount() {
	    var props = this.props;
	    if (props.onDestroy) {
	      props.onDestroy(props.eventKey);
	    }
	    if (props.parentMenu.menuItemInstance === this) {
	      this.clearMenuItemMouseLeaveTimer();
	    }
	  },
	  onKeyDown: function onKeyDown(e) {
	    var keyCode = e.keyCode;
	    if (keyCode === _KeyCode2["default"].ENTER) {
	      this.onClick(e);
	      return true;
	    }
	  },
	  onMouseLeave: function onMouseLeave(e) {
	    var _this = this;
	
	    var props = this.props;
	    var eventKey = props.eventKey,
	        parentMenu = props.parentMenu;
	
	    parentMenu.menuItemInstance = this;
	    parentMenu.menuItemMouseLeaveFn = function () {
	      if (props.active) {
	        props.onItemHover({
	          key: eventKey,
	          item: _this,
	          hover: false,
	          domEvent: e,
	          trigger: 'mouseleave'
	        });
	      }
	    };
	    parentMenu.menuItemMouseLeaveTimer = setTimeout(parentMenu.menuItemMouseLeaveFn, 30);
	    props.onMouseLeave({
	      key: eventKey,
	      domEvent: e
	    });
	  },
	  onMouseEnter: function onMouseEnter(e) {
	    var props = this.props;
	    var eventKey = props.eventKey,
	        parentMenu = props.parentMenu;
	
	    this.clearMenuItemMouseLeaveTimer(parentMenu.menuItemInstance !== this);
	    if (parentMenu.subMenuInstance) {
	      parentMenu.subMenuInstance.clearSubMenuTimers();
	    }
	    props.onItemHover({
	      key: eventKey,
	      item: this,
	      hover: true,
	      domEvent: e,
	      trigger: 'mouseenter'
	    });
	    props.onMouseEnter({
	      key: eventKey,
	      domEvent: e
	    });
	  },
	  onClick: function onClick(e) {
	    var props = this.props;
	    var selected = this.isSelected();
	    var eventKey = props.eventKey;
	    var info = {
	      key: eventKey,
	      keyPath: [eventKey],
	      item: this,
	      domEvent: e
	    };
	    props.onClick(info);
	    if (props.multiple) {
	      if (selected) {
	        props.onDeselect(info);
	      } else {
	        props.onSelect(info);
	      }
	    } else if (!selected) {
	      props.onSelect(info);
	    }
	  },
	  getPrefixCls: function getPrefixCls() {
	    return this.props.rootPrefixCls + '-item';
	  },
	  getActiveClassName: function getActiveClassName() {
	    return this.getPrefixCls() + '-active';
	  },
	  getSelectedClassName: function getSelectedClassName() {
	    return this.getPrefixCls() + '-selected';
	  },
	  getDisabledClassName: function getDisabledClassName() {
	    return this.getPrefixCls() + '-disabled';
	  },
	  clearMenuItemMouseLeaveTimer: function clearMenuItemMouseLeaveTimer() {
	    var props = this.props;
	    var callFn = void 0;
	    var parentMenu = props.parentMenu;
	    if (parentMenu.menuItemMouseLeaveTimer) {
	      clearTimeout(parentMenu.menuItemMouseLeaveTimer);
	      parentMenu.menuItemMouseLeaveTimer = null;
	      if (callFn && parentMenu.menuItemMouseLeaveFn) {
	        parentMenu.menuItemMouseLeaveFn();
	      }
	      parentMenu.menuItemMouseLeaveFn = null;
	    }
	  },
	  isSelected: function isSelected() {
	    return this.props.selectedKeys.indexOf(this.props.eventKey) !== -1;
	  },
	  render: function render() {
	    var props = this.props;
	    var selected = this.isSelected();
	    var classes = {};
	    classes[this.getActiveClassName()] = !props.disabled && props.active;
	    classes[this.getSelectedClassName()] = selected;
	    classes[this.getDisabledClassName()] = props.disabled;
	    classes[this.getPrefixCls()] = true;
	    classes[props.className] = !!props.className;
	    var attrs = (0, _extends3["default"])({}, props.attribute, {
	      title: props.title,
	      className: (0, _classnames2["default"])(classes),
	      role: 'menuitem',
	      'aria-selected': selected,
	      'aria-disabled': props.disabled
	    });
	    var mouseEvent = {};
	    if (!props.disabled) {
	      mouseEvent = {
	        onClick: this.onClick,
	        onMouseLeave: this.onMouseLeave,
	        onMouseEnter: this.onMouseEnter
	      };
	    }
	    var style = (0, _extends3["default"])({}, props.style);
	    if (props.mode === 'inline') {
	      style.paddingLeft = props.inlineIndent * props.level;
	    }
	    return _react2["default"].createElement(
	      'li',
	      (0, _extends3["default"])({
	        style: style
	      }, attrs, mouseEvent),
	      props.children
	    );
	  }
	});
	
	MenuItem.isMenuItem = 1;
	
	exports["default"] = MenuItem;
	module.exports = exports['default'];

/***/ }),
/* 715 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _createReactClass = __webpack_require__(14);
	
	var _createReactClass2 = _interopRequireDefault(_createReactClass);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
	
	var MenuItemGroup = (0, _createReactClass2["default"])({
	  displayName: 'MenuItemGroup',
	
	  propTypes: {
	    renderMenuItem: _propTypes2["default"].func,
	    index: _propTypes2["default"].number,
	    className: _propTypes2["default"].string,
	    rootPrefixCls: _propTypes2["default"].string
	  },
	
	  getDefaultProps: function getDefaultProps() {
	    return {
	      disabled: true
	    };
	  },
	  renderInnerMenuItem: function renderInnerMenuItem(item, subIndex) {
	    var _props = this.props,
	        renderMenuItem = _props.renderMenuItem,
	        index = _props.index;
	
	    return renderMenuItem(item, index, subIndex);
	  },
	  render: function render() {
	    var props = this.props;
	    var _props$className = props.className,
	        className = _props$className === undefined ? '' : _props$className,
	        rootPrefixCls = props.rootPrefixCls;
	
	    var titleClassName = rootPrefixCls + '-item-group-title';
	    var listClassName = rootPrefixCls + '-item-group-list';
	    return _react2["default"].createElement(
	      'li',
	      { className: className + ' ' + rootPrefixCls + '-item-group' },
	      _react2["default"].createElement(
	        'div',
	        {
	          className: titleClassName,
	          title: typeof props.title === 'string' ? props.title : undefined
	        },
	        props.title
	      ),
	      _react2["default"].createElement(
	        'ul',
	        { className: listClassName },
	        _react2["default"].Children.map(props.children, this.renderInnerMenuItem)
	      )
	    );
	  }
	});
	
	MenuItemGroup.isMenuItemGroup = true;
	
	exports["default"] = MenuItemGroup;
	module.exports = exports['default'];

/***/ }),
/* 716 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _createReactClass = __webpack_require__(14);
	
	var _createReactClass2 = _interopRequireDefault(_createReactClass);
	
	var _SubPopupMenu = __webpack_require__(718);
	
	var _SubPopupMenu2 = _interopRequireDefault(_SubPopupMenu);
	
	var _KeyCode = __webpack_require__(29);
	
	var _KeyCode2 = _interopRequireDefault(_KeyCode);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _util = __webpack_require__(97);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
	
	var guid = 0;
	
	/* eslint react/no-is-mounted:0 */
	
	var SubMenu = (0, _createReactClass2["default"])({
	  displayName: 'SubMenu',
	
	  propTypes: {
	    parentMenu: _propTypes2["default"].object,
	    title: _propTypes2["default"].node,
	    children: _propTypes2["default"].any,
	    selectedKeys: _propTypes2["default"].array,
	    openKeys: _propTypes2["default"].array,
	    onClick: _propTypes2["default"].func,
	    onOpenChange: _propTypes2["default"].func,
	    rootPrefixCls: _propTypes2["default"].string,
	    eventKey: _propTypes2["default"].string,
	    multiple: _propTypes2["default"].bool,
	    active: _propTypes2["default"].bool,
	    onSelect: _propTypes2["default"].func,
	    closeSubMenuOnMouseLeave: _propTypes2["default"].bool,
	    openSubMenuOnMouseEnter: _propTypes2["default"].bool,
	    onDeselect: _propTypes2["default"].func,
	    onDestroy: _propTypes2["default"].func,
	    onItemHover: _propTypes2["default"].func,
	    onMouseEnter: _propTypes2["default"].func,
	    onMouseLeave: _propTypes2["default"].func,
	    onTitleMouseEnter: _propTypes2["default"].func,
	    onTitleMouseLeave: _propTypes2["default"].func,
	    onTitleClick: _propTypes2["default"].func
	  },
	
	  mixins: [__webpack_require__(717)],
	
	  getDefaultProps: function getDefaultProps() {
	    return {
	      onMouseEnter: _util.noop,
	      onMouseLeave: _util.noop,
	      onTitleMouseEnter: _util.noop,
	      onTitleMouseLeave: _util.noop,
	      onTitleClick: _util.noop,
	      title: ''
	    };
	  },
	  getInitialState: function getInitialState() {
	    this.isSubMenu = 1;
	    return {
	      defaultActiveFirst: false
	    };
	  },
	  componentWillUnmount: function componentWillUnmount() {
	    var _props = this.props,
	        onDestroy = _props.onDestroy,
	        eventKey = _props.eventKey,
	        parentMenu = _props.parentMenu;
	
	    if (onDestroy) {
	      onDestroy(eventKey);
	    }
	    if (parentMenu.subMenuInstance === this) {
	      this.clearSubMenuTimers();
	    }
	  },
	  onDestroy: function onDestroy(key) {
	    this.props.onDestroy(key);
	  },
	  onKeyDown: function onKeyDown(e) {
	    var keyCode = e.keyCode;
	    var menu = this.menuInstance;
	    var isOpen = this.isOpen();
	
	    if (keyCode === _KeyCode2["default"].ENTER) {
	      this.onTitleClick(e);
	      this.setState({
	        defaultActiveFirst: true
	      });
	      return true;
	    }
	
	    if (keyCode === _KeyCode2["default"].RIGHT) {
	      if (isOpen) {
	        menu.onKeyDown(e);
	      } else {
	        this.triggerOpenChange(true);
	        this.setState({
	          defaultActiveFirst: true
	        });
	      }
	      return true;
	    }
	    if (keyCode === _KeyCode2["default"].LEFT) {
	      var handled = void 0;
	      if (isOpen) {
	        handled = menu.onKeyDown(e);
	      } else {
	        return undefined;
	      }
	      if (!handled) {
	        this.triggerOpenChange(false);
	        handled = true;
	      }
	      return handled;
	    }
	
	    if (isOpen && (keyCode === _KeyCode2["default"].UP || keyCode === _KeyCode2["default"].DOWN)) {
	      return menu.onKeyDown(e);
	    }
	  },
	  onOpenChange: function onOpenChange(e) {
	    this.props.onOpenChange(e);
	  },
	  onMouseEnter: function onMouseEnter(e) {
	    var props = this.props;
	    this.clearSubMenuLeaveTimer(props.parentMenu.subMenuInstance !== this);
	    props.onMouseEnter({
	      key: props.eventKey,
	      domEvent: e
	    });
	  },
	  onTitleMouseEnter: function onTitleMouseEnter(domEvent) {
	    var props = this.props;
	    var parentMenu = props.parentMenu,
	        key = props.eventKey;
	
	    var item = this;
	    this.clearSubMenuTitleLeaveTimer(parentMenu.subMenuInstance !== item);
	    if (parentMenu.menuItemInstance) {
	      parentMenu.menuItemInstance.clearMenuItemMouseLeaveTimer(true);
	    }
	    var openChanges = [];
	    if (props.openSubMenuOnMouseEnter) {
	      openChanges.push({
	        key: key,
	        item: item,
	        trigger: 'mouseenter',
	        open: true
	      });
	    }
	    props.onItemHover({
	      key: key,
	      item: item,
	      hover: true,
	      trigger: 'mouseenter',
	      openChanges: openChanges
	    });
	    this.setState({
	      defaultActiveFirst: false
	    });
	    props.onTitleMouseEnter({
	      key: key,
	      domEvent: domEvent
	    });
	  },
	  onTitleMouseLeave: function onTitleMouseLeave(e) {
	    var _this = this;
	
	    var props = this.props;
	    var parentMenu = props.parentMenu,
	        eventKey = props.eventKey;
	
	    parentMenu.subMenuInstance = this;
	    parentMenu.subMenuTitleLeaveFn = function () {
	      // leave whole sub tree
	      // still active
	      if (props.mode === 'inline' && props.active) {
	        props.onItemHover({
	          key: eventKey,
	          item: _this,
	          hover: false,
	          trigger: 'mouseleave'
	        });
	      }
	      props.onTitleMouseLeave({
	        key: props.eventKey,
	        domEvent: e
	      });
	    };
	    parentMenu.subMenuTitleLeaveTimer = setTimeout(parentMenu.subMenuTitleLeaveFn, 100);
	  },
	  onMouseLeave: function onMouseLeave(e) {
	    var _this2 = this;
	
	    var props = this.props;
	    var parentMenu = props.parentMenu,
	        eventKey = props.eventKey;
	
	    parentMenu.subMenuInstance = this;
	    parentMenu.subMenuLeaveFn = function () {
	      // leave whole sub tree
	      // still active
	      if (props.mode !== 'inline') {
	        var isOpen = _this2.isOpen();
	        if (isOpen && props.closeSubMenuOnMouseLeave && props.active) {
	          props.onItemHover({
	            key: eventKey,
	            item: _this2,
	            hover: false,
	            trigger: 'mouseleave',
	            openChanges: [{
	              key: eventKey,
	              item: _this2,
	              trigger: 'mouseleave',
	              open: false
	            }]
	          });
	        } else {
	          if (props.active) {
	            props.onItemHover({
	              key: eventKey,
	              item: _this2,
	              hover: false,
	              trigger: 'mouseleave'
	            });
	          }
	          if (isOpen && props.closeSubMenuOnMouseLeave) {
	            _this2.triggerOpenChange(false);
	          }
	        }
	      }
	      // trigger mouseleave
	      props.onMouseLeave({
	        key: eventKey,
	        domEvent: e
	      });
	    };
	    // prevent popup menu and submenu gap
	    parentMenu.subMenuLeaveTimer = setTimeout(parentMenu.subMenuLeaveFn, 100);
	  },
	  onTitleClick: function onTitleClick(e) {
	    var props = this.props;
	
	    props.onTitleClick({
	      key: props.eventKey,
	      domEvent: e
	    });
	    if (props.openSubMenuOnMouseEnter) {
	      return;
	    }
	    this.triggerOpenChange(!this.isOpen(), 'click');
	    this.setState({
	      defaultActiveFirst: false
	    });
	  },
	  onSubMenuClick: function onSubMenuClick(info) {
	    this.props.onClick(this.addKeyPath(info));
	  },
	  onSelect: function onSelect(info) {
	    this.props.onSelect(info);
	  },
	  onDeselect: function onDeselect(info) {
	    this.props.onDeselect(info);
	  },
	  getPrefixCls: function getPrefixCls() {
	    return this.props.rootPrefixCls + '-submenu';
	  },
	  getActiveClassName: function getActiveClassName() {
	    return this.getPrefixCls() + '-active';
	  },
	  getDisabledClassName: function getDisabledClassName() {
	    return this.getPrefixCls() + '-disabled';
	  },
	  getSelectedClassName: function getSelectedClassName() {
	    return this.getPrefixCls() + '-selected';
	  },
	  getOpenClassName: function getOpenClassName() {
	    return this.props.rootPrefixCls + '-submenu-open';
	  },
	  saveMenuInstance: function saveMenuInstance(c) {
	    this.menuInstance = c;
	  },
	  addKeyPath: function addKeyPath(info) {
	    return (0, _extends3["default"])({}, info, {
	      keyPath: (info.keyPath || []).concat(this.props.eventKey)
	    });
	  },
	  triggerOpenChange: function triggerOpenChange(open, type) {
	    var key = this.props.eventKey;
	    this.onOpenChange({
	      key: key,
	      item: this,
	      trigger: type,
	      open: open
	    });
	  },
	  clearSubMenuTimers: function clearSubMenuTimers() {
	    var callFn = void 0;
	    this.clearSubMenuLeaveTimer(callFn);
	    this.clearSubMenuTitleLeaveTimer(callFn);
	  },
	  clearSubMenuTitleLeaveTimer: function clearSubMenuTitleLeaveTimer() {
	    var callFn = void 0;
	    var parentMenu = this.props.parentMenu;
	    if (parentMenu.subMenuTitleLeaveTimer) {
	      clearTimeout(parentMenu.subMenuTitleLeaveTimer);
	      parentMenu.subMenuTitleLeaveTimer = null;
	      if (callFn && parentMenu.subMenuTitleLeaveFn) {
	        parentMenu.subMenuTitleLeaveFn();
	      }
	      parentMenu.subMenuTitleLeaveFn = null;
	    }
	  },
	  clearSubMenuLeaveTimer: function clearSubMenuLeaveTimer() {
	    var callFn = void 0;
	    var parentMenu = this.props.parentMenu;
	    if (parentMenu.subMenuLeaveTimer) {
	      clearTimeout(parentMenu.subMenuLeaveTimer);
	      parentMenu.subMenuLeaveTimer = null;
	      if (callFn && parentMenu.subMenuLeaveFn) {
	        parentMenu.subMenuLeaveFn();
	      }
	      parentMenu.subMenuLeaveFn = null;
	    }
	  },
	  isChildrenSelected: function isChildrenSelected() {
	    var ret = { find: false };
	    (0, _util.loopMenuItemRecusively)(this.props.children, this.props.selectedKeys, ret);
	    return ret.find;
	  },
	  isOpen: function isOpen() {
	    return this.props.openKeys.indexOf(this.props.eventKey) !== -1;
	  },
	  renderChildren: function renderChildren(children) {
	    var props = this.props;
	    var baseProps = {
	      mode: props.mode === 'horizontal' ? 'vertical' : props.mode,
	      visible: this.isOpen(),
	      level: props.level + 1,
	      inlineIndent: props.inlineIndent,
	      focusable: false,
	      onClick: this.onSubMenuClick,
	      onSelect: this.onSelect,
	      onDeselect: this.onDeselect,
	      onDestroy: this.onDestroy,
	      selectedKeys: props.selectedKeys,
	      eventKey: props.eventKey + '-menu-',
	      openKeys: props.openKeys,
	      openTransitionName: props.openTransitionName,
	      openAnimation: props.openAnimation,
	      onOpenChange: this.onOpenChange,
	      closeSubMenuOnMouseLeave: props.closeSubMenuOnMouseLeave,
	      defaultActiveFirst: this.state.defaultActiveFirst,
	      multiple: props.multiple,
	      prefixCls: props.rootPrefixCls,
	      id: this._menuId,
	      ref: this.saveMenuInstance
	    };
	    return _react2["default"].createElement(
	      _SubPopupMenu2["default"],
	      baseProps,
	      children
	    );
	  },
	  render: function render() {
	    var _classes;
	
	    var isOpen = this.isOpen();
	    this.haveOpen = this.haveOpen || isOpen;
	    var props = this.props;
	    var prefixCls = this.getPrefixCls();
	    var classes = (_classes = {}, (0, _defineProperty3["default"])(_classes, props.className, !!props.className), (0, _defineProperty3["default"])(_classes, prefixCls + '-' + props.mode, 1), _classes);
	
	    classes[this.getOpenClassName()] = isOpen;
	    classes[this.getActiveClassName()] = props.active;
	    classes[this.getDisabledClassName()] = props.disabled;
	    classes[this.getSelectedClassName()] = this.isChildrenSelected();
	
	    if (!this._menuId) {
	      if (props.eventKey) {
	        this._menuId = props.eventKey + '$Menu';
	      } else {
	        this._menuId = '$__$' + ++guid + '$Menu';
	      }
	    }
	
	    classes[prefixCls] = true;
	    classes[prefixCls + '-' + props.mode] = 1;
	    var titleClickEvents = {};
	    var mouseEvents = {};
	    var titleMouseEvents = {};
	    if (!props.disabled) {
	      titleClickEvents = {
	        onClick: this.onTitleClick
	      };
	      mouseEvents = {
	        onMouseLeave: this.onMouseLeave,
	        onMouseEnter: this.onMouseEnter
	      };
	      // only works in title, not outer li
	      titleMouseEvents = {
	        onMouseEnter: this.onTitleMouseEnter,
	        onMouseLeave: this.onTitleMouseLeave
	      };
	    }
	    var style = {};
	    if (props.mode === 'inline') {
	      style.paddingLeft = props.inlineIndent * props.level;
	    }
	    return _react2["default"].createElement(
	      'li',
	      (0, _extends3["default"])({ className: (0, _classnames2["default"])(classes) }, mouseEvents),
	      _react2["default"].createElement(
	        'div',
	        (0, _extends3["default"])({
	          style: style,
	          className: prefixCls + '-title'
	        }, titleMouseEvents, titleClickEvents, {
	          'aria-expanded': isOpen,
	          'aria-owns': this._menuId,
	          'aria-haspopup': 'true',
	          title: typeof props.title === 'string' ? props.title : undefined
	        }),
	        props.title
	      ),
	      this.renderChildren(props.children)
	    );
	  }
	});
	
	SubMenu.isSubMenu = 1;
	
	exports["default"] = SubMenu;
	module.exports = exports['default'];

/***/ }),
/* 717 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _KeyCode = __webpack_require__(29);
	
	var _KeyCode2 = _interopRequireDefault(_KeyCode);
	
	var _addEventListener = __webpack_require__(34);
	
	var _addEventListener2 = _interopRequireDefault(_addEventListener);
	
	var _contains = __webpack_require__(283);
	
	var _contains2 = _interopRequireDefault(_contains);
	
	var _reactDom = __webpack_require__(10);
	
	var _reactDom2 = _interopRequireDefault(_reactDom);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
	
	exports["default"] = {
	  componentDidMount: function componentDidMount() {
	    this.componentDidUpdate();
	  },
	  componentDidUpdate: function componentDidUpdate() {
	    if (this.props.mode !== 'inline') {
	      if (this.props.open) {
	        this.bindRootCloseHandlers();
	      } else {
	        this.unbindRootCloseHandlers();
	      }
	    }
	  },
	  handleDocumentKeyUp: function handleDocumentKeyUp(e) {
	    if (e.keyCode === _KeyCode2["default"].ESC) {
	      this.props.onItemHover({
	        key: this.props.eventKey,
	        item: this,
	        hover: false
	      });
	    }
	  },
	  handleDocumentClick: function handleDocumentClick(e) {
	    // If the click originated from within this component
	    // don't do anything.
	    if ((0, _contains2["default"])(_reactDom2["default"].findDOMNode(this), e.target)) {
	      return;
	    }
	    var props = this.props;
	    props.onItemHover({
	      hover: false,
	      item: this,
	      key: this.props.eventKey
	    });
	    this.triggerOpenChange(false);
	  },
	  bindRootCloseHandlers: function bindRootCloseHandlers() {
	    if (!this._onDocumentClickListener) {
	      this._onDocumentClickListener = (0, _addEventListener2["default"])(document, 'click', this.handleDocumentClick);
	      this._onDocumentKeyupListener = (0, _addEventListener2["default"])(document, 'keyup', this.handleDocumentKeyUp);
	    }
	  },
	  unbindRootCloseHandlers: function unbindRootCloseHandlers() {
	    if (this._onDocumentClickListener) {
	      this._onDocumentClickListener.remove();
	      this._onDocumentClickListener = null;
	    }
	
	    if (this._onDocumentKeyupListener) {
	      this._onDocumentKeyupListener.remove();
	      this._onDocumentKeyupListener = null;
	    }
	  },
	  componentWillUnmount: function componentWillUnmount() {
	    this.unbindRootCloseHandlers();
	  }
	};
	module.exports = exports['default'];

/***/ }),
/* 718 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _typeof2 = __webpack_require__(21);
	
	var _typeof3 = _interopRequireDefault(_typeof2);
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _createReactClass = __webpack_require__(14);
	
	var _createReactClass2 = _interopRequireDefault(_createReactClass);
	
	var _MenuMixin = __webpack_require__(260);
	
	var _MenuMixin2 = _interopRequireDefault(_MenuMixin);
	
	var _rcAnimate = __webpack_require__(22);
	
	var _rcAnimate2 = _interopRequireDefault(_rcAnimate);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
	
	var SubPopupMenu = (0, _createReactClass2["default"])({
	  displayName: 'SubPopupMenu',
	
	  propTypes: {
	    onSelect: _propTypes2["default"].func,
	    onClick: _propTypes2["default"].func,
	    onDeselect: _propTypes2["default"].func,
	    onOpenChange: _propTypes2["default"].func,
	    onDestroy: _propTypes2["default"].func,
	    openTransitionName: _propTypes2["default"].string,
	    openAnimation: _propTypes2["default"].oneOfType([_propTypes2["default"].string, _propTypes2["default"].object]),
	    openKeys: _propTypes2["default"].arrayOf(_propTypes2["default"].string),
	    closeSubMenuOnMouseLeave: _propTypes2["default"].bool,
	    visible: _propTypes2["default"].bool,
	    children: _propTypes2["default"].any
	  },
	
	  mixins: [_MenuMixin2["default"]],
	
	  onDeselect: function onDeselect(selectInfo) {
	    this.props.onDeselect(selectInfo);
	  },
	  onSelect: function onSelect(selectInfo) {
	    this.props.onSelect(selectInfo);
	  },
	  onClick: function onClick(e) {
	    this.props.onClick(e);
	  },
	  onOpenChange: function onOpenChange(e) {
	    this.props.onOpenChange(e);
	  },
	  onDestroy: function onDestroy(key) {
	    this.props.onDestroy(key);
	  },
	  onItemHover: function onItemHover(e) {
	    var _e$openChanges = e.openChanges,
	        openChanges = _e$openChanges === undefined ? [] : _e$openChanges;
	
	    openChanges = openChanges.concat(this.getOpenChangesOnItemHover(e));
	    if (openChanges.length) {
	      this.onOpenChange(openChanges);
	    }
	  },
	  getOpenTransitionName: function getOpenTransitionName() {
	    return this.props.openTransitionName;
	  },
	  renderMenuItem: function renderMenuItem(c, i, subIndex) {
	    if (!c) {
	      return null;
	    }
	    var props = this.props;
	    var extraProps = {
	      openKeys: props.openKeys,
	      selectedKeys: props.selectedKeys,
	      openSubMenuOnMouseEnter: true
	    };
	    return this.renderCommonMenuItem(c, i, subIndex, extraProps);
	  },
	  render: function render() {
	    var renderFirst = this.renderFirst;
	    this.renderFirst = 1;
	    this.haveOpened = this.haveOpened || this.props.visible;
	    if (!this.haveOpened) {
	      return null;
	    }
	    var transitionAppear = true;
	    if (!renderFirst && this.props.visible) {
	      transitionAppear = false;
	    }
	    var props = (0, _extends3["default"])({}, this.props);
	    props.className += ' ' + props.prefixCls + '-sub';
	    var animProps = {};
	    if (props.openTransitionName) {
	      animProps.transitionName = props.openTransitionName;
	    } else if ((0, _typeof3["default"])(props.openAnimation) === 'object') {
	      animProps.animation = (0, _extends3["default"])({}, props.openAnimation);
	      if (!transitionAppear) {
	        delete animProps.animation.appear;
	      }
	    }
	    return _react2["default"].createElement(
	      _rcAnimate2["default"],
	      (0, _extends3["default"])({}, animProps, {
	        showProp: 'visible',
	        component: '',
	        transitionAppear: transitionAppear
	      }),
	      this.renderRoot(props)
	    );
	  }
	});
	
	exports["default"] = SubPopupMenu;
	module.exports = exports['default'];

/***/ }),
/* 719 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var Notice = function (_Component) {
	  (0, _inherits3['default'])(Notice, _Component);
	
	  function Notice() {
	    var _ref;
	
	    var _temp, _this, _ret;
	
	    (0, _classCallCheck3['default'])(this, Notice);
	
	    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
	      args[_key] = arguments[_key];
	    }
	
	    return _ret = (_temp = (_this = (0, _possibleConstructorReturn3['default'])(this, (_ref = Notice.__proto__ || Object.getPrototypeOf(Notice)).call.apply(_ref, [this].concat(args))), _this), _this.close = function () {
	      _this.clearCloseTimer();
	      _this.props.onClose();
	    }, _this.startCloseTimer = function () {
	      if (_this.props.duration) {
	        _this.closeTimer = setTimeout(function () {
	          _this.close();
	        }, _this.props.duration * 1000);
	      }
	    }, _this.clearCloseTimer = function () {
	      if (_this.closeTimer) {
	        clearTimeout(_this.closeTimer);
	        _this.closeTimer = null;
	      }
	    }, _temp), (0, _possibleConstructorReturn3['default'])(_this, _ret);
	  }
	
	  (0, _createClass3['default'])(Notice, [{
	    key: 'componentDidMount',
	    value: function componentDidMount() {
	      this.startCloseTimer();
	    }
	  }, {
	    key: 'componentWillUnmount',
	    value: function componentWillUnmount() {
	      this.clearCloseTimer();
	    }
	  }, {
	    key: 'render',
	    value: function render() {
	      var _className;
	
	      var props = this.props;
	      var componentClass = props.prefixCls + '-notice';
	      var className = (_className = {}, (0, _defineProperty3['default'])(_className, '' + componentClass, 1), (0, _defineProperty3['default'])(_className, componentClass + '-closable', props.closable), (0, _defineProperty3['default'])(_className, props.className, !!props.className), _className);
	      return _react2['default'].createElement(
	        'div',
	        { className: (0, _classnames2['default'])(className), style: props.style, onMouseEnter: this.clearCloseTimer,
	          onMouseLeave: this.startCloseTimer
	        },
	        _react2['default'].createElement(
	          'div',
	          { className: componentClass + '-content' },
	          props.children
	        ),
	        props.closable ? _react2['default'].createElement(
	          'a',
	          { tabIndex: '0', onClick: this.close, className: componentClass + '-close' },
	          _react2['default'].createElement('span', { className: componentClass + '-close-x' })
	        ) : null
	      );
	    }
	  }]);
	  return Notice;
	}(_react.Component);
	
	Notice.propTypes = {
	  duration: _propTypes2['default'].number,
	  onClose: _propTypes2['default'].func,
	  children: _propTypes2['default'].any
	};
	Notice.defaultProps = {
	  onEnd: function onEnd() {},
	  onClose: function onClose() {},
	
	  duration: 1.5,
	  style: {
	    right: '50%'
	  }
	};
	exports['default'] = Notice;
	module.exports = exports['default'];

/***/ }),
/* 720 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _objectWithoutProperties2 = __webpack_require__(20);
	
	var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _reactDom = __webpack_require__(10);
	
	var _reactDom2 = _interopRequireDefault(_reactDom);
	
	var _rcAnimate = __webpack_require__(22);
	
	var _rcAnimate2 = _interopRequireDefault(_rcAnimate);
	
	var _createChainedFunction = __webpack_require__(153);
	
	var _createChainedFunction2 = _interopRequireDefault(_createChainedFunction);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _Notice = __webpack_require__(719);
	
	var _Notice2 = _interopRequireDefault(_Notice);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var seed = 0;
	var now = Date.now();
	
	function getUuid() {
	  return 'rcNotification_' + now + '_' + seed++;
	}
	
	var Notification = function (_Component) {
	  (0, _inherits3['default'])(Notification, _Component);
	
	  function Notification() {
	    var _ref;
	
	    var _temp, _this, _ret;
	
	    (0, _classCallCheck3['default'])(this, Notification);
	
	    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
	      args[_key] = arguments[_key];
	    }
	
	    return _ret = (_temp = (_this = (0, _possibleConstructorReturn3['default'])(this, (_ref = Notification.__proto__ || Object.getPrototypeOf(Notification)).call.apply(_ref, [this].concat(args))), _this), _this.state = {
	      notices: []
	    }, _this.add = function (notice) {
	      var key = notice.key = notice.key || getUuid();
	      _this.setState(function (previousState) {
	        var notices = previousState.notices;
	        if (!notices.filter(function (v) {
	          return v.key === key;
	        }).length) {
	          return {
	            notices: notices.concat(notice)
	          };
	        }
	      });
	    }, _this.remove = function (key) {
	      _this.setState(function (previousState) {
	        return {
	          notices: previousState.notices.filter(function (notice) {
	            return notice.key !== key;
	          })
	        };
	      });
	    }, _temp), (0, _possibleConstructorReturn3['default'])(_this, _ret);
	  }
	
	  (0, _createClass3['default'])(Notification, [{
	    key: 'getTransitionName',
	    value: function getTransitionName() {
	      var props = this.props;
	      var transitionName = props.transitionName;
	      if (!transitionName && props.animation) {
	        transitionName = props.prefixCls + '-' + props.animation;
	      }
	      return transitionName;
	    }
	  }, {
	    key: 'render',
	    value: function render() {
	      var _this2 = this,
	          _className;
	
	      var props = this.props;
	      var noticeNodes = this.state.notices.map(function (notice) {
	        var onClose = (0, _createChainedFunction2['default'])(_this2.remove.bind(_this2, notice.key), notice.onClose);
	        return _react2['default'].createElement(
	          _Notice2['default'],
	          (0, _extends3['default'])({
	            prefixCls: props.prefixCls
	          }, notice, {
	            onClose: onClose
	          }),
	          notice.content
	        );
	      });
	      var className = (_className = {}, (0, _defineProperty3['default'])(_className, props.prefixCls, 1), (0, _defineProperty3['default'])(_className, props.className, !!props.className), _className);
	      return _react2['default'].createElement(
	        'div',
	        { className: (0, _classnames2['default'])(className), style: props.style },
	        _react2['default'].createElement(
	          _rcAnimate2['default'],
	          { transitionName: this.getTransitionName() },
	          noticeNodes
	        )
	      );
	    }
	  }]);
	  return Notification;
	}(_react.Component);
	
	Notification.propTypes = {
	  prefixCls: _propTypes2['default'].string,
	  transitionName: _propTypes2['default'].string,
	  animation: _propTypes2['default'].oneOfType([_propTypes2['default'].string, _propTypes2['default'].object]),
	  style: _propTypes2['default'].object
	};
	Notification.defaultProps = {
	  prefixCls: 'rc-notification',
	  animation: 'fade',
	  style: {
	    top: 65,
	    left: '50%'
	  }
	};
	
	
	Notification.newInstance = function newNotificationInstance(properties) {
	  var _ref2 = properties || {},
	      getContainer = _ref2.getContainer,
	      props = (0, _objectWithoutProperties3['default'])(_ref2, ['getContainer']);
	
	  var div = void 0;
	  if (getContainer) {
	    div = getContainer();
	  } else {
	    div = document.createElement('div');
	    document.body.appendChild(div);
	  }
	  var notification = _reactDom2['default'].render(_react2['default'].createElement(Notification, props), div);
	  return {
	    notice: function notice(noticeProps) {
	      notification.add(noticeProps);
	    },
	    removeNotice: function removeNotice(key) {
	      notification.remove(key);
	    },
	
	    component: notification,
	    destroy: function destroy() {
	      _reactDom2['default'].unmountComponentAtNode(div);
	      if (!getContainer) {
	        document.body.removeChild(div);
	      }
	    }
	  };
	};
	
	exports['default'] = Notification;
	module.exports = exports['default'];

/***/ }),
/* 721 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _KeyCode = __webpack_require__(262);
	
	var _KeyCode2 = _interopRequireDefault(_KeyCode);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var Options = function (_React$Component) {
	  (0, _inherits3['default'])(Options, _React$Component);
	
	  function Options(props) {
	    (0, _classCallCheck3['default'])(this, Options);
	
	    var _this = (0, _possibleConstructorReturn3['default'])(this, (Options.__proto__ || Object.getPrototypeOf(Options)).call(this, props));
	
	    _this.buildOptionText = function (value) {
	      return value + ' ' + _this.props.locale.items_per_page;
	    };
	
	    _this.changeSize = function (value) {
	      _this.props.changeSize(Number(value));
	    };
	
	    _this.handleChange = function (e) {
	      _this.setState({
	        goInputText: e.target.value
	      });
	    };
	
	    _this.go = function (e) {
	      var val = _this.state.goInputText;
	      if (val === '') {
	        return;
	      }
	      val = Number(val);
	      if (isNaN(val)) {
	        val = _this.state.current;
	      }
	      if (e.keyCode === _KeyCode2['default'].ENTER || e.type === 'click') {
	        _this.setState({
	          goInputText: '',
	          current: _this.props.quickGo(val)
	        });
	      }
	    };
	
	    _this.state = {
	      current: props.current,
	      goInputText: ''
	    };
	    return _this;
	  }
	
	  (0, _createClass3['default'])(Options, [{
	    key: 'render',
	    value: function render() {
	      var props = this.props;
	      var state = this.state;
	      var locale = props.locale;
	      var prefixCls = props.rootPrefixCls + '-options';
	      var changeSize = props.changeSize;
	      var quickGo = props.quickGo;
	      var goButton = props.goButton;
	      var buildOptionText = props.buildOptionText || this.buildOptionText;
	      var Select = props.selectComponentClass;
	      var changeSelect = null;
	      var goInput = null;
	      var gotoButton = null;
	
	      if (!(changeSize || quickGo)) {
	        return null;
	      }
	
	      if (changeSize && Select) {
	        var Option = Select.Option;
	        var pageSize = props.pageSize || props.pageSizeOptions[0];
	        var options = props.pageSizeOptions.map(function (opt, i) {
	          return _react2['default'].createElement(
	            Option,
	            { key: i, value: opt },
	            buildOptionText(opt)
	          );
	        });
	
	        changeSelect = _react2['default'].createElement(
	          Select,
	          {
	            prefixCls: props.selectPrefixCls,
	            showSearch: false,
	            className: prefixCls + '-size-changer',
	            optionLabelProp: 'children',
	            dropdownMatchSelectWidth: false,
	            value: pageSize.toString(),
	            onChange: this.changeSize,
	            getPopupContainer: function getPopupContainer(triggerNode) {
	              return triggerNode.parentNode;
	            }
	          },
	          options
	        );
	      }
	
	      if (quickGo) {
	        if (goButton) {
	          if (typeof goButton === 'boolean') {
	            gotoButton = _react2['default'].createElement(
	              'button',
	              {
	                type: 'button',
	                onClick: this.go,
	                onKeyUp: this.go
	              },
	              locale.jump_to_confirm
	            );
	          } else {
	            gotoButton = goButton;
	          }
	        }
	        goInput = _react2['default'].createElement(
	          'div',
	          { className: prefixCls + '-quick-jumper' },
	          locale.jump_to,
	          _react2['default'].createElement('input', {
	            type: 'text',
	            value: state.goInputText,
	            onChange: this.handleChange,
	            onKeyUp: this.go
	          }),
	          locale.page,
	          gotoButton
	        );
	      }
	
	      return _react2['default'].createElement(
	        'li',
	        { className: '' + prefixCls },
	        changeSelect,
	        goInput
	      );
	    }
	  }]);
	  return Options;
	}(_react2['default'].Component);
	
	Options.propTypes = {
	  changeSize: _propTypes2['default'].func,
	  quickGo: _propTypes2['default'].func,
	  selectComponentClass: _propTypes2['default'].func,
	  current: _propTypes2['default'].number,
	  pageSizeOptions: _propTypes2['default'].arrayOf(_propTypes2['default'].string),
	  pageSize: _propTypes2['default'].number,
	  buildOptionText: _propTypes2['default'].func,
	  locale: _propTypes2['default'].object
	};
	Options.defaultProps = {
	  pageSizeOptions: ['10', '20', '30', '40']
	};
	exports['default'] = Options;
	module.exports = exports['default'];

/***/ }),
/* 722 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var Pager = function Pager(props) {
	  var prefixCls = props.rootPrefixCls + '-item';
	  var cls = prefixCls + ' ' + prefixCls + '-' + props.page;
	
	  if (props.active) {
	    cls = cls + ' ' + prefixCls + '-active';
	  }
	
	  if (props.className) {
	    cls = cls + ' ' + props.className;
	  }
	
	  var handleClick = function handleClick() {
	    props.onClick(props.page);
	  };
	
	  var handleKeyPress = function handleKeyPress(e) {
	    props.onKeyPress(e, props.onClick, props.page);
	  };
	
	  return _react2['default'].createElement(
	    'li',
	    {
	      title: props.showTitle ? props.page : null,
	      className: cls,
	      onClick: handleClick,
	      onKeyPress: handleKeyPress,
	      tabIndex: '0'
	    },
	    props.itemRender(props.page, 'page', _react2['default'].createElement(
	      'a',
	      null,
	      props.page
	    ))
	  );
	};
	
	Pager.propTypes = {
	  page: _propTypes2['default'].number,
	  active: _propTypes2['default'].bool,
	  last: _propTypes2['default'].bool,
	  locale: _propTypes2['default'].object,
	  className: _propTypes2['default'].string,
	  showTitle: _propTypes2['default'].bool,
	  rootPrefixCls: _propTypes2['default'].string,
	  onClick: _propTypes2['default'].func,
	  onKeyPress: _propTypes2['default'].func,
	  itemRender: _propTypes2['default'].func
	};
	
	exports['default'] = Pager;
	module.exports = exports['default'];

/***/ }),
/* 723 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _Pager = __webpack_require__(722);
	
	var _Pager2 = _interopRequireDefault(_Pager);
	
	var _Options = __webpack_require__(721);
	
	var _Options2 = _interopRequireDefault(_Options);
	
	var _KeyCode = __webpack_require__(262);
	
	var _KeyCode2 = _interopRequireDefault(_KeyCode);
	
	var _zh_CN = __webpack_require__(263);
	
	var _zh_CN2 = _interopRequireDefault(_zh_CN);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function noop() {}
	
	function isInteger(value) {
	  return typeof value === 'number' && isFinite(value) && Math.floor(value) === value;
	}
	
	function defaultItemRender(page, type, element) {
	  return element;
	}
	
	var Pagination = function (_React$Component) {
	  (0, _inherits3['default'])(Pagination, _React$Component);
	
	  function Pagination(props) {
	    (0, _classCallCheck3['default'])(this, Pagination);
	
	    var _this = (0, _possibleConstructorReturn3['default'])(this, (Pagination.__proto__ || Object.getPrototypeOf(Pagination)).call(this, props));
	
	    _initialiseProps.call(_this);
	
	    var hasOnChange = props.onChange !== noop;
	    var hasCurrent = 'current' in props;
	    if (hasCurrent && !hasOnChange) {
	      console.warn('Warning: You provided a `current` prop to a Pagination component without an `onChange` handler. This will render a read-only component.'); // eslint-disable-line
	    }
	
	    var current = props.defaultCurrent;
	    if ('current' in props) {
	      current = props.current;
	    }
	
	    var pageSize = props.defaultPageSize;
	    if ('pageSize' in props) {
	      pageSize = props.pageSize;
	    }
	
	    _this.state = {
	      current: current,
	      currentInputValue: current,
	      pageSize: pageSize
	    };
	    return _this;
	  }
	
	  (0, _createClass3['default'])(Pagination, [{
	    key: 'componentWillReceiveProps',
	    value: function componentWillReceiveProps(nextProps) {
	      if ('current' in nextProps) {
	        this.setState({
	          current: nextProps.current,
	          currentInputValue: nextProps.current
	        });
	      }
	
	      if ('pageSize' in nextProps) {
	        var newState = {};
	        var current = this.state.current;
	        var newCurrent = this.calculatePage(nextProps.pageSize);
	        current = current > newCurrent ? newCurrent : current;
	        if (!('current' in nextProps)) {
	          newState.current = current;
	          newState.currentInputValue = current;
	        }
	        newState.pageSize = nextProps.pageSize;
	        this.setState(newState);
	      }
	    }
	  }, {
	    key: 'getJumpPrevPage',
	    value: function getJumpPrevPage() {
	      return Math.max(1, this.state.current - (this.props.showLessItems ? 3 : 5));
	    }
	  }, {
	    key: 'getJumpNextPage',
	    value: function getJumpNextPage() {
	      return Math.min(this.calculatePage(), this.state.current + (this.props.showLessItems ? 3 : 5));
	    }
	  }, {
	    key: 'getJumpPrevPage',
	    value: function getJumpPrevPage() {
	      return Math.max(1, this.state.current - (this.props.showLessItems ? 3 : 5));
	    }
	  }, {
	    key: 'getJumpNextPage',
	    value: function getJumpNextPage() {
	      return Math.min(this.calculatePage(), this.state.current + (this.props.showLessItems ? 3 : 5));
	    }
	  }, {
	    key: 'render',
	    value: function render() {
	      // When hideOnSinglePage is true and there is only 1 page, hide the pager
	      if (this.props.hideOnSinglePage === true && this.props.total <= this.state.pageSize) {
	        return null;
	      }
	
	      var props = this.props;
	      var locale = props.locale;
	
	      var prefixCls = props.prefixCls;
	      var allPages = this.calculatePage();
	      var pagerList = [];
	      var jumpPrev = null;
	      var jumpNext = null;
	      var firstPager = null;
	      var lastPager = null;
	      var gotoButton = null;
	
	      var goButton = props.showQuickJumper && props.showQuickJumper.goButton;
	      var pageBufferSize = props.showLessItems ? 1 : 2;
	      var _state = this.state,
	          current = _state.current,
	          pageSize = _state.pageSize;
	
	
	      var prevPage = current - 1 > 0 ? current - 1 : 0;
	      var nextPage = current + 1 < allPages ? current + 1 : allPages;
	
	      if (props.simple) {
	        if (goButton) {
	          if (typeof goButton === 'boolean') {
	            gotoButton = _react2['default'].createElement(
	              'li',
	              {
	                title: props.showTitle ? '' + locale.jump_to + this.state.current + '/' + allPages : null,
	                className: prefixCls + '-simple-pager'
	              },
	              _react2['default'].createElement(
	                'button',
	                {
	                  type: 'button',
	                  onClick: this.handleGoTO,
	                  onKeyUp: this.handleGoTO
	                },
	                locale.jump_to_confirm
	              )
	            );
	          } else {
	            gotoButton = goButton;
	          }
	        }
	        return _react2['default'].createElement(
	          'ul',
	          { className: prefixCls + ' ' + prefixCls + '-simple ' + props.className, style: props.style },
	          _react2['default'].createElement(
	            'li',
	            {
	              title: props.showTitle ? locale.prev_page : null,
	              onClick: this.prev,
	              tabIndex: '0',
	              onKeyPress: this.runIfEnterPrev,
	              className: (this.hasPrev() ? '' : prefixCls + '-disabled') + ' ' + prefixCls + '-prev',
	              'aria-disabled': !this.hasPrev()
	            },
	            props.itemRender(prevPage, 'prev', _react2['default'].createElement('a', { className: prefixCls + '-item-link' }))
	          ),
	          _react2['default'].createElement(
	            'li',
	            {
	              title: props.showTitle ? this.state.current + '/' + allPages : null,
	              className: prefixCls + '-simple-pager'
	            },
	            _react2['default'].createElement('input', {
	              type: 'text',
	              value: this.state.currentInputValue,
	              onKeyDown: this.handleKeyDown,
	              onKeyUp: this.handleKeyUp,
	              onChange: this.handleKeyUp,
	              size: '3'
	            }),
	            _react2['default'].createElement(
	              'span',
	              { className: prefixCls + '-slash' },
	              '\uFF0F'
	            ),
	            allPages
	          ),
	          _react2['default'].createElement(
	            'li',
	            {
	              title: props.showTitle ? locale.next_page : null,
	              onClick: this.next,
	              tabIndex: '0',
	              onKeyPress: this.runIfEnterNext,
	              className: (this.hasNext() ? '' : prefixCls + '-disabled') + ' ' + prefixCls + '-next',
	              'aria-disabled': !this.hasNext()
	            },
	            props.itemRender(nextPage, 'next', _react2['default'].createElement('a', { className: prefixCls + '-item-link' }))
	          ),
	          gotoButton
	        );
	      }
	
	      if (allPages <= 5 + pageBufferSize * 2) {
	        for (var i = 1; i <= allPages; i++) {
	          var active = this.state.current === i;
	          pagerList.push(_react2['default'].createElement(_Pager2['default'], {
	            locale: locale,
	            rootPrefixCls: prefixCls,
	            onClick: this.handleChange,
	            onKeyPress: this.runIfEnter,
	            key: i,
	            page: i,
	            active: active,
	            showTitle: props.showTitle,
	            itemRender: props.itemRender
	          }));
	        }
	      } else {
	        var prevItemTitle = props.showLessItems ? locale.prev_3 : locale.prev_5;
	        var nextItemTitle = props.showLessItems ? locale.next_3 : locale.next_5;
	        jumpPrev = _react2['default'].createElement(
	          'li',
	          {
	            title: props.showTitle ? prevItemTitle : null,
	            key: 'prev',
	            onClick: this.jumpPrev,
	            tabIndex: '0',
	            onKeyPress: this.runIfEnterJumpPrev,
	            className: prefixCls + '-jump-prev'
	          },
	          props.itemRender(this.getJumpPrevPage(), 'jump-prev', _react2['default'].createElement('a', { className: prefixCls + '-item-link' }))
	        );
	        jumpNext = _react2['default'].createElement(
	          'li',
	          {
	            title: props.showTitle ? nextItemTitle : null,
	            key: 'next',
	            tabIndex: '0',
	            onClick: this.jumpNext,
	            onKeyPress: this.runIfEnterJumpNext,
	            className: prefixCls + '-jump-next'
	          },
	          props.itemRender(this.getJumpNextPage(), 'jump-next', _react2['default'].createElement('a', { className: prefixCls + '-item-link' }))
	        );
	        lastPager = _react2['default'].createElement(_Pager2['default'], {
	          locale: props.locale,
	          last: true,
	          rootPrefixCls: prefixCls,
	          onClick: this.handleChange,
	          onKeyPress: this.runIfEnter,
	          key: allPages,
	          page: allPages,
	          active: false,
	          showTitle: props.showTitle,
	          itemRender: props.itemRender
	        });
	        firstPager = _react2['default'].createElement(_Pager2['default'], {
	          locale: props.locale,
	          rootPrefixCls: prefixCls,
	          onClick: this.handleChange,
	          onKeyPress: this.runIfEnter,
	          key: 1,
	          page: 1,
	          active: false,
	          showTitle: props.showTitle,
	          itemRender: props.itemRender
	        });
	
	        var left = Math.max(1, current - pageBufferSize);
	        var right = Math.min(current + pageBufferSize, allPages);
	
	        if (current - 1 <= pageBufferSize) {
	          right = 1 + pageBufferSize * 2;
	        }
	
	        if (allPages - current <= pageBufferSize) {
	          left = allPages - pageBufferSize * 2;
	        }
	
	        for (var _i = left; _i <= right; _i++) {
	          var _active = current === _i;
	          pagerList.push(_react2['default'].createElement(_Pager2['default'], {
	            locale: props.locale,
	            rootPrefixCls: prefixCls,
	            onClick: this.handleChange,
	            onKeyPress: this.runIfEnter,
	            key: _i,
	            page: _i,
	            active: _active,
	            showTitle: props.showTitle,
	            itemRender: props.itemRender
	          }));
	        }
	
	        if (current - 1 >= pageBufferSize * 2 && current !== 1 + 2) {
	          pagerList[0] = _react2['default'].cloneElement(pagerList[0], {
	            className: prefixCls + '-item-after-jump-prev'
	          });
	          pagerList.unshift(jumpPrev);
	        }
	        if (allPages - current >= pageBufferSize * 2 && current !== allPages - 2) {
	          pagerList[pagerList.length - 1] = _react2['default'].cloneElement(pagerList[pagerList.length - 1], {
	            className: prefixCls + '-item-before-jump-next'
	          });
	          pagerList.push(jumpNext);
	        }
	
	        if (left !== 1) {
	          pagerList.unshift(firstPager);
	        }
	        if (right !== allPages) {
	          pagerList.push(lastPager);
	        }
	      }
	
	      var totalText = null;
	
	      if (props.showTotal) {
	        totalText = _react2['default'].createElement(
	          'li',
	          { className: prefixCls + '-total-text' },
	          props.showTotal(props.total, [(current - 1) * pageSize + 1, current * pageSize > props.total ? props.total : current * pageSize])
	        );
	      }
	      var prevDisabled = !this.hasPrev();
	      var nextDisabled = !this.hasNext();
	      return _react2['default'].createElement(
	        'ul',
	        {
	          className: prefixCls + ' ' + props.className,
	          style: props.style,
	          unselectable: 'unselectable'
	        },
	        totalText,
	        _react2['default'].createElement(
	          'li',
	          {
	            title: props.showTitle ? locale.prev_page : null,
	            onClick: this.prev,
	            tabIndex: '0',
	            onKeyPress: this.runIfEnterPrev,
	            className: (!prevDisabled ? '' : prefixCls + '-disabled') + ' ' + prefixCls + '-prev',
	            'aria-disabled': prevDisabled
	          },
	          props.itemRender(prevPage, 'prev', _react2['default'].createElement('a', { className: prefixCls + '-item-link' }))
	        ),
	        pagerList,
	        _react2['default'].createElement(
	          'li',
	          {
	            title: props.showTitle ? locale.next_page : null,
	            onClick: this.next,
	            tabIndex: '0',
	            onKeyPress: this.runIfEnterNext,
	            className: (!nextDisabled ? '' : prefixCls + '-disabled') + ' ' + prefixCls + '-next',
	            'aria-disabled': nextDisabled
	          },
	          props.itemRender(nextPage, 'next', _react2['default'].createElement('a', { className: prefixCls + '-item-link' }))
	        ),
	        _react2['default'].createElement(_Options2['default'], {
	          locale: props.locale,
	          rootPrefixCls: prefixCls,
	          selectComponentClass: props.selectComponentClass,
	          selectPrefixCls: props.selectPrefixCls,
	          changeSize: this.props.showSizeChanger ? this.changePageSize : null,
	          current: this.state.current,
	          pageSize: this.state.pageSize,
	          pageSizeOptions: this.props.pageSizeOptions,
	          quickGo: this.props.showQuickJumper ? this.handleChange : null,
	          goButton: goButton
	        })
	      );
	    }
	  }]);
	  return Pagination;
	}(_react2['default'].Component);
	
	Pagination.propTypes = {
	  current: _propTypes2['default'].number,
	  defaultCurrent: _propTypes2['default'].number,
	  total: _propTypes2['default'].number,
	  pageSize: _propTypes2['default'].number,
	  defaultPageSize: _propTypes2['default'].number,
	  onChange: _propTypes2['default'].func,
	  hideOnSinglePage: _propTypes2['default'].bool,
	  showSizeChanger: _propTypes2['default'].bool,
	  showLessItems: _propTypes2['default'].bool,
	  onShowSizeChange: _propTypes2['default'].func,
	  selectComponentClass: _propTypes2['default'].func,
	  showQuickJumper: _propTypes2['default'].oneOfType([_propTypes2['default'].bool, _propTypes2['default'].object]),
	  showTitle: _propTypes2['default'].bool,
	  pageSizeOptions: _propTypes2['default'].arrayOf(_propTypes2['default'].string),
	  showTotal: _propTypes2['default'].func,
	  locale: _propTypes2['default'].object,
	  style: _propTypes2['default'].object,
	  itemRender: _propTypes2['default'].func
	};
	Pagination.defaultProps = {
	  defaultCurrent: 1,
	  total: 0,
	  defaultPageSize: 10,
	  onChange: noop,
	  className: '',
	  selectPrefixCls: 'rc-select',
	  prefixCls: 'rc-pagination',
	  selectComponentClass: null,
	  hideOnSinglePage: false,
	  showQuickJumper: false,
	  showSizeChanger: false,
	  showLessItems: false,
	  showTitle: true,
	  onShowSizeChange: noop,
	  locale: _zh_CN2['default'],
	  style: {},
	  itemRender: defaultItemRender
	};
	
	var _initialiseProps = function _initialiseProps() {
	  var _this2 = this;
	
	  this.calculatePage = function (p) {
	    var pageSize = p;
	    if (typeof pageSize === 'undefined') {
	      pageSize = _this2.state.pageSize;
	    }
	    return Math.floor((_this2.props.total - 1) / pageSize) + 1;
	  };
	
	  this.isValid = function (page) {
	    return isInteger(page) && page >= 1 && page !== _this2.state.current;
	  };
	
	  this.handleKeyDown = function (e) {
	    if (e.keyCode === _KeyCode2['default'].ARROW_UP || e.keyCode === _KeyCode2['default'].ARROW_DOWN) {
	      e.preventDefault();
	    }
	  };
	
	  this.handleKeyUp = function (e) {
	    var inputValue = e.target.value;
	    var currentInputValue = _this2.state.currentInputValue;
	    var value = void 0;
	
	    if (inputValue === '') {
	      value = inputValue;
	    } else if (isNaN(Number(inputValue))) {
	      value = currentInputValue;
	    } else {
	      value = Number(inputValue);
	    }
	
	    if (value !== currentInputValue) {
	      _this2.setState({
	        currentInputValue: value
	      });
	    }
	
	    if (e.keyCode === _KeyCode2['default'].ENTER) {
	      _this2.handleChange(value);
	    } else if (e.keyCode === _KeyCode2['default'].ARROW_UP) {
	      _this2.handleChange(value - 1);
	    } else if (e.keyCode === _KeyCode2['default'].ARROW_DOWN) {
	      _this2.handleChange(value + 1);
	    }
	  };
	
	  this.changePageSize = function (size) {
	    var current = _this2.state.current;
	    var newCurrent = _this2.calculatePage(size);
	    current = current > newCurrent ? newCurrent : current;
	    if (typeof size === 'number') {
	      if (!('pageSize' in _this2.props)) {
	        _this2.setState({
	          pageSize: size
	        });
	      }
	      if (!('current' in _this2.props)) {
	        _this2.setState({
	          current: current,
	          currentInputValue: current
	        });
	      }
	    }
	    _this2.props.onShowSizeChange(current, size);
	  };
	
	  this.handleChange = function (p) {
	    var page = p;
	    if (_this2.isValid(page)) {
	      if (page > _this2.calculatePage()) {
	        page = _this2.calculatePage();
	      }
	
	      if (!('current' in _this2.props)) {
	        _this2.setState({
	          current: page,
	          currentInputValue: page
	        });
	      }
	
	      var pageSize = _this2.state.pageSize;
	      _this2.props.onChange(page, pageSize);
	
	      return page;
	    }
	
	    return _this2.state.current;
	  };
	
	  this.prev = function () {
	    if (_this2.hasPrev()) {
	      _this2.handleChange(_this2.state.current - 1);
	    }
	  };
	
	  this.next = function () {
	    if (_this2.hasNext()) {
	      _this2.handleChange(_this2.state.current + 1);
	    }
	  };
	
	  this.jumpPrev = function () {
	    _this2.handleChange(_this2.getJumpPrevPage());
	  };
	
	  this.jumpNext = function () {
	    _this2.handleChange(_this2.getJumpNextPage());
	  };
	
	  this.hasPrev = function () {
	    return _this2.state.current > 1;
	  };
	
	  this.hasNext = function () {
	    return _this2.state.current < _this2.calculatePage();
	  };
	
	  this.runIfEnter = function (event, callback) {
	    for (var _len = arguments.length, restParams = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
	      restParams[_key - 2] = arguments[_key];
	    }
	
	    if (event.key === 'Enter' || event.charCode === 13) {
	      callback.apply(undefined, restParams);
	    }
	  };
	
	  this.runIfEnterPrev = function (e) {
	    _this2.runIfEnter(e, _this2.prev);
	  };
	
	  this.runIfEnterNext = function (e) {
	    _this2.runIfEnter(e, _this2.next);
	  };
	
	  this.runIfEnterJumpPrev = function (e) {
	    _this2.runIfEnter(e, _this2.jumpPrev);
	  };
	
	  this.runIfEnterJumpNext = function (e) {
	    _this2.runIfEnter(e, _this2.jumpNext);
	  };
	
	  this.handleGoTO = function (e) {
	    if (e.keyCode === _KeyCode2['default'].ENTER || e.type === 'click') {
	      _this2.handleChange(_this2.state.currentInputValue);
	    }
	  };
	};
	
	exports['default'] = Pagination;
	module.exports = exports['default'];

/***/ }),
/* 724 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _Pagination = __webpack_require__(723);
	
	Object.defineProperty(exports, 'default', {
	  enumerable: true,
	  get: function get() {
	    return _interopRequireDefault(_Pagination)['default'];
	  }
	});
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	module.exports = exports['default'];

/***/ }),
/* 725 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	exports.__esModule = true;
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _objectWithoutProperties2 = __webpack_require__(20);
	
	var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _enhancer = __webpack_require__(264);
	
	var _enhancer2 = _interopRequireDefault(_enhancer);
	
	var _types = __webpack_require__(265);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	/* eslint react/prop-types: 0 */
	var Circle = function (_Component) {
	  (0, _inherits3['default'])(Circle, _Component);
	
	  function Circle() {
	    (0, _classCallCheck3['default'])(this, Circle);
	    return (0, _possibleConstructorReturn3['default'])(this, _Component.apply(this, arguments));
	  }
	
	  Circle.prototype.getPathStyles = function getPathStyles() {
	    var _props = this.props,
	        percent = _props.percent,
	        strokeWidth = _props.strokeWidth,
	        _props$gapDegree = _props.gapDegree,
	        gapDegree = _props$gapDegree === undefined ? 0 : _props$gapDegree,
	        gapPosition = _props.gapPosition;
	
	    var radius = 50 - strokeWidth / 2;
	    var beginPositionX = 0;
	    var beginPositionY = -radius;
	    var endPositionX = 0;
	    var endPositionY = -2 * radius;
	    switch (gapPosition) {
	      case 'left':
	        beginPositionX = -radius;
	        beginPositionY = 0;
	        endPositionX = 2 * radius;
	        endPositionY = 0;
	        break;
	      case 'right':
	        beginPositionX = radius;
	        beginPositionY = 0;
	        endPositionX = -2 * radius;
	        endPositionY = 0;
	        break;
	      case 'bottom':
	        beginPositionY = radius;
	        endPositionY = 2 * radius;
	        break;
	      default:
	    }
	    var pathString = 'M 50,50 m ' + beginPositionX + ',' + beginPositionY + '\n     a ' + radius + ',' + radius + ' 0 1 1 ' + endPositionX + ',' + -endPositionY + '\n     a ' + radius + ',' + radius + ' 0 1 1 ' + -endPositionX + ',' + endPositionY;
	    var len = Math.PI * 2 * radius;
	    var trailPathStyle = {
	      strokeDasharray: len - gapDegree + 'px ' + len + 'px',
	      strokeDashoffset: '-' + gapDegree / 2 + 'px',
	      transition: 'stroke-dashoffset .3s ease 0s, stroke-dasharray .3s ease 0s, stroke .3s'
	    };
	    var strokePathStyle = {
	      strokeDasharray: percent / 100 * (len - gapDegree) + 'px ' + len + 'px',
	      strokeDashoffset: '-' + gapDegree / 2 + 'px',
	      transition: 'stroke-dashoffset .3s ease 0s, stroke-dasharray .3s ease 0s, stroke .3s, stroke-width .06s ease .3s' // eslint-disable-line
	    };
	    return { pathString: pathString, trailPathStyle: trailPathStyle, strokePathStyle: strokePathStyle };
	  };
	
	  Circle.prototype.render = function render() {
	    var _this2 = this;
	
	    var _props2 = this.props,
	        prefixCls = _props2.prefixCls,
	        strokeWidth = _props2.strokeWidth,
	        trailWidth = _props2.trailWidth,
	        strokeColor = _props2.strokeColor,
	        percent = _props2.percent,
	        trailColor = _props2.trailColor,
	        strokeLinecap = _props2.strokeLinecap,
	        style = _props2.style,
	        className = _props2.className,
	        restProps = (0, _objectWithoutProperties3['default'])(_props2, ['prefixCls', 'strokeWidth', 'trailWidth', 'strokeColor', 'percent', 'trailColor', 'strokeLinecap', 'style', 'className']);
	
	    var _getPathStyles = this.getPathStyles(),
	        pathString = _getPathStyles.pathString,
	        trailPathStyle = _getPathStyles.trailPathStyle,
	        strokePathStyle = _getPathStyles.strokePathStyle;
	
	    delete restProps.percent;
	    delete restProps.gapDegree;
	    delete restProps.gapPosition;
	    return _react2['default'].createElement(
	      'svg',
	      (0, _extends3['default'])({
	        className: prefixCls + '-circle ' + className,
	        viewBox: '0 0 100 100',
	        style: style
	      }, restProps),
	      _react2['default'].createElement('path', {
	        className: prefixCls + '-circle-trail',
	        d: pathString,
	        stroke: trailColor,
	        strokeWidth: trailWidth || strokeWidth,
	        fillOpacity: '0',
	        style: trailPathStyle
	      }),
	      _react2['default'].createElement('path', {
	        className: prefixCls + '-circle-path',
	        d: pathString,
	        strokeLinecap: strokeLinecap,
	        stroke: strokeColor,
	        strokeWidth: this.props.percent === 0 ? 0 : strokeWidth,
	        fillOpacity: '0',
	        ref: function ref(path) {
	          _this2.path = path;
	        },
	        style: strokePathStyle
	      })
	    );
	  };
	
	  return Circle;
	}(_react.Component);
	
	Circle.propTypes = (0, _extends3['default'])({}, _types.propTypes, {
	  gapPosition: _propTypes2['default'].oneOf(['top', 'bottom', 'left', 'right'])
	});
	
	Circle.defaultProps = (0, _extends3['default'])({}, _types.defaultProps, {
	  gapPosition: 'top'
	});
	
	exports['default'] = (0, _enhancer2['default'])(Circle);
	module.exports = exports['default'];

/***/ }),
/* 726 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	exports.__esModule = true;
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _objectWithoutProperties2 = __webpack_require__(20);
	
	var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _enhancer = __webpack_require__(264);
	
	var _enhancer2 = _interopRequireDefault(_enhancer);
	
	var _types = __webpack_require__(265);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var Line = function (_Component) {
	  (0, _inherits3['default'])(Line, _Component);
	
	  function Line() {
	    (0, _classCallCheck3['default'])(this, Line);
	    return (0, _possibleConstructorReturn3['default'])(this, _Component.apply(this, arguments));
	  }
	
	  Line.prototype.render = function render() {
	    var _this2 = this;
	
	    var _props = this.props,
	        className = _props.className,
	        percent = _props.percent,
	        prefixCls = _props.prefixCls,
	        strokeColor = _props.strokeColor,
	        strokeLinecap = _props.strokeLinecap,
	        strokeWidth = _props.strokeWidth,
	        style = _props.style,
	        trailColor = _props.trailColor,
	        trailWidth = _props.trailWidth,
	        restProps = (0, _objectWithoutProperties3['default'])(_props, ['className', 'percent', 'prefixCls', 'strokeColor', 'strokeLinecap', 'strokeWidth', 'style', 'trailColor', 'trailWidth']);
	
	
	    delete restProps.gapPosition;
	
	    var pathStyle = {
	      strokeDasharray: '100px, 100px',
	      strokeDashoffset: 100 - percent + 'px',
	      transition: 'stroke-dashoffset 0.3s ease 0s, stroke 0.3s linear'
	    };
	
	    var center = strokeWidth / 2;
	    var right = 100 - strokeWidth / 2;
	    var pathString = 'M ' + (strokeLinecap === 'round' ? center : 0) + ',' + center + '\n           L ' + (strokeLinecap === 'round' ? right : 100) + ',' + center;
	    var viewBoxString = '0 0 100 ' + strokeWidth;
	
	    return _react2['default'].createElement(
	      'svg',
	      (0, _extends3['default'])({
	        className: prefixCls + '-line ' + className,
	        viewBox: viewBoxString,
	        preserveAspectRatio: 'none',
	        style: style
	      }, restProps),
	      _react2['default'].createElement('path', {
	        className: prefixCls + '-line-trail',
	        d: pathString,
	        strokeLinecap: strokeLinecap,
	        stroke: trailColor,
	        strokeWidth: trailWidth || strokeWidth,
	        fillOpacity: '0'
	      }),
	      _react2['default'].createElement('path', {
	        className: prefixCls + '-line-path',
	        d: pathString,
	        strokeLinecap: strokeLinecap,
	        stroke: strokeColor,
	        strokeWidth: strokeWidth,
	        fillOpacity: '0',
	        ref: function ref(path) {
	          _this2.path = path;
	        },
	        style: pathStyle
	      })
	    );
	  };
	
	  return Line;
	}(_react.Component);
	
	Line.propTypes = _types.propTypes;
	
	Line.defaultProps = _types.defaultProps;
	
	exports['default'] = (0, _enhancer2['default'])(Line);
	module.exports = exports['default'];

/***/ }),
/* 727 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	exports.__esModule = true;
	exports.Circle = exports.Line = undefined;
	
	var _Line = __webpack_require__(726);
	
	var _Line2 = _interopRequireDefault(_Line);
	
	var _Circle = __webpack_require__(725);
	
	var _Circle2 = _interopRequireDefault(_Circle);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	exports.Line = _Line2['default'];
	exports.Circle = _Circle2['default'];
	exports['default'] = {
	  Line: _Line2['default'],
	  Circle: _Circle2['default']
	};

/***/ }),
/* 728 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _reactDom = __webpack_require__(10);
	
	var _reactDom2 = _interopRequireDefault(_reactDom);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _util = __webpack_require__(731);
	
	var _Star = __webpack_require__(729);
	
	var _Star2 = _interopRequireDefault(_Star);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
	
	function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(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) : _defaults(subClass, superClass); }
	
	function noop() {}
	
	var Rate = function (_React$Component) {
	  _inherits(Rate, _React$Component);
	
	  function Rate(props) {
	    _classCallCheck(this, Rate);
	
	    var _this = _possibleConstructorReturn(this, _React$Component.call(this, props));
	
	    _initialiseProps.call(_this);
	
	    var value = props.value;
	    if (value === undefined) {
	      value = props.defaultValue;
	    }
	    _this.state = {
	      value: value
	    };
	    return _this;
	  }
	
	  Rate.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {
	    if ('value' in nextProps) {
	      var value = nextProps.value;
	      if (value === undefined) {
	        value = nextProps.defaultValue;
	      }
	      this.setState({
	        value: value
	      });
	    }
	  };
	
	  Rate.prototype.getStarDOM = function getStarDOM(index) {
	    return _reactDom2["default"].findDOMNode(this.refs['star_' + index]);
	  };
	
	  Rate.prototype.getStarValue = function getStarValue(index, x) {
	    var value = index + 1;
	    if (this.props.allowHalf) {
	      var leftEdge = (0, _util.getOffsetLeft)(this.getStarDOM(0));
	      var width = (0, _util.getOffsetLeft)(this.getStarDOM(1)) - leftEdge;
	      if (x - leftEdge - width * index < width / 2) {
	        value -= 0.5;
	      }
	    }
	    return value;
	  };
	
	  Rate.prototype.render = function render() {
	    var _props = this.props,
	        count = _props.count,
	        allowHalf = _props.allowHalf,
	        style = _props.style,
	        prefixCls = _props.prefixCls,
	        disabled = _props.disabled,
	        className = _props.className,
	        character = _props.character;
	    var _state = this.state,
	        value = _state.value,
	        hoverValue = _state.hoverValue;
	
	    var stars = [];
	    var disabledClass = disabled ? prefixCls + '-disabled' : '';
	    for (var index = 0; index < count; index++) {
	      stars.push(_react2["default"].createElement(_Star2["default"], {
	        ref: 'star_' + index,
	        index: index,
	        disabled: disabled,
	        prefixCls: prefixCls + '-star',
	        allowHalf: allowHalf,
	        value: hoverValue === undefined ? value : hoverValue,
	        onClick: this.onClick,
	        onHover: this.onHover,
	        key: index,
	        character: character
	      }));
	    }
	    return _react2["default"].createElement(
	      'ul',
	      {
	        className: (0, _classnames2["default"])(prefixCls, disabledClass, className),
	        style: style,
	        onMouseLeave: disabled ? null : this.onMouseLeave
	      },
	      stars
	    );
	  };
	
	  return Rate;
	}(_react2["default"].Component);
	
	Rate.propTypes = {
	  disabled: _propTypes2["default"].bool,
	  value: _propTypes2["default"].number,
	  defaultValue: _propTypes2["default"].number,
	  count: _propTypes2["default"].number,
	  allowHalf: _propTypes2["default"].bool,
	  style: _propTypes2["default"].object,
	  prefixCls: _propTypes2["default"].string,
	  onChange: _propTypes2["default"].func,
	  onHoverChange: _propTypes2["default"].func,
	  className: _propTypes2["default"].string,
	  character: _propTypes2["default"].node
	};
	Rate.defaultProps = {
	  defaultValue: 0,
	  count: 5,
	  allowHalf: false,
	  style: {},
	  prefixCls: 'rc-rate',
	  onChange: noop,
	  character: '★',
	  onHoverChange: noop
	};
	
	var _initialiseProps = function _initialiseProps() {
	  var _this2 = this;
	
	  this.onHover = function (event, index) {
	    var hoverValue = _this2.getStarValue(index, event.pageX);
	    _this2.setState({
	      hoverValue: hoverValue
	    });
	    _this2.props.onHoverChange(hoverValue);
	  };
	
	  this.onMouseLeave = function () {
	    _this2.setState({
	      hoverValue: undefined
	    });
	    _this2.props.onHoverChange(undefined);
	  };
	
	  this.onClick = function (event, index) {
	    var value = _this2.getStarValue(index, event.pageX);
	    if (!('value' in _this2.props)) {
	      _this2.setState({
	        value: value
	      });
	    }
	    _this2.onMouseLeave();
	    _this2.props.onChange(value);
	  };
	};
	
	exports["default"] = Rate;
	module.exports = exports['default'];

/***/ }),
/* 729 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
	
	function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(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) : _defaults(subClass, superClass); }
	
	var Star = function (_React$Component) {
	  _inherits(Star, _React$Component);
	
	  function Star() {
	    var _temp, _this, _ret;
	
	    _classCallCheck(this, Star);
	
	    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
	      args[_key] = arguments[_key];
	    }
	
	    return _ret = (_temp = (_this = _possibleConstructorReturn(this, _React$Component.call.apply(_React$Component, [this].concat(args))), _this), _this.onHover = function (e) {
	      var _this$props = _this.props,
	          onHover = _this$props.onHover,
	          index = _this$props.index;
	
	      onHover(e, index);
	    }, _this.onClick = function (e) {
	      var _this$props2 = _this.props,
	          onClick = _this$props2.onClick,
	          index = _this$props2.index;
	
	      onClick(e, index);
	    }, _temp), _possibleConstructorReturn(_this, _ret);
	  }
	
	  Star.prototype.getClassName = function getClassName() {
	    var _props = this.props,
	        prefixCls = _props.prefixCls,
	        index = _props.index,
	        value = _props.value,
	        allowHalf = _props.allowHalf;
	
	    var starValue = index + 1;
	    if (allowHalf && value + 0.5 === starValue) {
	      return prefixCls + ' ' + prefixCls + '-half ' + prefixCls + '-active';
	    }
	    return starValue <= value ? prefixCls + ' ' + prefixCls + '-full' : prefixCls + ' ' + prefixCls + '-zero';
	  };
	
	  Star.prototype.render = function render() {
	    var onHover = this.onHover,
	        onClick = this.onClick;
	    var _props2 = this.props,
	        disabled = _props2.disabled,
	        prefixCls = _props2.prefixCls,
	        character = _props2.character;
	
	    return _react2["default"].createElement(
	      'li',
	      {
	        className: this.getClassName(),
	        onClick: disabled ? null : onClick,
	        onMouseMove: disabled ? null : onHover
	      },
	      _react2["default"].createElement(
	        'div',
	        { className: prefixCls + '-first' },
	        character
	      ),
	      _react2["default"].createElement(
	        'div',
	        { className: prefixCls + '-second' },
	        character
	      )
	    );
	  };
	
	  return Star;
	}(_react2["default"].Component);
	
	Star.propTypes = {
	  value: _propTypes2["default"].number,
	  index: _propTypes2["default"].number,
	  prefixCls: _propTypes2["default"].string,
	  allowHalf: _propTypes2["default"].bool,
	  disabled: _propTypes2["default"].bool,
	  onHover: _propTypes2["default"].func,
	  onClick: _propTypes2["default"].func,
	  character: _propTypes2["default"].node
	};
	exports["default"] = Star;
	module.exports = exports['default'];

/***/ }),
/* 730 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _Rate = __webpack_require__(728);
	
	var _Rate2 = _interopRequireDefault(_Rate);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
	
	exports["default"] = _Rate2["default"];
	module.exports = exports['default'];

/***/ }),
/* 731 */
/***/ (function(module, exports) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.getOffsetLeft = getOffsetLeft;
	function getScroll(w, top) {
	  var ret = top ? w.pageYOffset : w.pageXOffset;
	  var method = top ? 'scrollTop' : 'scrollLeft';
	  if (typeof ret !== 'number') {
	    var d = w.document;
	    // ie6,7,8 standard mode
	    ret = d.documentElement[method];
	    if (typeof ret !== 'number') {
	      // quirks mode
	      ret = d.body[method];
	    }
	  }
	  return ret;
	}
	
	function getClientPosition(elem) {
	  var box = void 0;
	  var x = void 0;
	  var y = void 0;
	  var doc = elem.ownerDocument;
	  var body = doc.body;
	  var docElem = doc && doc.documentElement;
	  box = elem.getBoundingClientRect();
	  x = box.left;
	  y = box.top;
	  x -= docElem.clientLeft || body.clientLeft || 0;
	  y -= docElem.clientTop || body.clientTop || 0;
	  return {
	    left: x,
	    top: y
	  };
	}
	
	function getOffsetLeft(el) {
	  var pos = getClientPosition(el);
	  var doc = el.ownerDocument;
	  var w = doc.defaultView || doc.parentWindow;
	  pos.left += getScroll(w);
	  return pos.left;
	}

/***/ }),
/* 732 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _reactDom = __webpack_require__(10);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _toArray = __webpack_require__(152);
	
	var _toArray2 = _interopRequireDefault(_toArray);
	
	var _rcMenu = __webpack_require__(77);
	
	var _rcMenu2 = _interopRequireDefault(_rcMenu);
	
	var _domScrollIntoView = __webpack_require__(88);
	
	var _domScrollIntoView2 = _interopRequireDefault(_domScrollIntoView);
	
	var _util = __webpack_require__(148);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var DropdownMenu = function (_React$Component) {
	  (0, _inherits3['default'])(DropdownMenu, _React$Component);
	
	  function DropdownMenu() {
	    var _ref;
	
	    var _temp, _this, _ret;
	
	    (0, _classCallCheck3['default'])(this, DropdownMenu);
	
	    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
	      args[_key] = arguments[_key];
	    }
	
	    return _ret = (_temp = (_this = (0, _possibleConstructorReturn3['default'])(this, (_ref = DropdownMenu.__proto__ || Object.getPrototypeOf(DropdownMenu)).call.apply(_ref, [this].concat(args))), _this), _this.scrollActiveItemToView = function () {
	      // scroll into view
	      var itemComponent = (0, _reactDom.findDOMNode)(_this.firstActiveItem);
	      var props = _this.props;
	
	      if (itemComponent) {
	        var scrollIntoViewOpts = {
	          onlyScrollIfNeeded: true
	        };
	        if ((!props.value || props.value.length === 0) && props.firstActiveValue) {
	          scrollIntoViewOpts.alignWithTop = true;
	        }
	
	        (0, _domScrollIntoView2['default'])(itemComponent, (0, _reactDom.findDOMNode)(_this.refs.menu), scrollIntoViewOpts);
	      }
	    }, _temp), (0, _possibleConstructorReturn3['default'])(_this, _ret);
	  }
	
	  (0, _createClass3['default'])(DropdownMenu, [{
	    key: 'componentWillMount',
	    value: function componentWillMount() {
	      this.lastInputValue = this.props.inputValue;
	    }
	  }, {
	    key: 'componentDidMount',
	    value: function componentDidMount() {
	      this.scrollActiveItemToView();
	      this.lastVisible = this.props.visible;
	    }
	  }, {
	    key: 'shouldComponentUpdate',
	    value: function shouldComponentUpdate(nextProps) {
	      if (!nextProps.visible) {
	        this.lastVisible = false;
	      }
	      // freeze when hide
	      return nextProps.visible;
	    }
	  }, {
	    key: 'componentDidUpdate',
	    value: function componentDidUpdate(prevProps) {
	      var props = this.props;
	      if (!prevProps.visible && props.visible) {
	        this.scrollActiveItemToView();
	      }
	      this.lastVisible = props.visible;
	      this.lastInputValue = props.inputValue;
	    }
	  }, {
	    key: 'renderMenu',
	    value: function renderMenu() {
	      var _this2 = this;
	
	      var props = this.props;
	      var menuItems = props.menuItems,
	          defaultActiveFirstOption = props.defaultActiveFirstOption,
	          value = props.value,
	          prefixCls = props.prefixCls,
	          multiple = props.multiple,
	          onMenuSelect = props.onMenuSelect,
	          inputValue = props.inputValue,
	          firstActiveValue = props.firstActiveValue;
	
	      if (menuItems && menuItems.length) {
	        var menuProps = {};
	        if (multiple) {
	          menuProps.onDeselect = props.onMenuDeselect;
	          menuProps.onSelect = onMenuSelect;
	        } else {
	          menuProps.onClick = onMenuSelect;
	        }
	
	        var selectedKeys = (0, _util.getSelectKeys)(menuItems, value);
	        var activeKeyProps = {};
	
	        var clonedMenuItems = menuItems;
	        if (selectedKeys.length || firstActiveValue) {
	          if (props.visible && !this.lastVisible) {
	            activeKeyProps.activeKey = selectedKeys[0] || firstActiveValue;
	          }
	          var foundFirst = false;
	          // set firstActiveItem via cloning menus
	          // for scroll into view
	          var clone = function clone(item) {
	            if (!foundFirst && selectedKeys.indexOf(item.key) !== -1 || !foundFirst && !selectedKeys.length && firstActiveValue.indexOf(item.key) !== -1) {
	              foundFirst = true;
	              return (0, _react.cloneElement)(item, {
	                ref: function ref(_ref2) {
	                  _this2.firstActiveItem = _ref2;
	                }
	              });
	            }
	            return item;
	          };
	
	          clonedMenuItems = menuItems.map(function (item) {
	            if (item.type.isMenuItemGroup) {
	              var children = (0, _toArray2['default'])(item.props.children).map(clone);
	              return (0, _react.cloneElement)(item, {}, children);
	            }
	            return clone(item);
	          });
	        }
	
	        // clear activeKey when inputValue change
	        var lastValue = value && value[value.length - 1];
	        if (inputValue !== this.lastInputValue && (!lastValue || !lastValue.backfill)) {
	          activeKeyProps.activeKey = '';
	        }
	
	        return _react2['default'].createElement(
	          _rcMenu2['default'],
	          (0, _extends3['default'])({
	            ref: 'menu',
	            style: this.props.dropdownMenuStyle,
	            defaultActiveFirst: defaultActiveFirstOption
	          }, activeKeyProps, {
	            multiple: multiple,
	            focusable: false
	          }, menuProps, {
	            selectedKeys: selectedKeys,
	            prefixCls: prefixCls + '-menu'
	          }),
	          clonedMenuItems
	        );
	      }
	      return null;
	    }
	  }, {
	    key: 'render',
	    value: function render() {
	      var renderMenu = this.renderMenu();
	      return renderMenu ? _react2['default'].createElement(
	        'div',
	        {
	          style: { overflow: 'auto' },
	          onFocus: this.props.onPopupFocus,
	          onMouseDown: _util.preventDefaultEvent
	        },
	        renderMenu
	      ) : null;
	    }
	  }]);
	  return DropdownMenu;
	}(_react2['default'].Component);
	
	DropdownMenu.propTypes = {
	  defaultActiveFirstOption: _propTypes2['default'].bool,
	  value: _propTypes2['default'].any,
	  dropdownMenuStyle: _propTypes2['default'].object,
	  multiple: _propTypes2['default'].bool,
	  onPopupFocus: _propTypes2['default'].func,
	  onMenuDeSelect: _propTypes2['default'].func,
	  onMenuSelect: _propTypes2['default'].func,
	  prefixCls: _propTypes2['default'].string,
	  menuItems: _propTypes2['default'].any,
	  inputValue: _propTypes2['default'].string,
	  visible: _propTypes2['default'].bool
	};
	exports['default'] = DropdownMenu;
	
	
	DropdownMenu.displayName = 'DropdownMenu';
	module.exports = exports['default'];

/***/ }),
/* 733 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var OptGroup = function (_React$Component) {
	  (0, _inherits3['default'])(OptGroup, _React$Component);
	
	  function OptGroup() {
	    (0, _classCallCheck3['default'])(this, OptGroup);
	    return (0, _possibleConstructorReturn3['default'])(this, (OptGroup.__proto__ || Object.getPrototypeOf(OptGroup)).apply(this, arguments));
	  }
	
	  return OptGroup;
	}(_react2['default'].Component);
	
	OptGroup.isSelectOptGroup = true;
	exports['default'] = OptGroup;
	module.exports = exports['default'];

/***/ }),
/* 734 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var Option = function (_React$Component) {
	  (0, _inherits3['default'])(Option, _React$Component);
	
	  function Option() {
	    (0, _classCallCheck3['default'])(this, Option);
	    return (0, _possibleConstructorReturn3['default'])(this, (Option.__proto__ || Object.getPrototypeOf(Option)).apply(this, arguments));
	  }
	
	  return Option;
	}(_react2['default'].Component);
	
	Option.propTypes = {
	  value: _propTypes2['default'].string
	};
	Option.isSelectOption = true;
	exports['default'] = Option;
	module.exports = exports['default'];

/***/ }),
/* 735 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _reactDom = __webpack_require__(10);
	
	var _reactDom2 = _interopRequireDefault(_reactDom);
	
	var _KeyCode = __webpack_require__(29);
	
	var _KeyCode2 = _interopRequireDefault(_KeyCode);
	
	var _classnames2 = __webpack_require__(8);
	
	var _classnames3 = _interopRequireDefault(_classnames2);
	
	var _rcAnimate = __webpack_require__(22);
	
	var _rcAnimate2 = _interopRequireDefault(_rcAnimate);
	
	var _componentClasses = __webpack_require__(105);
	
	var _componentClasses2 = _interopRequireDefault(_componentClasses);
	
	var _util = __webpack_require__(148);
	
	var _SelectTrigger = __webpack_require__(736);
	
	var _SelectTrigger2 = _interopRequireDefault(_SelectTrigger);
	
	var _PropTypes = __webpack_require__(266);
	
	var _rcMenu = __webpack_require__(77);
	
	var _warning = __webpack_require__(35);
	
	var _warning2 = _interopRequireDefault(_warning);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function noop() {} /* eslint func-names: 0 */
	
	
	function saveRef(name, component) {
	  this[name] = component;
	}
	
	function chaining() {
	  for (var _len = arguments.length, fns = Array(_len), _key = 0; _key < _len; _key++) {
	    fns[_key] = arguments[_key];
	  }
	
	  return function () {
	    for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
	      args[_key2] = arguments[_key2];
	    }
	
	    // eslint-disable-line
	    for (var i = 0; i < fns.length; i++) {
	      if (fns[i] && typeof fns[i] === 'function') {
	        fns[i].apply(this, args);
	      }
	    }
	  };
	}
	
	var Select = function (_React$Component) {
	  (0, _inherits3['default'])(Select, _React$Component);
	
	  function Select(props) {
	    (0, _classCallCheck3['default'])(this, Select);
	
	    var _this = (0, _possibleConstructorReturn3['default'])(this, (Select.__proto__ || Object.getPrototypeOf(Select)).call(this, props));
	
	    _initialiseProps.call(_this);
	
	    var value = [];
	    if ('value' in props) {
	      value = (0, _util.toArray)(props.value);
	    } else {
	      value = (0, _util.toArray)(props.defaultValue);
	    }
	    value = _this.addLabelToValue(props, value);
	    value = _this.addTitleToValue(props, value);
	    var inputValue = '';
	    if (props.combobox) {
	      inputValue = value.length ? _this.getLabelFromProps(props, value[0].key) : '';
	    }
	    _this.saveInputRef = saveRef.bind(_this, 'inputInstance');
	    _this.saveInputMirrorRef = saveRef.bind(_this, 'inputMirrorInstance');
	    var open = props.open;
	    if (open === undefined) {
	      open = props.defaultOpen;
	    }
	    _this.state = {
	      value: value,
	      inputValue: inputValue,
	      open: open
	    };
	    _this.adjustOpenState();
	    return _this;
	  }
	
	  (0, _createClass3['default'])(Select, [{
	    key: 'componentWillUpdate',
	    value: function componentWillUpdate(nextProps, nextState) {
	      this.props = nextProps;
	      this.state = nextState;
	      this.adjustOpenState();
	    }
	  }, {
	    key: 'componentDidUpdate',
	    value: function componentDidUpdate() {
	      if ((0, _util.isMultipleOrTags)(this.props)) {
	        var inputNode = this.getInputDOMNode();
	        var mirrorNode = this.getInputMirrorDOMNode();
	        if (inputNode.value) {
	          inputNode.style.width = '';
	          inputNode.style.width = mirrorNode.clientWidth + 'px';
	        } else {
	          inputNode.style.width = '';
	        }
	      }
	    }
	  }, {
	    key: 'componentWillUnmount',
	    value: function componentWillUnmount() {
	      this.clearFocusTime();
	      this.clearBlurTime();
	      this.clearAdjustTimer();
	      if (this.dropdownContainer) {
	        _reactDom2['default'].unmountComponentAtNode(this.dropdownContainer);
	        document.body.removeChild(this.dropdownContainer);
	        this.dropdownContainer = null;
	      }
	    }
	
	    // combobox ignore
	
	  }, {
	    key: 'render',
	    value: function render() {
	      var _rootCls;
	
	      var props = this.props;
	      var multiple = (0, _util.isMultipleOrTags)(props);
	      var state = this.state;
	      var className = props.className,
	          disabled = props.disabled,
	          allowClear = props.allowClear,
	          prefixCls = props.prefixCls;
	
	      var ctrlNode = this.renderTopControlNode();
	      var extraSelectionProps = {};
	      var open = this.state.open;
	
	      var options = this._options;
	      if (!(0, _util.isMultipleOrTagsOrCombobox)(props)) {
	        extraSelectionProps = {
	          onKeyDown: this.onKeyDown,
	          tabIndex: 0
	        };
	      }
	      var rootCls = (_rootCls = {}, (0, _defineProperty3['default'])(_rootCls, className, !!className), (0, _defineProperty3['default'])(_rootCls, prefixCls, 1), (0, _defineProperty3['default'])(_rootCls, prefixCls + '-open', open), (0, _defineProperty3['default'])(_rootCls, prefixCls + '-focused', open || !!this._focused), (0, _defineProperty3['default'])(_rootCls, prefixCls + '-combobox', (0, _util.isCombobox)(props)), (0, _defineProperty3['default'])(_rootCls, prefixCls + '-disabled', disabled), (0, _defineProperty3['default'])(_rootCls, prefixCls + '-enabled', !disabled), (0, _defineProperty3['default'])(_rootCls, prefixCls + '-allow-clear', !!props.allowClear), _rootCls);
	      var clearStyle = (0, _extends3['default'])({}, _util.UNSELECTABLE_STYLE, {
	        display: 'none'
	      });
	      if (state.inputValue || state.value.length) {
	        clearStyle.display = 'block';
	      }
	      var clear = _react2['default'].createElement('span', (0, _extends3['default'])({
	        key: 'clear',
	        onMouseDown: _util.preventDefaultEvent,
	        style: clearStyle
	      }, _util.UNSELECTABLE_ATTRIBUTE, {
	        className: prefixCls + '-selection__clear',
	        onClick: this.onClearSelection
	      }));
	      return _react2['default'].createElement(
	        _SelectTrigger2['default'],
	        {
	          onPopupFocus: this.onPopupFocus,
	          dropdownAlign: props.dropdownAlign,
	          dropdownClassName: props.dropdownClassName,
	          dropdownMatchSelectWidth: props.dropdownMatchSelectWidth,
	          defaultActiveFirstOption: props.defaultActiveFirstOption,
	          dropdownMenuStyle: props.dropdownMenuStyle,
	          transitionName: props.transitionName,
	          animation: props.animation,
	          prefixCls: props.prefixCls,
	          dropdownStyle: props.dropdownStyle,
	          combobox: props.combobox,
	          showSearch: props.showSearch,
	          options: options,
	          multiple: multiple,
	          disabled: disabled,
	          visible: open,
	          inputValue: state.inputValue,
	          value: state.value,
	          firstActiveValue: props.firstActiveValue,
	          onDropdownVisibleChange: this.onDropdownVisibleChange,
	          getPopupContainer: props.getPopupContainer,
	          onMenuSelect: this.onMenuSelect,
	          onMenuDeselect: this.onMenuDeselect,
	          ref: 'trigger'
	        },
	        _react2['default'].createElement(
	          'div',
	          {
	            style: props.style,
	            ref: 'root',
	            onBlur: this.onOuterBlur,
	            onFocus: this.onOuterFocus,
	            className: (0, _classnames3['default'])(rootCls)
	          },
	          _react2['default'].createElement(
	            'div',
	            (0, _extends3['default'])({
	              ref: 'selection',
	              key: 'selection',
	              className: prefixCls + '-selection\n            ' + prefixCls + '-selection--' + (multiple ? 'multiple' : 'single'),
	              role: 'combobox',
	              'aria-autocomplete': 'list',
	              'aria-haspopup': 'true',
	              'aria-expanded': open
	            }, extraSelectionProps),
	            ctrlNode,
	            allowClear ? clear : null,
	            multiple || !props.showArrow ? null : _react2['default'].createElement(
	              'span',
	              (0, _extends3['default'])({
	                key: 'arrow',
	                className: prefixCls + '-arrow',
	                style: _util.UNSELECTABLE_STYLE
	              }, _util.UNSELECTABLE_ATTRIBUTE, {
	                onClick: this.onArrowClick
	              }),
	              _react2['default'].createElement('b', null)
	            )
	          )
	        )
	      );
	    }
	  }]);
	  return Select;
	}(_react2['default'].Component);
	
	Select.propTypes = _PropTypes.SelectPropTypes;
	Select.defaultProps = {
	  prefixCls: 'rc-select',
	  defaultOpen: false,
	  labelInValue: false,
	  defaultActiveFirstOption: true,
	  showSearch: true,
	  allowClear: false,
	  placeholder: '',
	  onChange: noop,
	  onFocus: noop,
	  onBlur: noop,
	  onSelect: noop,
	  onSearch: noop,
	  onDeselect: noop,
	  showArrow: true,
	  dropdownMatchSelectWidth: true,
	  dropdownStyle: {},
	  dropdownMenuStyle: {},
	  optionFilterProp: 'value',
	  optionLabelProp: 'value',
	  notFoundContent: 'Not Found',
	  backfill: false
	};
	
	var _initialiseProps = function _initialiseProps() {
	  var _this2 = this;
	
	  this.componentWillReceiveProps = function (nextProps) {
	    if ('value' in nextProps) {
	      var value = (0, _util.toArray)(nextProps.value);
	      value = _this2.addLabelToValue(nextProps, value);
	      value = _this2.addTitleToValue(nextProps, value);
	      _this2.setState({
	        value: value
	      });
	      if (nextProps.combobox) {
	        _this2.setState({
	          inputValue: value.length ? _this2.getLabelFromProps(nextProps, value[0].key) : ''
	        });
	      }
	    }
	  };
	
	  this.onInputChange = function (event) {
	    var tokenSeparators = _this2.props.tokenSeparators;
	
	    var val = event.target.value;
	    if ((0, _util.isMultipleOrTags)(_this2.props) && tokenSeparators && (0, _util.includesSeparators)(val, tokenSeparators)) {
	      var nextValue = _this2.tokenize(val);
	      _this2.fireChange(nextValue);
	      _this2.setOpenState(false, true);
	      _this2.setInputValue('', false);
	      return;
	    }
	    _this2.setInputValue(val);
	    _this2.setState({
	      open: true
	    });
	    if ((0, _util.isCombobox)(_this2.props)) {
	      _this2.fireChange([{
	        key: val
	      }]);
	    }
	  };
	
	  this.onDropdownVisibleChange = function (open) {
	    if (open && !_this2._focused) {
	      _this2.clearBlurTime();
	      _this2.timeoutFocus();
	      _this2._focused = true;
	      _this2.updateFocusClassName();
	    }
	    _this2.setOpenState(open);
	  };
	
	  this.onKeyDown = function (event) {
	    var props = _this2.props;
	    if (props.disabled) {
	      return;
	    }
	    var keyCode = event.keyCode;
	    if (_this2.state.open && !_this2.getInputDOMNode()) {
	      _this2.onInputKeyDown(event);
	    } else if (keyCode === _KeyCode2['default'].ENTER || keyCode === _KeyCode2['default'].DOWN) {
	      _this2.setOpenState(true);
	      event.preventDefault();
	    }
	  };
	
	  this.onInputKeyDown = function (event) {
	    var props = _this2.props;
	    if (props.disabled) {
	      return;
	    }
	    var state = _this2.state;
	    var keyCode = event.keyCode;
	    if ((0, _util.isMultipleOrTags)(props) && !event.target.value && keyCode === _KeyCode2['default'].BACKSPACE) {
	      event.preventDefault();
	      var value = state.value;
	
	      if (value.length) {
	        _this2.removeSelected(value[value.length - 1].key);
	      }
	      return;
	    }
	    if (keyCode === _KeyCode2['default'].DOWN) {
	      if (!state.open) {
	        _this2.openIfHasChildren();
	        event.preventDefault();
	        event.stopPropagation();
	        return;
	      }
	    } else if (keyCode === _KeyCode2['default'].ESC) {
	      if (state.open) {
	        _this2.setOpenState(false);
	        event.preventDefault();
	        event.stopPropagation();
	      }
	      return;
	    }
	
	    if (state.open) {
	      var menu = _this2.refs.trigger.getInnerMenu();
	      if (menu && menu.onKeyDown(event, _this2.handleBackfill)) {
	        event.preventDefault();
	        event.stopPropagation();
	      }
	    }
	  };
	
	  this.onMenuSelect = function (_ref) {
	    var item = _ref.item;
	
	    var value = _this2.state.value;
	    var props = _this2.props;
	    var selectedValue = (0, _util.getValuePropValue)(item);
	    var selectedLabel = _this2.getLabelFromOption(item);
	    var lastValue = value[value.length - 1];
	    var event = selectedValue;
	    if (props.labelInValue) {
	      event = {
	        key: event,
	        label: selectedLabel
	      };
	    }
	    props.onSelect(event, item);
	    var selectedTitle = item.props.title;
	    if ((0, _util.isMultipleOrTags)(props)) {
	      if ((0, _util.findIndexInValueByKey)(value, selectedValue) !== -1) {
	        return;
	      }
	      value = value.concat([{
	        key: selectedValue,
	        label: selectedLabel,
	        title: selectedTitle
	      }]);
	    } else {
	      if ((0, _util.isCombobox)(props)) {
	        _this2.skipAdjustOpen = true;
	        _this2.clearAdjustTimer();
	        _this2.skipAdjustOpenTimer = setTimeout(function () {
	          _this2.skipAdjustOpen = false;
	        }, 0);
	      }
	      if (lastValue && lastValue.key === selectedValue && !lastValue.backfill) {
	        _this2.setOpenState(false, true);
	        return;
	      }
	      value = [{
	        key: selectedValue,
	        label: selectedLabel,
	        title: selectedTitle
	      }];
	      _this2.setOpenState(false, true);
	    }
	    _this2.fireChange(value);
	    var inputValue = void 0;
	    if ((0, _util.isCombobox)(props)) {
	      inputValue = (0, _util.getPropValue)(item, props.optionLabelProp);
	    } else {
	      inputValue = '';
	    }
	    _this2.setInputValue(inputValue, false);
	  };
	
	  this.onMenuDeselect = function (_ref2) {
	    var item = _ref2.item,
	        domEvent = _ref2.domEvent;
	
	    if (domEvent.type === 'click') {
	      _this2.removeSelected((0, _util.getValuePropValue)(item));
	    }
	    _this2.setInputValue('', false);
	  };
	
	  this.onArrowClick = function (e) {
	    e.stopPropagation();
	    if (!_this2.props.disabled) {
	      _this2.setOpenState(!_this2.state.open, !_this2.state.open);
	    }
	  };
	
	  this.onPlaceholderClick = function () {
	    if (_this2.getInputDOMNode()) {
	      _this2.getInputDOMNode().focus();
	    }
	  };
	
	  this.onOuterFocus = function (e) {
	    if (_this2.props.disabled) {
	      e.preventDefault();
	      return;
	    }
	    _this2.clearBlurTime();
	    if (!(0, _util.isMultipleOrTagsOrCombobox)(_this2.props) && e.target === _this2.getInputDOMNode()) {
	      return;
	    }
	    if (_this2._focused) {
	      return;
	    }
	    _this2._focused = true;
	    _this2.updateFocusClassName();
	    _this2.timeoutFocus();
	  };
	
	  this.onPopupFocus = function () {
	    // fix ie scrollbar, focus element again
	    _this2.maybeFocus(true, true);
	  };
	
	  this.onOuterBlur = function (e) {
	    if (_this2.props.disabled) {
	      e.preventDefault();
	      return;
	    }
	    _this2.blurTimer = setTimeout(function () {
	      _this2._focused = false;
	      _this2.updateFocusClassName();
	      var props = _this2.props;
	      var value = _this2.state.value;
	      var inputValue = _this2.state.inputValue;
	
	      if ((0, _util.isSingleMode)(props) && props.showSearch && inputValue && props.defaultActiveFirstOption) {
	        var options = _this2._options || [];
	        if (options.length) {
	          var firstOption = (0, _util.findFirstMenuItem)(options);
	          if (firstOption) {
	            value = [{
	              key: firstOption.key,
	              label: _this2.getLabelFromOption(firstOption)
	            }];
	            _this2.fireChange(value);
	          }
	        }
	      } else if ((0, _util.isMultipleOrTags)(props) && inputValue) {
	        // why not use setState?
	        _this2.state.inputValue = _this2.getInputDOMNode().value = '';
	      }
	      props.onBlur(_this2.getVLForOnChange(value));
	      _this2.setOpenState(false);
	    }, 10);
	  };
	
	  this.onClearSelection = function (event) {
	    var props = _this2.props;
	    var state = _this2.state;
	    if (props.disabled) {
	      return;
	    }
	    var inputValue = state.inputValue,
	        value = state.value;
	
	    event.stopPropagation();
	    if (inputValue || value.length) {
	      if (value.length) {
	        _this2.fireChange([]);
	      }
	      _this2.setOpenState(false, true);
	      if (inputValue) {
	        _this2.setInputValue('');
	      }
	    }
	  };
	
	  this.onChoiceAnimationLeave = function () {
	    _this2.refs.trigger.refs.trigger.forcePopupAlign();
	  };
	
	  this.getLabelBySingleValue = function (children, value) {
	    if (value === undefined) {
	      return null;
	    }
	    var label = null;
	    _react2['default'].Children.forEach(children, function (child) {
	      if (!child) {
	        return;
	      }
	      if (child.type.isSelectOptGroup) {
	        var maybe = _this2.getLabelBySingleValue(child.props.children, value);
	        if (maybe !== null) {
	          label = maybe;
	        }
	      } else if ((0, _util.getValuePropValue)(child) === value) {
	        label = _this2.getLabelFromOption(child);
	      }
	    });
	    return label;
	  };
	
	  this.getValueByLabel = function (children, label) {
	    if (label === undefined) {
	      return null;
	    }
	    var value = null;
	    _react2['default'].Children.forEach(children, function (child) {
	      if (!child) {
	        return;
	      }
	      if (child.type.isSelectOptGroup) {
	        var maybe = _this2.getValueByLabel(child.props.children, label);
	        if (maybe !== null) {
	          value = maybe;
	        }
	      } else if ((0, _util.toArray)(_this2.getLabelFromOption(child)).join('') === label) {
	        value = (0, _util.getValuePropValue)(child);
	      }
	    });
	    return value;
	  };
	
	  this.getLabelFromOption = function (child) {
	    return (0, _util.getPropValue)(child, _this2.props.optionLabelProp);
	  };
	
	  this.getLabelFromProps = function (props, value) {
	    return _this2.getLabelByValue(props.children, value);
	  };
	
	  this.getVLForOnChange = function (vls_) {
	    var vls = vls_;
	    if (vls !== undefined) {
	      if (!_this2.props.labelInValue) {
	        vls = vls.map(function (v) {
	          return v.key;
	        });
	      } else {
	        vls = vls.map(function (vl) {
	          return { key: vl.key, label: vl.label };
	        });
	      }
	      return (0, _util.isMultipleOrTags)(_this2.props) ? vls : vls[0];
	    }
	    return vls;
	  };
	
	  this.getLabelByValue = function (children, value) {
	    var label = _this2.getLabelBySingleValue(children, value);
	    if (label === null) {
	      return value;
	    }
	    return label;
	  };
	
	  this.getDropdownContainer = function () {
	    if (!_this2.dropdownContainer) {
	      _this2.dropdownContainer = document.createElement('div');
	      document.body.appendChild(_this2.dropdownContainer);
	    }
	    return _this2.dropdownContainer;
	  };
	
	  this.getPlaceholderElement = function () {
	    var props = _this2.props,
	        state = _this2.state;
	
	    var hidden = false;
	    if (state.inputValue) {
	      hidden = true;
	    }
	    if (state.value.length) {
	      hidden = true;
	    }
	    if ((0, _util.isCombobox)(props) && state.value.length === 1 && !state.value[0].key) {
	      hidden = false;
	    }
	    var placeholder = props.placeholder;
	    if (placeholder) {
	      return _react2['default'].createElement(
	        'div',
	        (0, _extends3['default'])({
	          onMouseDown: _util.preventDefaultEvent,
	          style: (0, _extends3['default'])({
	            display: hidden ? 'none' : 'block'
	          }, _util.UNSELECTABLE_STYLE)
	        }, _util.UNSELECTABLE_ATTRIBUTE, {
	          onClick: _this2.onPlaceholderClick,
	          className: props.prefixCls + '-selection__placeholder'
	        }),
	        placeholder
	      );
	    }
	    return null;
	  };
	
	  this.getInputElement = function () {
	    var props = _this2.props;
	    var inputElement = props.getInputElement ? props.getInputElement() : _react2['default'].createElement('input', { id: props.id, autoComplete: 'off' });
	    var inputCls = (0, _classnames3['default'])(inputElement.props.className, (0, _defineProperty3['default'])({}, props.prefixCls + '-search__field', true));
	    // https://github.com/ant-design/ant-design/issues/4992#issuecomment-281542159
	    // Add space to the end of the inputValue as the width measurement tolerance
	    return _react2['default'].createElement(
	      'div',
	      { className: props.prefixCls + '-search__field__wrap' },
	      _react2['default'].cloneElement(inputElement, {
	        ref: _this2.saveInputRef,
	        onChange: _this2.onInputChange,
	        onKeyDown: chaining(_this2.onInputKeyDown, inputElement.props.onKeyDown),
	        value: _this2.state.inputValue,
	        disabled: props.disabled,
	        className: inputCls
	      }),
	      _react2['default'].createElement(
	        'span',
	        {
	          ref: _this2.saveInputMirrorRef,
	          className: props.prefixCls + '-search__field__mirror'
	        },
	        _this2.state.inputValue,
	        '\xA0'
	      )
	    );
	  };
	
	  this.getInputDOMNode = function () {
	    return _this2.topCtrlNode ? _this2.topCtrlNode.querySelector('input,textarea,div[contentEditable]') : _this2.inputInstance;
	  };
	
	  this.getInputMirrorDOMNode = function () {
	    return _this2.inputMirrorInstance;
	  };
	
	  this.getPopupDOMNode = function () {
	    return _this2.refs.trigger.getPopupDOMNode();
	  };
	
	  this.getPopupMenuComponent = function () {
	    return _this2.refs.trigger.getInnerMenu();
	  };
	
	  this.setOpenState = function (open, needFocus) {
	    var props = _this2.props,
	        state = _this2.state;
	
	    if (state.open === open) {
	      _this2.maybeFocus(open, needFocus);
	      return;
	    }
	    var nextState = {
	      open: open
	    };
	    // clear search input value when open is false in singleMode.
	    if (!open && (0, _util.isSingleMode)(props) && props.showSearch) {
	      _this2.setInputValue('');
	    }
	    if (!open) {
	      _this2.maybeFocus(open, needFocus);
	    }
	    _this2.setState(nextState, function () {
	      if (open) {
	        _this2.maybeFocus(open, needFocus);
	      }
	    });
	  };
	
	  this.setInputValue = function (inputValue) {
	    var fireSearch = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
	
	    if (inputValue !== _this2.state.inputValue) {
	      _this2.setState({
	        inputValue: inputValue
	      });
	      if (fireSearch) {
	        _this2.props.onSearch(inputValue);
	      }
	    }
	  };
	
	  this.handleBackfill = function (item) {
	    if (!_this2.props.backfill || !((0, _util.isSingleMode)(_this2.props) || (0, _util.isCombobox)(_this2.props))) {
	      return;
	    }
	
	    var key = (0, _util.getValuePropValue)(item);
	    var label = _this2.getLabelFromOption(item);
	    var backfillValue = {
	      key: key,
	      label: label,
	      backfill: true
	    };
	
	    if ((0, _util.isCombobox)(_this2.props)) {
	      _this2.setInputValue(key, false);
	    }
	
	    _this2.setState({
	      value: [backfillValue]
	    });
	  };
	
	  this.filterOption = function (input, child) {
	    var defaultFilter = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _util.defaultFilterFn;
	    var value = _this2.state.value;
	
	    var lastValue = value[value.length - 1];
	    if (!input || lastValue && lastValue.backfill) {
	      return true;
	    }
	    var filterFn = _this2.props.filterOption;
	    if ('filterOption' in _this2.props) {
	      if (_this2.props.filterOption === true) {
	        filterFn = defaultFilter;
	      }
	    } else {
	      filterFn = defaultFilter;
	    }
	
	    if (!filterFn) {
	      return true;
	    } else if (child.props.disabled) {
	      return false;
	    } else if (typeof filterFn === 'function') {
	      return filterFn.call(_this2, input, child);
	    }
	    return true;
	  };
	
	  this.timeoutFocus = function () {
	    if (_this2.focusTimer) {
	      _this2.clearFocusTime();
	    }
	    _this2.focusTimer = setTimeout(function () {
	      _this2.props.onFocus();
	    }, 10);
	  };
	
	  this.clearFocusTime = function () {
	    if (_this2.focusTimer) {
	      clearTimeout(_this2.focusTimer);
	      _this2.focusTimer = null;
	    }
	  };
	
	  this.clearBlurTime = function () {
	    if (_this2.blurTimer) {
	      clearTimeout(_this2.blurTimer);
	      _this2.blurTimer = null;
	    }
	  };
	
	  this.clearAdjustTimer = function () {
	    if (_this2.skipAdjustOpenTimer) {
	      clearTimeout(_this2.skipAdjustOpenTimer);
	      _this2.skipAdjustOpenTimer = null;
	    }
	  };
	
	  this.updateFocusClassName = function () {
	    var refs = _this2.refs,
	        props = _this2.props;
	    // avoid setState and its side effect
	
	    if (_this2._focused) {
	      (0, _componentClasses2['default'])(refs.root).add(props.prefixCls + '-focused');
	    } else {
	      (0, _componentClasses2['default'])(refs.root).remove(props.prefixCls + '-focused');
	    }
	  };
	
	  this.maybeFocus = function (open, needFocus) {
	    if (needFocus || open) {
	      var input = _this2.getInputDOMNode();
	      var _document = document,
	          activeElement = _document.activeElement;
	
	      if (input && (open || (0, _util.isMultipleOrTagsOrCombobox)(_this2.props))) {
	        if (activeElement !== input) {
	          input.focus();
	          _this2._focused = true;
	        }
	      } else {
	        var selection = _this2.refs.selection;
	        if (activeElement !== selection) {
	          selection.focus();
	          _this2._focused = true;
	        }
	      }
	    }
	  };
	
	  this.addLabelToValue = function (props, value_) {
	    var value = value_;
	    if (props.labelInValue) {
	      value.forEach(function (v) {
	        v.label = v.label || _this2.getLabelFromProps(props, v.key);
	      });
	    } else {
	      value = value.map(function (v) {
	        return {
	          key: v,
	          label: _this2.getLabelFromProps(props, v)
	        };
	      });
	    }
	    return value;
	  };
	
	  this.addTitleToValue = function (props, values) {
	    var nextValues = values;
	    var keys = values.map(function (v) {
	      return v.key;
	    });
	    _react2['default'].Children.forEach(props.children, function (child) {
	      if (!child) {
	        return;
	      }
	      if (child.type.isSelectOptGroup) {
	        nextValues = _this2.addTitleToValue(child.props, nextValues);
	      } else {
	        var value = (0, _util.getValuePropValue)(child);
	        var valueIndex = keys.indexOf(value);
	        if (valueIndex > -1) {
	          nextValues[valueIndex].title = child.props.title;
	        }
	      }
	    });
	    return nextValues;
	  };
	
	  this.removeSelected = function (selectedKey) {
	    var props = _this2.props;
	    if (props.disabled || _this2.isChildDisabled(selectedKey)) {
	      return;
	    }
	    var label = void 0;
	    var value = _this2.state.value.filter(function (singleValue) {
	      if (singleValue.key === selectedKey) {
	        label = singleValue.label;
	      }
	      return singleValue.key !== selectedKey;
	    });
	    var canMultiple = (0, _util.isMultipleOrTags)(props);
	
	    if (canMultiple) {
	      var event = selectedKey;
	      if (props.labelInValue) {
	        event = {
	          key: selectedKey,
	          label: label
	        };
	      }
	      props.onDeselect(event);
	    }
	    _this2.fireChange(value);
	  };
	
	  this.openIfHasChildren = function () {
	    var props = _this2.props;
	    if (_react2['default'].Children.count(props.children) || (0, _util.isSingleMode)(props)) {
	      _this2.setOpenState(true);
	    }
	  };
	
	  this.fireChange = function (value) {
	    var props = _this2.props;
	    if (!('value' in props)) {
	      _this2.setState({
	        value: value
	      });
	    }
	    props.onChange(_this2.getVLForOnChange(value));
	  };
	
	  this.isChildDisabled = function (key) {
	    return (0, _util.toArray)(_this2.props.children).some(function (child) {
	      var childValue = (0, _util.getValuePropValue)(child);
	      return childValue === key && child.props && child.props.disabled;
	    });
	  };
	
	  this.tokenize = function (string) {
	    var _props = _this2.props,
	        multiple = _props.multiple,
	        tokenSeparators = _props.tokenSeparators,
	        children = _props.children;
	
	    var nextValue = _this2.state.value;
	    (0, _util.splitBySeparators)(string, tokenSeparators).forEach(function (label) {
	      var selectedValue = { key: label, label: label };
	      if ((0, _util.findIndexInValueByLabel)(nextValue, label) === -1) {
	        if (multiple) {
	          var value = _this2.getValueByLabel(children, label);
	          if (value) {
	            selectedValue.key = value;
	            nextValue = nextValue.concat(selectedValue);
	          }
	        } else {
	          nextValue = nextValue.concat(selectedValue);
	        }
	      }
	    });
	    return nextValue;
	  };
	
	  this.adjustOpenState = function () {
	    if (_this2.skipAdjustOpen) {
	      return;
	    }
	    var open = _this2.state.open;
	
	    var options = [];
	    // If hidden menu due to no options, then it should be calculated again
	    if (open || _this2.hiddenForNoOptions) {
	      options = _this2.renderFilterOptions();
	    }
	    _this2._options = options;
	
	    if ((0, _util.isMultipleOrTagsOrCombobox)(_this2.props) || !_this2.props.showSearch) {
	      if (open && !options.length) {
	        open = false;
	        _this2.hiddenForNoOptions = true;
	      }
	      // Keep menu open if there are options and hidden for no options before
	      if (_this2.hiddenForNoOptions && options.length) {
	        open = true;
	        _this2.hiddenForNoOptions = false;
	      }
	    }
	    _this2.state.open = open;
	  };
	
	  this.renderFilterOptions = function (inputValue) {
	    return _this2.renderFilterOptionsFromChildren(_this2.props.children, true, inputValue);
	  };
	
	  this.renderFilterOptionsFromChildren = function (children, showNotFound, iv) {
	    var sel = [];
	    var props = _this2.props;
	    var inputValue = iv === undefined ? _this2.state.inputValue : iv;
	    var childrenKeys = [];
	    var tags = props.tags;
	    _react2['default'].Children.forEach(children, function (child) {
	      if (!child) {
	        return;
	      }
	      if (child.type.isSelectOptGroup) {
	        var innerItems = _this2.renderFilterOptionsFromChildren(child.props.children, false);
	        if (innerItems.length) {
	          var label = child.props.label;
	          var key = child.key;
	          if (!key && typeof label === 'string') {
	            key = label;
	          } else if (!label && key) {
	            label = key;
	          }
	          sel.push(_react2['default'].createElement(
	            _rcMenu.ItemGroup,
	            { key: key, title: label },
	            innerItems
	          ));
	        }
	        return;
	      }
	
	      (0, _warning2['default'])(child.type.isSelectOption, 'the children of `Select` should be `Select.Option` or `Select.OptGroup`, ' + ('instead of `' + (child.type.name || child.type.displayName || child.type) + '`.'));
	
	      var childValue = (0, _util.getValuePropValue)(child);
	      if (_this2.filterOption(inputValue, child)) {
	        sel.push(_react2['default'].createElement(_rcMenu.Item, (0, _extends3['default'])({
	          style: _util.UNSELECTABLE_STYLE,
	          attribute: _util.UNSELECTABLE_ATTRIBUTE,
	          value: childValue,
	          key: childValue
	        }, child.props)));
	      }
	      if (tags && !child.props.disabled) {
	        childrenKeys.push(childValue);
	      }
	    });
	    if (tags) {
	      // tags value must be string
	      var value = _this2.state.value || [];
	      value = value.filter(function (singleValue) {
	        return childrenKeys.indexOf(singleValue.key) === -1 && (!inputValue || String(singleValue.key).indexOf(String(inputValue)) > -1);
	      });
	      sel = sel.concat(value.map(function (singleValue) {
	        var key = singleValue.key;
	        return _react2['default'].createElement(
	          _rcMenu.Item,
	          {
	            style: _util.UNSELECTABLE_STYLE,
	            attribute: _util.UNSELECTABLE_ATTRIBUTE,
	            value: key,
	            key: key
	          },
	          key
	        );
	      }));
	      if (inputValue) {
	        var notFindInputItem = sel.every(function (option) {
	          // this.filterOption return true has two meaning,
	          // 1, some one exists after filtering
	          // 2, filterOption is set to false
	          // condition 2 does not mean the option has same value with inputValue
	          var filterFn = function filterFn() {
	            return (0, _util.getValuePropValue)(option) === inputValue;
	          };
	          if (_this2.props.filterOption !== false) {
	            return !_this2.filterOption.call(_this2, inputValue, option, filterFn);
	          }
	          return !filterFn();
	        });
	        if (notFindInputItem) {
	          sel.unshift(_react2['default'].createElement(
	            _rcMenu.Item,
	            {
	              style: _util.UNSELECTABLE_STYLE,
	              attribute: _util.UNSELECTABLE_ATTRIBUTE,
	              value: inputValue,
	              key: inputValue
	            },
	            inputValue
	          ));
	        }
	      }
	    }
	    if (!sel.length && showNotFound && props.notFoundContent) {
	      sel = [_react2['default'].createElement(
	        _rcMenu.Item,
	        {
	          style: _util.UNSELECTABLE_STYLE,
	          attribute: _util.UNSELECTABLE_ATTRIBUTE,
	          disabled: true,
	          value: 'NOT_FOUND',
	          key: 'NOT_FOUND'
	        },
	        props.notFoundContent
	      )];
	    }
	    return sel;
	  };
	
	  this.renderTopControlNode = function () {
	    var _state = _this2.state,
	        value = _state.value,
	        open = _state.open,
	        inputValue = _state.inputValue;
	
	    var props = _this2.props;
	    var choiceTransitionName = props.choiceTransitionName,
	        prefixCls = props.prefixCls,
	        maxTagTextLength = props.maxTagTextLength,
	        showSearch = props.showSearch;
	
	    var className = prefixCls + '-selection__rendered';
	    // search input is inside topControlNode in single, multiple & combobox. 2016/04/13
	    var innerNode = null;
	    if ((0, _util.isSingleMode)(props)) {
	      var selectedValue = null;
	      if (value.length) {
	        var showSelectedValue = false;
	        var opacity = 1;
	        if (!showSearch) {
	          showSelectedValue = true;
	        } else {
	          if (open) {
	            showSelectedValue = !inputValue;
	            if (showSelectedValue) {
	              opacity = 0.4;
	            }
	          } else {
	            showSelectedValue = true;
	          }
	        }
	        var singleValue = value[0];
	        selectedValue = _react2['default'].createElement(
	          'div',
	          {
	            key: 'value',
	            className: prefixCls + '-selection-selected-value',
	            title: singleValue.title || singleValue.label,
	            style: {
	              display: showSelectedValue ? 'block' : 'none',
	              opacity: opacity
	            }
	          },
	          value[0].label
	        );
	      }
	      if (!showSearch) {
	        innerNode = [selectedValue];
	      } else {
	        innerNode = [selectedValue, _react2['default'].createElement(
	          'div',
	          {
	            className: prefixCls + '-search ' + prefixCls + '-search--inline',
	            key: 'input',
	            style: {
	              display: open ? 'block' : 'none'
	            }
	          },
	          _this2.getInputElement()
	        )];
	      }
	    } else {
	      var selectedValueNodes = [];
	      if ((0, _util.isMultipleOrTags)(props)) {
	        selectedValueNodes = value.map(function (singleValue) {
	          var content = singleValue.label;
	          var title = singleValue.title || content;
	          if (maxTagTextLength && typeof content === 'string' && content.length > maxTagTextLength) {
	            content = content.slice(0, maxTagTextLength) + '...';
	          }
	          var disabled = _this2.isChildDisabled(singleValue.key);
	          var choiceClassName = disabled ? prefixCls + '-selection__choice ' + prefixCls + '-selection__choice__disabled' : prefixCls + '-selection__choice';
	          return _react2['default'].createElement(
	            'li',
	            (0, _extends3['default'])({
	              style: _util.UNSELECTABLE_STYLE
	            }, _util.UNSELECTABLE_ATTRIBUTE, {
	              onMouseDown: _util.preventDefaultEvent,
	              className: choiceClassName,
	              key: singleValue.key,
	              title: title
	            }),
	            _react2['default'].createElement(
	              'div',
	              { className: prefixCls + '-selection__choice__content' },
	              content
	            ),
	            disabled ? null : _react2['default'].createElement('span', {
	              className: prefixCls + '-selection__choice__remove',
	              onClick: _this2.removeSelected.bind(_this2, singleValue.key)
	            })
	          );
	        });
	      }
	      selectedValueNodes.push(_react2['default'].createElement(
	        'li',
	        {
	          className: prefixCls + '-search ' + prefixCls + '-search--inline',
	          key: '__input'
	        },
	        _this2.getInputElement()
	      ));
	
	      if ((0, _util.isMultipleOrTags)(props) && choiceTransitionName) {
	        innerNode = _react2['default'].createElement(
	          _rcAnimate2['default'],
	          {
	            onLeave: _this2.onChoiceAnimationLeave,
	            component: 'ul',
	            transitionName: choiceTransitionName
	          },
	          selectedValueNodes
	        );
	      } else {
	        innerNode = _react2['default'].createElement(
	          'ul',
	          null,
	          selectedValueNodes
	        );
	      }
	    }
	    return _react2['default'].createElement(
	      'div',
	      { className: className, ref: function ref(node) {
	          return _this2.topCtrlNode = node;
	        } },
	      _this2.getPlaceholderElement(),
	      innerNode
	    );
	  };
	};
	
	exports['default'] = Select;
	
	
	Select.displayName = 'Select';
	module.exports = exports['default'];

/***/ }),
/* 736 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _objectWithoutProperties2 = __webpack_require__(20);
	
	var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _rcTrigger = __webpack_require__(53);
	
	var _rcTrigger2 = _interopRequireDefault(_rcTrigger);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _DropdownMenu = __webpack_require__(732);
	
	var _DropdownMenu2 = _interopRequireDefault(_DropdownMenu);
	
	var _reactDom = __webpack_require__(10);
	
	var _reactDom2 = _interopRequireDefault(_reactDom);
	
	var _util = __webpack_require__(148);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	_rcTrigger2['default'].displayName = 'Trigger';
	
	var BUILT_IN_PLACEMENTS = {
	  bottomLeft: {
	    points: ['tl', 'bl'],
	    offset: [0, 4],
	    overflow: {
	      adjustX: 0,
	      adjustY: 1
	    }
	  },
	  topLeft: {
	    points: ['bl', 'tl'],
	    offset: [0, -4],
	    overflow: {
	      adjustX: 0,
	      adjustY: 1
	    }
	  }
	};
	
	var SelectTrigger = function (_React$Component) {
	  (0, _inherits3['default'])(SelectTrigger, _React$Component);
	
	  function SelectTrigger() {
	    var _ref;
	
	    var _temp, _this, _ret;
	
	    (0, _classCallCheck3['default'])(this, SelectTrigger);
	
	    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
	      args[_key] = arguments[_key];
	    }
	
	    return _ret = (_temp = (_this = (0, _possibleConstructorReturn3['default'])(this, (_ref = SelectTrigger.__proto__ || Object.getPrototypeOf(SelectTrigger)).call.apply(_ref, [this].concat(args))), _this), _this.state = {
	      dropdownWidth: null
	    }, _this.setDropdownWidth = function () {
	      var width = _reactDom2['default'].findDOMNode(_this).offsetWidth;
	      if (width !== _this.state.dropdownWidth) {
	        _this.setState({ dropdownWidth: width });
	      }
	    }, _this.getInnerMenu = function () {
	      return _this.popupMenu && _this.popupMenu.refs.menu;
	    }, _this.getPopupDOMNode = function () {
	      return _this.refs.trigger.getPopupDomNode();
	    }, _this.getDropdownElement = function (newProps) {
	      var props = _this.props;
	      return _react2['default'].createElement(_DropdownMenu2['default'], (0, _extends3['default'])({
	        ref: _this.saveMenu
	      }, newProps, {
	        prefixCls: _this.getDropdownPrefixCls(),
	        onMenuSelect: props.onMenuSelect,
	        onMenuDeselect: props.onMenuDeselect,
	        value: props.value,
	        firstActiveValue: props.firstActiveValue,
	        defaultActiveFirstOption: props.defaultActiveFirstOption,
	        dropdownMenuStyle: props.dropdownMenuStyle
	      }));
	    }, _this.getDropdownTransitionName = function () {
	      var props = _this.props;
	      var transitionName = props.transitionName;
	      if (!transitionName && props.animation) {
	        transitionName = _this.getDropdownPrefixCls() + '-' + props.animation;
	      }
	      return transitionName;
	    }, _this.getDropdownPrefixCls = function () {
	      return _this.props.prefixCls + '-dropdown';
	    }, _this.saveMenu = function (menu) {
	      _this.popupMenu = menu;
	    }, _temp), (0, _possibleConstructorReturn3['default'])(_this, _ret);
	  }
	
	  (0, _createClass3['default'])(SelectTrigger, [{
	    key: 'componentDidMount',
	    value: function componentDidMount() {
	      this.setDropdownWidth();
	    }
	  }, {
	    key: 'componentDidUpdate',
	    value: function componentDidUpdate() {
	      this.setDropdownWidth();
	    }
	  }, {
	    key: 'render',
	    value: function render() {
	      var _popupClassName;
	
	      var _props = this.props,
	          onPopupFocus = _props.onPopupFocus,
	          props = (0, _objectWithoutProperties3['default'])(_props, ['onPopupFocus']);
	      var multiple = props.multiple,
	          visible = props.visible,
	          inputValue = props.inputValue,
	          dropdownAlign = props.dropdownAlign,
	          disabled = props.disabled,
	          showSearch = props.showSearch,
	          dropdownClassName = props.dropdownClassName,
	          dropdownStyle = props.dropdownStyle,
	          dropdownMatchSelectWidth = props.dropdownMatchSelectWidth;
	
	      var dropdownPrefixCls = this.getDropdownPrefixCls();
	      var popupClassName = (_popupClassName = {}, (0, _defineProperty3['default'])(_popupClassName, dropdownClassName, !!dropdownClassName), (0, _defineProperty3['default'])(_popupClassName, dropdownPrefixCls + '--' + (multiple ? 'multiple' : 'single'), 1), _popupClassName);
	      var popupElement = this.getDropdownElement({
	        menuItems: props.options,
	        onPopupFocus: onPopupFocus,
	        multiple: multiple,
	        inputValue: inputValue,
	        visible: visible
	      });
	      var hideAction = void 0;
	      if (disabled) {
	        hideAction = [];
	      } else if ((0, _util.isSingleMode)(props) && !showSearch) {
	        hideAction = ['click'];
	      } else {
	        hideAction = ['blur'];
	      }
	      var popupStyle = (0, _extends3['default'])({}, dropdownStyle);
	      var widthProp = dropdownMatchSelectWidth ? 'width' : 'minWidth';
	      if (this.state.dropdownWidth) {
	        popupStyle[widthProp] = this.state.dropdownWidth + 'px';
	      }
	
	      return _react2['default'].createElement(
	        _rcTrigger2['default'],
	        (0, _extends3['default'])({}, props, {
	          showAction: disabled ? [] : ['click'],
	          hideAction: hideAction,
	          ref: 'trigger',
	          popupPlacement: 'bottomLeft',
	          builtinPlacements: BUILT_IN_PLACEMENTS,
	          prefixCls: dropdownPrefixCls,
	          popupTransitionName: this.getDropdownTransitionName(),
	          onPopupVisibleChange: props.onDropdownVisibleChange,
	          popup: popupElement,
	          popupAlign: dropdownAlign,
	          popupVisible: visible,
	          getPopupContainer: props.getPopupContainer,
	          popupClassName: (0, _classnames2['default'])(popupClassName),
	          popupStyle: popupStyle
	        }),
	        props.children
	      );
	    }
	  }]);
	  return SelectTrigger;
	}(_react2['default'].Component);
	
	SelectTrigger.propTypes = {
	  onPopupFocus: _propTypes2['default'].func,
	  dropdownMatchSelectWidth: _propTypes2['default'].bool,
	  dropdownAlign: _propTypes2['default'].object,
	  visible: _propTypes2['default'].bool,
	  disabled: _propTypes2['default'].bool,
	  showSearch: _propTypes2['default'].bool,
	  dropdownClassName: _propTypes2['default'].string,
	  multiple: _propTypes2['default'].bool,
	  inputValue: _propTypes2['default'].string,
	  filterOption: _propTypes2['default'].any,
	  options: _propTypes2['default'].any,
	  prefixCls: _propTypes2['default'].string,
	  popupClassName: _propTypes2['default'].string,
	  children: _propTypes2['default'].any
	};
	exports['default'] = SelectTrigger;
	
	
	SelectTrigger.displayName = 'SelectTrigger';
	module.exports = exports['default'];

/***/ }),
/* 737 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _toConsumableArray2 = __webpack_require__(31);
	
	var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _shallowequal = __webpack_require__(45);
	
	var _shallowequal2 = _interopRequireDefault(_shallowequal);
	
	var _warning = __webpack_require__(35);
	
	var _warning2 = _interopRequireDefault(_warning);
	
	var _Track = __webpack_require__(269);
	
	var _Track2 = _interopRequireDefault(_Track);
	
	var _createSlider = __webpack_require__(270);
	
	var _createSlider2 = _interopRequireDefault(_createSlider);
	
	var _utils = __webpack_require__(149);
	
	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 }; }
	
	/* eslint-disable react/prop-types */
	var Range = function (_React$Component) {
	  (0, _inherits3['default'])(Range, _React$Component);
	
	  function Range(props) {
	    (0, _classCallCheck3['default'])(this, Range);
	
	    var _this = (0, _possibleConstructorReturn3['default'])(this, (Range.__proto__ || Object.getPrototypeOf(Range)).call(this, props));
	
	    _this.onEnd = function () {
	      _this.setState({ handle: null });
	      _this.removeDocumentEvents();
	      _this.props.onAfterChange(_this.getValue());
	    };
	
	    var count = props.count,
	        min = props.min,
	        max = props.max;
	
	    var initialValue = Array.apply(null, Array(count + 1)).map(function () {
	      return min;
	    });
	    var defaultValue = 'defaultValue' in props ? props.defaultValue : initialValue;
	    var value = props.value !== undefined ? props.value : defaultValue;
	    var bounds = value.map(function (v) {
	      return _this.trimAlignValue(v);
	    });
	    var recent = bounds[0] === max ? 0 : bounds.length - 1;
	
	    _this.state = {
	      handle: null,
	      recent: recent,
	      bounds: bounds
	    };
	    return _this;
	  }
	
	  (0, _createClass3['default'])(Range, [{
	    key: 'componentWillReceiveProps',
	    value: function componentWillReceiveProps(nextProps) {
	      var _this2 = this;
	
	      if (!('value' in nextProps || 'min' in nextProps || 'max' in nextProps)) return;
	      if (this.props.min === nextProps.min && this.props.max === nextProps.max && (0, _shallowequal2['default'])(this.props.value, nextProps.value)) {
	        return;
	      }
	      var bounds = this.state.bounds;
	
	      var value = nextProps.value || bounds;
	      var nextBounds = value.map(function (v) {
	        return _this2.trimAlignValue(v, nextProps);
	      });
	      if (nextBounds.length === bounds.length && nextBounds.every(function (v, i) {
	        return v === bounds[i];
	      })) return;
	
	      this.setState({ bounds: nextBounds });
	      if (bounds.some(function (v) {
	        return utils.isValueOutOfRange(v, nextProps);
	      })) {
	        this.props.onChange(nextBounds);
	      }
	    }
	  }, {
	    key: 'onChange',
	    value: function onChange(state) {
	      var props = this.props;
	      var isNotControlled = !('value' in props);
	      if (isNotControlled) {
	        this.setState(state);
	      } else if (state.handle !== undefined) {
	        this.setState({ handle: state.handle });
	      }
	
	      var data = (0, _extends3['default'])({}, this.state, state);
	      var changedValue = data.bounds;
	      props.onChange(changedValue);
	    }
	  }, {
	    key: 'onStart',
	    value: function onStart(position) {
	      var props = this.props;
	      var state = this.state;
	      var bounds = this.getValue();
	      props.onBeforeChange(bounds);
	
	      var value = this.calcValueByPos(position);
	      this.startValue = value;
	      this.startPosition = position;
	
	      var closestBound = this.getClosestBound(value);
	      var boundNeedMoving = this.getBoundNeedMoving(value, closestBound);
	
	      this.setState({
	        handle: boundNeedMoving,
	        recent: boundNeedMoving
	      });
	
	      var prevValue = bounds[boundNeedMoving];
	      if (value === prevValue) return;
	
	      var nextBounds = [].concat((0, _toConsumableArray3['default'])(state.bounds));
	      nextBounds[boundNeedMoving] = value;
	      this.onChange({ bounds: nextBounds });
	    }
	  }, {
	    key: 'onMove',
	    value: function onMove(e, position) {
	      utils.pauseEvent(e);
	      var props = this.props;
	      var state = this.state;
	
	      var value = this.calcValueByPos(position);
	      var oldValue = state.bounds[state.handle];
	      if (value === oldValue) return;
	
	      var nextBounds = [].concat((0, _toConsumableArray3['default'])(state.bounds));
	      nextBounds[state.handle] = value;
	      var nextHandle = state.handle;
	      if (props.pushable !== false) {
	        var originalValue = state.bounds[nextHandle];
	        this.pushSurroundingHandles(nextBounds, nextHandle, originalValue);
	      } else if (props.allowCross) {
	        nextBounds.sort(function (a, b) {
	          return a - b;
	        });
	        nextHandle = nextBounds.indexOf(value);
	      }
	      this.onChange({
	        handle: nextHandle,
	        bounds: nextBounds
	      });
	    }
	  }, {
	    key: 'onKeyboard',
	    value: function onKeyboard() {
	      (0, _warning2['default'])(true, 'Keyboard support is not yet supported for ranges.');
	    }
	  }, {
	    key: 'getValue',
	    value: function getValue() {
	      return this.state.bounds;
	    }
	  }, {
	    key: 'getClosestBound',
	    value: function getClosestBound(value) {
	      var bounds = this.state.bounds;
	
	      var closestBound = 0;
	      for (var i = 1; i < bounds.length - 1; ++i) {
	        if (value > bounds[i]) {
	          closestBound = i;
	        }
	      }
	      if (Math.abs(bounds[closestBound + 1] - value) < Math.abs(bounds[closestBound] - value)) {
	        closestBound = closestBound + 1;
	      }
	      return closestBound;
	    }
	  }, {
	    key: 'getBoundNeedMoving',
	    value: function getBoundNeedMoving(value, closestBound) {
	      var _state = this.state,
	          bounds = _state.bounds,
	          recent = _state.recent;
	
	      var boundNeedMoving = closestBound;
	      var isAtTheSamePoint = bounds[closestBound + 1] === bounds[closestBound];
	
	      if (isAtTheSamePoint && bounds[recent] === bounds[closestBound]) {
	        boundNeedMoving = recent;
	      }
	
	      if (isAtTheSamePoint && value !== bounds[closestBound + 1]) {
	        boundNeedMoving = value < bounds[closestBound + 1] ? closestBound : closestBound + 1;
	      }
	      return boundNeedMoving;
	    }
	  }, {
	    key: 'getLowerBound',
	    value: function getLowerBound() {
	      return this.state.bounds[0];
	    }
	  }, {
	    key: 'getUpperBound',
	    value: function getUpperBound() {
	      var bounds = this.state.bounds;
	
	      return bounds[bounds.length - 1];
	    }
	
	    /**
	     * Returns an array of possible slider points, taking into account both
	     * `marks` and `step`. The result is cached.
	     */
	
	  }, {
	    key: 'getPoints',
	    value: function getPoints() {
	      var _props = this.props,
	          marks = _props.marks,
	          step = _props.step,
	          min = _props.min,
	          max = _props.max;
	
	      var cache = this._getPointsCache;
	      if (!cache || cache.marks !== marks || cache.step !== step) {
	        var pointsObject = (0, _extends3['default'])({}, marks);
	        if (step !== null) {
	          for (var point = min; point <= max; point += step) {
	            pointsObject[point] = point;
	          }
	        }
	        var points = Object.keys(pointsObject).map(parseFloat);
	        points.sort(function (a, b) {
	          return a - b;
	        });
	        this._getPointsCache = { marks: marks, step: step, points: points };
	      }
	      return this._getPointsCache.points;
	    }
	  }, {
	    key: 'pushSurroundingHandles',
	    value: function pushSurroundingHandles(bounds, handle, originalValue) {
	      var threshold = this.props.pushable;
	
	      var value = bounds[handle];
	
	      var direction = 0;
	      if (bounds[handle + 1] - value < threshold) {
	        direction = +1; // push to right
	      }
	      if (value - bounds[handle - 1] < threshold) {
	        direction = -1; // push to left
	      }
	
	      if (direction === 0) {
	        return;
	      }
	
	      var nextHandle = handle + direction;
	      var diffToNext = direction * (bounds[nextHandle] - value);
	      if (!this.pushHandle(bounds, nextHandle, direction, threshold - diffToNext)) {
	        // revert to original value if pushing is impossible
	        bounds[handle] = originalValue;
	      }
	    }
	  }, {
	    key: 'pushHandle',
	    value: function pushHandle(bounds, handle, direction, amount) {
	      var originalValue = bounds[handle];
	      var currentValue = bounds[handle];
	      while (direction * (currentValue - originalValue) < amount) {
	        if (!this.pushHandleOnePoint(bounds, handle, direction)) {
	          // can't push handle enough to create the needed `amount` gap, so we
	          // revert its position to the original value
	          bounds[handle] = originalValue;
	          return false;
	        }
	        currentValue = bounds[handle];
	      }
	      // the handle was pushed enough to create the needed `amount` gap
	      return true;
	    }
	  }, {
	    key: 'pushHandleOnePoint',
	    value: function pushHandleOnePoint(bounds, handle, direction) {
	      var points = this.getPoints();
	      var pointIndex = points.indexOf(bounds[handle]);
	      var nextPointIndex = pointIndex + direction;
	      if (nextPointIndex >= points.length || nextPointIndex < 0) {
	        // reached the minimum or maximum available point, can't push anymore
	        return false;
	      }
	      var nextHandle = handle + direction;
	      var nextValue = points[nextPointIndex];
	      var threshold = this.props.pushable;
	
	      var diffToNext = direction * (bounds[nextHandle] - nextValue);
	      if (!this.pushHandle(bounds, nextHandle, direction, threshold - diffToNext)) {
	        // couldn't push next handle, so we won't push this one either
	        return false;
	      }
	      // push the handle
	      bounds[handle] = nextValue;
	      return true;
	    }
	  }, {
	    key: 'trimAlignValue',
	    value: function trimAlignValue(v) {
	      var nextProps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
	
	      var mergedProps = (0, _extends3['default'])({}, this.props, nextProps);
	      var valInRange = utils.ensureValueInRange(v, mergedProps);
	      var valNotConflict = this.ensureValueNotConflict(valInRange, mergedProps);
	      return utils.ensureValuePrecision(valNotConflict, mergedProps);
	    }
	  }, {
	    key: 'ensureValueNotConflict',
	    value: function ensureValueNotConflict(val, _ref) {
	      var allowCross = _ref.allowCross;
	
	      var state = this.state || {};
	      var handle = state.handle,
	          bounds = state.bounds;
	      /* eslint-disable eqeqeq */
	
	      if (!allowCross && handle != null) {
	        if (handle > 0 && val <= bounds[handle - 1]) {
	          return bounds[handle - 1];
	        }
	        if (handle < bounds.length - 1 && val >= bounds[handle + 1]) {
	          return bounds[handle + 1];
	        }
	      }
	      /* eslint-enable eqeqeq */
	      return val;
	    }
	  }, {
	    key: 'render',
	    value: function render() {
	      var _this3 = this;
	
	      var _state2 = this.state,
	          handle = _state2.handle,
	          bounds = _state2.bounds;
	      var _props2 = this.props,
	          prefixCls = _props2.prefixCls,
	          vertical = _props2.vertical,
	          included = _props2.included,
	          disabled = _props2.disabled,
	          min = _props2.min,
	          max = _props2.max,
	          handleGenerator = _props2.handle,
	          trackStyle = _props2.trackStyle,
	          handleStyle = _props2.handleStyle;
	
	
	      var offsets = bounds.map(function (v) {
	        return _this3.calcOffset(v);
	      });
	
	      var handleClassName = prefixCls + '-handle';
	      var handles = bounds.map(function (v, i) {
	        var _classNames;
	
	        return handleGenerator({
	          className: (0, _classnames2['default'])((_classNames = {}, (0, _defineProperty3['default'])(_classNames, handleClassName, true), (0, _defineProperty3['default'])(_classNames, handleClassName + '-' + (i + 1), true), _classNames)),
	          vertical: vertical,
	          offset: offsets[i],
	          value: v,
	          dragging: handle === i,
	          index: i,
	          min: min,
	          max: max,
	          disabled: disabled,
	          style: handleStyle[i],
	          ref: function ref(h) {
	            return _this3.saveHandle(i, h);
	          }
	        });
	      });
	
	      var tracks = bounds.slice(0, -1).map(function (_, index) {
	        var _classNames2;
	
	        var i = index + 1;
	        var trackClassName = (0, _classnames2['default'])((_classNames2 = {}, (0, _defineProperty3['default'])(_classNames2, prefixCls + '-track', true), (0, _defineProperty3['default'])(_classNames2, prefixCls + '-track-' + i, true), _classNames2));
	        return _react2['default'].createElement(_Track2['default'], {
	          className: trackClassName,
	          vertical: vertical,
	          included: included,
	          offset: offsets[i - 1],
	          length: offsets[i] - offsets[i - 1],
	          style: trackStyle[index],
	          key: i
	        });
	      });
	
	      return { tracks: tracks, handles: handles };
	    }
	  }]);
	  return Range;
	}(_react2['default'].Component);
	
	Range.displayName = 'Range';
	Range.propTypes = {
	  defaultValue: _propTypes2['default'].arrayOf(_propTypes2['default'].number),
	  value: _propTypes2['default'].arrayOf(_propTypes2['default'].number),
	  count: _propTypes2['default'].number,
	  pushable: _propTypes2['default'].oneOfType([_propTypes2['default'].bool, _propTypes2['default'].number]),
	  allowCross: _propTypes2['default'].bool,
	  disabled: _propTypes2['default'].bool
	};
	Range.defaultProps = {
	  count: 1,
	  allowCross: true,
	  pushable: false
	};
	exports['default'] = (0, _createSlider2['default'])(Range);
	module.exports = exports['default'];

/***/ }),
/* 738 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _warning = __webpack_require__(35);
	
	var _warning2 = _interopRequireDefault(_warning);
	
	var _Track = __webpack_require__(269);
	
	var _Track2 = _interopRequireDefault(_Track);
	
	var _createSlider = __webpack_require__(270);
	
	var _createSlider2 = _interopRequireDefault(_createSlider);
	
	var _utils = __webpack_require__(149);
	
	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 }; }
	
	/* eslint-disable react/prop-types */
	var Slider = function (_React$Component) {
	  (0, _inherits3['default'])(Slider, _React$Component);
	
	  function Slider(props) {
	    (0, _classCallCheck3['default'])(this, Slider);
	
	    var _this = (0, _possibleConstructorReturn3['default'])(this, (Slider.__proto__ || Object.getPrototypeOf(Slider)).call(this, props));
	
	    _this.onEnd = function () {
	      _this.setState({ dragging: false });
	      _this.removeDocumentEvents();
	      _this.props.onAfterChange(_this.getValue());
	    };
	
	    var defaultValue = props.defaultValue !== undefined ? props.defaultValue : props.min;
	    var value = props.value !== undefined ? props.value : defaultValue;
	
	    _this.state = {
	      value: _this.trimAlignValue(value),
	      dragging: false
	    };
	    if (true) {
	      (0, _warning2['default'])(!('minimumTrackStyle' in props), 'minimumTrackStyle will be deprecate, please use trackStyle instead.');
	      (0, _warning2['default'])(!('maximumTrackStyle' in props), 'maximumTrackStyle will be deprecate, please use railStyle instead.');
	    }
	    return _this;
	  }
	
	  (0, _createClass3['default'])(Slider, [{
	    key: 'componentWillReceiveProps',
	    value: function componentWillReceiveProps(nextProps) {
	      if (!('value' in nextProps || 'min' in nextProps || 'max' in nextProps)) return;
	
	      var prevValue = this.state.value;
	      var value = nextProps.value !== undefined ? nextProps.value : prevValue;
	      var nextValue = this.trimAlignValue(value, nextProps);
	      if (nextValue === prevValue) return;
	
	      this.setState({ value: nextValue });
	      if (utils.isValueOutOfRange(value, nextProps)) {
	        this.props.onChange(nextValue);
	      }
	    }
	  }, {
	    key: 'onChange',
	    value: function onChange(state) {
	      var props = this.props;
	      var isNotControlled = !('value' in props);
	      if (isNotControlled) {
	        this.setState(state);
	      }
	
	      var changedValue = state.value;
	      props.onChange(changedValue);
	    }
	  }, {
	    key: 'onStart',
	    value: function onStart(position) {
	      this.setState({ dragging: true });
	      var props = this.props;
	      var prevValue = this.getValue();
	      props.onBeforeChange(prevValue);
	
	      var value = this.calcValueByPos(position);
	      this.startValue = value;
	      this.startPosition = position;
	
	      if (value === prevValue) return;
	
	      this.onChange({ value: value });
	    }
	  }, {
	    key: 'onMove',
	    value: function onMove(e, position) {
	      utils.pauseEvent(e);
	      var oldValue = this.state.value;
	
	      var value = this.calcValueByPos(position);
	      if (value === oldValue) return;
	
	      this.onChange({ value: value });
	    }
	  }, {
	    key: 'onKeyboard',
	    value: function onKeyboard(e) {
	      var valueMutator = utils.getKeyboardValueMutator(e);
	
	      if (valueMutator) {
	        utils.pauseEvent(e);
	        var state = this.state;
	        var oldValue = state.value;
	        var mutatedValue = valueMutator(oldValue, this.props);
	        var value = this.trimAlignValue(mutatedValue);
	        if (value === oldValue) return;
	
	        this.onChange({ value: value });
	      }
	    }
	  }, {
	    key: 'getValue',
	    value: function getValue() {
	      return this.state.value;
	    }
	  }, {
	    key: 'getLowerBound',
	    value: function getLowerBound() {
	      return this.props.min;
	    }
	  }, {
	    key: 'getUpperBound',
	    value: function getUpperBound() {
	      return this.state.value;
	    }
	  }, {
	    key: 'trimAlignValue',
	    value: function trimAlignValue(v) {
	      var nextProps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
	
	      var mergedProps = (0, _extends3['default'])({}, this.props, nextProps);
	      var val = utils.ensureValueInRange(v, mergedProps);
	      return utils.ensureValuePrecision(val, mergedProps);
	    }
	  }, {
	    key: 'render',
	    value: function render() {
	      var _this2 = this;
	
	      var _props = this.props,
	          prefixCls = _props.prefixCls,
	          vertical = _props.vertical,
	          included = _props.included,
	          disabled = _props.disabled,
	          minimumTrackStyle = _props.minimumTrackStyle,
	          trackStyle = _props.trackStyle,
	          handleStyle = _props.handleStyle,
	          min = _props.min,
	          max = _props.max,
	          handleGenerator = _props.handle;
	      var _state = this.state,
	          value = _state.value,
	          dragging = _state.dragging;
	
	      var offset = this.calcOffset(value);
	      var handle = handleGenerator({
	        className: prefixCls + '-handle',
	        vertical: vertical,
	        offset: offset,
	        value: value,
	        dragging: dragging,
	        disabled: disabled,
	        min: min,
	        max: max,
	        index: 0,
	        style: handleStyle[0] || handleStyle,
	        ref: function ref(h) {
	          return _this2.saveHandle(0, h);
	        }
	      });
	
	      var _trackStyle = trackStyle[0] || trackStyle;
	      var track = _react2['default'].createElement(_Track2['default'], {
	        className: prefixCls + '-track',
	        vertical: vertical,
	        included: included,
	        offset: 0,
	        length: offset,
	        style: (0, _extends3['default'])({}, minimumTrackStyle, _trackStyle)
	      });
	
	      return { tracks: track, handles: handle };
	    }
	  }]);
	  return Slider;
	}(_react2['default'].Component);
	
	Slider.propTypes = {
	  defaultValue: _propTypes2['default'].number,
	  value: _propTypes2['default'].number,
	  disabled: _propTypes2['default'].bool
	};
	exports['default'] = (0, _createSlider2['default'])(Slider);
	module.exports = exports['default'];

/***/ }),
/* 739 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _typeof2 = __webpack_require__(21);
	
	var _typeof3 = _interopRequireDefault(_typeof2);
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var Marks = function Marks(_ref) {
	  var className = _ref.className,
	      vertical = _ref.vertical,
	      marks = _ref.marks,
	      included = _ref.included,
	      upperBound = _ref.upperBound,
	      lowerBound = _ref.lowerBound,
	      max = _ref.max,
	      min = _ref.min;
	
	  var marksKeys = Object.keys(marks);
	  var marksCount = marksKeys.length;
	  var unit = marksCount > 1 ? 100 / (marksCount - 1) : 100;
	  var markWidth = unit * 0.9;
	
	  var range = max - min;
	  var elements = marksKeys.map(parseFloat).sort(function (a, b) {
	    return a - b;
	  }).map(function (point) {
	    var _classNames;
	
	    var isActive = !included && point === upperBound || included && point <= upperBound && point >= lowerBound;
	    var markClassName = (0, _classnames2['default'])((_classNames = {}, (0, _defineProperty3['default'])(_classNames, className + '-text', true), (0, _defineProperty3['default'])(_classNames, className + '-text-active', isActive), _classNames));
	
	    var bottomStyle = {
	      marginBottom: '-50%',
	      bottom: (point - min) / range * 100 + '%'
	    };
	
	    var leftStyle = {
	      width: markWidth + '%',
	      marginLeft: -markWidth / 2 + '%',
	      left: (point - min) / range * 100 + '%'
	    };
	
	    var style = vertical ? bottomStyle : leftStyle;
	
	    var markPoint = marks[point];
	    var markPointIsObject = (typeof markPoint === 'undefined' ? 'undefined' : (0, _typeof3['default'])(markPoint)) === 'object' && !_react2['default'].isValidElement(markPoint);
	    var markLabel = markPointIsObject ? markPoint.label : markPoint;
	    var markStyle = markPointIsObject ? (0, _extends3['default'])({}, style, markPoint.style) : style;
	    return _react2['default'].createElement(
	      'span',
	      {
	        className: markClassName,
	        style: markStyle,
	        key: point
	      },
	      markLabel
	    );
	  });
	
	  return _react2['default'].createElement(
	    'div',
	    { className: className },
	    elements
	  );
	};
	
	exports['default'] = Marks;
	module.exports = exports['default'];

/***/ }),
/* 740 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _warning = __webpack_require__(35);
	
	var _warning2 = _interopRequireDefault(_warning);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var calcPoints = function calcPoints(vertical, marks, dots, step, min, max) {
	  (0, _warning2['default'])(dots ? step > 0 : true, '`Slider[step]` should be a positive number in order to make Slider[dots] work.');
	  var points = Object.keys(marks).map(parseFloat);
	  if (dots) {
	    for (var i = min; i <= max; i = i + step) {
	      if (points.indexOf(i) >= 0) continue;
	      points.push(i);
	    }
	  }
	  return points;
	};
	
	var Steps = function Steps(_ref) {
	  var prefixCls = _ref.prefixCls,
	      vertical = _ref.vertical,
	      marks = _ref.marks,
	      dots = _ref.dots,
	      step = _ref.step,
	      included = _ref.included,
	      lowerBound = _ref.lowerBound,
	      upperBound = _ref.upperBound,
	      max = _ref.max,
	      min = _ref.min,
	      dotStyle = _ref.dotStyle,
	      activeDotStyle = _ref.activeDotStyle;
	
	  var range = max - min;
	  var elements = calcPoints(vertical, marks, dots, step, min, max).map(function (point) {
	    var _classNames;
	
	    var offset = Math.abs(point - min) / range * 100 + '%';
	
	    var isActived = !included && point === upperBound || included && point <= upperBound && point >= lowerBound;
	    var style = vertical ? (0, _extends3['default'])({ bottom: offset }, dotStyle) : (0, _extends3['default'])({ left: offset }, dotStyle);
	    if (isActived) {
	      style = (0, _extends3['default'])({}, style, activeDotStyle);
	    }
	
	    var pointClassName = (0, _classnames2['default'])((_classNames = {}, (0, _defineProperty3['default'])(_classNames, prefixCls + '-dot', true), (0, _defineProperty3['default'])(_classNames, prefixCls + '-dot-active', isActived), _classNames));
	
	    return _react2['default'].createElement('span', { className: pointClassName, style: style, key: point });
	  });
	
	  return _react2['default'].createElement(
	    'div',
	    { className: prefixCls + '-step' },
	    elements
	  );
	};
	
	exports['default'] = Steps;
	module.exports = exports['default'];

/***/ }),
/* 741 */
/***/ (function(module, exports, __webpack_require__) {

	'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 _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
	
	function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return 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 _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) : _defaults(subClass, superClass); }
	
	function isString(str) {
	  return typeof str === 'string';
	}
	
	var Step = function (_React$Component) {
	  _inherits(Step, _React$Component);
	
	  function Step() {
	    _classCallCheck(this, Step);
	
	    return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	  }
	
	  Step.prototype.render = function render() {
	    var _classNames, _classNames2;
	
	    var _props = this.props,
	        className = _props.className,
	        prefixCls = _props.prefixCls,
	        style = _props.style,
	        itemWidth = _props.itemWidth,
	        _props$status = _props.status,
	        status = _props$status === undefined ? 'wait' : _props$status,
	        iconPrefix = _props.iconPrefix,
	        icon = _props.icon,
	        wrapperStyle = _props.wrapperStyle,
	        adjustMarginRight = _props.adjustMarginRight,
	        stepNumber = _props.stepNumber,
	        description = _props.description,
	        title = _props.title,
	        progressDot = _props.progressDot,
	        restProps = _objectWithoutProperties(_props, ['className', 'prefixCls', 'style', 'itemWidth', 'status', 'iconPrefix', 'icon', 'wrapperStyle', 'adjustMarginRight', 'stepNumber', 'description', 'title', 'progressDot']);
	
	    var iconClassName = (0, _classnames2["default"])((_classNames = {}, _defineProperty(_classNames, prefixCls + '-icon', true), _defineProperty(_classNames, iconPrefix + 'icon', true), _defineProperty(_classNames, iconPrefix + 'icon-' + icon, icon && isString(icon)), _defineProperty(_classNames, iconPrefix + 'icon-check', !icon && status === 'finish'), _defineProperty(_classNames, iconPrefix + 'icon-cross', !icon && status === 'error'), _classNames));
	
	    var iconNode = void 0;
	    var iconDot = _react2["default"].createElement('span', { className: prefixCls + '-icon-dot' });
	    // `progressDot` enjoy the highest priority
	    if (!!progressDot) {
	      if (typeof progressDot === 'function') {
	        iconNode = _react2["default"].createElement(
	          'span',
	          { className: prefixCls + '-icon' },
	          progressDot(iconDot, { index: stepNumber - 1, status: status, title: title, description: description })
	        );
	      } else {
	        iconNode = _react2["default"].createElement(
	          'span',
	          { className: prefixCls + '-icon' },
	          iconDot
	        );
	      }
	    } else if (icon && !isString(icon)) {
	      iconNode = _react2["default"].createElement(
	        'span',
	        { className: prefixCls + '-icon' },
	        icon
	      );
	    } else if (icon || status === 'finish' || status === 'error') {
	      iconNode = _react2["default"].createElement('span', { className: iconClassName });
	    } else {
	      iconNode = _react2["default"].createElement(
	        'span',
	        { className: prefixCls + '-icon' },
	        stepNumber
	      );
	    }
	    var classString = (0, _classnames2["default"])((_classNames2 = {}, _defineProperty(_classNames2, prefixCls + '-item', true), _defineProperty(_classNames2, prefixCls + '-status-' + status, true), _defineProperty(_classNames2, prefixCls + '-custom', icon), _defineProperty(_classNames2, className, !!className), _classNames2));
	    return _react2["default"].createElement(
	      'div',
	      _extends({}, restProps, {
	        className: classString,
	        style: _extends({ width: itemWidth, marginRight: adjustMarginRight }, style)
	      }),
	      _react2["default"].createElement(
	        'div',
	        {
	          ref: 'tail',
	          className: prefixCls + '-tail',
	          style: { paddingRight: -adjustMarginRight }
	        },
	        _react2["default"].createElement('i', null)
	      ),
	      _react2["default"].createElement(
	        'div',
	        { className: prefixCls + '-step' },
	        _react2["default"].createElement(
	          'div',
	          {
	            className: prefixCls + '-head',
	            style: { background: wrapperStyle.background || wrapperStyle.backgroundColor }
	          },
	          _react2["default"].createElement(
	            'div',
	            { className: prefixCls + '-head-inner' },
	            iconNode
	          )
	        ),
	        _react2["default"].createElement(
	          'div',
	          { ref: 'main', className: prefixCls + '-main' },
	          _react2["default"].createElement(
	            'div',
	            {
	              className: prefixCls + '-title',
	              style: { background: wrapperStyle.background || wrapperStyle.backgroundColor }
	            },
	            title
	          ),
	          description ? _react2["default"].createElement(
	            'div',
	            { className: prefixCls + '-description' },
	            description
	          ) : ''
	        )
	      )
	    );
	  };
	
	  return Step;
	}(_react2["default"].Component);
	
	exports["default"] = Step;
	
	
	Step.propTypes = {
	  className: _propTypes2["default"].string,
	  prefixCls: _propTypes2["default"].string,
	  style: _propTypes2["default"].object,
	  wrapperStyle: _propTypes2["default"].object,
	  itemWidth: _propTypes2["default"].oneOfType([_propTypes2["default"].number, _propTypes2["default"].string]),
	  status: _propTypes2["default"].string,
	  iconPrefix: _propTypes2["default"].string,
	  icon: _propTypes2["default"].node,
	  adjustMarginRight: _propTypes2["default"].oneOfType([_propTypes2["default"].number, _propTypes2["default"].string]),
	  stepNumber: _propTypes2["default"].string,
	  description: _propTypes2["default"].any,
	  title: _propTypes2["default"].any,
	  progressDot: _propTypes2["default"].oneOfType([_propTypes2["default"].bool, _propTypes2["default"].func])
	};
	module.exports = exports['default'];

/***/ }),
/* 742 */
/***/ (function(module, exports, __webpack_require__) {

	'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 _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _reactDom = __webpack_require__(10);
	
	var _reactDom2 = _interopRequireDefault(_reactDom);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _lodash = __webpack_require__(91);
	
	var _lodash2 = _interopRequireDefault(_lodash);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
	
	function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return 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 _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) : _defaults(subClass, superClass); }
	
	var Steps = function (_React$Component) {
	  _inherits(Steps, _React$Component);
	
	  function Steps(props) {
	    _classCallCheck(this, Steps);
	
	    var _this = _possibleConstructorReturn(this, _React$Component.call(this, props));
	
	    _this.calcStepOffsetWidth = function () {
	      var domNode = _reactDom2["default"].findDOMNode(_this);
	      if (domNode.children.length > 0) {
	        if (_this.calcTimeout) {
	          clearTimeout(_this.calcTimeout);
	        }
	        _this.calcTimeout = setTimeout(function () {
	          // +1 for fit edge bug of digit width, like 35.4px
	          var lastStepOffsetWidth = (domNode.lastChild.offsetWidth || 0) + 1;
	          // Reduce shake bug
	          if (_this.state.lastStepOffsetWidth === lastStepOffsetWidth || Math.abs(_this.state.lastStepOffsetWidth - lastStepOffsetWidth) <= 3) {
	            return;
	          }
	          _this.setState({ lastStepOffsetWidth: lastStepOffsetWidth });
	        });
	      }
	    };
	
	    _this.state = {
	      lastStepOffsetWidth: 0
	    };
	    _this.calcStepOffsetWidth = (0, _lodash2["default"])(_this.calcStepOffsetWidth, 150);
	    return _this;
	  }
	
	  Steps.prototype.componentDidMount = function componentDidMount() {
	    this.calcStepOffsetWidth();
	  };
	
	  Steps.prototype.componentDidUpdate = function componentDidUpdate() {
	    this.calcStepOffsetWidth();
	  };
	
	  Steps.prototype.componentWillUnmount = function componentWillUnmount() {
	    if (this.calcTimeout) {
	      clearTimeout(this.calcTimeout);
	    }
	    if (this.calcStepOffsetWidth.cancel) {
	      this.calcStepOffsetWidth.cancel();
	    }
	  };
	
	  Steps.prototype.render = function render() {
	    var _classNames,
	        _this2 = this;
	
	    var props = this.props;
	
	    var prefixCls = props.prefixCls,
	        _props$style = props.style,
	        style = _props$style === undefined ? {} : _props$style,
	        className = props.className,
	        children = props.children,
	        direction = props.direction,
	        labelPlacement = props.labelPlacement,
	        iconPrefix = props.iconPrefix,
	        status = props.status,
	        size = props.size,
	        current = props.current,
	        progressDot = props.progressDot,
	        restProps = _objectWithoutProperties(props, ['prefixCls', 'style', 'className', 'children', 'direction', 'labelPlacement', 'iconPrefix', 'status', 'size', 'current', 'progressDot']);
	
	    var filteredChildren = _react2["default"].Children.toArray(children).filter(function (c) {
	      return !!c;
	    });
	    var lastIndex = filteredChildren.length - 1;
	    var reLayouted = this.state.lastStepOffsetWidth > 0;
	    var adjustedlabelPlacement = !!progressDot ? 'vertical' : labelPlacement;
	    var classString = (0, _classnames2["default"])((_classNames = {}, _defineProperty(_classNames, prefixCls, true), _defineProperty(_classNames, prefixCls + '-' + size, size), _defineProperty(_classNames, prefixCls + '-' + direction, true), _defineProperty(_classNames, prefixCls + '-label-' + adjustedlabelPlacement, direction === 'horizontal'), _defineProperty(_classNames, prefixCls + '-hidden', !reLayouted), _defineProperty(_classNames, prefixCls + '-dot', !!progressDot), _defineProperty(_classNames, className, className), _classNames));
	
	    return _react2["default"].createElement(
	      'div',
	      _extends({ className: classString, style: style }, restProps),
	      _react2["default"].Children.map(filteredChildren, function (ele, idx) {
	        if (!ele) {
	          return null;
	        }
	        var itemWidth = direction === 'vertical' || idx === lastIndex || !reLayouted ? null : 100 / lastIndex + '%';
	        var adjustMarginRight = direction === 'vertical' || idx === lastIndex ? null : -Math.round(_this2.state.lastStepOffsetWidth / lastIndex + 1);
	        var np = {
	          stepNumber: (idx + 1).toString(),
	          itemWidth: itemWidth,
	          adjustMarginRight: adjustMarginRight,
	          prefixCls: prefixCls,
	          iconPrefix: iconPrefix,
	          wrapperStyle: style,
	          progressDot: progressDot
	        };
	
	        // fix tail color
	        if (status === 'error' && idx === current - 1) {
	          np.className = props.prefixCls + '-next-error';
	        }
	
	        if (!ele.props.status) {
	          if (idx === current) {
	            np.status = status;
	          } else if (idx < current) {
	            np.status = 'finish';
	          } else {
	            np.status = 'wait';
	          }
	        }
	        return _react2["default"].cloneElement(ele, np);
	      }, this)
	    );
	  };
	
	  return Steps;
	}(_react2["default"].Component);
	
	exports["default"] = Steps;
	
	
	Steps.propTypes = {
	  prefixCls: _propTypes2["default"].string,
	  iconPrefix: _propTypes2["default"].string,
	  direction: _propTypes2["default"].string,
	  labelPlacement: _propTypes2["default"].string,
	  children: _propTypes2["default"].any,
	  status: _propTypes2["default"].string,
	  size: _propTypes2["default"].string,
	  progressDot: _propTypes2["default"].oneOfType([_propTypes2["default"].bool, _propTypes2["default"].func])
	};
	
	Steps.defaultProps = {
	  prefixCls: 'rc-steps',
	  iconPrefix: 'rc',
	  direction: 'horizontal',
	  labelPlacement: 'horizontal',
	  current: 0,
	  status: 'process',
	  size: '',
	  progressDot: false
	};
	module.exports = exports['default'];

/***/ }),
/* 743 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _Steps = __webpack_require__(742);
	
	var _Steps2 = _interopRequireDefault(_Steps);
	
	var _Step = __webpack_require__(741);
	
	var _Step2 = _interopRequireDefault(_Step);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
	
	_Steps2["default"].Step = _Step2["default"];
	exports["default"] = _Steps2["default"];
	module.exports = exports['default'];

/***/ }),
/* 744 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _objectWithoutProperties2 = __webpack_require__(20);
	
	var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var classNames = __webpack_require__(8);
	
	function noop() {}
	
	var Switch = function (_Component) {
	  (0, _inherits3['default'])(Switch, _Component);
	
	  function Switch(props) {
	    (0, _classCallCheck3['default'])(this, Switch);
	
	    var _this = (0, _possibleConstructorReturn3['default'])(this, (Switch.__proto__ || Object.getPrototypeOf(Switch)).call(this, props));
	
	    _initialiseProps.call(_this);
	
	    var checked = false;
	    if ('checked' in props) {
	      checked = !!props.checked;
	    } else {
	      checked = !!props.defaultChecked;
	    }
	    _this.state = { checked: checked };
	    return _this;
	  }
	
	  (0, _createClass3['default'])(Switch, [{
	    key: 'componentWillReceiveProps',
	    value: function componentWillReceiveProps(nextProps) {
	      if ('checked' in nextProps) {
	        this.setState({
	          checked: !!nextProps.checked
	        });
	      }
	    }
	  }, {
	    key: 'setChecked',
	    value: function setChecked(checked) {
	      if (this.props.disabled) {
	        return;
	      }
	      if (!('checked' in this.props)) {
	        this.setState({
	          checked: checked
	        });
	      }
	      this.props.onChange(checked);
	    }
	
	    // Handle auto focus when click switch in Chrome
	
	  }, {
	    key: 'render',
	    value: function render() {
	      var _classNames;
	
	      var _props = this.props,
	          className = _props.className,
	          prefixCls = _props.prefixCls,
	          disabled = _props.disabled,
	          checkedChildren = _props.checkedChildren,
	          tabIndex = _props.tabIndex,
	          unCheckedChildren = _props.unCheckedChildren,
	          restProps = (0, _objectWithoutProperties3['default'])(_props, ['className', 'prefixCls', 'disabled', 'checkedChildren', 'tabIndex', 'unCheckedChildren']);
	
	      var checked = this.state.checked;
	      var switchTabIndex = disabled ? -1 : tabIndex || 0;
	      var switchClassName = classNames((_classNames = {}, (0, _defineProperty3['default'])(_classNames, className, !!className), (0, _defineProperty3['default'])(_classNames, prefixCls, true), (0, _defineProperty3['default'])(_classNames, prefixCls + '-checked', checked), (0, _defineProperty3['default'])(_classNames, prefixCls + '-disabled', disabled), _classNames));
	      return _react2['default'].createElement(
	        'span',
	        (0, _extends3['default'])({}, restProps, {
	          className: switchClassName,
	          tabIndex: switchTabIndex,
	          ref: this.saveNode,
	          onKeyDown: this.handleKeyDown,
	          onClick: this.toggle,
	          onMouseUp: this.handleMouseUp
	        }),
	        _react2['default'].createElement(
	          'span',
	          { className: prefixCls + '-inner' },
	          checked ? checkedChildren : unCheckedChildren
	        )
	      );
	    }
	  }]);
	  return Switch;
	}(_react.Component);
	
	var _initialiseProps = function _initialiseProps() {
	  var _this2 = this;
	
	  this.toggle = function () {
	    var onClick = _this2.props.onClick;
	
	    var checked = !_this2.state.checked;
	    _this2.setChecked(checked);
	    onClick(checked);
	  };
	
	  this.handleKeyDown = function (e) {
	    if (e.keyCode === 37) {
	      // Left
	      _this2.setChecked(false);
	    } else if (e.keyCode === 39) {
	      // Right
	      _this2.setChecked(true);
	    } else if (e.keyCode === 32 || e.keyCode === 13) {
	      // Space, Enter
	      _this2.toggle();
	    }
	  };
	
	  this.handleMouseUp = function (e) {
	    if (_this2.node) {
	      _this2.node.blur();
	    }
	    if (_this2.props.onMouseUp) {
	      _this2.props.onMouseUp(e);
	    }
	  };
	
	  this.saveNode = function (node) {
	    _this2.node = node;
	  };
	};
	
	Switch.propTypes = {
	  className: _propTypes2['default'].string,
	  prefixCls: _propTypes2['default'].string,
	  disabled: _propTypes2['default'].bool,
	  checkedChildren: _propTypes2['default'].any,
	  unCheckedChildren: _propTypes2['default'].any,
	  onChange: _propTypes2['default'].func,
	  onMouseUp: _propTypes2['default'].func,
	  onClick: _propTypes2['default'].func,
	  tabIndex: _propTypes2['default'].number,
	  checked: _propTypes2['default'].bool,
	  defaultChecked: _propTypes2['default'].bool
	};
	
	Switch.defaultProps = {
	  prefixCls: 'rc-switch',
	  checkedChildren: null,
	  unCheckedChildren: null,
	  className: '',
	  defaultChecked: false,
	  onChange: noop,
	  onClick: noop
	};
	
	exports['default'] = Switch;
	module.exports = exports['default'];

/***/ }),
/* 745 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	module.exports = __webpack_require__(744);

/***/ }),
/* 746 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var Column = function (_Component) {
	  (0, _inherits3['default'])(Column, _Component);
	
	  function Column() {
	    (0, _classCallCheck3['default'])(this, Column);
	    return (0, _possibleConstructorReturn3['default'])(this, (Column.__proto__ || Object.getPrototypeOf(Column)).apply(this, arguments));
	  }
	
	  return Column;
	}(_react.Component);
	
	Column.propTypes = {
	  className: _propTypes2['default'].string,
	  colSpan: _propTypes2['default'].number,
	  title: _propTypes2['default'].node,
	  dataIndex: _propTypes2['default'].string,
	  width: _propTypes2['default'].oneOfType([_propTypes2['default'].number, _propTypes2['default'].string]),
	  fixed: _propTypes2['default'].oneOf([true, 'left', 'right']),
	  render: _propTypes2['default'].func,
	  onCellClick: _propTypes2['default'].func
	};
	exports['default'] = Column;
	module.exports = exports['default'];

/***/ }),
/* 747 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var ColumnGroup = function (_Component) {
	  (0, _inherits3['default'])(ColumnGroup, _Component);
	
	  function ColumnGroup() {
	    (0, _classCallCheck3['default'])(this, ColumnGroup);
	    return (0, _possibleConstructorReturn3['default'])(this, (ColumnGroup.__proto__ || Object.getPrototypeOf(ColumnGroup)).apply(this, arguments));
	  }
	
	  return ColumnGroup;
	}(_react.Component);
	
	ColumnGroup.propTypes = {
	  title: _propTypes2['default'].node
	};
	ColumnGroup.isTableColumnGroup = true;
	exports['default'] = ColumnGroup;
	module.exports = exports['default'];

/***/ }),
/* 748 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _toConsumableArray2 = __webpack_require__(31);
	
	var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var ColumnManager = function () {
	  function ColumnManager(columns, elements) {
	    (0, _classCallCheck3['default'])(this, ColumnManager);
	    this._cached = {};
	
	    this.columns = columns || this.normalize(elements);
	  }
	
	  (0, _createClass3['default'])(ColumnManager, [{
	    key: 'isAnyColumnsFixed',
	    value: function isAnyColumnsFixed() {
	      var _this = this;
	
	      return this._cache('isAnyColumnsFixed', function () {
	        return _this.columns.some(function (column) {
	          return !!column.fixed;
	        });
	      });
	    }
	  }, {
	    key: 'isAnyColumnsLeftFixed',
	    value: function isAnyColumnsLeftFixed() {
	      var _this2 = this;
	
	      return this._cache('isAnyColumnsLeftFixed', function () {
	        return _this2.columns.some(function (column) {
	          return column.fixed === 'left' || column.fixed === true;
	        });
	      });
	    }
	  }, {
	    key: 'isAnyColumnsRightFixed',
	    value: function isAnyColumnsRightFixed() {
	      var _this3 = this;
	
	      return this._cache('isAnyColumnsRightFixed', function () {
	        return _this3.columns.some(function (column) {
	          return column.fixed === 'right';
	        });
	      });
	    }
	  }, {
	    key: 'leftColumns',
	    value: function leftColumns() {
	      var _this4 = this;
	
	      return this._cache('leftColumns', function () {
	        return _this4.groupedColumns().filter(function (column) {
	          return column.fixed === 'left' || column.fixed === true;
	        });
	      });
	    }
	  }, {
	    key: 'rightColumns',
	    value: function rightColumns() {
	      var _this5 = this;
	
	      return this._cache('rightColumns', function () {
	        return _this5.groupedColumns().filter(function (column) {
	          return column.fixed === 'right';
	        });
	      });
	    }
	  }, {
	    key: 'leafColumns',
	    value: function leafColumns() {
	      var _this6 = this;
	
	      return this._cache('leafColumns', function () {
	        return _this6._leafColumns(_this6.columns);
	      });
	    }
	  }, {
	    key: 'leftLeafColumns',
	    value: function leftLeafColumns() {
	      var _this7 = this;
	
	      return this._cache('leftLeafColumns', function () {
	        return _this7._leafColumns(_this7.leftColumns());
	      });
	    }
	  }, {
	    key: 'rightLeafColumns',
	    value: function rightLeafColumns() {
	      var _this8 = this;
	
	      return this._cache('rightLeafColumns', function () {
	        return _this8._leafColumns(_this8.rightColumns());
	      });
	    }
	
	    // add appropriate rowspan and colspan to column
	
	  }, {
	    key: 'groupedColumns',
	    value: function groupedColumns() {
	      var _this9 = this;
	
	      return this._cache('groupedColumns', function () {
	        var _groupColumns = function _groupColumns(columns) {
	          var currentRow = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
	          var parentColumn = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
	          var rows = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
	
	          // track how many rows we got
	          rows[currentRow] = rows[currentRow] || [];
	          var grouped = [];
	          var setRowSpan = function setRowSpan(column) {
	            var rowSpan = rows.length - currentRow;
	            if (column && !column.children && // parent columns are supposed to be one row
	            rowSpan > 1 && (!column.rowSpan || column.rowSpan < rowSpan)) {
	              column.rowSpan = rowSpan;
	            }
	          };
	          columns.forEach(function (column, index) {
	            var newColumn = (0, _extends3['default'])({}, column);
	            rows[currentRow].push(newColumn);
	            parentColumn.colSpan = parentColumn.colSpan || 0;
	            if (newColumn.children && newColumn.children.length > 0) {
	              newColumn.children = _groupColumns(newColumn.children, currentRow + 1, newColumn, rows);
	              parentColumn.colSpan = parentColumn.colSpan + newColumn.colSpan;
	            } else {
	              parentColumn.colSpan++;
	            }
	            // update rowspan to all same row columns
	            for (var i = 0; i < rows[currentRow].length - 1; ++i) {
	              setRowSpan(rows[currentRow][i]);
	            }
	            // last column, update rowspan immediately
	            if (index + 1 === columns.length) {
	              setRowSpan(newColumn);
	            }
	            grouped.push(newColumn);
	          });
	          return grouped;
	        };
	        return _groupColumns(_this9.columns);
	      });
	    }
	  }, {
	    key: 'normalize',
	    value: function normalize(elements) {
	      var _this10 = this;
	
	      var columns = [];
	      _react2['default'].Children.forEach(elements, function (element) {
	        if (!_react2['default'].isValidElement(element)) {
	          return;
	        }
	        var column = (0, _extends3['default'])({}, element.props);
	        if (element.key) {
	          column.key = element.key;
	        }
	        if (element.type.isTableColumnGroup) {
	          column.children = _this10.normalize(column.children);
	        }
	        columns.push(column);
	      });
	      return columns;
	    }
	  }, {
	    key: 'reset',
	    value: function reset(columns, elements) {
	      this.columns = columns || this.normalize(elements);
	      this._cached = {};
	    }
	  }, {
	    key: '_cache',
	    value: function _cache(name, fn) {
	      if (name in this._cached) {
	        return this._cached[name];
	      }
	      this._cached[name] = fn();
	      return this._cached[name];
	    }
	  }, {
	    key: '_leafColumns',
	    value: function _leafColumns(columns) {
	      var _this11 = this;
	
	      var leafColumns = [];
	      columns.forEach(function (column) {
	        if (!column.children) {
	          leafColumns.push(column);
	        } else {
	          leafColumns.push.apply(leafColumns, (0, _toConsumableArray3['default'])(_this11._leafColumns(column.children)));
	        }
	      });
	      return leafColumns;
	    }
	  }]);
	  return ColumnManager;
	}();
	
	exports['default'] = ColumnManager;
	module.exports = exports['default'];

/***/ }),
/* 749 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _shallowequal = __webpack_require__(150);
	
	var _shallowequal2 = _interopRequireDefault(_shallowequal);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var ExpandIcon = function (_React$Component) {
	  (0, _inherits3['default'])(ExpandIcon, _React$Component);
	
	  function ExpandIcon() {
	    (0, _classCallCheck3['default'])(this, ExpandIcon);
	    return (0, _possibleConstructorReturn3['default'])(this, (ExpandIcon.__proto__ || Object.getPrototypeOf(ExpandIcon)).apply(this, arguments));
	  }
	
	  (0, _createClass3['default'])(ExpandIcon, [{
	    key: 'shouldComponentUpdate',
	    value: function shouldComponentUpdate(nextProps) {
	      return !(0, _shallowequal2['default'])(nextProps, this.props);
	    }
	  }, {
	    key: 'render',
	    value: function render() {
	      var _props = this.props,
	          expandable = _props.expandable,
	          prefixCls = _props.prefixCls,
	          onExpand = _props.onExpand,
	          needIndentSpaced = _props.needIndentSpaced,
	          expanded = _props.expanded,
	          record = _props.record;
	
	      if (expandable) {
	        var expandClassName = expanded ? 'expanded' : 'collapsed';
	        return _react2['default'].createElement('span', {
	          className: prefixCls + '-expand-icon ' + prefixCls + '-' + expandClassName,
	          onClick: function onClick(e) {
	            return onExpand(!expanded, record, e);
	          }
	        });
	      } else if (needIndentSpaced) {
	        return _react2['default'].createElement('span', { className: prefixCls + '-expand-icon ' + prefixCls + '-spaced' });
	      }
	      return null;
	    }
	  }]);
	  return ExpandIcon;
	}(_react2['default'].Component);
	
	ExpandIcon.propTypes = {
	  record: _propTypes2['default'].object,
	  prefixCls: _propTypes2['default'].string,
	  expandable: _propTypes2['default'].any,
	  expanded: _propTypes2['default'].bool,
	  needIndentSpaced: _propTypes2['default'].bool,
	  onExpand: _propTypes2['default'].func
	};
	exports['default'] = ExpandIcon;
	module.exports = exports['default'];

/***/ }),
/* 750 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _toConsumableArray2 = __webpack_require__(31);
	
	var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _TableRow = __webpack_require__(753);
	
	var _TableRow2 = _interopRequireDefault(_TableRow);
	
	var _TableHeader = __webpack_require__(752);
	
	var _TableHeader2 = _interopRequireDefault(_TableHeader);
	
	var _utils = __webpack_require__(756);
	
	var _shallowequal = __webpack_require__(150);
	
	var _shallowequal2 = _interopRequireDefault(_shallowequal);
	
	var _addEventListener = __webpack_require__(34);
	
	var _addEventListener2 = _interopRequireDefault(_addEventListener);
	
	var _ColumnManager = __webpack_require__(748);
	
	var _ColumnManager2 = _interopRequireDefault(_ColumnManager);
	
	var _createStore = __webpack_require__(754);
	
	var _createStore2 = _interopRequireDefault(_createStore);
	
	var _componentClasses = __webpack_require__(105);
	
	var _componentClasses2 = _interopRequireDefault(_componentClasses);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var Table = function (_React$Component) {
	  (0, _inherits3['default'])(Table, _React$Component);
	
	  function Table(props) {
	    (0, _classCallCheck3['default'])(this, Table);
	
	    var _this = (0, _possibleConstructorReturn3['default'])(this, (Table.__proto__ || Object.getPrototypeOf(Table)).call(this, props));
	
	    _this.onExpanded = function (expanded, record, e, index) {
	      if (e) {
	        e.preventDefault();
	        e.stopPropagation();
	      }
	      var info = _this.findExpandedRow(record);
	      if (typeof info !== 'undefined' && !expanded) {
	        _this.onRowDestroy(record, index);
	      } else if (!info && expanded) {
	        var expandedRows = _this.getExpandedRows().concat();
	        expandedRows.push(_this.getRowKey(record, index));
	        _this.onExpandedRowsChange(expandedRows);
	      }
	      _this.props.onExpand(expanded, record);
	    };
	
	    _this.onRowDestroy = function (record, rowIndex) {
	      var expandedRows = _this.getExpandedRows().concat();
	      var rowKey = _this.getRowKey(record, rowIndex);
	      var index = -1;
	      expandedRows.forEach(function (r, i) {
	        if (r === rowKey) {
	          index = i;
	        }
	      });
	      if (index !== -1) {
	        expandedRows.splice(index, 1);
	      }
	      _this.onExpandedRowsChange(expandedRows);
	    };
	
	    _this.handleWindowResize = function () {
	      _this.syncFixedTableRowHeight();
	      _this.setScrollPositionClassName();
	    };
	
	    _this.syncFixedTableRowHeight = function () {
	      var tableRect = _this.tableNode.getBoundingClientRect();
	      // If tableNode's height less than 0, suppose it is hidden and don't recalculate rowHeight.
	      // see: https://github.com/ant-design/ant-design/issues/4836
	      if (tableRect.height !== undefined && tableRect.height <= 0) {
	        return;
	      }
	      var prefixCls = _this.props.prefixCls;
	
	      var headRows = _this.refs.headTable ? _this.refs.headTable.querySelectorAll('thead') : _this.refs.bodyTable.querySelectorAll('thead');
	      var bodyRows = _this.refs.bodyTable.querySelectorAll('.' + prefixCls + '-row') || [];
	      var fixedColumnsHeadRowsHeight = [].map.call(headRows, function (row) {
	        return row.getBoundingClientRect().height || 'auto';
	      });
	      var fixedColumnsBodyRowsHeight = [].map.call(bodyRows, function (row) {
	        return row.getBoundingClientRect().height || 'auto';
	      });
	      if ((0, _shallowequal2['default'])(_this.state.fixedColumnsHeadRowsHeight, fixedColumnsHeadRowsHeight) && (0, _shallowequal2['default'])(_this.state.fixedColumnsBodyRowsHeight, fixedColumnsBodyRowsHeight)) {
	        return;
	      }
	      _this.setState({
	        fixedColumnsHeadRowsHeight: fixedColumnsHeadRowsHeight,
	        fixedColumnsBodyRowsHeight: fixedColumnsBodyRowsHeight
	      });
	    };
	
	    _this.handleBodyScrollLeft = function (e) {
	      // Fix https://github.com/ant-design/ant-design/issues/7635
	      if (e.currentTarget !== e.target) {
	        return;
	      }
	      var target = e.target;
	      var _this$props$scroll = _this.props.scroll,
	          scroll = _this$props$scroll === undefined ? {} : _this$props$scroll;
	      var _this$refs = _this.refs,
	          headTable = _this$refs.headTable,
	          bodyTable = _this$refs.bodyTable;
	
	      if (target.scrollLeft !== _this.lastScrollLeft && scroll.x) {
	        if (target === bodyTable && headTable) {
	          headTable.scrollLeft = target.scrollLeft;
	        } else if (target === headTable && bodyTable) {
	          bodyTable.scrollLeft = target.scrollLeft;
	        }
	        _this.setScrollPositionClassName();
	      }
	      // Remember last scrollLeft for scroll direction detecting.
	      _this.lastScrollLeft = target.scrollLeft;
	    };
	
	    _this.handleBodyScrollTop = function (e) {
	      var target = e.target;
	      var _this$props$scroll2 = _this.props.scroll,
	          scroll = _this$props$scroll2 === undefined ? {} : _this$props$scroll2;
	      var _this$refs2 = _this.refs,
	          headTable = _this$refs2.headTable,
	          bodyTable = _this$refs2.bodyTable,
	          fixedColumnsBodyLeft = _this$refs2.fixedColumnsBodyLeft,
	          fixedColumnsBodyRight = _this$refs2.fixedColumnsBodyRight;
	
	      if (target.scrollTop !== _this.lastScrollTop && scroll.y && target !== headTable) {
	        var scrollTop = target.scrollTop;
	        if (fixedColumnsBodyLeft && target !== fixedColumnsBodyLeft) {
	          fixedColumnsBodyLeft.scrollTop = scrollTop;
	        }
	        if (fixedColumnsBodyRight && target !== fixedColumnsBodyRight) {
	          fixedColumnsBodyRight.scrollTop = scrollTop;
	        }
	        if (bodyTable && target !== bodyTable) {
	          bodyTable.scrollTop = scrollTop;
	        }
	      }
	      // Remember last scrollTop for scroll direction detecting.
	      _this.lastScrollTop = target.scrollTop;
	    };
	
	    _this.handleBodyScroll = function (e) {
	      _this.handleBodyScrollLeft(e);
	      _this.handleBodyScrollTop(e);
	    };
	
	    _this.handleRowHover = function (isHover, key) {
	      _this.store.setState({
	        currentHoverKey: isHover ? key : null
	      });
	    };
	
	    var expandedRowKeys = [];
	    var rows = [].concat((0, _toConsumableArray3['default'])(props.data));
	    _this.columnManager = new _ColumnManager2['default'](props.columns, props.children);
	    _this.store = (0, _createStore2['default'])({
	      currentHoverKey: null,
	      expandedRowsHeight: {}
	    });
	    _this.setScrollPosition('left');
	
	    if (props.defaultExpandAllRows) {
	      for (var i = 0; i < rows.length; i++) {
	        var row = rows[i];
	        expandedRowKeys.push(_this.getRowKey(row, i));
	        rows = rows.concat(row[props.childrenColumnName] || []);
	      }
	    } else {
	      expandedRowKeys = props.expandedRowKeys || props.defaultExpandedRowKeys;
	    }
	    _this.state = {
	      expandedRowKeys: expandedRowKeys,
	      currentHoverKey: null,
	      fixedColumnsHeadRowsHeight: [],
	      fixedColumnsBodyRowsHeight: []
	    };
	    return _this;
	  }
	
	  (0, _createClass3['default'])(Table, [{
	    key: 'componentDidMount',
	    value: function componentDidMount() {
	      if (this.columnManager.isAnyColumnsFixed()) {
	        this.handleWindowResize();
	        this.debouncedWindowResize = (0, _utils.debounce)(this.handleWindowResize, 150);
	        this.resizeEvent = (0, _addEventListener2['default'])(window, 'resize', this.debouncedWindowResize);
	      }
	    }
	  }, {
	    key: 'componentWillReceiveProps',
	    value: function componentWillReceiveProps(nextProps) {
	      if ('expandedRowKeys' in nextProps) {
	        this.setState({
	          expandedRowKeys: nextProps.expandedRowKeys
	        });
	      }
	      if (nextProps.columns && nextProps.columns !== this.props.columns) {
	        this.columnManager.reset(nextProps.columns);
	      } else if (nextProps.children !== this.props.children) {
	        this.columnManager.reset(null, nextProps.children);
	      }
	    }
	  }, {
	    key: 'componentDidUpdate',
	    value: function componentDidUpdate(prevProps) {
	      if (this.columnManager.isAnyColumnsFixed()) {
	        this.handleWindowResize();
	      }
	      // when table changes to empty, reset scrollLeft
	      if (prevProps.data.length > 0 && this.props.data.length === 0 && this.hasScrollX()) {
	        this.resetScrollX();
	      }
	    }
	  }, {
	    key: 'componentWillUnmount',
	    value: function componentWillUnmount() {
	      if (this.resizeEvent) {
	        this.resizeEvent.remove();
	      }
	      if (this.debouncedWindowResize) {
	        this.debouncedWindowResize.cancel();
	      }
	    }
	  }, {
	    key: 'onExpandedRowsChange',
	    value: function onExpandedRowsChange(expandedRowKeys) {
	      if (!this.props.expandedRowKeys) {
	        this.setState({ expandedRowKeys: expandedRowKeys });
	      }
	      this.props.onExpandedRowsChange(expandedRowKeys);
	    }
	  }, {
	    key: 'getRowKey',
	    value: function getRowKey(record, index) {
	      var rowKey = this.props.rowKey;
	      var key = typeof rowKey === 'function' ? rowKey(record, index) : record[rowKey];
	      (0, _utils.warningOnce)(key !== undefined, 'Each record in table should have a unique `key` prop,' + 'or set `rowKey` to an unique primary key.');
	      return key === undefined ? index : key;
	    }
	  }, {
	    key: 'getExpandedRows',
	    value: function getExpandedRows() {
	      return this.props.expandedRowKeys || this.state.expandedRowKeys;
	    }
	  }, {
	    key: 'getHeader',
	    value: function getHeader(columns, fixed) {
	      var _props = this.props,
	          showHeader = _props.showHeader,
	          expandIconAsCell = _props.expandIconAsCell,
	          prefixCls = _props.prefixCls;
	
	      var rows = this.getHeaderRows(columns);
	
	      if (expandIconAsCell && fixed !== 'right') {
	        rows[0].unshift({
	          key: 'rc-table-expandIconAsCell',
	          className: prefixCls + '-expand-icon-th',
	          title: '',
	          rowSpan: rows.length
	        });
	      }
	
	      var trStyle = fixed ? this.getHeaderRowStyle(columns, rows) : null;
	
	      return showHeader ? _react2['default'].createElement(_TableHeader2['default'], {
	        prefixCls: prefixCls,
	        rows: rows,
	        rowStyle: trStyle
	      }) : null;
	    }
	  }, {
	    key: 'getHeaderRows',
	    value: function getHeaderRows(columns) {
	      var _this2 = this;
	
	      var currentRow = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
	      var rows = arguments[2];
	
	      rows = rows || [];
	      rows[currentRow] = rows[currentRow] || [];
	
	      columns.forEach(function (column) {
	        if (column.rowSpan && rows.length < column.rowSpan) {
	          while (rows.length < column.rowSpan) {
	            rows.push([]);
	          }
	        }
	        var cell = {
	          key: column.key,
	          className: column.className || '',
	          children: column.title
	        };
	        if (column.children) {
	          _this2.getHeaderRows(column.children, currentRow + 1, rows);
	        }
	        if ('colSpan' in column) {
	          cell.colSpan = column.colSpan;
	        }
	        if ('rowSpan' in column) {
	          cell.rowSpan = column.rowSpan;
	        }
	        if (cell.colSpan !== 0) {
	          rows[currentRow].push(cell);
	        }
	      });
	      return rows.filter(function (row) {
	        return row.length > 0;
	      });
	    }
	  }, {
	    key: 'getExpandedRow',
	    value: function getExpandedRow(key, content, visible, className, fixed) {
	      var _props2 = this.props,
	          prefixCls = _props2.prefixCls,
	          expandIconAsCell = _props2.expandIconAsCell;
	
	      var colCount = void 0;
	      if (fixed === 'left') {
	        colCount = this.columnManager.leftLeafColumns().length;
	      } else if (fixed === 'right') {
	        colCount = this.columnManager.rightLeafColumns().length;
	      } else {
	        colCount = this.columnManager.leafColumns().length;
	      }
	      var columns = [{
	        key: 'extra-row',
	        render: function render() {
	          return {
	            props: {
	              colSpan: colCount
	            },
	            children: fixed !== 'right' ? content : '&nbsp;'
	          };
	        }
	      }];
	      if (expandIconAsCell && fixed !== 'right') {
	        columns.unshift({
	          key: 'expand-icon-placeholder',
	          render: function render() {
	            return null;
	          }
	        });
	      }
	      return _react2['default'].createElement(_TableRow2['default'], {
	        columns: columns,
	        visible: visible,
	        className: className,
	        key: key + '-extra-row',
	        rowKey: key + '-extra-row',
	        prefixCls: prefixCls + '-expanded-row',
	        indent: 1,
	        expandable: false,
	        store: this.store,
	        expandedRow: true,
	        fixed: !!fixed
	      });
	    }
	  }, {
	    key: 'getRowsByData',
	    value: function getRowsByData(originalData, visible, indent, columns, fixed) {
	      var props = this.props;
	      var childrenColumnName = props.childrenColumnName,
	          expandedRowRender = props.expandedRowRender,
	          expandRowByClick = props.expandRowByClick,
	          rowClassName = props.rowClassName,
	          rowRef = props.rowRef,
	          expandedRowClassName = props.expandedRowClassName,
	          onRowClick = props.onRowClick,
	          onRowDoubleClick = props.onRowDoubleClick,
	          onRowContextMenu = props.onRowContextMenu,
	          onRowMouseEnter = props.onRowMouseEnter,
	          onRowMouseLeave = props.onRowMouseLeave;
	      var fixedColumnsBodyRowsHeight = this.state.fixedColumnsBodyRowsHeight;
	
	      var rst = [];
	      var needIndentSpaced = props.data.some(function (record) {
	        return record[childrenColumnName];
	      });
	
	      var expandIconAsCell = fixed !== 'right' ? props.expandIconAsCell : false;
	      var expandIconColumnIndex = fixed !== 'right' ? props.expandIconColumnIndex : -1;
	      var data = originalData;
	      for (var i = 0; i < data.length; i++) {
	        var record = data[i];
	        var key = this.getRowKey(record, i);
	        var childrenColumn = record[childrenColumnName];
	        var isRowExpanded = this.isRowExpanded(record, i);
	        var expandedRowContent = void 0;
	        if (expandedRowRender && isRowExpanded) {
	          expandedRowContent = expandedRowRender(record, i, indent);
	        }
	        var className = rowClassName(record, i, indent);
	
	        var onHoverProps = {};
	        if (this.columnManager.isAnyColumnsFixed()) {
	          onHoverProps.onHover = this.handleRowHover;
	        }
	
	        var height = fixed && fixedColumnsBodyRowsHeight[i] ? fixedColumnsBodyRowsHeight[i] : null;
	
	        var leafColumns = void 0;
	        if (fixed === 'left') {
	          leafColumns = this.columnManager.leftLeafColumns();
	        } else if (fixed === 'right') {
	          leafColumns = this.columnManager.rightLeafColumns();
	        } else {
	          leafColumns = this.columnManager.leafColumns();
	        }
	
	        rst.push(_react2['default'].createElement(_TableRow2['default'], (0, _extends3['default'])({
	          indent: indent,
	          indentSize: props.indentSize,
	          needIndentSpaced: needIndentSpaced,
	          className: className,
	          record: record,
	          expandIconAsCell: expandIconAsCell,
	          onDestroy: this.onRowDestroy,
	          index: i,
	          visible: visible,
	          expandRowByClick: expandRowByClick,
	          onExpand: this.onExpanded,
	          expandable: childrenColumn || expandedRowRender,
	          expanded: isRowExpanded,
	          prefixCls: props.prefixCls + '-row',
	          childrenColumnName: childrenColumnName,
	          columns: leafColumns,
	          expandIconColumnIndex: expandIconColumnIndex,
	          onRowClick: onRowClick,
	          onRowDoubleClick: onRowDoubleClick,
	          onRowContextMenu: onRowContextMenu,
	          onRowMouseEnter: onRowMouseEnter,
	          onRowMouseLeave: onRowMouseLeave,
	          height: height
	        }, onHoverProps, {
	          key: key,
	          hoverKey: key,
	          ref: rowRef(record, i, indent),
	          store: this.store
	        })));
	
	        var subVisible = visible && isRowExpanded;
	
	        if (expandedRowContent && isRowExpanded) {
	          rst.push(this.getExpandedRow(key, expandedRowContent, subVisible, expandedRowClassName(record, i, indent), fixed));
	        }
	        if (childrenColumn) {
	          rst = rst.concat(this.getRowsByData(childrenColumn, subVisible, indent + 1, columns, fixed));
	        }
	      }
	      return rst;
	    }
	  }, {
	    key: 'getRows',
	    value: function getRows(columns, fixed) {
	      return this.getRowsByData(this.props.data, true, 0, columns, fixed);
	    }
	  }, {
	    key: 'getColGroup',
	    value: function getColGroup(columns, fixed) {
	      var cols = [];
	      if (this.props.expandIconAsCell && fixed !== 'right') {
	        cols.push(_react2['default'].createElement('col', {
	          className: this.props.prefixCls + '-expand-icon-col',
	          key: 'rc-table-expand-icon-col'
	        }));
	      }
	      var leafColumns = void 0;
	      if (fixed === 'left') {
	        leafColumns = this.columnManager.leftLeafColumns();
	      } else if (fixed === 'right') {
	        leafColumns = this.columnManager.rightLeafColumns();
	      } else {
	        leafColumns = this.columnManager.leafColumns();
	      }
	      cols = cols.concat(leafColumns.map(function (c) {
	        return _react2['default'].createElement('col', { key: c.key || c.dataIndex, style: { width: c.width, minWidth: c.width } });
	      }));
	      return _react2['default'].createElement(
	        'colgroup',
	        null,
	        cols
	      );
	    }
	  }, {
	    key: 'getLeftFixedTable',
	    value: function getLeftFixedTable() {
	      return this.getTable({
	        columns: this.columnManager.leftColumns(),
	        fixed: 'left'
	      });
	    }
	  }, {
	    key: 'getRightFixedTable',
	    value: function getRightFixedTable() {
	      return this.getTable({
	        columns: this.columnManager.rightColumns(),
	        fixed: 'right'
	      });
	    }
	  }, {
	    key: 'getTable',
	    value: function getTable() {
	      var _this3 = this;
	
	      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
	      var columns = options.columns,
	          fixed = options.fixed;
	      var _props3 = this.props,
	          prefixCls = _props3.prefixCls,
	          _props3$scroll = _props3.scroll,
	          scroll = _props3$scroll === undefined ? {} : _props3$scroll,
	          getBodyWrapper = _props3.getBodyWrapper,
	          showHeader = _props3.showHeader;
	      var useFixedHeader = this.props.useFixedHeader;
	
	      var bodyStyle = (0, _extends3['default'])({}, this.props.bodyStyle);
	      var headStyle = {};
	
	      var tableClassName = '';
	      if (scroll.x || fixed) {
	        tableClassName = prefixCls + '-fixed';
	        bodyStyle.overflowX = bodyStyle.overflowX || 'auto';
	        // Fix weired webkit render bug
	        // https://github.com/ant-design/ant-design/issues/7783
	        bodyStyle.WebkitTransform = 'translate3d (0, 0, 0)';
	      }
	
	      var innerBodyStyle = {};
	      if (scroll.y) {
	        // maxHeight will make fixed-Table scrolling not working
	        // so we only set maxHeight to body-Table here
	        if (fixed) {
	          innerBodyStyle.maxHeight = bodyStyle.maxHeight || scroll.y;
	          innerBodyStyle.overflowY = bodyStyle.overflowY || 'scroll';
	        } else {
	          bodyStyle.maxHeight = bodyStyle.maxHeight || scroll.y;
	        }
	        bodyStyle.overflowY = bodyStyle.overflowY || 'scroll';
	        useFixedHeader = true;
	
	        // Add negative margin bottom for scroll bar overflow bug
	        var scrollbarWidth = (0, _utils.measureScrollbar)();
	        if (scrollbarWidth > 0) {
	          (fixed ? bodyStyle : headStyle).marginBottom = '-' + scrollbarWidth + 'px';
	          (fixed ? bodyStyle : headStyle).paddingBottom = '0px';
	        }
	      }
	
	      var renderTable = function renderTable() {
	        var hasHead = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
	        var hasBody = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
	
	        var tableStyle = {};
	        if (!fixed && scroll.x) {
	          // not set width, then use content fixed width
	          if (scroll.x === true) {
	            tableStyle.tableLayout = 'fixed';
	          } else {
	            tableStyle.width = scroll.x;
	          }
	        }
	        var tableBody = hasBody ? getBodyWrapper(_react2['default'].createElement(
	          'tbody',
	          { className: prefixCls + '-tbody' },
	          _this3.getRows(columns, fixed)
	        )) : null;
	        return _react2['default'].createElement(
	          'table',
	          { className: tableClassName, style: tableStyle, key: 'table' },
	          _this3.getColGroup(columns, fixed),
	          hasHead ? _this3.getHeader(columns, fixed) : null,
	          tableBody
	        );
	      };
	
	      var headTable = void 0;
	
	      if (useFixedHeader && showHeader) {
	        headTable = _react2['default'].createElement(
	          'div',
	          {
	            key: 'headTable',
	            className: prefixCls + '-header',
	            ref: fixed ? null : 'headTable',
	            style: headStyle,
	            onScroll: this.handleBodyScrollLeft
	          },
	          renderTable(true, false)
	        );
	      }
	
	      var bodyTable = _react2['default'].createElement(
	        'div',
	        {
	          key: 'bodyTable',
	          className: prefixCls + '-body',
	          style: bodyStyle,
	          ref: 'bodyTable',
	          onScroll: this.handleBodyScroll
	        },
	        renderTable(!useFixedHeader)
	      );
	
	      if (fixed && columns.length) {
	        var refName = void 0;
	        if (columns[0].fixed === 'left' || columns[0].fixed === true) {
	          refName = 'fixedColumnsBodyLeft';
	        } else if (columns[0].fixed === 'right') {
	          refName = 'fixedColumnsBodyRight';
	        }
	        delete bodyStyle.overflowX;
	        delete bodyStyle.overflowY;
	        bodyTable = _react2['default'].createElement(
	          'div',
	          {
	            key: 'bodyTable',
	            className: prefixCls + '-body-outer',
	            style: (0, _extends3['default'])({}, bodyStyle)
	          },
	          _react2['default'].createElement(
	            'div',
	            {
	              className: prefixCls + '-body-inner',
	              style: innerBodyStyle,
	              ref: refName,
	              onScroll: this.handleBodyScroll
	            },
	            renderTable(!useFixedHeader)
	          )
	        );
	      }
	      return [headTable, bodyTable];
	    }
	  }, {
	    key: 'getTitle',
	    value: function getTitle() {
	      var _props4 = this.props,
	          title = _props4.title,
	          prefixCls = _props4.prefixCls;
	
	      return title ? _react2['default'].createElement(
	        'div',
	        { className: prefixCls + '-title', key: 'title' },
	        title(this.props.data)
	      ) : null;
	    }
	  }, {
	    key: 'getFooter',
	    value: function getFooter() {
	      var _props5 = this.props,
	          footer = _props5.footer,
	          prefixCls = _props5.prefixCls;
	
	      return footer ? _react2['default'].createElement(
	        'div',
	        { className: prefixCls + '-footer', key: 'footer' },
	        footer(this.props.data)
	      ) : null;
	    }
	  }, {
	    key: 'getEmptyText',
	    value: function getEmptyText() {
	      var _props6 = this.props,
	          emptyText = _props6.emptyText,
	          prefixCls = _props6.prefixCls,
	          data = _props6.data;
	
	      if (data.length) {
	        return null;
	      }
	      var emptyClassName = prefixCls + '-placeholder';
	      return _react2['default'].createElement(
	        'div',
	        { className: emptyClassName, key: 'emptyText' },
	        typeof emptyText === 'function' ? emptyText() : emptyText
	      );
	    }
	  }, {
	    key: 'getHeaderRowStyle',
	    value: function getHeaderRowStyle(columns, rows) {
	      var fixedColumnsHeadRowsHeight = this.state.fixedColumnsHeadRowsHeight;
	
	      var headerHeight = fixedColumnsHeadRowsHeight[0];
	      if (headerHeight && columns) {
	        if (headerHeight === 'auto') {
	          return { height: 'auto' };
	        }
	        return { height: headerHeight / rows.length };
	      }
	      return null;
	    }
	  }, {
	    key: 'setScrollPosition',
	    value: function setScrollPosition(position) {
	      this.scrollPosition = position;
	      if (this.tableNode) {
	        var prefixCls = this.props.prefixCls;
	
	        if (position === 'both') {
	          (0, _componentClasses2['default'])(this.tableNode).remove(new RegExp('^' + prefixCls + '-scroll-position-.+$')).add(prefixCls + '-scroll-position-left').add(prefixCls + '-scroll-position-right');
	        } else {
	          (0, _componentClasses2['default'])(this.tableNode).remove(new RegExp('^' + prefixCls + '-scroll-position-.+$')).add(prefixCls + '-scroll-position-' + position);
	        }
	      }
	    }
	  }, {
	    key: 'setScrollPositionClassName',
	    value: function setScrollPositionClassName() {
	      var node = this.refs.bodyTable;
	      var scrollToLeft = node.scrollLeft === 0;
	      var scrollToRight = node.scrollLeft + 1 >= node.children[0].getBoundingClientRect().width - node.getBoundingClientRect().width;
	      if (scrollToLeft && scrollToRight) {
	        this.setScrollPosition('both');
	      } else if (scrollToLeft) {
	        this.setScrollPosition('left');
	      } else if (scrollToRight) {
	        this.setScrollPosition('right');
	      } else if (this.scrollPosition !== 'middle') {
	        this.setScrollPosition('middle');
	      }
	    }
	  }, {
	    key: 'resetScrollX',
	    value: function resetScrollX() {
	      if (this.refs.headTable) {
	        this.refs.headTable.scrollLeft = 0;
	      }
	      if (this.refs.bodyTable) {
	        this.refs.bodyTable.scrollLeft = 0;
	      }
	    }
	  }, {
	    key: 'findExpandedRow',
	    value: function findExpandedRow(record, index) {
	      var _this4 = this;
	
	      var rows = this.getExpandedRows().filter(function (i) {
	        return i === _this4.getRowKey(record, index);
	      });
	      return rows[0];
	    }
	  }, {
	    key: 'isRowExpanded',
	    value: function isRowExpanded(record, index) {
	      return typeof this.findExpandedRow(record, index) !== 'undefined';
	    }
	  }, {
	    key: 'hasScrollX',
	    value: function hasScrollX() {
	      var _props$scroll = this.props.scroll,
	          scroll = _props$scroll === undefined ? {} : _props$scroll;
	
	      return 'x' in scroll;
	    }
	  }, {
	    key: 'render',
	    value: function render() {
	      var _this5 = this;
	
	      var props = this.props;
	      var prefixCls = props.prefixCls;
	
	      var className = props.prefixCls;
	      if (props.className) {
	        className += ' ' + props.className;
	      }
	      if (props.useFixedHeader || props.scroll && props.scroll.y) {
	        className += ' ' + prefixCls + '-fixed-header';
	      }
	      if (this.scrollPosition === 'both') {
	        className += ' ' + prefixCls + '-scroll-position-left ' + prefixCls + '-scroll-position-right';
	      } else {
	        className += ' ' + prefixCls + '-scroll-position-' + this.scrollPosition;
	      }
	
	      var isTableScroll = this.columnManager.isAnyColumnsFixed() || props.scroll.x || props.scroll.y;
	
	      var content = [this.getTable({ columns: this.columnManager.groupedColumns() }), this.getEmptyText(), this.getFooter()];
	
	      var scrollTable = isTableScroll ? _react2['default'].createElement(
	        'div',
	        { className: prefixCls + '-scroll' },
	        content
	      ) : content;
	
	      return _react2['default'].createElement(
	        'div',
	        { ref: function ref(node) {
	            return _this5.tableNode = node;
	          }, className: className, style: props.style },
	        this.getTitle(),
	        _react2['default'].createElement(
	          'div',
	          { className: prefixCls + '-content' },
	          scrollTable,
	          this.columnManager.isAnyColumnsLeftFixed() && _react2['default'].createElement(
	            'div',
	            { className: prefixCls + '-fixed-left' },
	            this.getLeftFixedTable()
	          ),
	          this.columnManager.isAnyColumnsRightFixed() && _react2['default'].createElement(
	            'div',
	            { className: prefixCls + '-fixed-right' },
	            this.getRightFixedTable()
	          )
	        )
	      );
	    }
	  }]);
	  return Table;
	}(_react2['default'].Component);
	
	Table.propTypes = {
	  data: _propTypes2['default'].array,
	  expandIconAsCell: _propTypes2['default'].bool,
	  defaultExpandAllRows: _propTypes2['default'].bool,
	  expandedRowKeys: _propTypes2['default'].array,
	  defaultExpandedRowKeys: _propTypes2['default'].array,
	  useFixedHeader: _propTypes2['default'].bool,
	  columns: _propTypes2['default'].array,
	  prefixCls: _propTypes2['default'].string,
	  bodyStyle: _propTypes2['default'].object,
	  style: _propTypes2['default'].object,
	  rowKey: _propTypes2['default'].oneOfType([_propTypes2['default'].string, _propTypes2['default'].func]),
	  rowClassName: _propTypes2['default'].func,
	  expandedRowClassName: _propTypes2['default'].func,
	  childrenColumnName: _propTypes2['default'].string,
	  onExpand: _propTypes2['default'].func,
	  onExpandedRowsChange: _propTypes2['default'].func,
	  indentSize: _propTypes2['default'].number,
	  onRowClick: _propTypes2['default'].func,
	  onRowDoubleClick: _propTypes2['default'].func,
	  onRowContextMenu: _propTypes2['default'].func,
	  onRowMouseEnter: _propTypes2['default'].func,
	  onRowMouseLeave: _propTypes2['default'].func,
	  expandIconColumnIndex: _propTypes2['default'].number,
	  showHeader: _propTypes2['default'].bool,
	  title: _propTypes2['default'].func,
	  footer: _propTypes2['default'].func,
	  emptyText: _propTypes2['default'].oneOfType([_propTypes2['default'].node, _propTypes2['default'].func]),
	  scroll: _propTypes2['default'].object,
	  rowRef: _propTypes2['default'].func,
	  getBodyWrapper: _propTypes2['default'].func,
	  children: _propTypes2['default'].node
	};
	Table.defaultProps = {
	  data: [],
	  useFixedHeader: false,
	  expandIconAsCell: false,
	  defaultExpandAllRows: false,
	  defaultExpandedRowKeys: [],
	  rowKey: 'key',
	  rowClassName: function rowClassName() {
	    return '';
	  },
	  expandedRowClassName: function expandedRowClassName() {
	    return '';
	  },
	  onExpand: function onExpand() {},
	  onExpandedRowsChange: function onExpandedRowsChange() {},
	  onRowClick: function onRowClick() {},
	  onRowDoubleClick: function onRowDoubleClick() {},
	  onRowContextMenu: function onRowContextMenu() {},
	  onRowMouseEnter: function onRowMouseEnter() {},
	  onRowMouseLeave: function onRowMouseLeave() {},
	
	  prefixCls: 'rc-table',
	  bodyStyle: {},
	  style: {},
	  childrenColumnName: 'children',
	  indentSize: 15,
	  expandIconColumnIndex: 0,
	  showHeader: true,
	  scroll: {},
	  rowRef: function rowRef() {
	    return null;
	  },
	  getBodyWrapper: function getBodyWrapper(body) {
	    return body;
	  },
	  emptyText: function emptyText() {
	    return 'No Data';
	  }
	};
	exports['default'] = Table;
	module.exports = exports['default'];

/***/ }),
/* 751 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _lodash = __webpack_require__(577);
	
	var _lodash2 = _interopRequireDefault(_lodash);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var TableCell = function (_React$Component) {
	  (0, _inherits3['default'])(TableCell, _React$Component);
	
	  function TableCell() {
	    var _ref;
	
	    var _temp, _this, _ret;
	
	    (0, _classCallCheck3['default'])(this, TableCell);
	
	    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
	      args[_key] = arguments[_key];
	    }
	
	    return _ret = (_temp = (_this = (0, _possibleConstructorReturn3['default'])(this, (_ref = TableCell.__proto__ || Object.getPrototypeOf(TableCell)).call.apply(_ref, [this].concat(args))), _this), _this.handleClick = function (e) {
	      var _this$props = _this.props,
	          record = _this$props.record,
	          onCellClick = _this$props.column.onCellClick;
	
	      if (onCellClick) {
	        onCellClick(record, e);
	      }
	    }, _temp), (0, _possibleConstructorReturn3['default'])(_this, _ret);
	  }
	
	  (0, _createClass3['default'])(TableCell, [{
	    key: 'isInvalidRenderCellText',
	    value: function isInvalidRenderCellText(text) {
	      return text && !_react2['default'].isValidElement(text) && Object.prototype.toString.call(text) === '[object Object]';
	    }
	  }, {
	    key: 'render',
	    value: function render() {
	      var _props = this.props,
	          record = _props.record,
	          indentSize = _props.indentSize,
	          prefixCls = _props.prefixCls,
	          indent = _props.indent,
	          index = _props.index,
	          expandIcon = _props.expandIcon,
	          column = _props.column;
	      var dataIndex = column.dataIndex,
	          render = column.render,
	          _column$className = column.className,
	          className = _column$className === undefined ? '' : _column$className;
	
	      // We should return undefined if no dataIndex is specified, but in order to
	      // be compatible with object-path's behavior, we return the record object instead.
	
	      var text = void 0;
	      if (typeof dataIndex === 'number') {
	        text = (0, _lodash2['default'])(record, dataIndex);
	      } else if (!dataIndex || dataIndex.length === 0) {
	        text = record;
	      } else {
	        text = (0, _lodash2['default'])(record, dataIndex);
	      }
	      var tdProps = void 0;
	      var colSpan = void 0;
	      var rowSpan = void 0;
	
	      if (render) {
	        text = render(text, record, index);
	        if (this.isInvalidRenderCellText(text)) {
	          tdProps = text.props || {};
	          colSpan = tdProps.colSpan;
	          rowSpan = tdProps.rowSpan;
	          text = text.children;
	        }
	      }
	
	      // Fix https://github.com/ant-design/ant-design/issues/1202
	      if (this.isInvalidRenderCellText(text)) {
	        text = null;
	      }
	
	      var indentText = expandIcon ? _react2['default'].createElement('span', {
	        style: { paddingLeft: indentSize * indent + 'px' },
	        className: prefixCls + '-indent indent-level-' + indent
	      }) : null;
	
	      if (rowSpan === 0 || colSpan === 0) {
	        return null;
	      }
	      return _react2['default'].createElement(
	        'td',
	        (0, _extends3['default'])({
	          className: className
	        }, tdProps, {
	          onClick: this.handleClick
	        }),
	        indentText,
	        expandIcon,
	        text
	      );
	    }
	  }]);
	  return TableCell;
	}(_react2['default'].Component);
	
	TableCell.propTypes = {
	  record: _propTypes2['default'].object,
	  prefixCls: _propTypes2['default'].string,
	  index: _propTypes2['default'].number,
	  indent: _propTypes2['default'].number,
	  indentSize: _propTypes2['default'].number,
	  column: _propTypes2['default'].object,
	  expandIcon: _propTypes2['default'].node
	};
	exports['default'] = TableCell;
	module.exports = exports['default'];

/***/ }),
/* 752 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _shallowequal = __webpack_require__(150);
	
	var _shallowequal2 = _interopRequireDefault(_shallowequal);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var TableHeader = function (_React$Component) {
	  (0, _inherits3['default'])(TableHeader, _React$Component);
	
	  function TableHeader() {
	    (0, _classCallCheck3['default'])(this, TableHeader);
	    return (0, _possibleConstructorReturn3['default'])(this, (TableHeader.__proto__ || Object.getPrototypeOf(TableHeader)).apply(this, arguments));
	  }
	
	  (0, _createClass3['default'])(TableHeader, [{
	    key: 'shouldComponentUpdate',
	    value: function shouldComponentUpdate(nextProps) {
	      return !(0, _shallowequal2['default'])(nextProps, this.props);
	    }
	  }, {
	    key: 'render',
	    value: function render() {
	      var _props = this.props,
	          prefixCls = _props.prefixCls,
	          rowStyle = _props.rowStyle,
	          rows = _props.rows;
	
	      return _react2['default'].createElement(
	        'thead',
	        { className: prefixCls + '-thead' },
	        rows.map(function (row, index) {
	          return _react2['default'].createElement(
	            'tr',
	            { key: index, style: rowStyle },
	            row.map(function (cellProps, i) {
	              return _react2['default'].createElement('th', (0, _extends3['default'])({}, cellProps, { key: i }));
	            })
	          );
	        })
	      );
	    }
	  }]);
	  return TableHeader;
	}(_react2['default'].Component);
	
	TableHeader.propTypes = {
	  prefixCls: _propTypes2['default'].string,
	  rowStyle: _propTypes2['default'].object,
	  rows: _propTypes2['default'].array
	};
	exports['default'] = TableHeader;
	module.exports = exports['default'];

/***/ }),
/* 753 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _TableCell = __webpack_require__(751);
	
	var _TableCell2 = _interopRequireDefault(_TableCell);
	
	var _ExpandIcon = __webpack_require__(749);
	
	var _ExpandIcon2 = _interopRequireDefault(_ExpandIcon);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var TableRow = function (_React$Component) {
	  (0, _inherits3['default'])(TableRow, _React$Component);
	
	  function TableRow() {
	    var _ref;
	
	    var _temp, _this, _ret;
	
	    (0, _classCallCheck3['default'])(this, TableRow);
	
	    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
	      args[_key] = arguments[_key];
	    }
	
	    return _ret = (_temp = (_this = (0, _possibleConstructorReturn3['default'])(this, (_ref = TableRow.__proto__ || Object.getPrototypeOf(TableRow)).call.apply(_ref, [this].concat(args))), _this), _this.state = {
	      hovered: false,
	      height: null
	    }, _this.onRowClick = function (event) {
	      var _this$props = _this.props,
	          record = _this$props.record,
	          index = _this$props.index,
	          onRowClick = _this$props.onRowClick,
	          expandable = _this$props.expandable,
	          expandRowByClick = _this$props.expandRowByClick,
	          expanded = _this$props.expanded,
	          onExpand = _this$props.onExpand;
	
	      if (expandable && expandRowByClick) {
	        onExpand(!expanded, record, event, index);
	      }
	      onRowClick(record, index, event);
	    }, _this.onRowDoubleClick = function (event) {
	      var _this$props2 = _this.props,
	          record = _this$props2.record,
	          index = _this$props2.index,
	          onRowDoubleClick = _this$props2.onRowDoubleClick;
	
	      onRowDoubleClick(record, index, event);
	    }, _this.onContextMenu = function (event) {
	      var _this$props3 = _this.props,
	          record = _this$props3.record,
	          index = _this$props3.index,
	          onRowContextMenu = _this$props3.onRowContextMenu;
	
	      onRowContextMenu(record, index, event);
	    }, _this.onMouseEnter = function (event) {
	      var _this$props4 = _this.props,
	          record = _this$props4.record,
	          index = _this$props4.index,
	          onRowMouseEnter = _this$props4.onRowMouseEnter,
	          onHover = _this$props4.onHover,
	          hoverKey = _this$props4.hoverKey;
	
	      onHover(true, hoverKey);
	      onRowMouseEnter(record, index, event);
	    }, _this.onMouseLeave = function (event) {
	      var _this$props5 = _this.props,
	          record = _this$props5.record,
	          index = _this$props5.index,
	          onRowMouseLeave = _this$props5.onRowMouseLeave,
	          onHover = _this$props5.onHover,
	          hoverKey = _this$props5.hoverKey;
	
	      onHover(false, hoverKey);
	      onRowMouseLeave(record, index, event);
	    }, _temp), (0, _possibleConstructorReturn3['default'])(_this, _ret);
	  }
	
	  (0, _createClass3['default'])(TableRow, [{
	    key: 'componentDidMount',
	    value: function componentDidMount() {
	      var _this2 = this;
	
	      var store = this.props.store;
	
	      this.pushHeight();
	      this.pullHeight();
	      this.unsubscribe = store.subscribe(function () {
	        _this2.setHover();
	        _this2.pullHeight();
	      });
	    }
	  }, {
	    key: 'componentWillUnmount',
	    value: function componentWillUnmount() {
	      var _props = this.props,
	          record = _props.record,
	          onDestroy = _props.onDestroy,
	          index = _props.index;
	
	      onDestroy(record, index);
	      if (this.unsubscribe) {
	        this.unsubscribe();
	      }
	    }
	  }, {
	    key: 'setHover',
	    value: function setHover() {
	      var _props2 = this.props,
	          store = _props2.store,
	          hoverKey = _props2.hoverKey;
	
	      var _store$getState = store.getState(),
	          currentHoverKey = _store$getState.currentHoverKey;
	
	      if (currentHoverKey === hoverKey) {
	        this.setState({ hovered: true });
	      } else if (this.state.hovered === true) {
	        this.setState({ hovered: false });
	      }
	    }
	  }, {
	    key: 'pullHeight',
	    value: function pullHeight() {
	      var _props3 = this.props,
	          store = _props3.store,
	          expandedRow = _props3.expandedRow,
	          fixed = _props3.fixed,
	          rowKey = _props3.rowKey;
	
	      var _store$getState2 = store.getState(),
	          expandedRowsHeight = _store$getState2.expandedRowsHeight;
	
	      if (expandedRow && fixed && expandedRowsHeight[rowKey]) {
	        this.setState({ height: expandedRowsHeight[rowKey] });
	      }
	    }
	  }, {
	    key: 'pushHeight',
	    value: function pushHeight() {
	      var _props4 = this.props,
	          store = _props4.store,
	          expandedRow = _props4.expandedRow,
	          fixed = _props4.fixed,
	          rowKey = _props4.rowKey;
	
	      if (expandedRow && !fixed) {
	        var _store$getState3 = store.getState(),
	            expandedRowsHeight = _store$getState3.expandedRowsHeight;
	
	        var height = this.trRef.getBoundingClientRect().height;
	        expandedRowsHeight[rowKey] = height;
	        store.setState({ expandedRowsHeight: expandedRowsHeight });
	      }
	    }
	  }, {
	    key: 'render',
	    value: function render() {
	      var _this3 = this;
	
	      var _props5 = this.props,
	          prefixCls = _props5.prefixCls,
	          columns = _props5.columns,
	          record = _props5.record,
	          visible = _props5.visible,
	          index = _props5.index,
	          expandIconColumnIndex = _props5.expandIconColumnIndex,
	          expandIconAsCell = _props5.expandIconAsCell,
	          expanded = _props5.expanded,
	          expandRowByClick = _props5.expandRowByClick,
	          expandable = _props5.expandable,
	          onExpand = _props5.onExpand,
	          needIndentSpaced = _props5.needIndentSpaced,
	          indent = _props5.indent,
	          indentSize = _props5.indentSize;
	      var className = this.props.className;
	
	
	      if (this.state.hovered) {
	        className += ' ' + prefixCls + '-hover';
	      }
	
	      var cells = [];
	
	      var expandIcon = _react2['default'].createElement(_ExpandIcon2['default'], {
	        expandable: expandable,
	        prefixCls: prefixCls,
	        onExpand: onExpand,
	        needIndentSpaced: needIndentSpaced,
	        expanded: expanded,
	        record: record
	      });
	
	      for (var i = 0; i < columns.length; i++) {
	        if (expandIconAsCell && i === 0) {
	          cells.push(_react2['default'].createElement(
	            'td',
	            {
	              className: prefixCls + '-expand-icon-cell',
	              key: 'rc-table-expand-icon-cell'
	            },
	            expandIcon
	          ));
	        }
	        var isColumnHaveExpandIcon = expandIconAsCell || expandRowByClick ? false : i === expandIconColumnIndex;
	        cells.push(_react2['default'].createElement(_TableCell2['default'], {
	          prefixCls: prefixCls,
	          record: record,
	          indentSize: indentSize,
	          indent: indent,
	          index: index,
	          column: columns[i],
	          key: columns[i].key || columns[i].dataIndex,
	          expandIcon: isColumnHaveExpandIcon ? expandIcon : null
	        }));
	      }
	      var height = this.props.height || this.state.height;
	      var style = { height: height };
	      if (!visible) {
	        style.display = 'none';
	      }
	
	      var rowClassName = (prefixCls + ' ' + className + ' ' + prefixCls + '-level-' + indent).trim();
	
	      return _react2['default'].createElement(
	        'tr',
	        {
	          ref: function ref(node) {
	            return _this3.trRef = node;
	          },
	          onClick: this.onRowClick,
	          onDoubleClick: this.onRowDoubleClick,
	          onMouseEnter: this.onMouseEnter,
	          onMouseLeave: this.onMouseLeave,
	          onContextMenu: this.onContextMenu,
	          className: rowClassName,
	          style: style
	        },
	        cells
	      );
	    }
	  }]);
	  return TableRow;
	}(_react2['default'].Component);
	
	TableRow.propTypes = {
	  onDestroy: _propTypes2['default'].func,
	  onRowClick: _propTypes2['default'].func,
	  onRowDoubleClick: _propTypes2['default'].func,
	  onRowContextMenu: _propTypes2['default'].func,
	  onRowMouseEnter: _propTypes2['default'].func,
	  onRowMouseLeave: _propTypes2['default'].func,
	  record: _propTypes2['default'].object,
	  prefixCls: _propTypes2['default'].string,
	  expandIconColumnIndex: _propTypes2['default'].number,
	  onHover: _propTypes2['default'].func,
	  columns: _propTypes2['default'].array,
	  height: _propTypes2['default'].oneOfType([_propTypes2['default'].string, _propTypes2['default'].number]),
	  visible: _propTypes2['default'].bool,
	  index: _propTypes2['default'].number,
	  hoverKey: _propTypes2['default'].any,
	  expanded: _propTypes2['default'].bool,
	  expandable: _propTypes2['default'].any,
	  onExpand: _propTypes2['default'].func,
	  needIndentSpaced: _propTypes2['default'].bool,
	  className: _propTypes2['default'].string,
	  indent: _propTypes2['default'].number,
	  indentSize: _propTypes2['default'].number,
	  expandIconAsCell: _propTypes2['default'].bool,
	  expandRowByClick: _propTypes2['default'].bool,
	  store: _propTypes2['default'].object.isRequired,
	  expandedRow: _propTypes2['default'].bool,
	  fixed: _propTypes2['default'].bool,
	  rowKey: _propTypes2['default'].string
	};
	TableRow.defaultProps = {
	  onRowClick: function onRowClick() {},
	  onRowDoubleClick: function onRowDoubleClick() {},
	  onRowContextMenu: function onRowContextMenu() {},
	  onRowMouseEnter: function onRowMouseEnter() {},
	  onRowMouseLeave: function onRowMouseLeave() {},
	  onDestroy: function onDestroy() {},
	
	  expandIconColumnIndex: 0,
	  expandRowByClick: false,
	  onHover: function onHover() {}
	};
	exports['default'] = TableRow;
	module.exports = exports['default'];

/***/ }),
/* 754 */
/***/ (function(module, exports, __webpack_require__) {

	"use strict";
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	exports["default"] = createStore;
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
	
	function createStore(initialState) {
	  var state = initialState;
	  var listeners = [];
	
	  function setState(partial) {
	    state = (0, _extends3["default"])({}, state, partial);
	    for (var i = 0; i < listeners.length; i++) {
	      listeners[i]();
	    }
	  }
	
	  function getState() {
	    return state;
	  }
	
	  function subscribe(listener) {
	    listeners.push(listener);
	
	    return function unsubscribe() {
	      var index = listeners.indexOf(listener);
	      listeners.splice(index, 1);
	    };
	  }
	
	  return {
	    setState: setState,
	    getState: getState,
	    subscribe: subscribe
	  };
	}
	module.exports = exports['default'];

/***/ }),
/* 755 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.ColumnGroup = exports.Column = undefined;
	
	var _Table = __webpack_require__(750);
	
	var _Table2 = _interopRequireDefault(_Table);
	
	var _Column = __webpack_require__(746);
	
	var _Column2 = _interopRequireDefault(_Column);
	
	var _ColumnGroup = __webpack_require__(747);
	
	var _ColumnGroup2 = _interopRequireDefault(_ColumnGroup);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	_Table2['default'].Column = _Column2['default'];
	_Table2['default'].ColumnGroup = _ColumnGroup2['default'];
	
	exports['default'] = _Table2['default'];
	exports.Column = _Column2['default'];
	exports.ColumnGroup = _ColumnGroup2['default'];

/***/ }),
/* 756 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.measureScrollbar = measureScrollbar;
	exports.debounce = debounce;
	exports.warningOnce = warningOnce;
	
	var _warning = __webpack_require__(35);
	
	var _warning2 = _interopRequireDefault(_warning);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var scrollbarWidth = void 0;
	
	// Measure scrollbar width for padding body during modal show/hide
	var scrollbarMeasure = {
	  position: 'absolute',
	  top: '-9999px',
	  width: '50px',
	  height: '50px',
	  overflow: 'scroll'
	};
	
	function measureScrollbar() {
	  if (typeof document === 'undefined' || typeof window === 'undefined') {
	    return 0;
	  }
	  if (scrollbarWidth) {
	    return scrollbarWidth;
	  }
	  var scrollDiv = document.createElement('div');
	  for (var scrollProp in scrollbarMeasure) {
	    if (scrollbarMeasure.hasOwnProperty(scrollProp)) {
	      scrollDiv.style[scrollProp] = scrollbarMeasure[scrollProp];
	    }
	  }
	  document.body.appendChild(scrollDiv);
	  var width = scrollDiv.offsetWidth - scrollDiv.clientWidth;
	  document.body.removeChild(scrollDiv);
	  scrollbarWidth = width;
	  return scrollbarWidth;
	}
	
	function debounce(func, wait, immediate) {
	  var timeout = void 0;
	  function debounceFunc() {
	    var context = this;
	    var args = arguments;
	    // https://fb.me/react-event-pooling
	    if (args[0] && args[0].persist) {
	      args[0].persist();
	    }
	    var later = function later() {
	      timeout = null;
	      if (!immediate) {
	        func.apply(context, args);
	      }
	    };
	    var callNow = immediate && !timeout;
	    clearTimeout(timeout);
	    timeout = setTimeout(later, wait);
	    if (callNow) {
	      func.apply(context, args);
	    }
	  }
	  debounceFunc.cancel = function cancel() {
	    if (timeout) {
	      clearTimeout(timeout);
	      timeout = null;
	    }
	  };
	  return debounceFunc;
	}
	
	var warned = {};
	function warningOnce(condition, format, args) {
	  if (!warned[format]) {
	    (0, _warning2['default'])(condition, format, args);
	    warned[format] = !condition;
	  }
	}

/***/ }),
/* 757 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	exports.getScroll = getScroll;
	
	var _utils = __webpack_require__(66);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _classnames2 = __webpack_require__(8);
	
	var _classnames3 = _interopRequireDefault(_classnames2);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var isDev = ("development") !== 'production';
	
	function getScroll(w, top) {
	  var ret = w['page' + (top ? 'Y' : 'X') + 'Offset'];
	  var method = 'scroll' + (top ? 'Top' : 'Left');
	  if (typeof ret !== 'number') {
	    var d = w.document;
	    // ie6,7,8 standard mode
	    ret = d.documentElement[method];
	    if (typeof ret !== 'number') {
	      // quirks mode
	      ret = d.body[method];
	    }
	  }
	  return ret;
	}
	
	function offset(elem) {
	  var box = void 0;
	  var x = void 0;
	  var y = void 0;
	  var doc = elem.ownerDocument;
	  var body = doc.body;
	  var docElem = doc && doc.documentElement;
	  box = elem.getBoundingClientRect();
	  x = box.left;
	  y = box.top;
	  x -= docElem.clientLeft || body.clientLeft || 0;
	  y -= docElem.clientTop || body.clientTop || 0;
	  var w = doc.defaultView || doc.parentWindow;
	  x += getScroll(w);
	  y += getScroll(w, true);
	  return {
	    left: x, top: y
	  };
	}
	
	function _componentDidUpdate(component, init) {
	  var styles = component.props.styles;
	
	  var wrapNode = component.nav || component.root;
	  var containerOffset = offset(wrapNode);
	  var inkBarNode = component.inkBar;
	  var activeTab = component.activeTab;
	  var inkBarNodeStyle = inkBarNode.style;
	  var tabBarPosition = component.props.tabBarPosition;
	  if (init) {
	    // prevent mount animation
	    inkBarNodeStyle.display = 'none';
	  }
	  if (activeTab) {
	    var tabNode = activeTab;
	    var tabOffset = offset(tabNode);
	    var transformSupported = (0, _utils.isTransformSupported)(inkBarNodeStyle);
	    if (tabBarPosition === 'top' || tabBarPosition === 'bottom') {
	      var left = tabOffset.left - containerOffset.left;
	      var width = tabNode.offsetWidth;
	
	      // If tabNode'width width equal to wrapNode'width when tabBarPosition is top or bottom
	      // It means no css working, then ink bar should not have width until css is loaded
	      // Fix https://github.com/ant-design/ant-design/issues/7564
	      if (width === wrapNode.offsetWidth) {
	        width = 0;
	      } else if (styles.inkBar && styles.inkBar.width !== undefined) {
	        width = parseFloat(styles.inkBar.width, 10);
	        if (width) {
	          left = left + (tabNode.offsetWidth - width) / 2;
	        }
	      }
	      // use 3d gpu to optimize render
	      if (transformSupported) {
	        (0, _utils.setTransform)(inkBarNodeStyle, 'translate3d(' + left + 'px,0,0)');
	        inkBarNodeStyle.width = width + 'px';
	        inkBarNodeStyle.height = '';
	      } else {
	        inkBarNodeStyle.left = left + 'px';
	        inkBarNodeStyle.top = '';
	        inkBarNodeStyle.bottom = '';
	        inkBarNodeStyle.right = wrapNode.offsetWidth - left - width + 'px';
	      }
	    } else {
	      var top = tabOffset.top - containerOffset.top;
	      var height = tabNode.offsetHeight;
	      if (styles.inkBar && styles.inkBar.height !== undefined) {
	        height = parseFloat(styles.inkBar.height, 10);
	        if (height) {
	          top = top + (tabNode.offsetHeight - height) / 2;
	        }
	      }
	      if (transformSupported) {
	        (0, _utils.setTransform)(inkBarNodeStyle, 'translate3d(0,' + top + 'px,0)');
	        inkBarNodeStyle.height = height + 'px';
	        inkBarNodeStyle.width = '';
	      } else {
	        inkBarNodeStyle.left = '';
	        inkBarNodeStyle.right = '';
	        inkBarNodeStyle.top = top + 'px';
	        inkBarNodeStyle.bottom = wrapNode.offsetHeight - top - height + 'px';
	      }
	    }
	  }
	  inkBarNodeStyle.display = activeTab ? 'block' : 'none';
	}
	
	exports['default'] = {
	  getDefaultProps: function getDefaultProps() {
	    return {
	      inkBarAnimated: true
	    };
	  },
	  componentDidUpdate: function componentDidUpdate() {
	    _componentDidUpdate(this);
	  },
	  componentDidMount: function componentDidMount() {
	    var _this = this;
	
	    if (isDev) {
	      // https://github.com/ant-design/ant-design/issues/8678
	      this.timeout = setTimeout(function () {
	        _componentDidUpdate(_this, true);
	      }, 0);
	    } else {
	      _componentDidUpdate(this, true);
	    }
	  },
	  componentWillUnmount: function componentWillUnmount() {
	    clearTimeout(this.timeout);
	  },
	  getInkBarNode: function getInkBarNode() {
	    var _classnames;
	
	    var _props = this.props,
	        prefixCls = _props.prefixCls,
	        styles = _props.styles,
	        inkBarAnimated = _props.inkBarAnimated;
	
	    var className = prefixCls + '-ink-bar';
	    var classes = (0, _classnames3['default'])((_classnames = {}, (0, _defineProperty3['default'])(_classnames, className, true), (0, _defineProperty3['default'])(_classnames, inkBarAnimated ? className + '-animated' : className + '-no-animated', true), _classnames));
	    return _react2['default'].createElement('div', {
	      style: styles.inkBar,
	      className: classes,
	      key: 'inkBar',
	      ref: this.saveRef('inkBar')
	    });
	  }
	};

/***/ }),
/* 758 */
/***/ (function(module, exports) {

	"use strict";
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports["default"] = {
	  /**
	   * LEFT
	   */
	  LEFT: 37, // also NUM_WEST
	  /**
	   * UP
	   */
	  UP: 38, // also NUM_NORTH
	  /**
	   * RIGHT
	   */
	  RIGHT: 39, // also NUM_EAST
	  /**
	   * DOWN
	   */
	  DOWN: 40 // also NUM_SOUTH
	};
	module.exports = exports['default'];

/***/ }),
/* 759 */
/***/ (function(module, exports) {

	"use strict";
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports["default"] = {
	  saveRef: function saveRef(name) {
	    var _this = this;
	
	    return function (node) {
	      _this[name] = node;
	    };
	  }
	};
	module.exports = exports['default'];

/***/ }),
/* 760 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _createReactClass = __webpack_require__(14);
	
	var _createReactClass2 = _interopRequireDefault(_createReactClass);
	
	var _InkTabBarMixin = __webpack_require__(757);
	
	var _InkTabBarMixin2 = _interopRequireDefault(_InkTabBarMixin);
	
	var _ScrollableTabBarMixin = __webpack_require__(761);
	
	var _ScrollableTabBarMixin2 = _interopRequireDefault(_ScrollableTabBarMixin);
	
	var _TabBarMixin = __webpack_require__(762);
	
	var _TabBarMixin2 = _interopRequireDefault(_TabBarMixin);
	
	var _RefMixin = __webpack_require__(759);
	
	var _RefMixin2 = _interopRequireDefault(_RefMixin);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var ScrollableInkTabBar = (0, _createReactClass2['default'])({
	  displayName: 'ScrollableInkTabBar',
	  mixins: [_RefMixin2['default'], _TabBarMixin2['default'], _InkTabBarMixin2['default'], _ScrollableTabBarMixin2['default']],
	  render: function render() {
	    var inkBarNode = this.getInkBarNode();
	    var tabs = this.getTabs();
	    var scrollbarNode = this.getScrollBarNode([inkBarNode, tabs]);
	    return this.getRootNode(scrollbarNode);
	  }
	});
	
	exports['default'] = ScrollableInkTabBar;
	module.exports = exports['default'];

/***/ }),
/* 761 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _classnames5 = __webpack_require__(8);
	
	var _classnames6 = _interopRequireDefault(_classnames5);
	
	var _utils = __webpack_require__(66);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _addEventListener = __webpack_require__(34);
	
	var _addEventListener2 = _interopRequireDefault(_addEventListener);
	
	var _lodash = __webpack_require__(91);
	
	var _lodash2 = _interopRequireDefault(_lodash);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	exports['default'] = {
	  getDefaultProps: function getDefaultProps() {
	    return {
	      scrollAnimated: true,
	      onPrevClick: function onPrevClick() {},
	      onNextClick: function onNextClick() {}
	    };
	  },
	  getInitialState: function getInitialState() {
	    this.offset = 0;
	    return {
	      next: false,
	      prev: false
	    };
	  },
	  componentDidMount: function componentDidMount() {
	    var _this = this;
	
	    this.componentDidUpdate();
	    var debouncedResize = (0, _lodash2['default'])(function () {
	      _this.setNextPrev();
	      _this.scrollToActiveTab();
	    }, 200);
	    this.resizeEvent = (0, _addEventListener2['default'])(window, 'resize', debouncedResize);
	  },
	  componentDidUpdate: function componentDidUpdate(prevProps) {
	    var props = this.props;
	    if (prevProps && prevProps.tabBarPosition !== props.tabBarPosition) {
	      this.setOffset(0);
	      return;
	    }
	    var nextPrev = this.setNextPrev();
	    // wait next, prev show hide
	    /* eslint react/no-did-update-set-state:0 */
	    if (this.isNextPrevShown(this.state) !== this.isNextPrevShown(nextPrev)) {
	      this.setState({}, this.scrollToActiveTab);
	    } else if (!prevProps || props.activeKey !== prevProps.activeKey) {
	      // can not use props.activeKey
	      this.scrollToActiveTab();
	    }
	  },
	  componentWillUnmount: function componentWillUnmount() {
	    if (this.resizeEvent) {
	      this.resizeEvent.remove();
	    }
	  },
	  setNextPrev: function setNextPrev() {
	    var navNode = this.nav;
	    var navNodeWH = this.getOffsetWH(navNode);
	    var navWrapNode = this.navWrap;
	    var navWrapNodeWH = this.getOffsetWH(navWrapNode);
	    var offset = this.offset;
	
	    var minOffset = navWrapNodeWH - navNodeWH;
	    var _state = this.state,
	        next = _state.next,
	        prev = _state.prev;
	
	    if (minOffset >= 0) {
	      next = false;
	      this.setOffset(0, false);
	      offset = 0;
	    } else if (minOffset < offset) {
	      next = true;
	    } else {
	      next = false;
	      this.setOffset(minOffset, false);
	      offset = minOffset;
	    }
	
	    if (offset < 0) {
	      prev = true;
	    } else {
	      prev = false;
	    }
	
	    this.setNext(next);
	    this.setPrev(prev);
	    return {
	      next: next,
	      prev: prev
	    };
	  },
	  getOffsetWH: function getOffsetWH(node) {
	    var tabBarPosition = this.props.tabBarPosition;
	    var prop = 'offsetWidth';
	    if (tabBarPosition === 'left' || tabBarPosition === 'right') {
	      prop = 'offsetHeight';
	    }
	    return node[prop];
	  },
	  getOffsetLT: function getOffsetLT(node) {
	    var tabBarPosition = this.props.tabBarPosition;
	    var prop = 'left';
	    if (tabBarPosition === 'left' || tabBarPosition === 'right') {
	      prop = 'top';
	    }
	    return node.getBoundingClientRect()[prop];
	  },
	  setOffset: function setOffset(offset) {
	    var checkNextPrev = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
	
	    var target = Math.min(0, offset);
	    if (this.offset !== target) {
	      this.offset = target;
	      var navOffset = {};
	      var tabBarPosition = this.props.tabBarPosition;
	      var navStyle = this.nav.style;
	      var transformSupported = (0, _utils.isTransformSupported)(navStyle);
	      if (tabBarPosition === 'left' || tabBarPosition === 'right') {
	        if (transformSupported) {
	          navOffset = {
	            value: 'translate3d(0,' + target + 'px,0)'
	          };
	        } else {
	          navOffset = {
	            name: 'top',
	            value: target + 'px'
	          };
	        }
	      } else {
	        if (transformSupported) {
	          navOffset = {
	            value: 'translate3d(' + target + 'px,0,0)'
	          };
	        } else {
	          navOffset = {
	            name: 'left',
	            value: target + 'px'
	          };
	        }
	      }
	      if (transformSupported) {
	        (0, _utils.setTransform)(navStyle, navOffset.value);
	      } else {
	        navStyle[navOffset.name] = navOffset.value;
	      }
	      if (checkNextPrev) {
	        this.setNextPrev();
	      }
	    }
	  },
	  setPrev: function setPrev(v) {
	    if (this.state.prev !== v) {
	      this.setState({
	        prev: v
	      });
	    }
	  },
	  setNext: function setNext(v) {
	    if (this.state.next !== v) {
	      this.setState({
	        next: v
	      });
	    }
	  },
	  isNextPrevShown: function isNextPrevShown(state) {
	    if (state) {
	      return state.next || state.prev;
	    }
	    return this.state.next || this.state.prev;
	  },
	  prevTransitionEnd: function prevTransitionEnd(e) {
	    if (e.propertyName !== 'opacity') {
	      return;
	    }
	    var container = this.container;
	
	    this.scrollToActiveTab({
	      target: container,
	      currentTarget: container
	    });
	  },
	  scrollToActiveTab: function scrollToActiveTab(e) {
	    var activeTab = this.activeTab,
	        navWrap = this.navWrap;
	
	    if (e && e.target !== e.currentTarget || !activeTab) {
	      return;
	    }
	
	    // when not scrollable or enter scrollable first time, don't emit scrolling
	    var needToSroll = this.isNextPrevShown() && this.lastNextPrevShown;
	    this.lastNextPrevShown = this.isNextPrevShown();
	    if (!needToSroll) {
	      return;
	    }
	
	    var activeTabWH = this.getOffsetWH(activeTab);
	    var navWrapNodeWH = this.getOffsetWH(navWrap);
	    var offset = this.offset;
	
	    var wrapOffset = this.getOffsetLT(navWrap);
	    var activeTabOffset = this.getOffsetLT(activeTab);
	    if (wrapOffset > activeTabOffset) {
	      offset += wrapOffset - activeTabOffset;
	      this.setOffset(offset);
	    } else if (wrapOffset + navWrapNodeWH < activeTabOffset + activeTabWH) {
	      offset -= activeTabOffset + activeTabWH - (wrapOffset + navWrapNodeWH);
	      this.setOffset(offset);
	    }
	  },
	  prev: function prev(e) {
	    this.props.onPrevClick(e);
	    var navWrapNode = this.navWrap;
	    var navWrapNodeWH = this.getOffsetWH(navWrapNode);
	    var offset = this.offset;
	
	    this.setOffset(offset + navWrapNodeWH);
	  },
	  next: function next(e) {
	    this.props.onNextClick(e);
	    var navWrapNode = this.navWrap;
	    var navWrapNodeWH = this.getOffsetWH(navWrapNode);
	    var offset = this.offset;
	
	    this.setOffset(offset - navWrapNodeWH);
	  },
	  getScrollBarNode: function getScrollBarNode(content) {
	    var _classnames, _classnames2, _classnames3, _classnames4;
	
	    var _state2 = this.state,
	        next = _state2.next,
	        prev = _state2.prev;
	    var _props = this.props,
	        prefixCls = _props.prefixCls,
	        scrollAnimated = _props.scrollAnimated;
	
	    var showNextPrev = prev || next;
	
	    var prevButton = _react2['default'].createElement(
	      'span',
	      {
	        onClick: prev ? this.prev : null,
	        unselectable: 'unselectable',
	        className: (0, _classnames6['default'])((_classnames = {}, (0, _defineProperty3['default'])(_classnames, prefixCls + '-tab-prev', 1), (0, _defineProperty3['default'])(_classnames, prefixCls + '-tab-btn-disabled', !prev), (0, _defineProperty3['default'])(_classnames, prefixCls + '-tab-arrow-show', showNextPrev), _classnames)),
	        onTransitionEnd: this.prevTransitionEnd
	      },
	      _react2['default'].createElement('span', { className: prefixCls + '-tab-prev-icon' })
	    );
	
	    var nextButton = _react2['default'].createElement(
	      'span',
	      {
	        onClick: next ? this.next : null,
	        unselectable: 'unselectable',
	        className: (0, _classnames6['default'])((_classnames2 = {}, (0, _defineProperty3['default'])(_classnames2, prefixCls + '-tab-next', 1), (0, _defineProperty3['default'])(_classnames2, prefixCls + '-tab-btn-disabled', !next), (0, _defineProperty3['default'])(_classnames2, prefixCls + '-tab-arrow-show', showNextPrev), _classnames2))
	      },
	      _react2['default'].createElement('span', { className: prefixCls + '-tab-next-icon' })
	    );
	
	    var navClassName = prefixCls + '-nav';
	    var navClasses = (0, _classnames6['default'])((_classnames3 = {}, (0, _defineProperty3['default'])(_classnames3, navClassName, true), (0, _defineProperty3['default'])(_classnames3, scrollAnimated ? navClassName + '-animated' : navClassName + '-no-animated', true), _classnames3));
	
	    return _react2['default'].createElement(
	      'div',
	      {
	        className: (0, _classnames6['default'])((_classnames4 = {}, (0, _defineProperty3['default'])(_classnames4, prefixCls + '-nav-container', 1), (0, _defineProperty3['default'])(_classnames4, prefixCls + '-nav-container-scrolling', showNextPrev), _classnames4)),
	        key: 'container',
	        ref: this.saveRef('container')
	      },
	      prevButton,
	      nextButton,
	      _react2['default'].createElement(
	        'div',
	        { className: prefixCls + '-nav-wrap', ref: this.saveRef('navWrap') },
	        _react2['default'].createElement(
	          'div',
	          { className: prefixCls + '-nav-scroll' },
	          _react2['default'].createElement(
	            'div',
	            { className: navClasses, ref: this.saveRef('nav') },
	            content
	          )
	        )
	      )
	    );
	  }
	};
	module.exports = exports['default'];

/***/ }),
/* 762 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _objectWithoutProperties2 = __webpack_require__(20);
	
	var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _classnames2 = __webpack_require__(8);
	
	var _classnames3 = _interopRequireDefault(_classnames2);
	
	var _warning = __webpack_require__(35);
	
	var _warning2 = _interopRequireDefault(_warning);
	
	var _utils = __webpack_require__(66);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	exports['default'] = {
	  getDefaultProps: function getDefaultProps() {
	    return {
	      styles: {}
	    };
	  },
	  onTabClick: function onTabClick(key) {
	    this.props.onTabClick(key);
	  },
	  getTabs: function getTabs() {
	    var _this = this;
	
	    var _props = this.props,
	        children = _props.panels,
	        activeKey = _props.activeKey,
	        prefixCls = _props.prefixCls;
	
	    var rst = [];
	
	    _react2['default'].Children.forEach(children, function (child) {
	      if (!child) {
	        return;
	      }
	      var key = child.key;
	      var cls = activeKey === key ? prefixCls + '-tab-active' : '';
	      cls += ' ' + prefixCls + '-tab';
	      var events = {};
	      if (child.props.disabled) {
	        cls += ' ' + prefixCls + '-tab-disabled';
	      } else {
	        events = {
	          onClick: _this.onTabClick.bind(_this, key)
	        };
	      }
	      var ref = {};
	      if (activeKey === key) {
	        ref.ref = _this.saveRef('activeTab');
	      }
	      (0, _warning2['default'])('tab' in child.props, 'There must be `tab` property on children of Tabs.');
	      rst.push(_react2['default'].createElement(
	        'div',
	        (0, _extends3['default'])({
	          role: 'tab',
	          'aria-disabled': child.props.disabled ? 'true' : 'false',
	          'aria-selected': activeKey === key ? 'true' : 'false'
	        }, events, {
	          className: cls,
	          key: key
	        }, ref),
	        child.props.tab
	      ));
	    });
	
	    return rst;
	  },
	  getRootNode: function getRootNode(contents) {
	    var _props2 = this.props,
	        prefixCls = _props2.prefixCls,
	        onKeyDown = _props2.onKeyDown,
	        className = _props2.className,
	        extraContent = _props2.extraContent,
	        style = _props2.style,
	        tabBarPosition = _props2.tabBarPosition,
	        restProps = (0, _objectWithoutProperties3['default'])(_props2, ['prefixCls', 'onKeyDown', 'className', 'extraContent', 'style', 'tabBarPosition']);
	
	    var cls = (0, _classnames3['default'])(prefixCls + '-bar', (0, _defineProperty3['default'])({}, className, !!className));
	    var topOrBottom = tabBarPosition === 'top' || tabBarPosition === 'bottom';
	    var tabBarExtraContentStyle = topOrBottom ? { float: 'right' } : {};
	    var extraContentStyle = extraContent && extraContent.props ? extraContent.props.style : {};
	    var children = contents;
	    if (extraContent) {
	      children = [(0, _react.cloneElement)(extraContent, {
	        key: 'extra',
	        style: (0, _extends3['default'])({}, tabBarExtraContentStyle, extraContentStyle)
	      }), (0, _react.cloneElement)(contents, { key: 'content' })];
	      children = topOrBottom ? children : children.reverse();
	    }
	    return _react2['default'].createElement(
	      'div',
	      (0, _extends3['default'])({
	        role: 'tablist',
	        className: cls,
	        tabIndex: '0',
	        ref: this.saveRef('root'),
	        onKeyDown: onKeyDown,
	        style: style
	      }, (0, _utils.getDataAttr)(restProps)),
	      children
	    );
	  }
	};
	module.exports = exports['default'];

/***/ }),
/* 763 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _objectWithoutProperties2 = __webpack_require__(20);
	
	var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _KeyCode = __webpack_require__(758);
	
	var _KeyCode2 = _interopRequireDefault(_KeyCode);
	
	var _TabPane = __webpack_require__(272);
	
	var _TabPane2 = _interopRequireDefault(_TabPane);
	
	var _classnames2 = __webpack_require__(8);
	
	var _classnames3 = _interopRequireDefault(_classnames2);
	
	var _utils = __webpack_require__(66);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function noop() {}
	
	function getDefaultActiveKey(props) {
	  var activeKey = void 0;
	  _react2['default'].Children.forEach(props.children, function (child) {
	    if (child && !activeKey && !child.props.disabled) {
	      activeKey = child.key;
	    }
	  });
	  return activeKey;
	}
	
	function activeKeyIsValid(props, key) {
	  var keys = _react2['default'].Children.map(props.children, function (child) {
	    return child && child.key;
	  });
	  return keys.indexOf(key) >= 0;
	}
	
	var Tabs = function (_React$Component) {
	  (0, _inherits3['default'])(Tabs, _React$Component);
	
	  function Tabs(props) {
	    (0, _classCallCheck3['default'])(this, Tabs);
	
	    var _this = (0, _possibleConstructorReturn3['default'])(this, (Tabs.__proto__ || Object.getPrototypeOf(Tabs)).call(this, props));
	
	    _initialiseProps.call(_this);
	
	    var activeKey = void 0;
	    if ('activeKey' in props) {
	      activeKey = props.activeKey;
	    } else if ('defaultActiveKey' in props) {
	      activeKey = props.defaultActiveKey;
	    } else {
	      activeKey = getDefaultActiveKey(props);
	    }
	
	    _this.state = {
	      activeKey: activeKey
	    };
	    return _this;
	  }
	
	  (0, _createClass3['default'])(Tabs, [{
	    key: 'componentWillReceiveProps',
	    value: function componentWillReceiveProps(nextProps) {
	      if ('activeKey' in nextProps) {
	        this.setState({
	          activeKey: nextProps.activeKey
	        });
	      } else if (!activeKeyIsValid(nextProps, this.state.activeKey)) {
	        // https://github.com/ant-design/ant-design/issues/7093
	        this.setState({
	          activeKey: getDefaultActiveKey(nextProps)
	        });
	      }
	    }
	  }, {
	    key: 'render',
	    value: function render() {
	      var _classnames;
	
	      var props = this.props;
	      var prefixCls = props.prefixCls,
	          tabBarPosition = props.tabBarPosition,
	          className = props.className,
	          renderTabContent = props.renderTabContent,
	          renderTabBar = props.renderTabBar,
	          destroyInactiveTabPane = props.destroyInactiveTabPane,
	          restProps = (0, _objectWithoutProperties3['default'])(props, ['prefixCls', 'tabBarPosition', 'className', 'renderTabContent', 'renderTabBar', 'destroyInactiveTabPane']);
	
	      var cls = (0, _classnames3['default'])((_classnames = {}, (0, _defineProperty3['default'])(_classnames, prefixCls, 1), (0, _defineProperty3['default'])(_classnames, prefixCls + '-' + tabBarPosition, 1), (0, _defineProperty3['default'])(_classnames, className, !!className), _classnames));
	
	      this.tabBar = renderTabBar();
	      var contents = [_react2['default'].cloneElement(this.tabBar, {
	        prefixCls: prefixCls,
	        key: 'tabBar',
	        onKeyDown: this.onNavKeyDown,
	        tabBarPosition: tabBarPosition,
	        onTabClick: this.onTabClick,
	        panels: props.children,
	        activeKey: this.state.activeKey
	      }), _react2['default'].cloneElement(renderTabContent(), {
	        prefixCls: prefixCls,
	        tabBarPosition: tabBarPosition,
	        activeKey: this.state.activeKey,
	        destroyInactiveTabPane: destroyInactiveTabPane,
	        children: props.children,
	        onChange: this.setActiveKey,
	        key: 'tabContent'
	      })];
	      if (tabBarPosition === 'bottom') {
	        contents.reverse();
	      }
	      return _react2['default'].createElement(
	        'div',
	        (0, _extends3['default'])({
	          className: cls,
	          style: props.style
	        }, (0, _utils.getDataAttr)(restProps)),
	        contents
	      );
	    }
	  }]);
	  return Tabs;
	}(_react2['default'].Component);
	
	var _initialiseProps = function _initialiseProps() {
	  var _this2 = this;
	
	  this.onTabClick = function (activeKey) {
	    if (_this2.tabBar.props.onTabClick) {
	      _this2.tabBar.props.onTabClick(activeKey);
	    }
	    _this2.setActiveKey(activeKey);
	  };
	
	  this.onNavKeyDown = function (e) {
	    var eventKeyCode = e.keyCode;
	    if (eventKeyCode === _KeyCode2['default'].RIGHT || eventKeyCode === _KeyCode2['default'].DOWN) {
	      e.preventDefault();
	      var nextKey = _this2.getNextActiveKey(true);
	      _this2.onTabClick(nextKey);
	    } else if (eventKeyCode === _KeyCode2['default'].LEFT || eventKeyCode === _KeyCode2['default'].UP) {
	      e.preventDefault();
	      var previousKey = _this2.getNextActiveKey(false);
	      _this2.onTabClick(previousKey);
	    }
	  };
	
	  this.setActiveKey = function (activeKey) {
	    if (_this2.state.activeKey !== activeKey) {
	      if (!('activeKey' in _this2.props)) {
	        _this2.setState({
	          activeKey: activeKey
	        });
	      }
	      _this2.props.onChange(activeKey);
	    }
	  };
	
	  this.getNextActiveKey = function (next) {
	    var activeKey = _this2.state.activeKey;
	    var children = [];
	    _react2['default'].Children.forEach(_this2.props.children, function (c) {
	      if (c && !c.props.disabled) {
	        if (next) {
	          children.push(c);
	        } else {
	          children.unshift(c);
	        }
	      }
	    });
	    var length = children.length;
	    var ret = length && children[0].key;
	    children.forEach(function (child, i) {
	      if (child.key === activeKey) {
	        if (i === length - 1) {
	          ret = children[0].key;
	        } else {
	          ret = children[i + 1].key;
	        }
	      }
	    });
	    return ret;
	  };
	};
	
	exports['default'] = Tabs;
	
	
	Tabs.propTypes = {
	  destroyInactiveTabPane: _propTypes2['default'].bool,
	  renderTabBar: _propTypes2['default'].func.isRequired,
	  renderTabContent: _propTypes2['default'].func.isRequired,
	  onChange: _propTypes2['default'].func,
	  children: _propTypes2['default'].any,
	  prefixCls: _propTypes2['default'].string,
	  className: _propTypes2['default'].string,
	  tabBarPosition: _propTypes2['default'].string,
	  style: _propTypes2['default'].object,
	  activeKey: _propTypes2['default'].string,
	  defaultActiveKey: _propTypes2['default'].string
	};
	
	Tabs.defaultProps = {
	  prefixCls: 'rc-tabs',
	  destroyInactiveTabPane: false,
	  onChange: noop,
	  tabBarPosition: 'top',
	  style: {}
	};
	
	Tabs.TabPane = _TabPane2['default'];
	module.exports = exports['default'];

/***/ }),
/* 764 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.TabContent = exports.TabPane = undefined;
	
	var _Tabs = __webpack_require__(763);
	
	var _Tabs2 = _interopRequireDefault(_Tabs);
	
	var _TabPane = __webpack_require__(272);
	
	var _TabPane2 = _interopRequireDefault(_TabPane);
	
	var _TabContent = __webpack_require__(271);
	
	var _TabContent2 = _interopRequireDefault(_TabContent);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	exports['default'] = _Tabs2['default'];
	exports.TabPane = _TabPane2['default'];
	exports.TabContent = _TabContent2['default'];

/***/ }),
/* 765 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _Select = __webpack_require__(767);
	
	var _Select2 = _interopRequireDefault(_Select);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var formatOption = function formatOption(option, disabledOptions) {
	  var value = '' + option;
	  if (option < 10) {
	    value = '0' + option;
	  }
	
	  var disabled = false;
	  if (disabledOptions && disabledOptions.indexOf(option) >= 0) {
	    disabled = true;
	  }
	
	  return {
	    value: value,
	    disabled: disabled
	  };
	};
	
	var Combobox = function (_Component) {
	  (0, _inherits3['default'])(Combobox, _Component);
	
	  function Combobox() {
	    var _ref;
	
	    var _temp, _this, _ret;
	
	    (0, _classCallCheck3['default'])(this, Combobox);
	
	    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
	      args[_key] = arguments[_key];
	    }
	
	    return _ret = (_temp = (_this = (0, _possibleConstructorReturn3['default'])(this, (_ref = Combobox.__proto__ || Object.getPrototypeOf(Combobox)).call.apply(_ref, [this].concat(args))), _this), _this.onItemChange = function (type, itemValue) {
	      var _this$props = _this.props,
	          onChange = _this$props.onChange,
	          defaultOpenValue = _this$props.defaultOpenValue,
	          use12Hours = _this$props.use12Hours;
	
	      var value = (_this.props.value || defaultOpenValue).clone();
	
	      if (type === 'hour') {
	        if (use12Hours) {
	          if (_this.isAM()) {
	            value.hour(+itemValue % 12);
	          } else {
	            value.hour(+itemValue % 12 + 12);
	          }
	        } else {
	          value.hour(+itemValue);
	        }
	      } else if (type === 'minute') {
	        value.minute(+itemValue);
	      } else if (type === 'ampm') {
	        var ampm = itemValue.toUpperCase();
	        if (use12Hours) {
	          if (ampm === 'PM' && value.hour() < 12) {
	            value.hour(value.hour() % 12 + 12);
	          }
	
	          if (ampm === 'AM') {
	            if (value.hour() >= 12) {
	              value.hour(value.hour() - 12);
	            }
	          }
	        }
	      } else {
	        value.second(+itemValue);
	      }
	      onChange(value);
	    }, _this.onEnterSelectPanel = function (range) {
	      _this.props.onCurrentSelectPanelChange(range);
	    }, _temp), (0, _possibleConstructorReturn3['default'])(_this, _ret);
	  }
	
	  (0, _createClass3['default'])(Combobox, [{
	    key: 'getHourSelect',
	    value: function getHourSelect(hour) {
	      var _props = this.props,
	          prefixCls = _props.prefixCls,
	          hourOptions = _props.hourOptions,
	          disabledHours = _props.disabledHours,
	          showHour = _props.showHour,
	          use12Hours = _props.use12Hours;
	
	      if (!showHour) {
	        return null;
	      }
	      var disabledOptions = disabledHours();
	      var hourOptionsAdj = void 0;
	      var hourAdj = void 0;
	      if (use12Hours) {
	        hourOptionsAdj = [12].concat(hourOptions.filter(function (h) {
	          return h < 12 && h > 0;
	        }));
	        hourAdj = hour % 12 || 12;
	      } else {
	        hourOptionsAdj = hourOptions;
	        hourAdj = hour;
	      }
	
	      return _react2['default'].createElement(_Select2['default'], {
	        prefixCls: prefixCls,
	        options: hourOptionsAdj.map(function (option) {
	          return formatOption(option, disabledOptions);
	        }),
	        selectedIndex: hourOptionsAdj.indexOf(hourAdj),
	        type: 'hour',
	        onSelect: this.onItemChange,
	        onMouseEnter: this.onEnterSelectPanel.bind(this, 'hour')
	      });
	    }
	  }, {
	    key: 'getMinuteSelect',
	    value: function getMinuteSelect(minute) {
	      var _props2 = this.props,
	          prefixCls = _props2.prefixCls,
	          minuteOptions = _props2.minuteOptions,
	          disabledMinutes = _props2.disabledMinutes,
	          defaultOpenValue = _props2.defaultOpenValue,
	          showMinute = _props2.showMinute;
	
	      if (!showMinute) {
	        return null;
	      }
	      var value = this.props.value || defaultOpenValue;
	      var disabledOptions = disabledMinutes(value.hour());
	
	      return _react2['default'].createElement(_Select2['default'], {
	        prefixCls: prefixCls,
	        options: minuteOptions.map(function (option) {
	          return formatOption(option, disabledOptions);
	        }),
	        selectedIndex: minuteOptions.indexOf(minute),
	        type: 'minute',
	        onSelect: this.onItemChange,
	        onMouseEnter: this.onEnterSelectPanel.bind(this, 'minute')
	      });
	    }
	  }, {
	    key: 'getSecondSelect',
	    value: function getSecondSelect(second) {
	      var _props3 = this.props,
	          prefixCls = _props3.prefixCls,
	          secondOptions = _props3.secondOptions,
	          disabledSeconds = _props3.disabledSeconds,
	          showSecond = _props3.showSecond,
	          defaultOpenValue = _props3.defaultOpenValue;
	
	      if (!showSecond) {
	        return null;
	      }
	      var value = this.props.value || defaultOpenValue;
	      var disabledOptions = disabledSeconds(value.hour(), value.minute());
	
	      return _react2['default'].createElement(_Select2['default'], {
	        prefixCls: prefixCls,
	        options: secondOptions.map(function (option) {
	          return formatOption(option, disabledOptions);
	        }),
	        selectedIndex: secondOptions.indexOf(second),
	        type: 'second',
	        onSelect: this.onItemChange,
	        onMouseEnter: this.onEnterSelectPanel.bind(this, 'second')
	      });
	    }
	  }, {
	    key: 'getAMPMSelect',
	    value: function getAMPMSelect() {
	      var _props4 = this.props,
	          prefixCls = _props4.prefixCls,
	          use12Hours = _props4.use12Hours,
	          format = _props4.format;
	
	      if (!use12Hours) {
	        return null;
	      }
	
	      var AMPMOptions = ['am', 'pm'] // If format has A char, then we should uppercase AM/PM
	      .map(function (c) {
	        return format.match(/\sA/) ? c.toUpperCase() : c;
	      }).map(function (c) {
	        return { value: c };
	      });
	
	      var selected = this.isAM() ? 0 : 1;
	
	      return _react2['default'].createElement(_Select2['default'], {
	        prefixCls: prefixCls,
	        options: AMPMOptions,
	        selectedIndex: selected,
	        type: 'ampm',
	        onSelect: this.onItemChange,
	        onMouseEnter: this.onEnterSelectPanel.bind(this, 'ampm')
	      });
	    }
	  }, {
	    key: 'isAM',
	    value: function isAM() {
	      var value = this.props.value || this.props.defaultOpenValue;
	      return value.hour() >= 0 && value.hour() < 12;
	    }
	  }, {
	    key: 'render',
	    value: function render() {
	      var _props5 = this.props,
	          prefixCls = _props5.prefixCls,
	          defaultOpenValue = _props5.defaultOpenValue;
	
	      var value = this.props.value || defaultOpenValue;
	      return _react2['default'].createElement(
	        'div',
	        { className: prefixCls + '-combobox' },
	        this.getHourSelect(value.hour()),
	        this.getMinuteSelect(value.minute()),
	        this.getSecondSelect(value.second()),
	        this.getAMPMSelect(value.hour())
	      );
	    }
	  }]);
	  return Combobox;
	}(_react.Component);
	
	Combobox.propTypes = {
	  format: _propTypes2['default'].string,
	  defaultOpenValue: _propTypes2['default'].object,
	  prefixCls: _propTypes2['default'].string,
	  value: _propTypes2['default'].object,
	  onChange: _propTypes2['default'].func,
	  showHour: _propTypes2['default'].bool,
	  showMinute: _propTypes2['default'].bool,
	  showSecond: _propTypes2['default'].bool,
	  hourOptions: _propTypes2['default'].array,
	  minuteOptions: _propTypes2['default'].array,
	  secondOptions: _propTypes2['default'].array,
	  disabledHours: _propTypes2['default'].func,
	  disabledMinutes: _propTypes2['default'].func,
	  disabledSeconds: _propTypes2['default'].func,
	  onCurrentSelectPanelChange: _propTypes2['default'].func,
	  use12Hours: _propTypes2['default'].bool
	};
	exports['default'] = Combobox;
	module.exports = exports['default'];

/***/ }),
/* 766 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _moment = __webpack_require__(13);
	
	var _moment2 = _interopRequireDefault(_moment);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var Header = function (_Component) {
	  (0, _inherits3['default'])(Header, _Component);
	
	  function Header(props) {
	    (0, _classCallCheck3['default'])(this, Header);
	
	    var _this = (0, _possibleConstructorReturn3['default'])(this, (Header.__proto__ || Object.getPrototypeOf(Header)).call(this, props));
	
	    _initialiseProps.call(_this);
	
	    var value = props.value,
	        format = props.format;
	
	    _this.state = {
	      str: value && value.format(format) || '',
	      invalid: false
	    };
	    return _this;
	  }
	
	  (0, _createClass3['default'])(Header, [{
	    key: 'componentWillReceiveProps',
	    value: function componentWillReceiveProps(nextProps) {
	      var value = nextProps.value,
	          format = nextProps.format;
	
	      this.setState({
	        str: value && value.format(format) || '',
	        invalid: false
	      });
	    }
	  }, {
	    key: 'getClearButton',
	    value: function getClearButton() {
	      var _props = this.props,
	          prefixCls = _props.prefixCls,
	          allowEmpty = _props.allowEmpty;
	
	      if (!allowEmpty) {
	        return null;
	      }
	      return _react2['default'].createElement('a', {
	        className: prefixCls + '-clear-btn',
	        role: 'button',
	        title: this.props.clearText,
	        onMouseDown: this.onClear
	      });
	    }
	  }, {
	    key: 'getProtoValue',
	    value: function getProtoValue() {
	      return this.props.value || this.props.defaultOpenValue;
	    }
	  }, {
	    key: 'getInput',
	    value: function getInput() {
	      var _props2 = this.props,
	          prefixCls = _props2.prefixCls,
	          placeholder = _props2.placeholder;
	      var _state = this.state,
	          invalid = _state.invalid,
	          str = _state.str;
	
	      var invalidClass = invalid ? prefixCls + '-input-invalid' : '';
	      return _react2['default'].createElement('input', {
	        className: prefixCls + '-input  ' + invalidClass,
	        ref: 'input',
	        onKeyDown: this.onKeyDown,
	        value: str,
	        placeholder: placeholder,
	        onChange: this.onInputChange
	      });
	    }
	  }, {
	    key: 'render',
	    value: function render() {
	      var prefixCls = this.props.prefixCls;
	
	      return _react2['default'].createElement(
	        'div',
	        { className: prefixCls + '-input-wrap' },
	        this.getInput(),
	        this.getClearButton()
	      );
	    }
	  }]);
	  return Header;
	}(_react.Component);
	
	Header.propTypes = {
	  format: _propTypes2['default'].string,
	  prefixCls: _propTypes2['default'].string,
	  disabledDate: _propTypes2['default'].func,
	  placeholder: _propTypes2['default'].string,
	  clearText: _propTypes2['default'].string,
	  value: _propTypes2['default'].object,
	  hourOptions: _propTypes2['default'].array,
	  minuteOptions: _propTypes2['default'].array,
	  secondOptions: _propTypes2['default'].array,
	  disabledHours: _propTypes2['default'].func,
	  disabledMinutes: _propTypes2['default'].func,
	  disabledSeconds: _propTypes2['default'].func,
	  onChange: _propTypes2['default'].func,
	  onClear: _propTypes2['default'].func,
	  onEsc: _propTypes2['default'].func,
	  allowEmpty: _propTypes2['default'].bool,
	  defaultOpenValue: _propTypes2['default'].object,
	  currentSelectPanel: _propTypes2['default'].string
	};
	
	var _initialiseProps = function _initialiseProps() {
	  var _this2 = this;
	
	  this.onInputChange = function (event) {
	    var str = event.target.value;
	    _this2.setState({
	      str: str
	    });
	    var _props3 = _this2.props,
	        format = _props3.format,
	        hourOptions = _props3.hourOptions,
	        minuteOptions = _props3.minuteOptions,
	        secondOptions = _props3.secondOptions,
	        disabledHours = _props3.disabledHours,
	        disabledMinutes = _props3.disabledMinutes,
	        disabledSeconds = _props3.disabledSeconds,
	        onChange = _props3.onChange,
	        allowEmpty = _props3.allowEmpty;
	
	
	    if (str) {
	      var originalValue = _this2.props.value;
	      var value = _this2.getProtoValue().clone();
	      var parsed = (0, _moment2['default'])(str, format, true);
	      if (!parsed.isValid()) {
	        _this2.setState({
	          invalid: true
	        });
	        return;
	      }
	      value.hour(parsed.hour()).minute(parsed.minute()).second(parsed.second());
	
	      // if time value not allowed, response warning.
	      if (hourOptions.indexOf(value.hour()) < 0 || minuteOptions.indexOf(value.minute()) < 0 || secondOptions.indexOf(value.second()) < 0) {
	        _this2.setState({
	          invalid: true
	        });
	        return;
	      }
	
	      // if time value is disabled, response warning.
	      var disabledHourOptions = disabledHours();
	      var disabledMinuteOptions = disabledMinutes(value.hour());
	      var disabledSecondOptions = disabledSeconds(value.hour(), value.minute());
	      if (disabledHourOptions && disabledHourOptions.indexOf(value.hour()) >= 0 || disabledMinuteOptions && disabledMinuteOptions.indexOf(value.minute()) >= 0 || disabledSecondOptions && disabledSecondOptions.indexOf(value.second()) >= 0) {
	        _this2.setState({
	          invalid: true
	        });
	        return;
	      }
	
	      if (originalValue) {
	        if (originalValue.hour() !== value.hour() || originalValue.minute() !== value.minute() || originalValue.second() !== value.second()) {
	          // keep other fields for rc-calendar
	          var changedValue = originalValue.clone();
	          changedValue.hour(value.hour());
	          changedValue.minute(value.minute());
	          changedValue.second(value.second());
	          onChange(changedValue);
	        }
	      } else if (originalValue !== value) {
	        onChange(value);
	      }
	    } else if (allowEmpty) {
	      onChange(null);
	    } else {
	      _this2.setState({
	        invalid: true
	      });
	      return;
	    }
	
	    _this2.setState({
	      invalid: false
	    });
	  };
	
	  this.onKeyDown = function (e) {
	    if (e.keyCode === 27) {
	      _this2.props.onEsc();
	    }
	  };
	
	  this.onClear = function () {
	    _this2.setState({ str: '' });
	    _this2.props.onClear();
	  };
	};
	
	exports['default'] = Header;
	module.exports = exports['default'];

/***/ }),
/* 767 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _reactDom = __webpack_require__(10);
	
	var _reactDom2 = _interopRequireDefault(_reactDom);
	
	var _classnames3 = __webpack_require__(8);
	
	var _classnames4 = _interopRequireDefault(_classnames3);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var scrollTo = function scrollTo(element, to, duration) {
	  var requestAnimationFrame = window.requestAnimationFrame || function requestAnimationFrameTimeout() {
	    return setTimeout(arguments[0], 10);
	  };
	  // jump to target if duration zero
	  if (duration <= 0) {
	    element.scrollTop = to;
	    return;
	  }
	  var difference = to - element.scrollTop;
	  var perTick = difference / duration * 10;
	
	  requestAnimationFrame(function () {
	    element.scrollTop = element.scrollTop + perTick;
	    if (element.scrollTop === to) return;
	    scrollTo(element, to, duration - 10);
	  });
	};
	
	var Select = function (_Component) {
	  (0, _inherits3['default'])(Select, _Component);
	
	  function Select() {
	    var _ref;
	
	    var _temp, _this, _ret;
	
	    (0, _classCallCheck3['default'])(this, Select);
	
	    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
	      args[_key] = arguments[_key];
	    }
	
	    return _ret = (_temp = (_this = (0, _possibleConstructorReturn3['default'])(this, (_ref = Select.__proto__ || Object.getPrototypeOf(Select)).call.apply(_ref, [this].concat(args))), _this), _this.state = {
	      active: false
	    }, _this.onSelect = function (value) {
	      var _this$props = _this.props,
	          onSelect = _this$props.onSelect,
	          type = _this$props.type;
	
	      onSelect(type, value);
	    }, _this.handleMouseEnter = function (e) {
	      _this.setState({ active: true });
	      _this.props.onMouseEnter(e);
	    }, _this.handleMouseLeave = function () {
	      _this.setState({ active: false });
	    }, _temp), (0, _possibleConstructorReturn3['default'])(_this, _ret);
	  }
	
	  (0, _createClass3['default'])(Select, [{
	    key: 'componentDidMount',
	    value: function componentDidMount() {
	      // jump to selected option
	      this.scrollToSelected(0);
	    }
	  }, {
	    key: 'componentDidUpdate',
	    value: function componentDidUpdate(prevProps) {
	      // smooth scroll to selected option
	      if (prevProps.selectedIndex !== this.props.selectedIndex) {
	        this.scrollToSelected(120);
	      }
	    }
	  }, {
	    key: 'getOptions',
	    value: function getOptions() {
	      var _this2 = this;
	
	      var _props = this.props,
	          options = _props.options,
	          selectedIndex = _props.selectedIndex,
	          prefixCls = _props.prefixCls;
	
	      return options.map(function (item, index) {
	        var _classnames;
	
	        var cls = (0, _classnames4['default'])((_classnames = {}, (0, _defineProperty3['default'])(_classnames, prefixCls + '-select-option-selected', selectedIndex === index), (0, _defineProperty3['default'])(_classnames, prefixCls + '-select-option-disabled', item.disabled), _classnames));
	        var onclick = null;
	        if (!item.disabled) {
	          onclick = _this2.onSelect.bind(_this2, item.value);
	        }
	        return _react2['default'].createElement(
	          'li',
	          {
	            className: cls,
	            key: index,
	            onClick: onclick,
	            disabled: item.disabled
	          },
	          item.value
	        );
	      });
	    }
	  }, {
	    key: 'scrollToSelected',
	    value: function scrollToSelected(duration) {
	      // move to selected item
	      var select = _reactDom2['default'].findDOMNode(this);
	      var list = _reactDom2['default'].findDOMNode(this.refs.list);
	      if (!list) {
	        return;
	      }
	      var index = this.props.selectedIndex;
	      if (index < 0) {
	        index = 0;
	      }
	      var topOption = list.children[index];
	      var to = topOption.offsetTop;
	      scrollTo(select, to, duration);
	    }
	  }, {
	    key: 'render',
	    value: function render() {
	      var _classnames2;
	
	      if (this.props.options.length === 0) {
	        return null;
	      }
	
	      var prefixCls = this.props.prefixCls;
	
	      var cls = (0, _classnames4['default'])((_classnames2 = {}, (0, _defineProperty3['default'])(_classnames2, prefixCls + '-select', 1), (0, _defineProperty3['default'])(_classnames2, prefixCls + '-select-active', this.state.active), _classnames2));
	
	      return _react2['default'].createElement(
	        'div',
	        {
	          className: cls,
	          onMouseEnter: this.handleMouseEnter,
	          onMouseLeave: this.handleMouseLeave
	        },
	        _react2['default'].createElement(
	          'ul',
	          { ref: 'list' },
	          this.getOptions()
	        )
	      );
	    }
	  }]);
	  return Select;
	}(_react.Component);
	
	Select.propTypes = {
	  prefixCls: _propTypes2['default'].string,
	  options: _propTypes2['default'].array,
	  selectedIndex: _propTypes2['default'].number,
	  type: _propTypes2['default'].string,
	  onSelect: _propTypes2['default'].func,
	  onMouseEnter: _propTypes2['default'].func
	};
	exports['default'] = Select;
	module.exports = exports['default'];

/***/ }),
/* 768 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _rcTrigger = __webpack_require__(53);
	
	var _rcTrigger2 = _interopRequireDefault(_rcTrigger);
	
	var _Panel = __webpack_require__(273);
	
	var _Panel2 = _interopRequireDefault(_Panel);
	
	var _placements = __webpack_require__(769);
	
	var _placements2 = _interopRequireDefault(_placements);
	
	var _moment = __webpack_require__(13);
	
	var _moment2 = _interopRequireDefault(_moment);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function noop() {}
	
	function refFn(field, component) {
	  this[field] = component;
	}
	
	var Picker = function (_Component) {
	  (0, _inherits3['default'])(Picker, _Component);
	
	  function Picker(props) {
	    (0, _classCallCheck3['default'])(this, Picker);
	
	    var _this = (0, _possibleConstructorReturn3['default'])(this, (Picker.__proto__ || Object.getPrototypeOf(Picker)).call(this, props));
	
	    _initialiseProps.call(_this);
	
	    _this.saveInputRef = refFn.bind(_this, 'picker');
	    _this.savePanelRef = refFn.bind(_this, 'panelInstance');
	    var defaultOpen = props.defaultOpen,
	        defaultValue = props.defaultValue,
	        _props$open = props.open,
	        open = _props$open === undefined ? defaultOpen : _props$open,
	        _props$value = props.value,
	        value = _props$value === undefined ? defaultValue : _props$value;
	
	    _this.state = {
	      open: open,
	      value: value
	    };
	    return _this;
	  }
	
	  (0, _createClass3['default'])(Picker, [{
	    key: 'componentWillReceiveProps',
	    value: function componentWillReceiveProps(nextProps) {
	      var value = nextProps.value,
	          open = nextProps.open;
	
	      if ('value' in nextProps) {
	        this.setState({
	          value: value
	        });
	      }
	      if (open !== undefined) {
	        this.setState({ open: open });
	      }
	    }
	  }, {
	    key: 'setValue',
	    value: function setValue(value) {
	      if (!('value' in this.props)) {
	        this.setState({
	          value: value
	        });
	      }
	      this.props.onChange(value);
	    }
	  }, {
	    key: 'getFormat',
	    value: function getFormat() {
	      var _props = this.props,
	          format = _props.format,
	          showHour = _props.showHour,
	          showMinute = _props.showMinute,
	          showSecond = _props.showSecond,
	          use12Hours = _props.use12Hours;
	
	      if (format) {
	        return format;
	      }
	
	      if (use12Hours) {
	        var fmtString = [showHour ? 'h' : '', showMinute ? 'mm' : '', showSecond ? 'ss' : ''].filter(function (item) {
	          return !!item;
	        }).join(':');
	
	        return fmtString.concat(' a');
	      }
	
	      return [showHour ? 'HH' : '', showMinute ? 'mm' : '', showSecond ? 'ss' : ''].filter(function (item) {
	        return !!item;
	      }).join(':');
	    }
	  }, {
	    key: 'getPanelElement',
	    value: function getPanelElement() {
	      var _props2 = this.props,
	          prefixCls = _props2.prefixCls,
	          placeholder = _props2.placeholder,
	          disabledHours = _props2.disabledHours,
	          disabledMinutes = _props2.disabledMinutes,
	          disabledSeconds = _props2.disabledSeconds,
	          hideDisabledOptions = _props2.hideDisabledOptions,
	          allowEmpty = _props2.allowEmpty,
	          showHour = _props2.showHour,
	          showMinute = _props2.showMinute,
	          showSecond = _props2.showSecond,
	          defaultOpenValue = _props2.defaultOpenValue,
	          clearText = _props2.clearText,
	          addon = _props2.addon,
	          use12Hours = _props2.use12Hours;
	
	      return _react2['default'].createElement(_Panel2['default'], {
	        clearText: clearText,
	        prefixCls: prefixCls + '-panel',
	        ref: this.savePanelRef,
	        value: this.state.value,
	        onChange: this.onPanelChange,
	        onClear: this.onPanelClear,
	        defaultOpenValue: defaultOpenValue,
	        showHour: showHour,
	        showMinute: showMinute,
	        showSecond: showSecond,
	        onEsc: this.onEsc,
	        allowEmpty: allowEmpty,
	        format: this.getFormat(),
	        placeholder: placeholder,
	        disabledHours: disabledHours,
	        disabledMinutes: disabledMinutes,
	        disabledSeconds: disabledSeconds,
	        hideDisabledOptions: hideDisabledOptions,
	        use12Hours: use12Hours,
	        addon: addon
	      });
	    }
	  }, {
	    key: 'getPopupClassName',
	    value: function getPopupClassName() {
	      var _props3 = this.props,
	          showHour = _props3.showHour,
	          showMinute = _props3.showMinute,
	          showSecond = _props3.showSecond,
	          use12Hours = _props3.use12Hours,
	          prefixCls = _props3.prefixCls;
	
	      var popupClassName = this.props.popupClassName;
	      // Keep it for old compatibility
	      if ((!showHour || !showMinute || !showSecond) && !use12Hours) {
	        popupClassName += ' ' + prefixCls + '-panel-narrow';
	      }
	      var selectColumnCount = 0;
	      if (showHour) {
	        selectColumnCount += 1;
	      }
	      if (showMinute) {
	        selectColumnCount += 1;
	      }
	      if (showSecond) {
	        selectColumnCount += 1;
	      }
	      if (use12Hours) {
	        selectColumnCount += 1;
	      }
	      popupClassName += ' ' + prefixCls + '-panel-column-' + selectColumnCount;
	      return popupClassName;
	    }
	  }, {
	    key: 'setOpen',
	    value: function setOpen(open) {
	      var _props4 = this.props,
	          onOpen = _props4.onOpen,
	          onClose = _props4.onClose;
	
	      if (this.state.open !== open) {
	        if (!('open' in this.props)) {
	          this.setState({ open: open });
	        }
	        if (open) {
	          onOpen({ open: open });
	        } else {
	          onClose({ open: open });
	        }
	      }
	    }
	  }, {
	    key: 'focus',
	    value: function focus() {
	      this.picker.focus();
	    }
	  }, {
	    key: 'render',
	    value: function render() {
	      var _props5 = this.props,
	          prefixCls = _props5.prefixCls,
	          placeholder = _props5.placeholder,
	          placement = _props5.placement,
	          align = _props5.align,
	          disabled = _props5.disabled,
	          transitionName = _props5.transitionName,
	          style = _props5.style,
	          className = _props5.className,
	          getPopupContainer = _props5.getPopupContainer,
	          name = _props5.name,
	          autoComplete = _props5.autoComplete;
	      var _state = this.state,
	          open = _state.open,
	          value = _state.value;
	
	      var popupClassName = this.getPopupClassName();
	      return _react2['default'].createElement(
	        _rcTrigger2['default'],
	        {
	          prefixCls: prefixCls + '-panel',
	          popupClassName: popupClassName,
	          popup: this.getPanelElement(),
	          popupAlign: align,
	          builtinPlacements: _placements2['default'],
	          popupPlacement: placement,
	          action: disabled ? [] : ['click'],
	          destroyPopupOnHide: true,
	          getPopupContainer: getPopupContainer,
	          popupTransitionName: transitionName,
	          popupVisible: open,
	          onPopupVisibleChange: this.onVisibleChange
	        },
	        _react2['default'].createElement(
	          'span',
	          { className: prefixCls + ' ' + className, style: style },
	          _react2['default'].createElement('input', {
	            className: prefixCls + '-input',
	            ref: this.saveInputRef,
	            type: 'text',
	            placeholder: placeholder,
	            name: name,
	            readOnly: true,
	            onKeyDown: this.onKeyDown,
	            disabled: disabled, value: value && value.format(this.getFormat()) || '',
	            autoComplete: autoComplete
	          }),
	          _react2['default'].createElement('span', { className: prefixCls + '-icon' })
	        )
	      );
	    }
	  }]);
	  return Picker;
	}(_react.Component);
	
	Picker.propTypes = {
	  prefixCls: _propTypes2['default'].string,
	  clearText: _propTypes2['default'].string,
	  value: _propTypes2['default'].object,
	  defaultOpenValue: _propTypes2['default'].object,
	  disabled: _propTypes2['default'].bool,
	  allowEmpty: _propTypes2['default'].bool,
	  defaultValue: _propTypes2['default'].object,
	  open: _propTypes2['default'].bool,
	  defaultOpen: _propTypes2['default'].bool,
	  align: _propTypes2['default'].object,
	  placement: _propTypes2['default'].any,
	  transitionName: _propTypes2['default'].string,
	  getPopupContainer: _propTypes2['default'].func,
	  placeholder: _propTypes2['default'].string,
	  format: _propTypes2['default'].string,
	  showHour: _propTypes2['default'].bool,
	  showMinute: _propTypes2['default'].bool,
	  showSecond: _propTypes2['default'].bool,
	  style: _propTypes2['default'].object,
	  className: _propTypes2['default'].string,
	  popupClassName: _propTypes2['default'].string,
	  disabledHours: _propTypes2['default'].func,
	  disabledMinutes: _propTypes2['default'].func,
	  disabledSeconds: _propTypes2['default'].func,
	  hideDisabledOptions: _propTypes2['default'].bool,
	  onChange: _propTypes2['default'].func,
	  onOpen: _propTypes2['default'].func,
	  onClose: _propTypes2['default'].func,
	  addon: _propTypes2['default'].func,
	  name: _propTypes2['default'].string,
	  autoComplete: _propTypes2['default'].string,
	  use12Hours: _propTypes2['default'].bool
	};
	Picker.defaultProps = {
	  clearText: 'clear',
	  prefixCls: 'rc-time-picker',
	  defaultOpen: false,
	  style: {},
	  className: '',
	  popupClassName: '',
	  align: {},
	  defaultOpenValue: (0, _moment2['default'])(),
	  allowEmpty: true,
	  showHour: true,
	  showMinute: true,
	  showSecond: true,
	  disabledHours: noop,
	  disabledMinutes: noop,
	  disabledSeconds: noop,
	  hideDisabledOptions: false,
	  placement: 'bottomLeft',
	  onChange: noop,
	  onOpen: noop,
	  onClose: noop,
	  addon: noop,
	  use12Hours: false
	};
	
	var _initialiseProps = function _initialiseProps() {
	  var _this2 = this;
	
	  this.onPanelChange = function (value) {
	    _this2.setValue(value);
	  };
	
	  this.onPanelClear = function () {
	    _this2.setValue(null);
	    _this2.setOpen(false);
	  };
	
	  this.onVisibleChange = function (open) {
	    _this2.setOpen(open);
	  };
	
	  this.onEsc = function () {
	    _this2.setOpen(false);
	    _this2.focus();
	  };
	
	  this.onKeyDown = function (e) {
	    if (e.keyCode === 40) {
	      _this2.setOpen(true);
	    }
	  };
	};
	
	exports['default'] = Picker;
	module.exports = exports['default'];

/***/ }),
/* 769 */
668,
/* 770 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _objectWithoutProperties2 = __webpack_require__(20);
	
	var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _rcTrigger = __webpack_require__(53);
	
	var _rcTrigger2 = _interopRequireDefault(_rcTrigger);
	
	var _placements = __webpack_require__(274);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var Tooltip = function (_Component) {
	  (0, _inherits3['default'])(Tooltip, _Component);
	
	  function Tooltip() {
	    var _ref;
	
	    var _temp, _this, _ret;
	
	    (0, _classCallCheck3['default'])(this, Tooltip);
	
	    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
	      args[_key] = arguments[_key];
	    }
	
	    return _ret = (_temp = (_this = (0, _possibleConstructorReturn3['default'])(this, (_ref = Tooltip.__proto__ || Object.getPrototypeOf(Tooltip)).call.apply(_ref, [this].concat(args))), _this), _this.getPopupElement = function () {
	      var _this$props = _this.props,
	          arrowContent = _this$props.arrowContent,
	          overlay = _this$props.overlay,
	          prefixCls = _this$props.prefixCls;
	
	      return [_react2['default'].createElement(
	        'div',
	        { className: prefixCls + '-arrow', key: 'arrow' },
	        arrowContent
	      ), _react2['default'].createElement(
	        'div',
	        { className: prefixCls + '-inner', key: 'content' },
	        typeof overlay === 'function' ? overlay() : overlay
	      )];
	    }, _this.saveTrigger = function (node) {
	      _this.trigger = node;
	    }, _temp), (0, _possibleConstructorReturn3['default'])(_this, _ret);
	  }
	
	  (0, _createClass3['default'])(Tooltip, [{
	    key: 'getPopupDomNode',
	    value: function getPopupDomNode() {
	      return this.trigger.getPopupDomNode();
	    }
	  }, {
	    key: 'render',
	    value: function render() {
	      var _props = this.props,
	          overlayClassName = _props.overlayClassName,
	          trigger = _props.trigger,
	          mouseEnterDelay = _props.mouseEnterDelay,
	          mouseLeaveDelay = _props.mouseLeaveDelay,
	          overlayStyle = _props.overlayStyle,
	          prefixCls = _props.prefixCls,
	          children = _props.children,
	          onVisibleChange = _props.onVisibleChange,
	          afterVisibleChange = _props.afterVisibleChange,
	          transitionName = _props.transitionName,
	          animation = _props.animation,
	          placement = _props.placement,
	          align = _props.align,
	          destroyTooltipOnHide = _props.destroyTooltipOnHide,
	          defaultVisible = _props.defaultVisible,
	          getTooltipContainer = _props.getTooltipContainer,
	          restProps = (0, _objectWithoutProperties3['default'])(_props, ['overlayClassName', 'trigger', 'mouseEnterDelay', 'mouseLeaveDelay', 'overlayStyle', 'prefixCls', 'children', 'onVisibleChange', 'afterVisibleChange', 'transitionName', 'animation', 'placement', 'align', 'destroyTooltipOnHide', 'defaultVisible', 'getTooltipContainer']);
	
	      var extraProps = (0, _extends3['default'])({}, restProps);
	      if ('visible' in this.props) {
	        extraProps.popupVisible = this.props.visible;
	      }
	      return _react2['default'].createElement(
	        _rcTrigger2['default'],
	        (0, _extends3['default'])({
	          popupClassName: overlayClassName,
	          ref: this.saveTrigger,
	          prefixCls: prefixCls,
	          popup: this.getPopupElement,
	          action: trigger,
	          builtinPlacements: _placements.placements,
	          popupPlacement: placement,
	          popupAlign: align,
	          getPopupContainer: getTooltipContainer,
	          onPopupVisibleChange: onVisibleChange,
	          afterPopupVisibleChange: afterVisibleChange,
	          popupTransitionName: transitionName,
	          popupAnimation: animation,
	          defaultPopupVisible: defaultVisible,
	          destroyPopupOnHide: destroyTooltipOnHide,
	          mouseLeaveDelay: mouseLeaveDelay,
	          popupStyle: overlayStyle,
	          mouseEnterDelay: mouseEnterDelay
	        }, extraProps),
	        children
	      );
	    }
	  }]);
	  return Tooltip;
	}(_react.Component);
	
	Tooltip.propTypes = {
	  trigger: _propTypes2['default'].any,
	  children: _propTypes2['default'].any,
	  defaultVisible: _propTypes2['default'].bool,
	  visible: _propTypes2['default'].bool,
	  placement: _propTypes2['default'].string,
	  transitionName: _propTypes2['default'].string,
	  animation: _propTypes2['default'].any,
	  onVisibleChange: _propTypes2['default'].func,
	  afterVisibleChange: _propTypes2['default'].func,
	  overlay: _propTypes2['default'].oneOfType([_propTypes2['default'].node, _propTypes2['default'].func]).isRequired,
	  overlayStyle: _propTypes2['default'].object,
	  overlayClassName: _propTypes2['default'].string,
	  prefixCls: _propTypes2['default'].string,
	  mouseEnterDelay: _propTypes2['default'].number,
	  mouseLeaveDelay: _propTypes2['default'].number,
	  getTooltipContainer: _propTypes2['default'].func,
	  destroyTooltipOnHide: _propTypes2['default'].bool,
	  align: _propTypes2['default'].object,
	  arrowContent: _propTypes2['default'].any
	};
	Tooltip.defaultProps = {
	  prefixCls: 'rc-tooltip',
	  mouseEnterDelay: 0,
	  destroyTooltipOnHide: false,
	  mouseLeaveDelay: 0.1,
	  align: {},
	  placement: 'right',
	  trigger: ['hover'],
	  arrowContent: null
	};
	exports['default'] = Tooltip;
	module.exports = exports['default'];

/***/ }),
/* 771 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _Tooltip = __webpack_require__(770);
	
	var _Tooltip2 = _interopRequireDefault(_Tooltip);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	exports['default'] = _Tooltip2['default'];
	module.exports = exports['default'];

/***/ }),
/* 772 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	exports.shouldFirePress = shouldFirePress;
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function PressEvent(nativeEvent) {
	    var _this = this;
	
	    this.nativeEvent = nativeEvent;
	    ['type', 'currentTarget', 'target', 'touches', 'changedTouches'].forEach(function (m) {
	        _this[m] = nativeEvent[m];
	    });
	    if (!nativeEvent.$pressSeq) {
	        nativeEvent.$pressSeq = 1;
	    } else {
	        nativeEvent.$pressSeq += 1;
	    }
	    this.$pressSeq = nativeEvent.$pressSeq;
	}
	PressEvent.prototype = (0, _extends3['default'])({}, PressEvent.prototype, {
	    preventDefault: function preventDefault() {
	        this.nativeEvent.preventDefault();
	    },
	    stopPropagation: function stopPropagation() {
	        var nativeEvent = this.nativeEvent,
	            $pressSeq = this.$pressSeq;
	
	        if (nativeEvent.$stopPressSeq) {
	            return;
	        }
	        nativeEvent.$stopPressSeq = $pressSeq;
	    }
	});
	function shouldFirePress(e) {
	    var nativeEvent = e.nativeEvent,
	        $pressSeq = e.$pressSeq;
	
	    if (!nativeEvent.$stopPressSeq) {
	        return true;
	    }
	    return nativeEvent.$stopPressSeq >= $pressSeq;
	}
	exports['default'] = PressEvent;

/***/ }),
/* 773 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _reactDom = __webpack_require__(10);
	
	var _reactDom2 = _interopRequireDefault(_reactDom);
	
	var _PressEvent = __webpack_require__(772);
	
	var _PressEvent2 = _interopRequireDefault(_PressEvent);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function keyMirror(obj) {
	    Object.keys(obj).forEach(function (k) {
	        return obj[k] = k;
	    });
	    return obj;
	} // inspired by react-native
	
	function copy(from, list) {
	    var to = {};
	    list.forEach(function (k) {
	        to[k] = from[k];
	    });
	    return to;
	}
	function extractSingleTouch(_nativeEvent) {
	    var nativeEvent = _nativeEvent;
	    if (nativeEvent.nativeEvent) {
	        nativeEvent = nativeEvent.nativeEvent;
	    }
	    var touches = nativeEvent.touches;
	    var changedTouches = nativeEvent.changedTouches;
	    var hasTouches = touches && touches.length > 0;
	    var hasChangedTouches = changedTouches && changedTouches.length > 0;
	    return !hasTouches && hasChangedTouches ? changedTouches[0] : hasTouches ? touches[0] : nativeEvent;
	}
	/**
	 * Touchable states.
	 */
	var States = keyMirror({
	    NOT_RESPONDER: null,
	    RESPONDER_INACTIVE_PRESS_IN: null,
	    RESPONDER_INACTIVE_PRESS_OUT: null,
	    RESPONDER_ACTIVE_PRESS_IN: null,
	    RESPONDER_ACTIVE_PRESS_OUT: null,
	    RESPONDER_ACTIVE_LONG_PRESS_IN: null,
	    RESPONDER_ACTIVE_LONG_PRESS_OUT: null,
	    ERROR: null
	});
	/**
	 * Quick lookup map for states that are considered to be "active"
	 */
	var IsActive = {
	    RESPONDER_ACTIVE_PRESS_OUT: true,
	    RESPONDER_ACTIVE_PRESS_IN: true
	};
	/**
	 * Quick lookup for states that are considered to be "pressing" and are
	 * therefore eligible to result in a "selection" if the press stops.
	 */
	var IsPressingIn = {
	    RESPONDER_INACTIVE_PRESS_IN: true,
	    RESPONDER_ACTIVE_PRESS_IN: true,
	    RESPONDER_ACTIVE_LONG_PRESS_IN: true
	};
	var IsLongPressingIn = {
	    RESPONDER_ACTIVE_LONG_PRESS_IN: true
	};
	/**
	 * Inputs to the state machine.
	 */
	var Signals = keyMirror({
	    DELAY: null,
	    RESPONDER_GRANT: null,
	    RESPONDER_RELEASE: null,
	    RESPONDER_TERMINATED: null,
	    ENTER_PRESS_RECT: null,
	    LEAVE_PRESS_RECT: null,
	    LONG_PRESS_DETECTED: null
	});
	/**
	 * Mapping from States x Signals => States
	 */
	var Transitions = {
	    NOT_RESPONDER: {
	        DELAY: States.ERROR,
	        RESPONDER_GRANT: States.RESPONDER_INACTIVE_PRESS_IN,
	        RESPONDER_RELEASE: States.ERROR,
	        RESPONDER_TERMINATED: States.ERROR,
	        ENTER_PRESS_RECT: States.ERROR,
	        LEAVE_PRESS_RECT: States.ERROR,
	        LONG_PRESS_DETECTED: States.ERROR
	    },
	    RESPONDER_INACTIVE_PRESS_IN: {
	        DELAY: States.RESPONDER_ACTIVE_PRESS_IN,
	        RESPONDER_GRANT: States.ERROR,
	        RESPONDER_RELEASE: States.NOT_RESPONDER,
	        RESPONDER_TERMINATED: States.NOT_RESPONDER,
	        ENTER_PRESS_RECT: States.RESPONDER_INACTIVE_PRESS_IN,
	        LEAVE_PRESS_RECT: States.RESPONDER_INACTIVE_PRESS_OUT,
	        LONG_PRESS_DETECTED: States.ERROR
	    },
	    RESPONDER_INACTIVE_PRESS_OUT: {
	        DELAY: States.RESPONDER_ACTIVE_PRESS_OUT,
	        RESPONDER_GRANT: States.ERROR,
	        RESPONDER_RELEASE: States.NOT_RESPONDER,
	        RESPONDER_TERMINATED: States.NOT_RESPONDER,
	        ENTER_PRESS_RECT: States.RESPONDER_INACTIVE_PRESS_IN,
	        LEAVE_PRESS_RECT: States.RESPONDER_INACTIVE_PRESS_OUT,
	        LONG_PRESS_DETECTED: States.ERROR
	    },
	    RESPONDER_ACTIVE_PRESS_IN: {
	        DELAY: States.ERROR,
	        RESPONDER_GRANT: States.ERROR,
	        RESPONDER_RELEASE: States.NOT_RESPONDER,
	        RESPONDER_TERMINATED: States.NOT_RESPONDER,
	        ENTER_PRESS_RECT: States.RESPONDER_ACTIVE_PRESS_IN,
	        LEAVE_PRESS_RECT: States.RESPONDER_ACTIVE_PRESS_OUT,
	        LONG_PRESS_DETECTED: States.RESPONDER_ACTIVE_LONG_PRESS_IN
	    },
	    RESPONDER_ACTIVE_PRESS_OUT: {
	        DELAY: States.ERROR,
	        RESPONDER_GRANT: States.ERROR,
	        RESPONDER_RELEASE: States.NOT_RESPONDER,
	        RESPONDER_TERMINATED: States.NOT_RESPONDER,
	        ENTER_PRESS_RECT: States.RESPONDER_ACTIVE_PRESS_IN,
	        LEAVE_PRESS_RECT: States.RESPONDER_ACTIVE_PRESS_OUT,
	        LONG_PRESS_DETECTED: States.ERROR
	    },
	    RESPONDER_ACTIVE_LONG_PRESS_IN: {
	        DELAY: States.ERROR,
	        RESPONDER_GRANT: States.ERROR,
	        RESPONDER_RELEASE: States.NOT_RESPONDER,
	        RESPONDER_TERMINATED: States.NOT_RESPONDER,
	        ENTER_PRESS_RECT: States.RESPONDER_ACTIVE_LONG_PRESS_IN,
	        LEAVE_PRESS_RECT: States.RESPONDER_ACTIVE_LONG_PRESS_OUT,
	        LONG_PRESS_DETECTED: States.RESPONDER_ACTIVE_LONG_PRESS_IN
	    },
	    RESPONDER_ACTIVE_LONG_PRESS_OUT: {
	        DELAY: States.ERROR,
	        RESPONDER_GRANT: States.ERROR,
	        RESPONDER_RELEASE: States.NOT_RESPONDER,
	        RESPONDER_TERMINATED: States.NOT_RESPONDER,
	        ENTER_PRESS_RECT: States.RESPONDER_ACTIVE_LONG_PRESS_IN,
	        LEAVE_PRESS_RECT: States.RESPONDER_ACTIVE_LONG_PRESS_OUT,
	        LONG_PRESS_DETECTED: States.ERROR
	    },
	    error: {
	        DELAY: States.NOT_RESPONDER,
	        RESPONDER_GRANT: States.RESPONDER_INACTIVE_PRESS_IN,
	        RESPONDER_RELEASE: States.NOT_RESPONDER,
	        RESPONDER_TERMINATED: States.NOT_RESPONDER,
	        ENTER_PRESS_RECT: States.NOT_RESPONDER,
	        LEAVE_PRESS_RECT: States.NOT_RESPONDER,
	        LONG_PRESS_DETECTED: States.NOT_RESPONDER
	    }
	};
	// ==== Typical Constants for integrating into UI components ====
	// const HIT_EXPAND_PX = 20;
	// const HIT_VERT_OFFSET_PX = 10;
	var HIGHLIGHT_DELAY_MS = 130;
	var PRESS_EXPAND_PX = 20;
	var LONG_PRESS_THRESHOLD = 500;
	var LONG_PRESS_DELAY_MS = LONG_PRESS_THRESHOLD - HIGHLIGHT_DELAY_MS;
	var LONG_PRESS_ALLOWED_MOVEMENT = 10;
	var lastClickTime = 0;
	var pressDelay = 200;
	function isAllowPress() {
	    // avoid click penetration
	    return Date.now() - lastClickTime >= pressDelay;
	}
	
	var Touchable = function (_React$Component) {
	    (0, _inherits3['default'])(Touchable, _React$Component);
	
	    function Touchable() {
	        (0, _classCallCheck3['default'])(this, Touchable);
	
	        var _this = (0, _possibleConstructorReturn3['default'])(this, (Touchable.__proto__ || Object.getPrototypeOf(Touchable)).apply(this, arguments));
	
	        _this.state = {
	            active: false
	        };
	        _this.onTouchStart = function (e) {
	            _this.callChildEvent('onTouchStart', e);
	            _this.lockMouse = true;
	            if (_this.releaseLockTimer) {
	                clearTimeout(_this.releaseLockTimer);
	            }
	            _this.touchableHandleResponderGrant(e.nativeEvent);
	        };
	        _this.onTouchMove = function (e) {
	            _this.callChildEvent('onTouchMove', e);
	            _this.touchableHandleResponderMove(e.nativeEvent);
	        };
	        _this.onTouchEnd = function (e) {
	            _this.callChildEvent('onTouchEnd', e);
	            _this.releaseLockTimer = setTimeout(function () {
	                _this.lockMouse = false;
	            }, 300);
	            _this.touchableHandleResponderRelease(new _PressEvent2['default'](e.nativeEvent));
	        };
	        _this.onTouchCancel = function (e) {
	            _this.callChildEvent('onTouchCancel', e);
	            _this.releaseLockTimer = setTimeout(function () {
	                _this.lockMouse = false;
	            }, 300);
	            _this.touchableHandleResponderTerminate(e.nativeEvent);
	        };
	        _this.onMouseDown = function (e) {
	            _this.callChildEvent('onMouseDown', e);
	            if (_this.lockMouse) {
	                return;
	            }
	            _this.touchableHandleResponderGrant(e.nativeEvent);
	            document.addEventListener('mousemove', _this.touchableHandleResponderMove, false);
	            document.addEventListener('mouseup', _this.onMouseUp, false);
	        };
	        _this.onMouseUp = function (e) {
	            document.removeEventListener('mousemove', _this.touchableHandleResponderMove, false);
	            document.removeEventListener('mouseup', _this.onMouseUp, false);
	            _this.touchableHandleResponderRelease(new _PressEvent2['default'](e));
	        };
	        _this.touchableHandleResponderMove = function (e) {
	            if (!_this.touchable.startMouse) {
	                return;
	            }
	            // Measurement may not have returned yet.
	            if (!_this.touchable.dimensionsOnActivate || _this.touchable.touchState === States.NOT_RESPONDER) {
	                return;
	            }
	            // Not enough time elapsed yet, wait for highlight -
	            // this is just a perf optimization.
	            if (_this.touchable.touchState === States.RESPONDER_INACTIVE_PRESS_IN) {
	                return;
	            }
	            var touch = extractSingleTouch(e);
	            var pageX = touch && touch.pageX;
	            var pageY = touch && touch.pageY;
	            if (_this.pressInLocation) {
	                var movedDistance = _this._getDistanceBetweenPoints(pageX, pageY, _this.pressInLocation.pageX, _this.pressInLocation.pageY);
	                if (movedDistance > LONG_PRESS_ALLOWED_MOVEMENT) {
	                    _this._cancelLongPressDelayTimeout();
	                }
	            }
	            if (_this.checkTouchWithinActive(e)) {
	                _this._receiveSignal(Signals.ENTER_PRESS_RECT, e);
	                var curState = _this.touchable.touchState;
	                if (curState === States.RESPONDER_INACTIVE_PRESS_IN) {
	                    _this._cancelLongPressDelayTimeout();
	                }
	            } else {
	                _this._cancelLongPressDelayTimeout();
	                _this._receiveSignal(Signals.LEAVE_PRESS_RECT, e);
	            }
	        };
	        return _this;
	    }
	
	    (0, _createClass3['default'])(Touchable, [{
	        key: 'componentWillMount',
	        value: function componentWillMount() {
	            this.touchable = { touchState: undefined };
	        }
	    }, {
	        key: 'componentDidMount',
	        value: function componentDidMount() {
	            this.root = _reactDom2['default'].findDOMNode(this);
	        }
	    }, {
	        key: 'componentDidUpdate',
	        value: function componentDidUpdate() {
	            this.root = _reactDom2['default'].findDOMNode(this);
	            // disabled auto clear active state
	            if (this.props.disabled && this.state.active) {
	                this.setState({
	                    active: false
	                });
	            }
	        }
	    }, {
	        key: 'componentWillUnmount',
	        value: function componentWillUnmount() {
	            if (this.releaseLockTimer) {
	                clearTimeout(this.releaseLockTimer);
	            }
	            if (this.touchableDelayTimeout) {
	                clearTimeout(this.touchableDelayTimeout);
	            }
	            if (this.longPressDelayTimeout) {
	                clearTimeout(this.longPressDelayTimeout);
	            }
	            if (this.pressOutDelayTimeout) {
	                clearTimeout(this.pressOutDelayTimeout);
	            }
	        }
	    }, {
	        key: 'callChildEvent',
	        value: function callChildEvent(event, e) {
	            var childHandle = _react2['default'].Children.only(this.props.children).props[event];
	            if (childHandle) {
	                childHandle(e);
	            }
	        }
	    }, {
	        key: '_remeasureMetricsOnInit',
	        value: function _remeasureMetricsOnInit(e) {
	            var root = this.root;
	
	            var touch = extractSingleTouch(e);
	            var boundingRect = root.getBoundingClientRect();
	            this.touchable = {
	                touchState: this.touchable.touchState,
	                startMouse: {
	                    pageX: touch.pageX,
	                    pageY: touch.pageY
	                },
	                positionOnGrant: {
	                    left: boundingRect.left + window.pageXOffset,
	                    top: boundingRect.top + window.pageYOffset,
	                    width: boundingRect.width,
	                    height: boundingRect.height,
	                    clientLeft: boundingRect.left,
	                    clientTop: boundingRect.top
	                }
	            };
	        }
	    }, {
	        key: 'touchableHandleResponderGrant',
	        value: function touchableHandleResponderGrant(e) {
	            var _this2 = this;
	
	            this.touchable.touchState = States.NOT_RESPONDER;
	            if (this.pressOutDelayTimeout) {
	                clearTimeout(this.pressOutDelayTimeout);
	                this.pressOutDelayTimeout = null;
	            }
	            if (this.props.fixClickPenetration && !isAllowPress()) {
	                return;
	            }
	            this._remeasureMetricsOnInit(e);
	            this._receiveSignal(Signals.RESPONDER_GRANT, e);
	            var _props = this.props,
	                delayMS = _props.delayPressIn,
	                longDelayMS = _props.delayLongPress;
	
	            if (delayMS) {
	                this.touchableDelayTimeout = setTimeout(function () {
	                    _this2._handleDelay(e);
	                }, delayMS);
	            } else {
	                this._handleDelay(e);
	            }
	            var longPressEvent = new _PressEvent2['default'](e);
	            this.longPressDelayTimeout = setTimeout(function () {
	                _this2._handleLongDelay(longPressEvent);
	            }, longDelayMS + delayMS);
	        }
	    }, {
	        key: 'checkScroll',
	        value: function checkScroll(e) {
	            var positionOnGrant = this.touchable.positionOnGrant;
	            // container or window scroll
	            var boundingRect = this.root.getBoundingClientRect();
	            if (boundingRect.left !== positionOnGrant.clientLeft || boundingRect.top !== positionOnGrant.clientTop) {
	                this._receiveSignal(Signals.RESPONDER_TERMINATED, e);
	                return false;
	            }
	        }
	    }, {
	        key: 'touchableHandleResponderRelease',
	        value: function touchableHandleResponderRelease(e) {
	            if (!this.touchable.startMouse) {
	                return;
	            }
	            var touch = extractSingleTouch(e);
	            if (Math.abs(touch.pageX - this.touchable.startMouse.pageX) > 30 || Math.abs(touch.pageY - this.touchable.startMouse.pageY) > 30) {
	                this._receiveSignal(Signals.RESPONDER_TERMINATED, e);
	                return;
	            }
	            if (this.checkScroll(e) === false) {
	                return;
	            }
	            this._receiveSignal(Signals.RESPONDER_RELEASE, e);
	        }
	    }, {
	        key: 'touchableHandleResponderTerminate',
	        value: function touchableHandleResponderTerminate(e) {
	            if (!this.touchable.startMouse) {
	                return;
	            }
	            this._receiveSignal(Signals.RESPONDER_TERMINATED, e);
	        }
	    }, {
	        key: 'checkTouchWithinActive',
	        value: function checkTouchWithinActive(e) {
	            var positionOnGrant = this.touchable.positionOnGrant;
	            var _props2 = this.props,
	                _props2$pressRetentio = _props2.pressRetentionOffset,
	                pressRetentionOffset = _props2$pressRetentio === undefined ? {} : _props2$pressRetentio,
	                hitSlop = _props2.hitSlop;
	
	            var pressExpandLeft = pressRetentionOffset.left;
	            var pressExpandTop = pressRetentionOffset.top;
	            var pressExpandRight = pressRetentionOffset.right;
	            var pressExpandBottom = pressRetentionOffset.bottom;
	            if (hitSlop) {
	                pressExpandLeft += hitSlop.left;
	                pressExpandTop += hitSlop.top;
	                pressExpandRight += hitSlop.right;
	                pressExpandBottom += hitSlop.bottom;
	            }
	            var touch = extractSingleTouch(e);
	            var pageX = touch && touch.pageX;
	            var pageY = touch && touch.pageY;
	            return pageX > positionOnGrant.left - pressExpandLeft && pageY > positionOnGrant.top - pressExpandTop && pageX < positionOnGrant.left + positionOnGrant.width + pressExpandRight && pageY < positionOnGrant.top + positionOnGrant.height + pressExpandBottom;
	        }
	    }, {
	        key: 'callProp',
	        value: function callProp(name, e) {
	            if (this.props[name] && !this.props.disabled) {
	                this.props[name](e);
	            }
	        }
	    }, {
	        key: 'touchableHandleActivePressIn',
	        value: function touchableHandleActivePressIn(e) {
	            this.setActive(true);
	            this.callProp('onPressIn', e);
	        }
	    }, {
	        key: 'touchableHandleActivePressOut',
	        value: function touchableHandleActivePressOut(e) {
	            this.setActive(false);
	            this.callProp('onPressOut', e);
	        }
	    }, {
	        key: 'touchableHandlePress',
	        value: function touchableHandlePress(e) {
	            if ((0, _PressEvent.shouldFirePress)(e)) {
	                this.callProp('onPress', e);
	            }
	            lastClickTime = Date.now();
	        }
	    }, {
	        key: 'touchableHandleLongPress',
	        value: function touchableHandleLongPress(e) {
	            if ((0, _PressEvent.shouldFirePress)(e)) {
	                this.callProp('onLongPress', e);
	            }
	        }
	    }, {
	        key: 'setActive',
	        value: function setActive(active) {
	            if (this.props.activeClassName || this.props.activeStyle) {
	                this.setState({
	                    active: active
	                });
	            }
	        }
	    }, {
	        key: '_remeasureMetricsOnActivation',
	        value: function _remeasureMetricsOnActivation() {
	            this.touchable.dimensionsOnActivate = this.touchable.positionOnGrant;
	        }
	    }, {
	        key: '_handleDelay',
	        value: function _handleDelay(e) {
	            this.touchableDelayTimeout = null;
	            this._receiveSignal(Signals.DELAY, e);
	        }
	    }, {
	        key: '_handleLongDelay',
	        value: function _handleLongDelay(e) {
	            this.longPressDelayTimeout = null;
	            var curState = this.touchable.touchState;
	            if (curState !== States.RESPONDER_ACTIVE_PRESS_IN && curState !== States.RESPONDER_ACTIVE_LONG_PRESS_IN) {
	                console.error('Attempted to transition from state `' + curState + '` to `' + States.RESPONDER_ACTIVE_LONG_PRESS_IN + '`, which is not supported. This is ' + 'most likely due to `Touchable.longPressDelayTimeout` not being cancelled.');
	            } else {
	                this._receiveSignal(Signals.LONG_PRESS_DETECTED, e);
	            }
	        }
	    }, {
	        key: '_receiveSignal',
	        value: function _receiveSignal(signal, e) {
	            var curState = this.touchable.touchState;
	            var nextState = Transitions[curState] && Transitions[curState][signal];
	            if (!nextState) {
	                return;
	            }
	            if (nextState === States.ERROR) {
	                return;
	            }
	            if (curState !== nextState) {
	                this._performSideEffectsForTransition(curState, nextState, signal, e);
	                this.touchable.touchState = nextState;
	            }
	        }
	    }, {
	        key: '_cancelLongPressDelayTimeout',
	        value: function _cancelLongPressDelayTimeout() {
	            if (this.longPressDelayTimeout) {
	                clearTimeout(this.longPressDelayTimeout);
	                this.longPressDelayTimeout = null;
	            }
	        }
	    }, {
	        key: '_isHighlight',
	        value: function _isHighlight(state) {
	            return state === States.RESPONDER_ACTIVE_PRESS_IN || state === States.RESPONDER_ACTIVE_LONG_PRESS_IN;
	        }
	    }, {
	        key: '_savePressInLocation',
	        value: function _savePressInLocation(e) {
	            var touch = extractSingleTouch(e);
	            var pageX = touch && touch.pageX;
	            var pageY = touch && touch.pageY;
	            this.pressInLocation = { pageX: pageX, pageY: pageY };
	        }
	    }, {
	        key: '_getDistanceBetweenPoints',
	        value: function _getDistanceBetweenPoints(aX, aY, bX, bY) {
	            var deltaX = aX - bX;
	            var deltaY = aY - bY;
	            return Math.sqrt(deltaX * deltaX + deltaY * deltaY);
	        }
	    }, {
	        key: '_performSideEffectsForTransition',
	        value: function _performSideEffectsForTransition(curState, nextState, signal, e) {
	            var curIsHighlight = this._isHighlight(curState);
	            var newIsHighlight = this._isHighlight(nextState);
	            var isFinalSignal = signal === Signals.RESPONDER_TERMINATED || signal === Signals.RESPONDER_RELEASE;
	            if (isFinalSignal) {
	                this._cancelLongPressDelayTimeout();
	            }
	            if (!IsActive[curState] && IsActive[nextState]) {
	                this._remeasureMetricsOnActivation();
	            }
	            if (IsPressingIn[curState] && signal === Signals.LONG_PRESS_DETECTED) {
	                this.touchableHandleLongPress(e);
	            }
	            if (newIsHighlight && !curIsHighlight) {
	                this._startHighlight(e);
	            } else if (!newIsHighlight && curIsHighlight) {
	                this._endHighlight(e);
	            }
	            if (IsPressingIn[curState] && signal === Signals.RESPONDER_RELEASE) {
	                var hasLongPressHandler = !!this.props.onLongPress;
	                var pressIsLongButStillCallOnPress = IsLongPressingIn[curState] && (!hasLongPressHandler || !this.props.longPressCancelsPress // or we're told to ignore it.
	                );
	                var shouldInvokePress = !IsLongPressingIn[curState] || pressIsLongButStillCallOnPress;
	                if (shouldInvokePress) {
	                    if (!newIsHighlight && !curIsHighlight) {
	                        // we never highlighted because of delay, but we should highlight now
	                        this._startHighlight(e);
	                        this._endHighlight(e);
	                    }
	                    this.touchableHandlePress(e);
	                }
	            }
	            if (this.touchableDelayTimeout) {
	                clearTimeout(this.touchableDelayTimeout);
	                this.touchableDelayTimeout = null;
	            }
	        }
	    }, {
	        key: '_startHighlight',
	        value: function _startHighlight(e) {
	            this._savePressInLocation(e);
	            this.touchableHandleActivePressIn(e);
	        }
	    }, {
	        key: '_endHighlight',
	        value: function _endHighlight(e) {
	            var _this3 = this;
	
	            if (this.props.delayPressOut) {
	                this.pressOutDelayTimeout = setTimeout(function () {
	                    _this3.touchableHandleActivePressOut(e);
	                }, this.props.delayPressOut);
	            } else {
	                this.touchableHandleActivePressOut(e);
	            }
	        }
	    }, {
	        key: 'render',
	        value: function render() {
	            var _props3 = this.props,
	                children = _props3.children,
	                disabled = _props3.disabled,
	                activeStyle = _props3.activeStyle,
	                activeClassName = _props3.activeClassName;
	
	            var events = disabled ? undefined : copy(this, ['onTouchStart', 'onTouchMove', 'onTouchEnd', 'onTouchCancel', 'onMouseDown']);
	            var child = _react2['default'].Children.only(children);
	            if (!disabled && this.state.active) {
	                var _child$props = child.props,
	                    style = _child$props.style,
	                    className = _child$props.className;
	
	                if (activeStyle) {
	                    style = (0, _extends3['default'])({}, style, activeStyle);
	                }
	                if (activeClassName) {
	                    if (className) {
	                        className += ' ' + activeClassName;
	                    } else {
	                        className = activeClassName;
	                    }
	                }
	                return _react2['default'].cloneElement(child, (0, _extends3['default'])({ className: className,
	                    style: style }, events));
	            }
	            return _react2['default'].cloneElement(child, events);
	        }
	    }]);
	    return Touchable;
	}(_react2['default'].Component);
	
	exports['default'] = Touchable;
	
	Touchable.defaultProps = {
	    fixClickPenetration: false,
	    disabled: false,
	    delayPressIn: HIGHLIGHT_DELAY_MS,
	    delayLongPress: LONG_PRESS_DELAY_MS,
	    delayPressOut: 100,
	    pressRetentionOffset: {
	        left: PRESS_EXPAND_PX,
	        right: PRESS_EXPAND_PX,
	        top: PRESS_EXPAND_PX,
	        bottom: PRESS_EXPAND_PX
	    },
	    hitSlop: undefined,
	    longPressCancelsPress: true
	};
	module.exports = exports['default'];

/***/ }),
/* 774 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	exports.__esModule = true;
	exports.SelectPropTypes = undefined;
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _strategies = __webpack_require__(151);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function valueType(props, propName, componentName) {
	  var labelInValueShape = _propTypes2['default'].shape({
	    value: _propTypes2['default'].string.isRequired,
	    label: _propTypes2['default'].node
	  });
	  if (props.labelInValue) {
	    var validate = _propTypes2['default'].oneOfType([_propTypes2['default'].arrayOf(labelInValueShape), labelInValueShape]);
	    var error = validate.apply(undefined, arguments);
	    if (error) {
	      return new Error('Invalid prop `' + propName + '` supplied to `' + componentName + '`, ' + ('when `labelInValue` is `true`, `' + propName + '` should in ') + 'shape of `{ value: string, label?: string }`.');
	    }
	  } else if (props.treeCheckable && props.treeCheckStrictly) {
	    var _validate = _propTypes2['default'].oneOfType([_propTypes2['default'].arrayOf(labelInValueShape), labelInValueShape]);
	    var _error = _validate.apply(undefined, arguments);
	    if (_error) {
	      return new Error('Invalid prop `' + propName + '` supplied to `' + componentName + '`, ' + 'when `treeCheckable` and `treeCheckStrictly` are `true`, ' + ('`' + propName + '` should in shape of `{ value: string, label?: string }`.'));
	    }
	  } else if (props.multiple && props[propName] === '') {
	    return new Error('Invalid prop `' + propName + '` of type `string` supplied to `' + componentName + '`, ' + 'expected `array` when `multiple` is `true`.');
	  } else {
	    var _validate2 = _propTypes2['default'].oneOfType([_propTypes2['default'].arrayOf(_propTypes2['default'].string), _propTypes2['default'].string]);
	    return _validate2.apply(undefined, arguments);
	  }
	}
	
	var SelectPropTypes = exports.SelectPropTypes = {
	  className: _propTypes2['default'].string,
	  prefixCls: _propTypes2['default'].string,
	  multiple: _propTypes2['default'].bool,
	  filterTreeNode: _propTypes2['default'].any,
	  showSearch: _propTypes2['default'].bool,
	  disabled: _propTypes2['default'].bool,
	  showArrow: _propTypes2['default'].bool,
	  allowClear: _propTypes2['default'].bool,
	  defaultOpen: _propTypes2['default'].bool,
	  open: _propTypes2['default'].bool,
	  transitionName: _propTypes2['default'].string,
	  animation: _propTypes2['default'].string,
	  choiceTransitionName: _propTypes2['default'].string,
	  onClick: _propTypes2['default'].func,
	  onChange: _propTypes2['default'].func,
	  onSelect: _propTypes2['default'].func,
	  onDeselect: _propTypes2['default'].func,
	  onSearch: _propTypes2['default'].func,
	  searchPlaceholder: _propTypes2['default'].string,
	  placeholder: _propTypes2['default'].any,
	  inputValue: _propTypes2['default'].any,
	  value: valueType,
	  defaultValue: valueType,
	  label: _propTypes2['default'].node,
	  defaultLabel: _propTypes2['default'].any,
	  labelInValue: _propTypes2['default'].bool,
	  dropdownStyle: _propTypes2['default'].object,
	  drodownPopupAlign: _propTypes2['default'].object,
	  onDropdownVisibleChange: _propTypes2['default'].func,
	  maxTagTextLength: _propTypes2['default'].number,
	  showCheckedStrategy: _propTypes2['default'].oneOf([_strategies.SHOW_ALL, _strategies.SHOW_PARENT, _strategies.SHOW_CHILD]),
	  treeCheckStrictly: _propTypes2['default'].bool,
	  treeIcon: _propTypes2['default'].bool,
	  treeLine: _propTypes2['default'].bool,
	  treeDefaultExpandAll: _propTypes2['default'].bool,
	  treeCheckable: _propTypes2['default'].oneOfType([_propTypes2['default'].bool, _propTypes2['default'].node]),
	  treeNodeLabelProp: _propTypes2['default'].string,
	  treeNodeFilterProp: _propTypes2['default'].string,
	  treeData: _propTypes2['default'].array,
	  treeDataSimpleMode: _propTypes2['default'].oneOfType([_propTypes2['default'].bool, _propTypes2['default'].object]),
	  loadData: _propTypes2['default'].func
	};

/***/ }),
/* 775 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	exports.__esModule = true;
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _objectWithoutProperties2 = __webpack_require__(20);
	
	var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _reactDom = __webpack_require__(10);
	
	var _reactDom2 = _interopRequireDefault(_reactDom);
	
	var _KeyCode = __webpack_require__(29);
	
	var _KeyCode2 = _interopRequireDefault(_KeyCode);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _objectAssign = __webpack_require__(18);
	
	var _objectAssign2 = _interopRequireDefault(_objectAssign);
	
	var _rcAnimate = __webpack_require__(22);
	
	var _rcAnimate2 = _interopRequireDefault(_rcAnimate);
	
	var _util = __webpack_require__(276);
	
	var _SelectTrigger = __webpack_require__(776);
	
	var _SelectTrigger2 = _interopRequireDefault(_SelectTrigger);
	
	var _TreeNode2 = __webpack_require__(275);
	
	var _TreeNode3 = _interopRequireDefault(_TreeNode2);
	
	var _strategies = __webpack_require__(151);
	
	var _PropTypes = __webpack_require__(774);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function noop() {}
	
	function filterFn(input, child) {
	  return String((0, _util.getPropValue)(child, (0, _util.labelCompatible)(this.props.treeNodeFilterProp))).indexOf(input) > -1;
	}
	
	function saveRef(name, component) {
	  this[name] = component;
	}
	
	function loopTreeData(data) {
	  var level = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
	
	  return data.map(function (item, index) {
	    var pos = level + '-' + index;
	    var label = item.label,
	        value = item.value,
	        disabled = item.disabled,
	        key = item.key,
	        hasOwnProperty = item.hasOwnProperty,
	        selectable = item.selectable,
	        children = item.children,
	        isLeaf = item.isLeaf,
	        otherProps = (0, _objectWithoutProperties3['default'])(item, ['label', 'value', 'disabled', 'key', 'hasOwnProperty', 'selectable', 'children', 'isLeaf']);
	
	    var props = (0, _extends3['default'])({
	      value: value,
	      title: label,
	      // value: value || String(key || label), // cause onChange callback error
	      key: key || value || pos,
	      disabled: disabled || false,
	      selectable: selectable === false ? selectable : true
	    }, otherProps);
	    var ret = void 0;
	    if (children && children.length) {
	      ret = _react2['default'].createElement(
	        _TreeNode3['default'],
	        props,
	        loopTreeData(children, pos)
	      );
	    } else {
	      ret = _react2['default'].createElement(_TreeNode3['default'], (0, _extends3['default'])({}, props, { isLeaf: isLeaf }));
	    }
	    return ret;
	  });
	}
	
	var Select = function (_Component) {
	  (0, _inherits3['default'])(Select, _Component);
	
	  function Select(props) {
	    (0, _classCallCheck3['default'])(this, Select);
	
	    var _this = (0, _possibleConstructorReturn3['default'])(this, _Component.call(this, props));
	
	    _initialiseProps.call(_this);
	
	    var value = [];
	    if ('value' in props) {
	      value = (0, _util.toArray)(props.value);
	    } else {
	      value = (0, _util.toArray)(props.defaultValue);
	    }
	    // save parsed treeData, for performance (treeData may be very big)
	    _this.renderedTreeData = _this.renderTreeData();
	    value = _this.addLabelToValue(props, value);
	    value = _this.getValue(props, value, props.inputValue ? '__strict' : true);
	    var inputValue = props.inputValue || '';
	    // if (props.combobox) {
	    //   inputValue = value.length ? String(value[0].value) : '';
	    // }
	    _this.saveInputRef = saveRef.bind(_this, 'inputInstance');
	    _this.saveInputMirrorRef = saveRef.bind(_this, 'inputMirrorInstance');
	    _this.state = {
	      value: value,
	      inputValue: inputValue,
	      open: props.open || props.defaultOpen,
	      focused: false
	    };
	    return _this;
	  }
	
	  Select.prototype.componentDidMount = function componentDidMount() {
	    if ((0, _util.isMultipleOrTags)(this.props)) {
	      var inputNode = this.getInputDOMNode();
	      if (inputNode.value) {
	        inputNode.style.width = '';
	        inputNode.style.width = this.inputMirrorInstance.clientWidth + 'px';
	      } else {
	        inputNode.style.width = '';
	      }
	    }
	  };
	
	  Select.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {
	    // save parsed treeData, for performance (treeData may be very big)
	    this.renderedTreeData = this.renderTreeData(nextProps);
	    // Detecting whether the object of `onChange`'s argument  is old ref.
	    // Better to do a deep equal later.
	    this._cacheTreeNodesStates = this._cacheTreeNodesStates !== 'no' && this._savedValue && nextProps.value === this._savedValue;
	    if (this.props.treeData !== nextProps.treeData || this.props.children !== nextProps.children) {
	      // refresh this._treeNodesStates cache
	      this._treeNodesStates = (0, _util.getTreeNodesStates)(this.renderedTreeData || nextProps.children, this.state.value.map(function (item) {
	        return item.value;
	      }));
	    }
	    if ('value' in nextProps) {
	      var value = (0, _util.toArray)(nextProps.value);
	      value = this.addLabelToValue(nextProps, value);
	      value = this.getValue(nextProps, value);
	      this.setState({
	        value: value
	      });
	      // if (nextProps.combobox) {
	      //   this.setState({
	      //     inputValue: value.length ? String(value[0].key) : '',
	      //   });
	      // }
	    }
	    if (nextProps.inputValue !== this.props.inputValue) {
	      this.setState({
	        inputValue: nextProps.inputValue
	      });
	    }
	    if ('open' in nextProps) {
	      this.setState({
	        open: nextProps.open
	      });
	    }
	  };
	
	  Select.prototype.componentWillUpdate = function componentWillUpdate(nextProps) {
	    if (this._savedValue && nextProps.value && nextProps.value !== this._savedValue && nextProps.value === this.props.value) {
	      this._cacheTreeNodesStates = false;
	      this.getValue(nextProps, this.addLabelToValue(nextProps, (0, _util.toArray)(nextProps.value)));
	    }
	  };
	
	  Select.prototype.componentDidUpdate = function componentDidUpdate() {
	    var state = this.state;
	    var props = this.props;
	    if (state.open && (0, _util.isMultipleOrTags)(props)) {
	      var inputNode = this.getInputDOMNode();
	      if (inputNode.value) {
	        inputNode.style.width = '';
	        inputNode.style.width = this.inputMirrorInstance.clientWidth + 'px';
	      } else {
	        inputNode.style.width = '';
	      }
	    }
	  };
	
	  Select.prototype.componentWillUnmount = function componentWillUnmount() {
	    this.clearDelayTimer();
	    if (this.dropdownContainer) {
	      _reactDom2['default'].unmountComponentAtNode(this.dropdownContainer);
	      document.body.removeChild(this.dropdownContainer);
	      this.dropdownContainer = null;
	    }
	  };
	
	  // combobox ignore
	
	
	  Select.prototype.getLabelFromNode = function getLabelFromNode(child) {
	    return (0, _util.getPropValue)(child, this.props.treeNodeLabelProp);
	  };
	
	  Select.prototype.getLabelFromProps = function getLabelFromProps(props, value) {
	    var _this2 = this;
	
	    if (value === undefined) {
	      return null;
	    }
	    var label = null;
	    (0, _util.loopAllChildren)(this.renderedTreeData || props.children, function (item) {
	      if ((0, _util.getValuePropValue)(item) === value) {
	        label = _this2.getLabelFromNode(item);
	      }
	    });
	    if (label === null) {
	      return value;
	    }
	    return label;
	  };
	
	  Select.prototype.getDropdownContainer = function getDropdownContainer() {
	    if (!this.dropdownContainer) {
	      this.dropdownContainer = document.createElement('div');
	      document.body.appendChild(this.dropdownContainer);
	    }
	    return this.dropdownContainer;
	  };
	
	  Select.prototype.getSearchPlaceholderElement = function getSearchPlaceholderElement(hidden) {
	    var props = this.props;
	    var placeholder = void 0;
	    if ((0, _util.isMultipleOrTagsOrCombobox)(props)) {
	      placeholder = props.placeholder || props.searchPlaceholder;
	    } else {
	      placeholder = props.searchPlaceholder;
	    }
	    if (placeholder) {
	      return _react2['default'].createElement(
	        'span',
	        {
	          style: { display: hidden ? 'none' : 'block' },
	          onClick: this.onPlaceholderClick,
	          className: props.prefixCls + '-search__field__placeholder'
	        },
	        placeholder
	      );
	    }
	    return null;
	  };
	
	  Select.prototype.getInputElement = function getInputElement() {
	    var inputValue = this.state.inputValue;
	    var _props2 = this.props,
	        prefixCls = _props2.prefixCls,
	        disabled = _props2.disabled;
	
	    return _react2['default'].createElement(
	      'span',
	      { className: prefixCls + '-search__field__wrap' },
	      _react2['default'].createElement('input', {
	        ref: this.saveInputRef,
	        onChange: this.onInputChange,
	        onKeyDown: this.onInputKeyDown,
	        value: inputValue,
	        disabled: disabled,
	        className: prefixCls + '-search__field',
	        role: 'textbox'
	      }),
	      _react2['default'].createElement(
	        'span',
	        {
	          ref: this.saveInputMirrorRef,
	          className: prefixCls + '-search__field__mirror'
	        },
	        inputValue,
	        '\xA0'
	      ),
	      (0, _util.isMultipleOrTags)(this.props) ? null : this.getSearchPlaceholderElement(!!inputValue)
	    );
	  };
	
	  Select.prototype.getInputDOMNode = function getInputDOMNode() {
	    return this.inputInstance;
	  };
	
	  Select.prototype.getPopupDOMNode = function getPopupDOMNode() {
	    return this.refs.trigger.getPopupDOMNode();
	  };
	
	  Select.prototype.getPopupComponentRefs = function getPopupComponentRefs() {
	    return this.refs.trigger.getPopupEleRefs();
	  };
	
	  Select.prototype.getValue = function getValue(_props, val) {
	    var _this3 = this;
	
	    var init = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
	
	    var value = val;
	    // if inputValue existing, tree is checkStrictly
	    var _strict = init === '__strict' || init && (this.state && this.state.inputValue || this.props.inputValue !== _props.inputValue);
	    if (_props.treeCheckable && (_props.treeCheckStrictly || _strict)) {
	      this.halfCheckedValues = [];
	      value = [];
	      val.forEach(function (i) {
	        if (!i.halfChecked) {
	          value.push(i);
	        } else {
	          _this3.halfCheckedValues.push(i);
	        }
	      });
	    }
	    // if (!(_props.treeCheckable && !_props.treeCheckStrictly)) {
	    if (!!!_props.treeCheckable || _props.treeCheckable && (_props.treeCheckStrictly || _strict)) {
	      return value;
	    }
	    var checkedTreeNodes = void 0;
	    if (this._cachetreeData && this._cacheTreeNodesStates && this._checkedNodes && this.state && !this.state.inputValue) {
	      this.checkedTreeNodes = checkedTreeNodes = this._checkedNodes;
	    } else {
	      /**
	       * Note: `this._treeNodesStates`'s treeNodesStates must correspond to nodes of the
	       * final tree (`processTreeNode` function from SelectTrigger.jsx produce the final tree).
	       *
	       * And, `this._treeNodesStates` from `onSelect` is previous value,
	       * so it perhaps only have a few nodes, but the newly filtered tree can have many nodes,
	       * thus, you cannot use previous _treeNodesStates.
	       */
	      // getTreeNodesStates is not effective.
	      this._treeNodesStates = (0, _util.getTreeNodesStates)(this.renderedTreeData || _props.children, value.map(function (item) {
	        return item.value;
	      }));
	      this.checkedTreeNodes = checkedTreeNodes = this._treeNodesStates.checkedNodes;
	    }
	    var mapLabVal = function mapLabVal(arr) {
	      return arr.map(function (itemObj) {
	        return {
	          value: (0, _util.getValuePropValue)(itemObj.node),
	          label: (0, _util.getPropValue)(itemObj.node, _props.treeNodeLabelProp)
	        };
	      });
	    };
	    var props = this.props;
	    var checkedValues = [];
	    if (props.showCheckedStrategy === _strategies.SHOW_ALL) {
	      checkedValues = mapLabVal(checkedTreeNodes);
	    } else if (props.showCheckedStrategy === _strategies.SHOW_PARENT) {
	      var posArr = (0, _util.filterParentPosition)(checkedTreeNodes.map(function (itemObj) {
	        return itemObj.pos;
	      }));
	      checkedValues = mapLabVal(checkedTreeNodes.filter(function (itemObj) {
	        return posArr.indexOf(itemObj.pos) !== -1;
	      }));
	    } else {
	      checkedValues = mapLabVal(checkedTreeNodes.filter(function (itemObj) {
	        return !itemObj.node.props.children;
	      }));
	    }
	    return checkedValues;
	  };
	
	  Select.prototype.getCheckedNodes = function getCheckedNodes(info, props) {
	    // TODO treeCheckable does not support tags/dynamic
	    var checkedNodes = info.checkedNodes;
	    // if inputValue existing, tree is checkStrictly
	
	    if (props.treeCheckStrictly || this.state.inputValue) {
	      return checkedNodes;
	    }
	    var checkedNodesPositions = info.checkedNodesPositions;
	    if (props.showCheckedStrategy === _strategies.SHOW_ALL) {
	      checkedNodes = checkedNodes;
	    } else if (props.showCheckedStrategy === _strategies.SHOW_PARENT) {
	      var posArr = (0, _util.filterParentPosition)(checkedNodesPositions.map(function (itemObj) {
	        return itemObj.pos;
	      }));
	      checkedNodes = checkedNodesPositions.filter(function (itemObj) {
	        return posArr.indexOf(itemObj.pos) !== -1;
	      }).map(function (itemObj) {
	        return itemObj.node;
	      });
	    } else {
	      checkedNodes = checkedNodes.filter(function (n) {
	        return !n.props.children;
	      });
	    }
	    return checkedNodes;
	  };
	
	  Select.prototype.getDeselectedValue = function getDeselectedValue(selectedValue) {
	    var checkedTreeNodes = this.checkedTreeNodes;
	    var unCheckPos = void 0;
	    checkedTreeNodes.forEach(function (itemObj) {
	      if (itemObj.node.props.value === selectedValue) {
	        unCheckPos = itemObj.pos;
	      }
	    });
	    var nArr = unCheckPos && unCheckPos.split('-');
	    var newVals = [];
	    var newCkTns = [];
	    checkedTreeNodes.forEach(function (itemObj) {
	      var iArr = itemObj.pos.split('-');
	      if (itemObj.pos === unCheckPos || nArr.length > iArr.length && (0, _util.isInclude)(iArr, nArr) || nArr.length < iArr.length && (0, _util.isInclude)(nArr, iArr)) {
	        // Filter ancestral and children nodes when uncheck a node.
	        return;
	      }
	      newCkTns.push(itemObj);
	      newVals.push(itemObj.node.props.value);
	    });
	    this.checkedTreeNodes = this._checkedNodes = newCkTns;
	    var nv = this.state.value.filter(function (val) {
	      return newVals.indexOf(val.value) !== -1;
	    });
	    this.fireChange(nv, { triggerValue: selectedValue, clear: true });
	  };
	
	  Select.prototype.setOpenState = function setOpenState(open, needFocus) {
	    var _this4 = this;
	
	    var documentClickClose = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
	
	    this.clearDelayTimer();
	    var props = this.props,
	        refs = this.refs;
	    // can not optimize, if children is empty
	    // if (this.state.open === open) {
	    //   return;
	    // }
	
	    if (!this.props.onDropdownVisibleChange(open, { documentClickClose: documentClickClose })) {
	      return;
	    }
	    this.setState({
	      open: open
	    }, function () {
	      if (needFocus || open) {
	        if (open || (0, _util.isMultipleOrTagsOrCombobox)(props)) {
	          var input = _this4.getInputDOMNode();
	          if (input && document.activeElement !== input) {
	            input.focus();
	          }
	        } else if (refs.selection) {
	          refs.selection.focus();
	        }
	      }
	    });
	  };
	
	  Select.prototype.clearSearchInput = function clearSearchInput() {
	    this.getInputDOMNode().focus();
	    if (!('inputValue' in this.props)) {
	      this.setState({ inputValue: '' });
	    }
	  };
	
	  Select.prototype.addLabelToValue = function addLabelToValue(props, value_) {
	    var _this5 = this;
	
	    var value = value_;
	    if (this.isLabelInValue()) {
	      value.forEach(function (v, i) {
	        if (Object.prototype.toString.call(value[i]) !== '[object Object]') {
	          value[i] = {
	            value: '',
	            label: ''
	          };
	          return;
	        }
	        v.label = v.label || _this5.getLabelFromProps(props, v.value);
	      });
	    } else {
	      value = value.map(function (v) {
	        return {
	          value: v,
	          label: _this5.getLabelFromProps(props, v)
	        };
	      });
	    }
	    return value;
	  };
	
	  Select.prototype.clearDelayTimer = function clearDelayTimer() {
	    if (this.delayTimer) {
	      clearTimeout(this.delayTimer);
	      this.delayTimer = null;
	    }
	  };
	
	  Select.prototype.removeSelected = function removeSelected(selectedVal) {
	    var props = this.props;
	    if (props.disabled) {
	      return;
	    }
	    this._cacheTreeNodesStates = 'no';
	    if (props.treeCheckable && (props.showCheckedStrategy === _strategies.SHOW_ALL || props.showCheckedStrategy === _strategies.SHOW_PARENT) && !(props.treeCheckStrictly || this.state.inputValue)) {
	      this.getDeselectedValue(selectedVal);
	      return;
	    }
	    // click the node's `x`(in select box), likely trigger the TreeNode's `unCheck` event,
	    // cautiously, they are completely different, think about it, the tree may not render at first,
	    // but the nodes in select box are ready.
	    var label = void 0;
	    var value = this.state.value.filter(function (singleValue) {
	      if (singleValue.value === selectedVal) {
	        label = singleValue.label;
	      }
	      return singleValue.value !== selectedVal;
	    });
	    var canMultiple = (0, _util.isMultipleOrTags)(props);
	
	    if (canMultiple) {
	      var event = selectedVal;
	      if (this.isLabelInValue()) {
	        event = {
	          value: selectedVal,
	          label: label
	        };
	      }
	      props.onDeselect(event);
	    }
	    if (props.treeCheckable) {
	      if (this.checkedTreeNodes && this.checkedTreeNodes.length) {
	        this.checkedTreeNodes = this._checkedNodes = this.checkedTreeNodes.filter(function (item) {
	          return value.some(function (i) {
	            return i.value === item.node.props.value;
	          });
	        });
	      }
	    }
	    this.fireChange(value, { triggerValue: selectedVal, clear: true });
	  };
	
	  Select.prototype.openIfHasChildren = function openIfHasChildren() {
	    var props = this.props;
	    if (_react2['default'].Children.count(props.children) || (0, _util.isSingleMode)(props)) {
	      this.setOpenState(true);
	    }
	  };
	
	  Select.prototype.fireChange = function fireChange(value, extraInfo) {
	    var _this6 = this;
	
	    var props = this.props;
	    var vals = value.map(function (i) {
	      return i.value;
	    });
	    var sv = this.state.value.map(function (i) {
	      return i.value;
	    });
	    if (vals.length !== sv.length || !vals.every(function (val, index) {
	      return sv[index] === val;
	    })) {
	      var ex = { preValue: [].concat(this.state.value) };
	      if (extraInfo) {
	        (0, _objectAssign2['default'])(ex, extraInfo);
	      }
	      var labs = null;
	      var vls = value;
	      if (!this.isLabelInValue()) {
	        labs = value.map(function (i) {
	          return i.label;
	        });
	        vls = vls.map(function (v) {
	          return v.value;
	        });
	      } else if (this.halfCheckedValues && this.halfCheckedValues.length) {
	        this.halfCheckedValues.forEach(function (i) {
	          if (!vls.some(function (v) {
	            return v.value === i.value;
	          })) {
	            vls.push(i);
	          }
	        });
	      }
	      if (props.treeCheckable && ex.clear) {
	        var treeData = this.renderedTreeData || props.children;
	        ex.allCheckedNodes = (0, _util.flatToHierarchy)((0, _util.filterAllCheckedData)(vals, treeData));
	      }
	      if (props.treeCheckable && this.state.inputValue) {
	        var _vls = [].concat(this.state.value);
	        if (ex.checked) {
	          value.forEach(function (i) {
	            if (_vls.every(function (ii) {
	              return ii.value !== i.value;
	            })) {
	              _vls.push((0, _extends3['default'])({}, i));
	            }
	          });
	        } else {
	          var index = void 0;
	          var includeVal = _vls.some(function (i, ind) {
	            if (i.value === ex.triggerValue) {
	              index = ind;
	              return true;
	            }
	          });
	          if (includeVal) {
	            _vls.splice(index, 1);
	          }
	        }
	        vls = _vls;
	        if (!this.isLabelInValue()) {
	          labs = _vls.map(function (v) {
	            return v.label;
	          });
	          vls = _vls.map(function (v) {
	            return v.value;
	          });
	        }
	      }
	      this._savedValue = (0, _util.isMultipleOrTags)(props) ? vls : vls[0];
	      props.onChange(this._savedValue, labs, ex);
	      if (!('value' in props)) {
	        this._cacheTreeNodesStates = false;
	        this.setState({
	          value: this.getValue(props, (0, _util.toArray)(this._savedValue).map(function (v, i) {
	            return _this6.isLabelInValue() ? v : {
	              value: v,
	              label: labs && labs[i]
	            };
	          }))
	        });
	      }
	    }
	  };
	
	  Select.prototype.isLabelInValue = function isLabelInValue() {
	    var _props3 = this.props,
	        treeCheckable = _props3.treeCheckable,
	        treeCheckStrictly = _props3.treeCheckStrictly,
	        labelInValue = _props3.labelInValue;
	
	    if (treeCheckable && treeCheckStrictly) {
	      return true;
	    }
	    return labelInValue || false;
	  };
	
	  Select.prototype.renderTopControlNode = function renderTopControlNode() {
	    var _this7 = this;
	
	    var value = this.state.value;
	
	    var props = this.props;
	    var choiceTransitionName = props.choiceTransitionName,
	        prefixCls = props.prefixCls,
	        maxTagTextLength = props.maxTagTextLength;
	    // single and not combobox, input is inside dropdown
	
	    if ((0, _util.isSingleMode)(props)) {
	      var innerNode = _react2['default'].createElement(
	        'span',
	        {
	          key: 'placeholder',
	          className: prefixCls + '-selection__placeholder'
	        },
	        props.placeholder
	      );
	      if (value.length) {
	        innerNode = _react2['default'].createElement(
	          'span',
	          {
	            key: 'value',
	            title: value[0].label,
	            className: prefixCls + '-selection-selected-value'
	          },
	          value[0].label
	        );
	      }
	      return _react2['default'].createElement(
	        'span',
	        { className: prefixCls + '-selection__rendered' },
	        innerNode
	      );
	    }
	
	    var selectedValueNodes = [];
	    if ((0, _util.isMultipleOrTags)(props)) {
	      selectedValueNodes = value.map(function (singleValue) {
	        var content = singleValue.label;
	        var title = content;
	        if (maxTagTextLength && typeof content === 'string' && content.length > maxTagTextLength) {
	          content = content.slice(0, maxTagTextLength) + '...';
	        }
	        return _react2['default'].createElement(
	          'li',
	          (0, _extends3['default'])({
	            style: _util.UNSELECTABLE_STYLE
	          }, _util.UNSELECTABLE_ATTRIBUTE, {
	            onMouseDown: _util.preventDefaultEvent,
	            className: prefixCls + '-selection__choice',
	            key: singleValue.value,
	            title: title
	          }),
	          _react2['default'].createElement('span', {
	            className: prefixCls + '-selection__choice__remove',
	            onClick: _this7.removeSelected.bind(_this7, singleValue.value)
	          }),
	          _react2['default'].createElement(
	            'span',
	            { className: prefixCls + '-selection__choice__content' },
	            content
	          )
	        );
	      });
	    }
	    selectedValueNodes.push(_react2['default'].createElement(
	      'li',
	      {
	        className: prefixCls + '-search ' + prefixCls + '-search--inline',
	        key: '__input'
	      },
	      this.getInputElement()
	    ));
	    var className = prefixCls + '-selection__rendered';
	    if ((0, _util.isMultipleOrTags)(props) && choiceTransitionName) {
	      return _react2['default'].createElement(
	        _rcAnimate2['default'],
	        {
	          className: className,
	          component: 'ul',
	          transitionName: choiceTransitionName,
	          onLeave: this.onChoiceAnimationLeave
	        },
	        selectedValueNodes
	      );
	    }
	    return _react2['default'].createElement(
	      'ul',
	      { className: className },
	      selectedValueNodes
	    );
	  };
	
	  Select.prototype.renderTreeData = function renderTreeData(props) {
	    var validProps = props || this.props;
	    if (validProps.treeData) {
	      if (props && props.treeData === this.props.treeData && this.renderedTreeData) {
	        // cache and use pre data.
	        this._cachetreeData = true;
	        return this.renderedTreeData;
	      }
	      this._cachetreeData = false;
	      var treeData = [].concat(validProps.treeData);
	      // process treeDataSimpleMode
	      if (validProps.treeDataSimpleMode) {
	        var simpleFormat = {
	          id: 'id',
	          pId: 'pId',
	          rootPId: null
	        };
	        if (Object.prototype.toString.call(validProps.treeDataSimpleMode) === '[object Object]') {
	          (0, _objectAssign2['default'])(simpleFormat, validProps.treeDataSimpleMode);
	        }
	        treeData = (0, _util.processSimpleTreeData)(treeData, simpleFormat);
	      }
	      return loopTreeData(treeData);
	    }
	  };
	
	  Select.prototype.render = function render() {
	    var _rootCls;
	
	    var props = this.props;
	    var multiple = (0, _util.isMultipleOrTags)(props);
	    var state = this.state;
	    var className = props.className,
	        disabled = props.disabled,
	        allowClear = props.allowClear,
	        prefixCls = props.prefixCls;
	
	    var ctrlNode = this.renderTopControlNode();
	    var extraSelectionProps = {};
	    if (!(0, _util.isMultipleOrTagsOrCombobox)(props)) {
	      extraSelectionProps = {
	        onKeyDown: this.onKeyDown,
	        tabIndex: 0
	      };
	    }
	    var rootCls = (_rootCls = {}, _rootCls[className] = !!className, _rootCls[prefixCls] = 1, _rootCls[prefixCls + '-open'] = state.open, _rootCls[prefixCls + '-focused'] = state.open || state.focused, _rootCls[prefixCls + '-disabled'] = disabled, _rootCls[prefixCls + '-enabled'] = !disabled, _rootCls[prefixCls + '-allow-clear'] = !!props.allowClear, _rootCls);
	
	    var clear = _react2['default'].createElement('span', {
	      key: 'clear',
	      className: prefixCls + '-selection__clear',
	      onClick: this.onClearSelection
	    });
	    return _react2['default'].createElement(
	      _SelectTrigger2['default'],
	      (0, _extends3['default'])({}, props, {
	        treeNodes: props.children,
	        treeData: this.renderedTreeData,
	        _cachetreeData: this._cachetreeData,
	        _treeNodesStates: this._treeNodesStates,
	        halfCheckedValues: this.halfCheckedValues,
	        multiple: multiple,
	        disabled: disabled,
	        visible: state.open,
	        inputValue: state.inputValue,
	        inputElement: this.getInputElement(),
	        value: state.value,
	        onDropdownVisibleChange: this.onDropdownVisibleChange,
	        getPopupContainer: props.getPopupContainer,
	        onSelect: this.onSelect,
	        ref: 'trigger'
	      }),
	      _react2['default'].createElement(
	        'span',
	        {
	          style: props.style,
	          onClick: props.onClick,
	          className: (0, _classnames2['default'])(rootCls)
	        },
	        _react2['default'].createElement(
	          'span',
	          (0, _extends3['default'])({
	            ref: 'selection',
	            key: 'selection',
	            className: prefixCls + '-selection\n            ' + prefixCls + '-selection--' + (multiple ? 'multiple' : 'single'),
	            role: 'combobox',
	            'aria-autocomplete': 'list',
	            'aria-haspopup': 'true',
	            'aria-expanded': state.open
	          }, extraSelectionProps),
	          ctrlNode,
	          allowClear && this.state.value.length && this.state.value[0].value ? clear : null,
	          multiple || !props.showArrow ? null : _react2['default'].createElement(
	            'span',
	            {
	              key: 'arrow',
	              className: prefixCls + '-arrow',
	              style: { outline: 'none' }
	            },
	            _react2['default'].createElement('b', null)
	          ),
	          multiple ? this.getSearchPlaceholderElement(!!this.state.inputValue || this.state.value.length) : null
	        )
	      )
	    );
	  };
	
	  return Select;
	}(_react.Component);
	
	Select.propTypes = _PropTypes.SelectPropTypes;
	Select.defaultProps = {
	  prefixCls: 'rc-tree-select',
	  filterTreeNode: filterFn,
	  showSearch: true,
	  allowClear: false,
	  placeholder: '',
	  searchPlaceholder: '',
	  labelInValue: false,
	  onClick: noop,
	  onChange: noop,
	  onSelect: noop,
	  onDeselect: noop,
	  onSearch: noop,
	  showArrow: true,
	  dropdownMatchSelectWidth: true,
	  dropdownStyle: {},
	  onDropdownVisibleChange: function onDropdownVisibleChange() {
	    return true;
	  },
	  notFoundContent: 'Not Found',
	  showCheckedStrategy: _strategies.SHOW_CHILD,
	  // skipHandleInitValue: false, // Deprecated (use treeCheckStrictly)
	  treeCheckStrictly: false,
	  treeIcon: false,
	  treeLine: false,
	  treeDataSimpleMode: false,
	  treeDefaultExpandAll: false,
	  treeCheckable: false,
	  treeNodeFilterProp: 'value',
	  treeNodeLabelProp: 'title'
	};
	
	var _initialiseProps = function _initialiseProps() {
	  var _this8 = this;
	
	  this.onInputChange = function (event) {
	    var val = event.target.value;
	    var props = _this8.props;
	
	    _this8.setState({
	      inputValue: val,
	      open: true
	    });
	    if (props.treeCheckable && !val) {
	      _this8.setState({
	        value: _this8.getValue(props, [].concat(_this8.state.value), false)
	      });
	    }
	    props.onSearch(val);
	  };
	
	  this.onDropdownVisibleChange = function (open) {
	    // selection inside combobox cause click
	    if (!open && document.activeElement === _this8.getInputDOMNode()) {}
	    // return;
	
	    // this.setOpenState(open);
	    // setTimeout, then have animation. why?
	    setTimeout(function () {
	      _this8.setOpenState(open, undefined, !open);
	    }, 10);
	  };
	
	  this.onKeyDown = function (event) {
	    var props = _this8.props;
	    if (props.disabled) {
	      return;
	    }
	    var keyCode = event.keyCode;
	    if (_this8.state.open && !_this8.getInputDOMNode()) {
	      _this8.onInputKeyDown(event);
	    } else if (keyCode === _KeyCode2['default'].ENTER || keyCode === _KeyCode2['default'].DOWN) {
	      _this8.setOpenState(true);
	      event.preventDefault();
	    }
	  };
	
	  this.onInputKeyDown = function (event) {
	    var props = _this8.props;
	    if (props.disabled) {
	      return;
	    }
	    var state = _this8.state;
	    var keyCode = event.keyCode;
	    if ((0, _util.isMultipleOrTags)(props) && !event.target.value && keyCode === _KeyCode2['default'].BACKSPACE) {
	      var value = state.value.concat();
	      if (value.length) {
	        var popValue = value.pop();
	        _this8.removeSelected(_this8.isLabelInValue() ? popValue : popValue.value);
	      }
	      return;
	    }
	    if (keyCode === _KeyCode2['default'].DOWN) {
	      if (!state.open) {
	        _this8.openIfHasChildren();
	        event.preventDefault();
	        event.stopPropagation();
	        return;
	      }
	    } else if (keyCode === _KeyCode2['default'].ESC) {
	      if (state.open) {
	        _this8.setOpenState(false);
	        event.preventDefault();
	        event.stopPropagation();
	      }
	      return;
	    }
	  };
	
	  this.onSelect = function (selectedKeys, info) {
	    if (info.selected === false) {
	      _this8.onDeselect(info);
	      return;
	    }
	    var item = info.node;
	    var value = _this8.state.value;
	    var props = _this8.props;
	    var selectedValue = (0, _util.getValuePropValue)(item);
	    var selectedLabel = _this8.getLabelFromNode(item);
	    var event = selectedValue;
	    if (_this8.isLabelInValue()) {
	      event = {
	        value: event,
	        label: selectedLabel
	      };
	    }
	    props.onSelect(event, item, info);
	    var checkEvt = info.event === 'check';
	    if ((0, _util.isMultipleOrTags)(props)) {
	      _this8.clearSearchInput();
	      if (checkEvt) {
	        value = _this8.getCheckedNodes(info, props).map(function (n) {
	          return {
	            value: (0, _util.getValuePropValue)(n),
	            label: _this8.getLabelFromNode(n)
	          };
	        });
	      } else {
	        if (value.some(function (i) {
	          return i.value === selectedValue;
	        })) {
	          return;
	        }
	        value = value.concat([{
	          value: selectedValue,
	          label: selectedLabel
	        }]);
	      }
	    } else {
	      if (value.length && value[0].value === selectedValue) {
	        _this8.setOpenState(false);
	        return;
	      }
	      value = [{
	        value: selectedValue,
	        label: selectedLabel
	      }];
	      _this8.setOpenState(false);
	    }
	
	    var extraInfo = {
	      triggerValue: selectedValue,
	      triggerNode: item
	    };
	    if (checkEvt) {
	      extraInfo.checked = info.checked;
	      // if inputValue existing, tree is checkStrictly
	      extraInfo.allCheckedNodes = props.treeCheckStrictly || _this8.state.inputValue ? info.checkedNodes : (0, _util.flatToHierarchy)(info.checkedNodesPositions);
	      _this8._checkedNodes = info.checkedNodesPositions;
	      var _tree = _this8.refs.trigger.popupEle;
	      _this8._treeNodesStates = _tree.checkKeys;
	    } else {
	      extraInfo.selected = info.selected;
	    }
	
	    _this8.fireChange(value, extraInfo);
	    if (props.inputValue === null) {
	      _this8.setState({
	        inputValue: ''
	      });
	    }
	  };
	
	  this.onDeselect = function (info) {
	    _this8.removeSelected((0, _util.getValuePropValue)(info.node));
	    if (!(0, _util.isMultipleOrTags)(_this8.props)) {
	      _this8.setOpenState(false);
	    } else {
	      _this8.clearSearchInput();
	    }
	  };
	
	  this.onPlaceholderClick = function () {
	    _this8.getInputDOMNode().focus();
	  };
	
	  this.onClearSelection = function (event) {
	    var props = _this8.props;
	    var state = _this8.state;
	    if (props.disabled) {
	      return;
	    }
	    event.stopPropagation();
	    _this8._cacheTreeNodesStates = 'no';
	    _this8._checkedNodes = [];
	    if (state.inputValue || state.value.length) {
	      _this8.setOpenState(false);
	      if (typeof props.inputValue === 'undefined') {
	        _this8.setState({
	          inputValue: ''
	        }, function () {
	          _this8.fireChange([]);
	        });
	      } else {
	        _this8.fireChange([]);
	      }
	    }
	  };
	
	  this.onChoiceAnimationLeave = function () {
	    _this8.refs.trigger.refs.trigger.forcePopupAlign();
	  };
	};
	
	Select.SHOW_ALL = _strategies.SHOW_ALL;
	Select.SHOW_PARENT = _strategies.SHOW_PARENT;
	Select.SHOW_CHILD = _strategies.SHOW_CHILD;
	
	exports['default'] = Select;
	module.exports = exports['default'];

/***/ }),
/* 776 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	exports.__esModule = true;
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _reactDom = __webpack_require__(10);
	
	var _reactDom2 = _interopRequireDefault(_reactDom);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _rcTrigger = __webpack_require__(53);
	
	var _rcTrigger2 = _interopRequireDefault(_rcTrigger);
	
	var _rcTree = __webpack_require__(278);
	
	var _rcTree2 = _interopRequireDefault(_rcTree);
	
	var _util = __webpack_require__(276);
	
	var _toArray = __webpack_require__(152);
	
	var _toArray2 = _interopRequireDefault(_toArray);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var BUILT_IN_PLACEMENTS = {
	  bottomLeft: {
	    points: ['tl', 'bl'],
	    offset: [0, 4],
	    overflow: {
	      adjustX: 0,
	      adjustY: 1
	    }
	  },
	  topLeft: {
	    points: ['bl', 'tl'],
	    offset: [0, -4],
	    overflow: {
	      adjustX: 0,
	      adjustY: 1
	    }
	  }
	};
	
	var SelectTrigger = function (_Component) {
	  (0, _inherits3['default'])(SelectTrigger, _Component);
	
	  function SelectTrigger() {
	    var _temp, _this, _ret;
	
	    (0, _classCallCheck3['default'])(this, SelectTrigger);
	
	    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
	      args[_key] = arguments[_key];
	    }
	
	    return _ret = (_temp = (_this = (0, _possibleConstructorReturn3['default'])(this, _Component.call.apply(_Component, [this].concat(args))), _this), _this.state = {
	      _expandedKeys: [],
	      fireOnExpand: false,
	      dropdownWidth: null
	    }, _this.onExpand = function (expandedKeys) {
	      // rerender
	      _this.setState({
	        _expandedKeys: expandedKeys,
	        fireOnExpand: true
	      }, function () {
	        // Fix https://github.com/ant-design/ant-design/issues/5689
	        if (_this.refs.trigger && _this.refs.trigger.forcePopupAlign) {
	          _this.refs.trigger.forcePopupAlign();
	        }
	      });
	    }, _this.highlightTreeNode = function (treeNode) {
	      var props = _this.props;
	      var filterVal = treeNode.props[(0, _util.labelCompatible)(props.treeNodeFilterProp)];
	      if (typeof filterVal === 'string') {
	        return props.inputValue && filterVal.indexOf(props.inputValue) > -1;
	      }
	      return false;
	    }, _this.filterTreeNode = function (input, child) {
	      if (!input) {
	        return true;
	      }
	      var filterTreeNode = _this.props.filterTreeNode;
	      if (!filterTreeNode) {
	        return true;
	      }
	      if (child.props.disabled) {
	        return false;
	      }
	      return filterTreeNode.call(_this, input, child);
	    }, _this.savePopupElement = function (ele) {
	      _this.popupEle = ele;
	    }, _temp), (0, _possibleConstructorReturn3['default'])(_this, _ret);
	  }
	
	  SelectTrigger.prototype.componentDidMount = function componentDidMount() {
	    this.setDropdownWidth();
	  };
	
	  SelectTrigger.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {
	    if (nextProps.inputValue && nextProps.inputValue !== this.props.inputValue) {
	      // set autoExpandParent to true
	      this.setState({
	        _expandedKeys: [],
	        fireOnExpand: false
	      });
	    }
	  };
	
	  SelectTrigger.prototype.componentDidUpdate = function componentDidUpdate() {
	    this.setDropdownWidth();
	  };
	
	  SelectTrigger.prototype.setDropdownWidth = function setDropdownWidth() {
	    var width = _reactDom2['default'].findDOMNode(this).offsetWidth;
	    if (width !== this.state.dropdownWidth) {
	      this.setState({ dropdownWidth: width });
	    }
	  };
	
	  SelectTrigger.prototype.getPopupEleRefs = function getPopupEleRefs() {
	    return this.popupEle && this.popupEle.refs;
	  };
	
	  SelectTrigger.prototype.getPopupDOMNode = function getPopupDOMNode() {
	    return this.refs.trigger.getPopupDomNode();
	  };
	
	  SelectTrigger.prototype.getDropdownTransitionName = function getDropdownTransitionName() {
	    var props = this.props;
	    var transitionName = props.transitionName;
	    if (!transitionName && props.animation) {
	      transitionName = this.getDropdownPrefixCls() + '-' + props.animation;
	    }
	    return transitionName;
	  };
	
	  SelectTrigger.prototype.getDropdownPrefixCls = function getDropdownPrefixCls() {
	    return this.props.prefixCls + '-dropdown';
	  };
	
	  SelectTrigger.prototype.processTreeNode = function processTreeNode(treeNodes) {
	    var _this2 = this;
	
	    var filterPoss = [];
	    this._expandedKeys = [];
	    (0, _util.loopAllChildren)(treeNodes, function (child, index, pos) {
	      if (_this2.filterTreeNode(_this2.props.inputValue, child)) {
	        filterPoss.push(pos);
	        _this2._expandedKeys.push(child.key);
	      }
	    });
	
	    // Include the filtered nodes's ancestral nodes.
	    var processedPoss = [];
	    filterPoss.forEach(function (pos) {
	      var arr = pos.split('-');
	      arr.reduce(function (pre, cur) {
	        var res = pre + '-' + cur;
	        if (processedPoss.indexOf(res) < 0) {
	          processedPoss.push(res);
	        }
	        return res;
	      });
	    });
	    var filterNodesPositions = [];
	    (0, _util.loopAllChildren)(treeNodes, function (child, index, pos) {
	      if (processedPoss.indexOf(pos) > -1) {
	        filterNodesPositions.push({ node: child, pos: pos });
	      }
	    });
	
	    var hierarchyNodes = (0, _util.flatToHierarchy)(filterNodesPositions);
	
	    var recursive = function recursive(children) {
	      return children.map(function (child) {
	        if (child.children) {
	          return _react2['default'].cloneElement(child.node, {}, recursive(child.children));
	        }
	        return child.node;
	      });
	    };
	    return recursive(hierarchyNodes);
	  };
	
	  SelectTrigger.prototype.renderTree = function renderTree(keys, halfCheckedKeys, newTreeNodes, multiple) {
	    var props = this.props;
	
	    var trProps = {
	      multiple: multiple,
	      prefixCls: props.prefixCls + '-tree',
	      showIcon: props.treeIcon,
	      showLine: props.treeLine,
	      defaultExpandAll: props.treeDefaultExpandAll,
	      defaultExpandedKeys: props.treeDefaultExpandedKeys,
	      filterTreeNode: this.highlightTreeNode
	    };
	
	    if (props.treeCheckable) {
	      trProps.selectable = false;
	      trProps.checkable = props.treeCheckable;
	      trProps.onCheck = props.onSelect;
	      trProps.checkStrictly = props.treeCheckStrictly;
	      if (props.inputValue) {
	        // enable checkStrictly when search tree.
	        trProps.checkStrictly = true;
	      } else {
	        trProps._treeNodesStates = props._treeNodesStates;
	      }
	      if (trProps.treeCheckStrictly && halfCheckedKeys.length) {
	        trProps.checkedKeys = { checked: keys, halfChecked: halfCheckedKeys };
	      } else {
	        trProps.checkedKeys = keys;
	      }
	    } else {
	      trProps.selectedKeys = keys;
	      trProps.onSelect = props.onSelect;
	    }
	
	    // expand keys
	    if (!trProps.defaultExpandAll && !trProps.defaultExpandedKeys && !props.loadData) {
	      trProps.expandedKeys = keys;
	    }
	    trProps.autoExpandParent = true;
	    trProps.onExpand = this.onExpand;
	    if (this._expandedKeys && this._expandedKeys.length) {
	      trProps.expandedKeys = this._expandedKeys;
	    }
	    if (this.state.fireOnExpand) {
	      trProps.expandedKeys = this.state._expandedKeys;
	      trProps.autoExpandParent = false;
	    }
	
	    // async loadData
	    if (props.loadData) {
	      trProps.loadData = props.loadData;
	    }
	
	    return _react2['default'].createElement(
	      _rcTree2['default'],
	      (0, _extends3['default'])({ ref: this.savePopupElement }, trProps),
	      newTreeNodes
	    );
	  };
	
	  SelectTrigger.prototype.render = function render() {
	    var _popupClassName;
	
	    var props = this.props;
	    var multiple = props.multiple;
	    var dropdownPrefixCls = this.getDropdownPrefixCls();
	    var popupClassName = (_popupClassName = {}, _popupClassName[props.dropdownClassName] = !!props.dropdownClassName, _popupClassName[dropdownPrefixCls + '--' + (multiple ? 'multiple' : 'single')] = 1, _popupClassName);
	    var visible = props.visible;
	    var search = multiple || props.combobox || !props.showSearch ? null : _react2['default'].createElement(
	      'span',
	      { className: dropdownPrefixCls + '-search' },
	      props.inputElement
	    );
	
	    var recursive = function recursive(children) {
	      // Note: if use `React.Children.map`, the node's key will be modified.
	      return (0, _toArray2['default'])(children).map(function handler(child) {
	        // eslint-disable-line
	        if (!child) {
	          return null;
	        }
	        if (child && child.props.children) {
	          // null or String has no Prop
	          return _react2['default'].createElement(
	            _rcTree.TreeNode,
	            (0, _extends3['default'])({}, child.props, { key: child.key }),
	            recursive(child.props.children)
	          );
	        }
	        return _react2['default'].createElement(_rcTree.TreeNode, (0, _extends3['default'])({}, child.props, { key: child.key }));
	      });
	    };
	    // const s = Date.now();
	    var treeNodes = void 0;
	    if (props._cachetreeData && this.treeNodes) {
	      treeNodes = this.treeNodes;
	    } else {
	      treeNodes = recursive(props.treeData || props.treeNodes);
	      this.treeNodes = treeNodes;
	    }
	    // console.log(Date.now()-s);
	
	    if (props.inputValue) {
	      treeNodes = this.processTreeNode(treeNodes);
	    }
	
	    var keys = [];
	    var halfCheckedKeys = [];
	    (0, _util.loopAllChildren)(treeNodes, function (child) {
	      if (props.value.some(function (item) {
	        return item.value === (0, _util.getValuePropValue)(child);
	      })) {
	        keys.push(child.key);
	      }
	      if (props.halfCheckedValues && props.halfCheckedValues.some(function (item) {
	        return item.value === (0, _util.getValuePropValue)(child);
	      })) {
	        halfCheckedKeys.push(child.key);
	      }
	    });
	
	    var notFoundContent = void 0;
	    if (!treeNodes.length) {
	      if (props.notFoundContent) {
	        notFoundContent = _react2['default'].createElement(
	          'span',
	          { className: props.prefixCls + '-not-found' },
	          props.notFoundContent
	        );
	      } else if (!search) {
	        visible = false;
	      }
	    }
	    var popupElement = _react2['default'].createElement(
	      'div',
	      null,
	      search,
	      notFoundContent || this.renderTree(keys, halfCheckedKeys, treeNodes, multiple)
	    );
	
	    var popupStyle = (0, _extends3['default'])({}, props.dropdownStyle);
	    var widthProp = props.dropdownMatchSelectWidth ? 'width' : 'minWidth';
	    if (this.state.dropdownWidth) {
	      popupStyle[widthProp] = this.state.dropdownWidth + 'px';
	    }
	
	    return _react2['default'].createElement(
	      _rcTrigger2['default'],
	      {
	        action: props.disabled ? [] : ['click'],
	        ref: 'trigger',
	        popupPlacement: 'bottomLeft',
	        builtinPlacements: BUILT_IN_PLACEMENTS,
	        popupAlign: props.dropdownPopupAlign,
	        prefixCls: dropdownPrefixCls,
	        popupTransitionName: this.getDropdownTransitionName(),
	        onPopupVisibleChange: props.onDropdownVisibleChange,
	        popup: popupElement,
	        popupVisible: visible,
	        getPopupContainer: props.getPopupContainer,
	        popupClassName: (0, _classnames2['default'])(popupClassName),
	        popupStyle: popupStyle
	      },
	      this.props.children
	    );
	  };
	
	  return SelectTrigger;
	}(_react.Component);
	
	SelectTrigger.propTypes = {
	  dropdownMatchSelectWidth: _propTypes2['default'].bool,
	  dropdownPopupAlign: _propTypes2['default'].object,
	  visible: _propTypes2['default'].bool,
	  filterTreeNode: _propTypes2['default'].any,
	  treeNodes: _propTypes2['default'].any,
	  inputValue: _propTypes2['default'].string,
	  prefixCls: _propTypes2['default'].string,
	  popupClassName: _propTypes2['default'].string,
	  children: _propTypes2['default'].any
	};
	exports['default'] = SelectTrigger;
	module.exports = exports['default'];

/***/ }),
/* 777 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	exports.__esModule = true;
	exports.SHOW_CHILD = exports.SHOW_PARENT = exports.SHOW_ALL = exports.TreeNode = undefined;
	
	var _strategies = __webpack_require__(151);
	
	Object.defineProperty(exports, 'SHOW_ALL', {
	  enumerable: true,
	  get: function get() {
	    return _strategies.SHOW_ALL;
	  }
	});
	Object.defineProperty(exports, 'SHOW_PARENT', {
	  enumerable: true,
	  get: function get() {
	    return _strategies.SHOW_PARENT;
	  }
	});
	Object.defineProperty(exports, 'SHOW_CHILD', {
	  enumerable: true,
	  get: function get() {
	    return _strategies.SHOW_CHILD;
	  }
	});
	
	var _Select = __webpack_require__(775);
	
	var _Select2 = _interopRequireDefault(_Select);
	
	var _TreeNode = __webpack_require__(275);
	
	var _TreeNode2 = _interopRequireDefault(_TreeNode);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	// export this package's api
	_Select2['default'].TreeNode = _TreeNode2['default'];
	
	exports['default'] = _Select2['default'];
	exports.TreeNode = _TreeNode2['default'];

/***/ }),
/* 778 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	exports.__esModule = true;
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _rcAnimate = __webpack_require__(22);
	
	var _rcAnimate2 = _interopRequireDefault(_rcAnimate);
	
	var _toArray = __webpack_require__(152);
	
	var _toArray2 = _interopRequireDefault(_toArray);
	
	var _Tree = __webpack_require__(277);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var defaultTitle = '---';
	
	var TreeNode = function (_React$Component) {
	  (0, _inherits3['default'])(TreeNode, _React$Component);
	
	  function TreeNode(props) {
	    (0, _classCallCheck3['default'])(this, TreeNode);
	
	    var _this = (0, _possibleConstructorReturn3['default'])(this, _React$Component.call(this, props));
	
	    _this.onCheck = function () {
	      _this.props.root.onCheck(_this);
	    };
	
	    _this.onMouseEnter = function (e) {
	      e.preventDefault();
	      _this.props.root.onMouseEnter(e, _this);
	    };
	
	    _this.onMouseLeave = function (e) {
	      e.preventDefault();
	      _this.props.root.onMouseLeave(e, _this);
	    };
	
	    _this.onContextMenu = function (e) {
	      _this.props.root.onContextMenu(e, _this);
	    };
	
	    _this.onDragStart = function (e) {
	      e.stopPropagation();
	      _this.setState({
	        dragNodeHighlight: true
	      });
	      _this.props.root.onDragStart(e, _this);
	      try {
	        // ie throw error
	        // firefox-need-it
	        e.dataTransfer.setData('text/plain', '');
	      } catch (error) {
	        // empty
	      }
	    };
	
	    _this.onDragEnter = function (e) {
	      e.preventDefault();
	      e.stopPropagation();
	      _this.props.root.onDragEnter(e, _this);
	    };
	
	    _this.onDragOver = function (e) {
	      e.preventDefault();
	      e.stopPropagation();
	      _this.props.root.onDragOver(e, _this);
	    };
	
	    _this.onDragLeave = function (e) {
	      e.stopPropagation();
	      _this.props.root.onDragLeave(e, _this);
	    };
	
	    _this.onDrop = function (e) {
	      e.preventDefault();
	      e.stopPropagation();
	      _this.setState({
	        dragNodeHighlight: false
	      });
	      _this.props.root.onDrop(e, _this);
	    };
	
	    _this.onDragEnd = function (e) {
	      e.stopPropagation();
	      _this.setState({
	        dragNodeHighlight: false
	      });
	      _this.props.root.onDragEnd(e, _this);
	    };
	
	    _this.onExpand = function () {
	      var callbackPromise = _this.props.root.onExpand(_this);
	      if (callbackPromise && typeof callbackPromise === 'object') {
	        var setLoading = function setLoading(dataLoading) {
	          _this.setState({ dataLoading: dataLoading });
	        };
	        setLoading(true);
	        callbackPromise.then(function () {
	          setLoading(false);
	        }, function () {
	          setLoading(false);
	        });
	      }
	    };
	
	    _this.saveSelectHandle = function (node) {
	      _this.selectHandle = node;
	    };
	
	    _this.state = {
	      dataLoading: false,
	      dragNodeHighlight: false
	    };
	    return _this;
	  }
	
	  TreeNode.prototype.onSelect = function onSelect() {
	    this.props.root.onSelect(this);
	  };
	
	  // keyboard event support
	  TreeNode.prototype.onKeyDown = function onKeyDown(e) {
	    e.preventDefault();
	  };
	
	  TreeNode.prototype.isSelectable = function isSelectable() {
	    var props = this.props,
	        context = this.context;
	
	    return 'selectable' in props ? props.selectable : context.rcTree.selectable;
	  };
	
	  TreeNode.prototype.renderSwitcher = function renderSwitcher(props, expandedState) {
	    var prefixCls = props.prefixCls;
	    var switcherCls = (0, _classnames2['default'])(prefixCls + '-switcher', prefixCls + '-switcher_' + expandedState);
	    return _react2['default'].createElement('span', { className: switcherCls, onClick: this.onExpand });
	  };
	
	  TreeNode.prototype.renderCheckbox = function renderCheckbox(props) {
	    var _checkboxCls;
	
	    var prefixCls = props.prefixCls;
	    var checkboxCls = (_checkboxCls = {}, _checkboxCls[prefixCls + '-checkbox'] = true, _checkboxCls);
	    if (props.checked) {
	      checkboxCls[prefixCls + '-checkbox-checked'] = true;
	    } else if (props.halfChecked) {
	      checkboxCls[prefixCls + '-checkbox-indeterminate'] = true;
	    }
	    var customEle = null;
	    if (typeof props.checkable !== 'boolean') {
	      customEle = props.checkable;
	    }
	    if (props.disabled || props.disableCheckbox) {
	      checkboxCls[prefixCls + '-checkbox-disabled'] = true;
	      return _react2['default'].createElement(
	        'span',
	        { className: (0, _classnames2['default'])(checkboxCls) },
	        customEle
	      );
	    }
	    return _react2['default'].createElement(
	      'span',
	      {
	        className: (0, _classnames2['default'])(checkboxCls),
	        onClick: this.onCheck
	      },
	      customEle
	    );
	  };
	
	  TreeNode.prototype.renderChildren = function renderChildren(props) {
	    var renderFirst = this.renderFirst;
	    this.renderFirst = 1;
	    var transitionAppear = true;
	    if (!renderFirst && props.expanded) {
	      transitionAppear = false;
	    }
	    var children = null;
	    if (props.children) {
	      children = (0, _toArray2['default'])(props.children).filter(function (item) {
	        return !!item;
	      });
	    }
	    var newChildren = children;
	    if (children && (Array.isArray(children) && children.length && children.every(function (item) {
	      return item.type && item.type.isTreeNode;
	    }) || children.type && children.type.isTreeNode)) {
	      var _classNames;
	
	      var animProps = {};
	      if (props.openTransitionName) {
	        animProps.transitionName = props.openTransitionName;
	      } else if (typeof props.openAnimation === 'object') {
	        animProps.animation = (0, _extends3['default'])({}, props.openAnimation);
	        if (!transitionAppear) {
	          delete animProps.animation.appear;
	        }
	      }
	      var cls = (0, _classnames2['default'])(props.prefixCls + '-child-tree', (_classNames = {}, _classNames[props.prefixCls + '-child-tree-open'] = props.expanded, _classNames));
	      newChildren = _react2['default'].createElement(
	        _rcAnimate2['default'],
	        (0, _extends3['default'])({}, animProps, {
	          showProp: 'data-expanded',
	          transitionAppear: transitionAppear,
	          component: ''
	        }),
	        !props.expanded ? null : _react2['default'].createElement(
	          'ul',
	          { className: cls, 'data-expanded': props.expanded },
	          _react2['default'].Children.map(children, function (item, index) {
	            return props.root.renderTreeNode(item, index, props.pos);
	          }, props.root)
	        )
	      );
	    }
	    return newChildren;
	  };
	
	  TreeNode.prototype.render = function render() {
	    var _iconEleCls,
	        _this2 = this;
	
	    var props = this.props;
	
	    var prefixCls = props.prefixCls;
	    var expandedState = props.expanded ? 'open' : 'close';
	    var iconState = expandedState;
	
	    var canRenderSwitcher = true;
	    var content = props.title;
	    var newChildren = this.renderChildren(props);
	    if (!newChildren || newChildren === props.children) {
	      // content = newChildren;
	      newChildren = null;
	      if (!props.loadData || props.isLeaf) {
	        canRenderSwitcher = false;
	        iconState = 'docu';
	      }
	    }
	    // For performance, does't render children into dom when `!props.expanded` (move to Animate)
	    // if (!props.expanded) {
	    //   newChildren = null;
	    // }
	
	    var iconEleCls = (_iconEleCls = {}, _iconEleCls[prefixCls + '-iconEle'] = true, _iconEleCls[prefixCls + '-icon_loading'] = this.state.dataLoading, _iconEleCls[prefixCls + '-icon__' + iconState] = true, _iconEleCls);
	
	    var selectHandle = function selectHandle() {
	      var icon = props.showIcon || props.loadData && _this2.state.dataLoading ? _react2['default'].createElement('span', { className: (0, _classnames2['default'])(iconEleCls) }) : null;
	      var title = _react2['default'].createElement(
	        'span',
	        { className: prefixCls + '-title' },
	        content
	      );
	      var wrap = prefixCls + '-node-content-wrapper';
	      var domProps = {
	        className: wrap + ' ' + wrap + '-' + (iconState === expandedState ? iconState : 'normal'),
	        onMouseEnter: _this2.onMouseEnter,
	        onMouseLeave: _this2.onMouseLeave,
	        onContextMenu: _this2.onContextMenu
	      };
	      if (!props.disabled) {
	        if (props.selected || _this2.state.dragNodeHighlight) {
	          domProps.className += ' ' + prefixCls + '-node-selected';
	        }
	        domProps.onClick = function (e) {
	          if (_this2.isSelectable()) {
	            e.preventDefault();
	            _this2.onSelect();
	          } else if (props.checkable && !props.disableCheckbox) {
	            e.preventDefault();
	            // && !props.disabled is checked on line 259
	            _this2.onCheck();
	          }
	        };
	        if (props.draggable) {
	          domProps.className += ' draggable';
	          domProps.draggable = true;
	          domProps['aria-grabbed'] = true;
	          domProps.onDragStart = _this2.onDragStart;
	        }
	      }
	      return _react2['default'].createElement(
	        'span',
	        (0, _extends3['default'])({
	          ref: _this2.saveSelectHandle,
	          title: typeof content === 'string' ? content : ''
	        }, domProps),
	        icon,
	        title
	      );
	    };
	
	    var liProps = {};
	    if (props.draggable) {
	      liProps.onDragEnter = this.onDragEnter;
	      liProps.onDragOver = this.onDragOver;
	      liProps.onDragLeave = this.onDragLeave;
	      liProps.onDrop = this.onDrop;
	      liProps.onDragEnd = this.onDragEnd;
	    }
	
	    var disabledCls = '';
	    var dragOverCls = '';
	    if (props.disabled) {
	      disabledCls = prefixCls + '-treenode-disabled';
	    } else if (props.dragOver) {
	      dragOverCls = 'drag-over';
	    } else if (props.dragOverGapTop) {
	      dragOverCls = 'drag-over-gap-top';
	    } else if (props.dragOverGapBottom) {
	      dragOverCls = 'drag-over-gap-bottom';
	    }
	
	    var filterCls = props.filterTreeNode(this) ? 'filter-node' : '';
	
	    var renderNoopSwitcher = function renderNoopSwitcher() {
	      return _react2['default'].createElement('span', { className: prefixCls + '-switcher ' + prefixCls + '-switcher-noop' });
	    };
	
	    return _react2['default'].createElement(
	      'li',
	      (0, _extends3['default'])({}, liProps, {
	        className: (0, _classnames2['default'])(props.className, disabledCls, dragOverCls, filterCls)
	      }),
	      canRenderSwitcher ? this.renderSwitcher(props, expandedState) : renderNoopSwitcher(),
	      props.checkable ? this.renderCheckbox(props) : null,
	      selectHandle(),
	      newChildren
	    );
	  };
	
	  return TreeNode;
	}(_react2['default'].Component);
	
	TreeNode.propTypes = {
	  prefixCls: _propTypes2['default'].string,
	  disabled: _propTypes2['default'].bool,
	  disableCheckbox: _propTypes2['default'].bool,
	  expanded: _propTypes2['default'].bool,
	  isLeaf: _propTypes2['default'].bool,
	  root: _propTypes2['default'].object,
	  onSelect: _propTypes2['default'].func
	};
	TreeNode.contextTypes = _Tree.contextTypes;
	TreeNode.defaultProps = {
	  title: defaultTitle
	};
	
	
	TreeNode.isTreeNode = 1;
	
	exports['default'] = TreeNode;
	module.exports = exports['default'];

/***/ }),
/* 779 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	exports.__esModule = true;
	exports.getOffset = getOffset;
	exports.traverseTreeNodes = traverseTreeNodes;
	exports.updateCheckState = updateCheckState;
	exports.getCheck = getCheck;
	exports.getStrictlyValue = getStrictlyValue;
	exports.isPositionPrefix = isPositionPrefix;
	
	var _react = __webpack_require__(1);
	
	function getOffset(ele) {
	  if (!ele.getClientRects().length) {
	    return { top: 0, left: 0 };
	  }
	
	  var rect = ele.getBoundingClientRect();
	  if (rect.width || rect.height) {
	    var doc = ele.ownerDocument;
	    var win = doc.defaultView;
	    var docElem = doc.documentElement;
	
	    return {
	      top: rect.top + win.pageYOffset - docElem.clientTop,
	      left: rect.left + win.pageXOffset - docElem.clientLeft
	    };
	  }
	
	  return rect;
	} /* eslint no-loop-func: 0*/
	function traverseTreeNodes(treeNodes, callback) {
	  var traverse = function traverse(subTreeNodes, level, parentsChildrenPos, parentPos) {
	    if (Array.isArray(subTreeNodes)) {
	      subTreeNodes = subTreeNodes.filter(function (item) {
	        return !!item;
	      });
	    }
	    _react.Children.forEach(subTreeNodes, function (item, index) {
	      var pos = level + '-' + index;
	      parentsChildrenPos.push(pos); // Note: side effect
	
	      var childrenPos = [];
	      if (item.props.children && item.type && item.type.isTreeNode) {
	        traverse(item.props.children, pos, childrenPos, pos);
	      }
	      callback(item, index, pos, item.key || pos, childrenPos, parentPos);
	    });
	  };
	  traverse(treeNodes, 0, []);
	}
	
	function updateCheckState(obj, checkedPosition, checkIt) {
	  var childrenLoop = function childrenLoop(parentObj) {
	    parentObj.childrenPos.forEach(function (childPos) {
	      var childObj = obj[childPos];
	      // User click don't change disabled item checked state
	      if (!childObj.disableCheckbox && !childObj.disabled) {
	        childObj.halfChecked = false;
	        childObj.checked = checkIt;
	      }
	      childrenLoop(childObj);
	    });
	  };
	
	  childrenLoop(obj[checkedPosition]);
	
	  var parentLoop = function parentLoop(childObj) {
	    if (!childObj.parentPos) return;
	    var parentObj = obj[childObj.parentPos];
	
	    var childrenCount = parentObj.childrenPos.length;
	
	    var checkedChildrenCount = 0;
	    parentObj.childrenPos.forEach(function (childPos) {
	      if (obj[childPos].disableCheckbox) {
	        childrenCount -= 1;
	        return;
	      }
	      if (obj[childPos].checked === true) checkedChildrenCount++;else if (obj[childPos].halfChecked === true) checkedChildrenCount += 0.5;
	    });
	
	    if (checkedChildrenCount === childrenCount) {
	      parentObj.checked = true;
	      parentObj.halfChecked = false;
	    } else if (checkedChildrenCount > 0) {
	      parentObj.halfChecked = true;
	      parentObj.checked = false;
	    } else {
	      parentObj.checked = false;
	      parentObj.halfChecked = false;
	    }
	    parentLoop(parentObj);
	  };
	
	  parentLoop(obj[checkedPosition]);
	}
	
	function getCheck(treeNodesStates) {
	  var halfCheckedKeys = [];
	  var checkedKeys = [];
	  var checkedNodes = [];
	  var checkedNodesPositions = [];
	  Object.keys(treeNodesStates).forEach(function (item) {
	    var itemObj = treeNodesStates[item];
	    if (itemObj.checked) {
	      checkedKeys.push(itemObj.key);
	      checkedNodes.push(itemObj.node);
	      checkedNodesPositions.push({ node: itemObj.node, pos: item });
	    } else if (itemObj.halfChecked) {
	      halfCheckedKeys.push(itemObj.key);
	    }
	  });
	  return {
	    halfCheckedKeys: halfCheckedKeys,
	    checkedKeys: checkedKeys,
	    checkedNodes: checkedNodes,
	    checkedNodesPositions: checkedNodesPositions
	  };
	}
	
	function getStrictlyValue(checkedKeys, halfChecked) {
	  if (halfChecked) {
	    return { checked: checkedKeys, halfChecked: halfChecked };
	  }
	  return checkedKeys;
	}
	
	function isPositionPrefix(smallPos, bigPos) {
	  if (bigPos.length < smallPos.length) {
	    return false;
	  }
	  // attention: "0-0-1" "0-0-10"
	  if (bigPos.length > smallPos.length && bigPos.charAt(smallPos.length) !== '-') {
	    return false;
	  }
	  return bigPos.substr(0, smallPos.length) === smallPos;
	}

/***/ }),
/* 780 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _reactDom = __webpack_require__(10);
	
	var _reactDom2 = _interopRequireDefault(_reactDom);
	
	var _rcAlign = __webpack_require__(656);
	
	var _rcAlign2 = _interopRequireDefault(_rcAlign);
	
	var _rcAnimate = __webpack_require__(22);
	
	var _rcAnimate2 = _interopRequireDefault(_rcAnimate);
	
	var _PopupInner = __webpack_require__(781);
	
	var _PopupInner2 = _interopRequireDefault(_PopupInner);
	
	var _LazyRenderBox = __webpack_require__(279);
	
	var _LazyRenderBox2 = _interopRequireDefault(_LazyRenderBox);
	
	var _utils = __webpack_require__(280);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var Popup = function (_Component) {
	  (0, _inherits3['default'])(Popup, _Component);
	
	  function Popup(props) {
	    (0, _classCallCheck3['default'])(this, Popup);
	
	    var _this = (0, _possibleConstructorReturn3['default'])(this, (Popup.__proto__ || Object.getPrototypeOf(Popup)).call(this, props));
	
	    _initialiseProps.call(_this);
	
	    _this.savePopupRef = _utils.saveRef.bind(_this, 'popupInstance');
	    _this.saveAlignRef = _utils.saveRef.bind(_this, 'alignInstance');
	    return _this;
	  }
	
	  (0, _createClass3['default'])(Popup, [{
	    key: 'componentDidMount',
	    value: function componentDidMount() {
	      this.rootNode = this.getPopupDomNode();
	    }
	  }, {
	    key: 'getPopupDomNode',
	    value: function getPopupDomNode() {
	      return _reactDom2['default'].findDOMNode(this.popupInstance);
	    }
	  }, {
	    key: 'getMaskTransitionName',
	    value: function getMaskTransitionName() {
	      var props = this.props;
	      var transitionName = props.maskTransitionName;
	      var animation = props.maskAnimation;
	      if (!transitionName && animation) {
	        transitionName = props.prefixCls + '-' + animation;
	      }
	      return transitionName;
	    }
	  }, {
	    key: 'getTransitionName',
	    value: function getTransitionName() {
	      var props = this.props;
	      var transitionName = props.transitionName;
	      if (!transitionName && props.animation) {
	        transitionName = props.prefixCls + '-' + props.animation;
	      }
	      return transitionName;
	    }
	  }, {
	    key: 'getClassName',
	    value: function getClassName(currentAlignClassName) {
	      return this.props.prefixCls + ' ' + this.props.className + ' ' + currentAlignClassName;
	    }
	  }, {
	    key: 'getPopupElement',
	    value: function getPopupElement() {
	      var savePopupRef = this.savePopupRef,
	          props = this.props;
	      var align = props.align,
	          style = props.style,
	          visible = props.visible,
	          prefixCls = props.prefixCls,
	          destroyPopupOnHide = props.destroyPopupOnHide;
	
	      var className = this.getClassName(this.currentAlignClassName || props.getClassNameFromAlign(align));
	      var hiddenClassName = prefixCls + '-hidden';
	      if (!visible) {
	        this.currentAlignClassName = null;
	      }
	      var newStyle = (0, _extends3['default'])({}, style, this.getZIndexStyle());
	      var popupInnerProps = {
	        className: className,
	        prefixCls: prefixCls,
	        ref: savePopupRef,
	        onMouseEnter: props.onMouseEnter,
	        onMouseLeave: props.onMouseLeave,
	        style: newStyle
	      };
	      if (destroyPopupOnHide) {
	        return _react2['default'].createElement(
	          _rcAnimate2['default'],
	          {
	            component: '',
	            exclusive: true,
	            transitionAppear: true,
	            transitionName: this.getTransitionName()
	          },
	          visible ? _react2['default'].createElement(
	            _rcAlign2['default'],
	            {
	              target: this.getTarget,
	              key: 'popup',
	              ref: this.saveAlignRef,
	              monitorWindowResize: true,
	              align: align,
	              onAlign: this.onAlign
	            },
	            _react2['default'].createElement(
	              _PopupInner2['default'],
	              (0, _extends3['default'])({
	                visible: true
	              }, popupInnerProps),
	              props.children
	            )
	          ) : null
	        );
	      }
	      return _react2['default'].createElement(
	        _rcAnimate2['default'],
	        {
	          component: '',
	          exclusive: true,
	          transitionAppear: true,
	          transitionName: this.getTransitionName(),
	          showProp: 'xVisible'
	        },
	        _react2['default'].createElement(
	          _rcAlign2['default'],
	          {
	            target: this.getTarget,
	            key: 'popup',
	            ref: this.saveAlignRef,
	            monitorWindowResize: true,
	            xVisible: visible,
	            childrenProps: { visible: 'xVisible' },
	            disabled: !visible,
	            align: align,
	            onAlign: this.onAlign
	          },
	          _react2['default'].createElement(
	            _PopupInner2['default'],
	            (0, _extends3['default'])({
	              hiddenClassName: hiddenClassName
	            }, popupInnerProps),
	            props.children
	          )
	        )
	      );
	    }
	  }, {
	    key: 'getZIndexStyle',
	    value: function getZIndexStyle() {
	      var style = {};
	      var props = this.props;
	      if (props.zIndex !== undefined) {
	        style.zIndex = props.zIndex;
	      }
	      return style;
	    }
	  }, {
	    key: 'getMaskElement',
	    value: function getMaskElement() {
	      var props = this.props;
	      var maskElement = void 0;
	      if (props.mask) {
	        var maskTransition = this.getMaskTransitionName();
	        maskElement = _react2['default'].createElement(_LazyRenderBox2['default'], {
	          style: this.getZIndexStyle(),
	          key: 'mask',
	          className: props.prefixCls + '-mask',
	          hiddenClassName: props.prefixCls + '-mask-hidden',
	          visible: props.visible
	        });
	        if (maskTransition) {
	          maskElement = _react2['default'].createElement(
	            _rcAnimate2['default'],
	            {
	              key: 'mask',
	              showProp: 'visible',
	              transitionAppear: true,
	              component: '',
	              transitionName: maskTransition
	            },
	            maskElement
	          );
	        }
	      }
	      return maskElement;
	    }
	  }, {
	    key: 'render',
	    value: function render() {
	      return _react2['default'].createElement(
	        'div',
	        null,
	        this.getMaskElement(),
	        this.getPopupElement()
	      );
	    }
	  }]);
	  return Popup;
	}(_react.Component);
	
	Popup.propTypes = {
	  visible: _propTypes2['default'].bool,
	  style: _propTypes2['default'].object,
	  getClassNameFromAlign: _propTypes2['default'].func,
	  onAlign: _propTypes2['default'].func,
	  getRootDomNode: _propTypes2['default'].func,
	  onMouseEnter: _propTypes2['default'].func,
	  align: _propTypes2['default'].any,
	  destroyPopupOnHide: _propTypes2['default'].bool,
	  className: _propTypes2['default'].string,
	  prefixCls: _propTypes2['default'].string,
	  onMouseLeave: _propTypes2['default'].func
	};
	
	var _initialiseProps = function _initialiseProps() {
	  var _this2 = this;
	
	  this.onAlign = function (popupDomNode, align) {
	    var props = _this2.props;
	    var currentAlignClassName = props.getClassNameFromAlign(align);
	    // FIX: https://github.com/react-component/trigger/issues/56
	    // FIX: https://github.com/react-component/tooltip/issues/79
	    if (_this2.currentAlignClassName !== currentAlignClassName) {
	      _this2.currentAlignClassName = currentAlignClassName;
	      popupDomNode.className = _this2.getClassName(currentAlignClassName);
	    }
	    props.onAlign(popupDomNode, align);
	  };
	
	  this.getTarget = function () {
	    return _this2.props.getRootDomNode();
	  };
	};
	
	exports['default'] = Popup;
	module.exports = exports['default'];

/***/ }),
/* 781 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _LazyRenderBox = __webpack_require__(279);
	
	var _LazyRenderBox2 = _interopRequireDefault(_LazyRenderBox);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var PopupInner = function (_Component) {
	  (0, _inherits3['default'])(PopupInner, _Component);
	
	  function PopupInner() {
	    (0, _classCallCheck3['default'])(this, PopupInner);
	    return (0, _possibleConstructorReturn3['default'])(this, (PopupInner.__proto__ || Object.getPrototypeOf(PopupInner)).apply(this, arguments));
	  }
	
	  (0, _createClass3['default'])(PopupInner, [{
	    key: 'render',
	    value: function render() {
	      var props = this.props;
	      var className = props.className;
	      if (!props.visible) {
	        className += ' ' + props.hiddenClassName;
	      }
	      return _react2['default'].createElement(
	        'div',
	        {
	          className: className,
	          onMouseEnter: props.onMouseEnter,
	          onMouseLeave: props.onMouseLeave,
	          style: props.style
	        },
	        _react2['default'].createElement(
	          _LazyRenderBox2['default'],
	          { className: props.prefixCls + '-content', visible: props.visible },
	          props.children
	        )
	      );
	    }
	  }]);
	  return PopupInner;
	}(_react.Component);
	
	PopupInner.propTypes = {
	  hiddenClassName: _propTypes2['default'].string,
	  className: _propTypes2['default'].string,
	  prefixCls: _propTypes2['default'].string,
	  onMouseEnter: _propTypes2['default'].func,
	  onMouseLeave: _propTypes2['default'].func,
	  children: _propTypes2['default'].any
	};
	exports['default'] = PopupInner;
	module.exports = exports['default'];

/***/ }),
/* 782 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _request = __webpack_require__(787);
	
	var _request2 = _interopRequireDefault(_request);
	
	var _uid = __webpack_require__(281);
	
	var _uid2 = _interopRequireDefault(_uid);
	
	var _attrAccept = __webpack_require__(785);
	
	var _attrAccept2 = _interopRequireDefault(_attrAccept);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	/* eslint react/no-is-mounted:0 react/sort-comp:0 */
	
	var AjaxUploader = function (_Component) {
	  (0, _inherits3['default'])(AjaxUploader, _Component);
	
	  function AjaxUploader() {
	    var _ref;
	
	    var _temp, _this, _ret;
	
	    (0, _classCallCheck3['default'])(this, AjaxUploader);
	
	    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
	      args[_key] = arguments[_key];
	    }
	
	    return _ret = (_temp = (_this = (0, _possibleConstructorReturn3['default'])(this, (_ref = AjaxUploader.__proto__ || Object.getPrototypeOf(AjaxUploader)).call.apply(_ref, [this].concat(args))), _this), _this.state = { uid: (0, _uid2['default'])() }, _this.reqs = {}, _this.onChange = function (e) {
	      var files = e.target.files;
	      _this.uploadFiles(files);
	      _this.reset();
	    }, _this.onClick = function () {
	      var el = _this.fileInput;
	      if (!el) {
	        return;
	      }
	      el.click();
	    }, _this.onKeyDown = function (e) {
	      if (e.key === 'Enter') {
	        _this.onClick();
	      }
	    }, _this.onFileDrop = function (e) {
	      if (e.type === 'dragover') {
	        e.preventDefault();
	        return;
	      }
	      var files = Array.prototype.slice.call(e.dataTransfer.files).filter(function (file) {
	        return (0, _attrAccept2['default'])(file, _this.props.accept);
	      });
	      _this.uploadFiles(files);
	
	      e.preventDefault();
	    }, _this.saveFileInput = function (node) {
	      _this.fileInput = node;
	    }, _temp), (0, _possibleConstructorReturn3['default'])(_this, _ret);
	  }
	
	  (0, _createClass3['default'])(AjaxUploader, [{
	    key: 'componentDidMount',
	    value: function componentDidMount() {
	      this._isMounted = true;
	    }
	  }, {
	    key: 'componentWillUnmount',
	    value: function componentWillUnmount() {
	      this._isMounted = false;
	      this.abort();
	    }
	  }, {
	    key: 'uploadFiles',
	    value: function uploadFiles(files) {
	      var _this2 = this;
	
	      var postFiles = Array.prototype.slice.call(files);
	      postFiles.forEach(function (file) {
	        file.uid = (0, _uid2['default'])();
	        _this2.upload(file, postFiles);
	      });
	    }
	  }, {
	    key: 'upload',
	    value: function upload(file, fileList) {
	      var _this3 = this;
	
	      var props = this.props;
	
	      if (!props.beforeUpload) {
	        // always async in case use react state to keep fileList
	        return setTimeout(function () {
	          return _this3.post(file);
	        }, 0);
	      }
	
	      var before = props.beforeUpload(file, fileList);
	      if (before && before.then) {
	        before.then(function (processedFile) {
	          var processedFileType = Object.prototype.toString.call(processedFile);
	          if (processedFileType === '[object File]' || processedFileType === '[object Blob]') {
	            _this3.post(processedFile);
	          } else {
	            _this3.post(file);
	          }
	        })['catch'](function (e) {
	          console && console.log(e); // eslint-disable-line
	        });
	      } else if (before !== false) {
	        setTimeout(function () {
	          return _this3.post(file);
	        }, 0);
	      }
	    }
	  }, {
	    key: 'post',
	    value: function post(file) {
	      var _this4 = this;
	
	      if (!this._isMounted) {
	        return;
	      }
	      var props = this.props;
	      var data = props.data;
	      var onStart = props.onStart,
	          onProgress = props.onProgress;
	
	      if (typeof data === 'function') {
	        data = data(file);
	      }
	      var uid = file.uid;
	
	      var request = props.customRequest || _request2['default'];
	      this.reqs[uid] = request({
	        action: props.action,
	        filename: props.name,
	        file: file,
	        data: data,
	        headers: props.headers,
	        withCredentials: props.withCredentials,
	        onProgress: onProgress ? function (e) {
	          onProgress(e, file);
	        } : null,
	        onSuccess: function onSuccess(ret, xhr) {
	          delete _this4.reqs[uid];
	          props.onSuccess(ret, file, xhr);
	        },
	        onError: function onError(err, ret) {
	          delete _this4.reqs[uid];
	          props.onError(err, ret, file);
	        }
	      });
	      onStart(file);
	    }
	  }, {
	    key: 'reset',
	    value: function reset() {
	      this.setState({
	        uid: (0, _uid2['default'])()
	      });
	    }
	  }, {
	    key: 'abort',
	    value: function abort(file) {
	      var reqs = this.reqs;
	
	      if (file) {
	        var uid = file;
	        if (file && file.uid) {
	          uid = file.uid;
	        }
	        if (reqs[uid]) {
	          reqs[uid].abort();
	          delete reqs[uid];
	        }
	      } else {
	        Object.keys(reqs).forEach(function (uid) {
	          if (reqs[uid]) {
	            reqs[uid].abort();
	          }
	
	          delete reqs[uid];
	        });
	      }
	    }
	  }, {
	    key: 'render',
	    value: function render() {
	      var _classNames;
	
	      var _props = this.props,
	          Tag = _props.component,
	          prefixCls = _props.prefixCls,
	          className = _props.className,
	          disabled = _props.disabled,
	          style = _props.style,
	          multiple = _props.multiple,
	          accept = _props.accept,
	          children = _props.children;
	
	      var cls = (0, _classnames2['default'])((_classNames = {}, (0, _defineProperty3['default'])(_classNames, prefixCls, true), (0, _defineProperty3['default'])(_classNames, prefixCls + '-disabled', disabled), (0, _defineProperty3['default'])(_classNames, className, className), _classNames));
	      var events = disabled ? {} : {
	        onClick: this.onClick,
	        onKeyDown: this.onKeyDown,
	        onDrop: this.onFileDrop,
	        onDragOver: this.onFileDrop,
	        tabIndex: '0'
	      };
	      return _react2['default'].createElement(
	        Tag,
	        (0, _extends3['default'])({}, events, {
	          className: cls,
	          role: 'button',
	          style: style
	        }),
	        _react2['default'].createElement('input', {
	          type: 'file',
	          ref: this.saveFileInput,
	          key: this.state.uid,
	          style: { display: 'none' },
	          accept: accept,
	          multiple: multiple,
	          onChange: this.onChange
	        }),
	        children
	      );
	    }
	  }]);
	  return AjaxUploader;
	}(_react.Component);
	
	AjaxUploader.propTypes = {
	  component: _propTypes2['default'].string,
	  style: _propTypes2['default'].object,
	  prefixCls: _propTypes2['default'].string,
	  className: _propTypes2['default'].string,
	  multiple: _propTypes2['default'].bool,
	  disabled: _propTypes2['default'].bool,
	  accept: _propTypes2['default'].string,
	  children: _propTypes2['default'].any,
	  onStart: _propTypes2['default'].func,
	  data: _propTypes2['default'].oneOfType([_propTypes2['default'].object, _propTypes2['default'].func]),
	  headers: _propTypes2['default'].object,
	  beforeUpload: _propTypes2['default'].func,
	  customRequest: _propTypes2['default'].func,
	  onProgress: _propTypes2['default'].func,
	  withCredentials: _propTypes2['default'].bool
	};
	exports['default'] = AjaxUploader;
	module.exports = exports['default'];

/***/ }),
/* 783 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _defineProperty2 = __webpack_require__(9);
	
	var _defineProperty3 = _interopRequireDefault(_defineProperty2);
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _reactDom = __webpack_require__(10);
	
	var _reactDom2 = _interopRequireDefault(_reactDom);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _uid = __webpack_require__(281);
	
	var _uid2 = _interopRequireDefault(_uid);
	
	var _warning = __webpack_require__(788);
	
	var _warning2 = _interopRequireDefault(_warning);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	/* eslint react/sort-comp:0 */
	var IFRAME_STYLE = {
	  position: 'absolute',
	  top: 0,
	  opacity: 0,
	  filter: 'alpha(opacity=0)',
	  left: 0,
	  zIndex: 9999
	};
	
	// diferent from AjaxUpload, can only upload on at one time, serial seriously
	
	var IframeUploader = function (_Component) {
	  (0, _inherits3['default'])(IframeUploader, _Component);
	
	  function IframeUploader() {
	    var _ref;
	
	    var _temp, _this, _ret;
	
	    (0, _classCallCheck3['default'])(this, IframeUploader);
	
	    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
	      args[_key] = arguments[_key];
	    }
	
	    return _ret = (_temp = (_this = (0, _possibleConstructorReturn3['default'])(this, (_ref = IframeUploader.__proto__ || Object.getPrototypeOf(IframeUploader)).call.apply(_ref, [this].concat(args))), _this), _this.state = { uploading: false }, _this.file = {}, _this.onLoad = function () {
	      if (!_this.state.uploading) {
	        return;
	      }
	      var _this2 = _this,
	          props = _this2.props,
	          file = _this2.file;
	
	      var response = void 0;
	      try {
	        var doc = _this.getIframeDocument();
	        var script = doc.getElementsByTagName('script')[0];
	        if (script && script.parentNode === doc.body) {
	          doc.body.removeChild(script);
	        }
	        response = doc.body.innerHTML;
	        props.onSuccess(response, file);
	      } catch (err) {
	        (0, _warning2['default'])(false, 'cross domain error for Upload. Maybe server should return document.domain script. see Note from https://github.com/react-component/upload');
	        response = 'cross-domain';
	        props.onError(err, null, file);
	      }
	      _this.endUpload();
	    }, _this.onChange = function () {
	      var target = _this.getFormInputNode();
	      // ie8/9 don't support FileList Object
	      // http://stackoverflow.com/questions/12830058/ie8-input-type-file-get-files
	      var file = _this.file = {
	        uid: (0, _uid2['default'])(),
	        name: target.value
	      };
	      _this.startUpload();
	      var _this3 = _this,
	          props = _this3.props;
	
	      if (!props.beforeUpload) {
	        return _this.post(file);
	      }
	      var before = props.beforeUpload(file);
	      if (before && before.then) {
	        before.then(function () {
	          _this.post(file);
	        }, function () {
	          _this.endUpload();
	        });
	      } else if (before !== false) {
	        _this.post(file);
	      } else {
	        _this.endUpload();
	      }
	    }, _this.saveIframe = function (node) {
	      _this.iframe = node;
	    }, _temp), (0, _possibleConstructorReturn3['default'])(_this, _ret);
	  }
	
	  (0, _createClass3['default'])(IframeUploader, [{
	    key: 'componentDidMount',
	    value: function componentDidMount() {
	      this.updateIframeWH();
	      this.initIframe();
	    }
	  }, {
	    key: 'componentDidUpdate',
	    value: function componentDidUpdate() {
	      this.updateIframeWH();
	    }
	  }, {
	    key: 'getIframeNode',
	    value: function getIframeNode() {
	      return this.iframe;
	    }
	  }, {
	    key: 'getIframeDocument',
	    value: function getIframeDocument() {
	      return this.getIframeNode().contentDocument;
	    }
	  }, {
	    key: 'getFormNode',
	    value: function getFormNode() {
	      return this.getIframeDocument().getElementById('form');
	    }
	  }, {
	    key: 'getFormInputNode',
	    value: function getFormInputNode() {
	      return this.getIframeDocument().getElementById('input');
	    }
	  }, {
	    key: 'getFormDataNode',
	    value: function getFormDataNode() {
	      return this.getIframeDocument().getElementById('data');
	    }
	  }, {
	    key: 'getFileForMultiple',
	    value: function getFileForMultiple(file) {
	      return this.props.multiple ? [file] : file;
	    }
	  }, {
	    key: 'getIframeHTML',
	    value: function getIframeHTML(domain) {
	      var domainScript = '';
	      var domainInput = '';
	      if (domain) {
	        var script = 'script';
	        domainScript = '<' + script + '>document.domain="' + domain + '";</' + script + '>';
	        domainInput = '<input name="_documentDomain" value="' + domain + '" />';
	      }
	      return '\n    <!DOCTYPE html>\n    <html>\n    <head>\n    <meta http-equiv="X-UA-Compatible" content="IE=edge" />\n    <style>\n    body,html {padding:0;margin:0;border:0;overflow:hidden;}\n    </style>\n    ' + domainScript + '\n    </head>\n    <body>\n    <form method="post"\n    encType="multipart/form-data"\n    action="' + this.props.action + '" id="form"\n    style="display:block;height:9999px;position:relative;overflow:hidden;">\n    <input id="input" type="file"\n     name="' + this.props.name + '"\n     style="position:absolute;top:0;right:0;height:9999px;font-size:9999px;cursor:pointer;"/>\n    ' + domainInput + '\n    <span id="data"></span>\n    </form>\n    </body>\n    </html>\n    ';
	    }
	  }, {
	    key: 'initIframeSrc',
	    value: function initIframeSrc() {
	      if (this.domain) {
	        this.getIframeNode().src = 'javascript:void((function(){\n        var d = document;\n        d.open();\n        d.domain=\'' + this.domain + '\';\n        d.write(\'\');\n        d.close();\n      })())';
	      }
	    }
	  }, {
	    key: 'initIframe',
	    value: function initIframe() {
	      var iframeNode = this.getIframeNode();
	      var win = iframeNode.contentWindow;
	      var doc = void 0;
	      this.domain = this.domain || '';
	      this.initIframeSrc();
	      try {
	        doc = win.document;
	      } catch (e) {
	        this.domain = document.domain;
	        this.initIframeSrc();
	        win = iframeNode.contentWindow;
	        doc = win.document;
	      }
	      doc.open('text/html', 'replace');
	      doc.write(this.getIframeHTML(this.domain));
	      doc.close();
	      this.getFormInputNode().onchange = this.onChange;
	    }
	  }, {
	    key: 'endUpload',
	    value: function endUpload() {
	      if (this.state.uploading) {
	        this.file = {};
	        // hack avoid batch
	        this.state.uploading = false;
	        this.setState({
	          uploading: false
	        });
	        this.initIframe();
	      }
	    }
	  }, {
	    key: 'startUpload',
	    value: function startUpload() {
	      if (!this.state.uploading) {
	        this.state.uploading = true;
	        this.setState({
	          uploading: true
	        });
	      }
	    }
	  }, {
	    key: 'updateIframeWH',
	    value: function updateIframeWH() {
	      var rootNode = _reactDom2['default'].findDOMNode(this);
	      var iframeNode = this.getIframeNode();
	      iframeNode.style.height = rootNode.offsetHeight + 'px';
	      iframeNode.style.width = rootNode.offsetWidth + 'px';
	    }
	  }, {
	    key: 'abort',
	    value: function abort(file) {
	      if (file) {
	        var uid = file;
	        if (file && file.uid) {
	          uid = file.uid;
	        }
	        if (uid === this.file.uid) {
	          this.endUpload();
	        }
	      } else {
	        this.endUpload();
	      }
	    }
	  }, {
	    key: 'post',
	    value: function post(file) {
	      var formNode = this.getFormNode();
	      var dataSpan = this.getFormDataNode();
	      var data = this.props.data;
	      var onStart = this.props.onStart;
	
	      if (typeof data === 'function') {
	        data = data(file);
	      }
	      var inputs = document.createDocumentFragment();
	      for (var key in data) {
	        if (data.hasOwnProperty(key)) {
	          var input = document.createElement('input');
	          input.setAttribute('name', key);
	          input.value = data[key];
	          inputs.appendChild(input);
	        }
	      }
	      dataSpan.appendChild(inputs);
	      formNode.submit();
	      dataSpan.innerHTML = '';
	      onStart(file);
	    }
	  }, {
	    key: 'render',
	    value: function render() {
	      var _classNames;
	
	      var _props = this.props,
	          Tag = _props.component,
	          disabled = _props.disabled,
	          className = _props.className,
	          prefixCls = _props.prefixCls,
	          children = _props.children,
	          style = _props.style;
	
	      var iframeStyle = (0, _extends3['default'])({}, IFRAME_STYLE, {
	        display: this.state.uploading || disabled ? 'none' : ''
	      });
	      var cls = (0, _classnames2['default'])((_classNames = {}, (0, _defineProperty3['default'])(_classNames, prefixCls, true), (0, _defineProperty3['default'])(_classNames, prefixCls + '-disabled', disabled), (0, _defineProperty3['default'])(_classNames, className, className), _classNames));
	      return _react2['default'].createElement(
	        Tag,
	        {
	          className: cls,
	          style: (0, _extends3['default'])({ position: 'relative', zIndex: 0 }, style)
	        },
	        _react2['default'].createElement('iframe', {
	          ref: this.saveIframe,
	          onLoad: this.onLoad,
	          style: iframeStyle
	        }),
	        children
	      );
	    }
	  }]);
	  return IframeUploader;
	}(_react.Component);
	
	IframeUploader.propTypes = {
	  component: _propTypes2['default'].string,
	  style: _propTypes2['default'].object,
	  disabled: _propTypes2['default'].bool,
	  prefixCls: _propTypes2['default'].string,
	  className: _propTypes2['default'].string,
	  accept: _propTypes2['default'].string,
	  onStart: _propTypes2['default'].func,
	  multiple: _propTypes2['default'].bool,
	  children: _propTypes2['default'].any,
	  data: _propTypes2['default'].oneOfType([_propTypes2['default'].object, _propTypes2['default'].func]),
	  action: _propTypes2['default'].string,
	  name: _propTypes2['default'].string
	};
	exports['default'] = IframeUploader;
	module.exports = exports['default'];

/***/ }),
/* 784 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _extends2 = __webpack_require__(2);
	
	var _extends3 = _interopRequireDefault(_extends2);
	
	var _classCallCheck2 = __webpack_require__(3);
	
	var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
	
	var _createClass2 = __webpack_require__(7);
	
	var _createClass3 = _interopRequireDefault(_createClass2);
	
	var _possibleConstructorReturn2 = __webpack_require__(5);
	
	var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
	
	var _inherits2 = __webpack_require__(4);
	
	var _inherits3 = _interopRequireDefault(_inherits2);
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _AjaxUploader = __webpack_require__(782);
	
	var _AjaxUploader2 = _interopRequireDefault(_AjaxUploader);
	
	var _IframeUploader = __webpack_require__(783);
	
	var _IframeUploader2 = _interopRequireDefault(_IframeUploader);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function empty() {}
	
	var Upload = function (_Component) {
	  (0, _inherits3['default'])(Upload, _Component);
	
	  function Upload() {
	    var _ref;
	
	    var _temp, _this, _ret;
	
	    (0, _classCallCheck3['default'])(this, Upload);
	
	    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
	      args[_key] = arguments[_key];
	    }
	
	    return _ret = (_temp = (_this = (0, _possibleConstructorReturn3['default'])(this, (_ref = Upload.__proto__ || Object.getPrototypeOf(Upload)).call.apply(_ref, [this].concat(args))), _this), _this.state = {
	      Component: null
	    }, _this.saveUploader = function (node) {
	      _this.uploader = node;
	    }, _temp), (0, _possibleConstructorReturn3['default'])(_this, _ret);
	  }
	
	  (0, _createClass3['default'])(Upload, [{
	    key: 'componentDidMount',
	    value: function componentDidMount() {
	      if (this.props.supportServerRender) {
	        /* eslint react/no-did-mount-set-state:0 */
	        this.setState({
	          Component: this.getComponent()
	        }, this.props.onReady);
	      }
	    }
	  }, {
	    key: 'getComponent',
	    value: function getComponent() {
	      return typeof File !== 'undefined' ? _AjaxUploader2['default'] : _IframeUploader2['default'];
	    }
	  }, {
	    key: 'abort',
	    value: function abort(file) {
	      this.uploader.abort(file);
	    }
	  }, {
	    key: 'render',
	    value: function render() {
	      if (this.props.supportServerRender) {
	        var _ComponentUploader = this.state.Component;
	        if (_ComponentUploader) {
	          return _react2['default'].createElement(_ComponentUploader, (0, _extends3['default'])({}, this.props, { ref: this.saveUploader }));
	        }
	        return null;
	      }
	      var ComponentUploader = this.getComponent();
	      return _react2['default'].createElement(ComponentUploader, (0, _extends3['default'])({}, this.props, { ref: this.saveUploader }));
	    }
	  }]);
	  return Upload;
	}(_react.Component);
	
	Upload.propTypes = {
	  component: _propTypes2['default'].string,
	  style: _propTypes2['default'].object,
	  prefixCls: _propTypes2['default'].string,
	  action: _propTypes2['default'].string,
	  name: _propTypes2['default'].string,
	  multipart: _propTypes2['default'].bool,
	  onError: _propTypes2['default'].func,
	  onSuccess: _propTypes2['default'].func,
	  onProgress: _propTypes2['default'].func,
	  onStart: _propTypes2['default'].func,
	  data: _propTypes2['default'].oneOfType([_propTypes2['default'].object, _propTypes2['default'].func]),
	  headers: _propTypes2['default'].object,
	  accept: _propTypes2['default'].string,
	  multiple: _propTypes2['default'].bool,
	  disabled: _propTypes2['default'].bool,
	  beforeUpload: _propTypes2['default'].func,
	  customRequest: _propTypes2['default'].func,
	  onReady: _propTypes2['default'].func,
	  withCredentials: _propTypes2['default'].bool,
	  supportServerRender: _propTypes2['default'].bool
	};
	Upload.defaultProps = {
	  component: 'span',
	  prefixCls: 'rc-upload',
	  data: {},
	  headers: {},
	  name: 'file',
	  multipart: false,
	  onReady: empty,
	  onStart: empty,
	  onError: empty,
	  onSuccess: empty,
	  supportServerRender: false,
	  multiple: false,
	  beforeUpload: null,
	  customRequest: null,
	  withCredentials: false
	};
	exports['default'] = Upload;
	module.exports = exports['default'];

/***/ }),
/* 785 */
/***/ (function(module, exports) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	function endsWith(str, suffix) {
	  return str.indexOf(suffix, str.length - suffix.length) !== -1;
	}
	
	exports['default'] = function (file, acceptedFiles) {
	  if (file && acceptedFiles) {
	    var acceptedFilesArray = Array.isArray(acceptedFiles) ? acceptedFiles : acceptedFiles.split(',');
	    var fileName = file.name || '';
	    var mimeType = file.type || '';
	    var baseMimeType = mimeType.replace(/\/.*$/, '');
	
	    return acceptedFilesArray.some(function (type) {
	      var validType = type.trim();
	      if (validType.charAt(0) === '.') {
	        return endsWith(fileName.toLowerCase(), validType.toLowerCase());
	      } else if (/\/\*$/.test(validType)) {
	        // This is something like a image/* mime type
	        return baseMimeType === validType.replace(/\/.*$/, '');
	      }
	      return mimeType === validType;
	    });
	  }
	  return true;
	};
	
	module.exports = exports['default'];

/***/ }),
/* 786 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _Upload = __webpack_require__(784);
	
	var _Upload2 = _interopRequireDefault(_Upload);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	exports['default'] = _Upload2['default']; // export this package's api
	
	module.exports = exports['default'];

/***/ }),
/* 787 */
/***/ (function(module, exports) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports['default'] = upload;
	function getError(option, xhr) {
	  var msg = 'cannot post ' + option.action + ' ' + xhr.status + '\'';
	  var err = new Error(msg);
	  err.status = xhr.status;
	  err.method = 'post';
	  err.url = option.action;
	  return err;
	}
	
	function getBody(xhr) {
	  var text = xhr.responseText || xhr.response;
	  if (!text) {
	    return text;
	  }
	
	  try {
	    return JSON.parse(text);
	  } catch (e) {
	    return text;
	  }
	}
	
	// option {
	//  onProgress: (event: { percent: number }): void,
	//  onError: (event: Error, body?: Object): void,
	//  onSuccess: (body: Object): void,
	//  data: Object,
	//  filename: String,
	//  file: File,
	//  withCredentials: Boolean,
	//  action: String,
	//  headers: Object,
	// }
	function upload(option) {
	  var xhr = new XMLHttpRequest();
	
	  if (option.onProgress && xhr.upload) {
	    xhr.upload.onprogress = function progress(e) {
	      if (e.total > 0) {
	        e.percent = e.loaded / e.total * 100;
	      }
	      option.onProgress(e);
	    };
	  }
	
	  var formData = new FormData();
	
	  if (option.data) {
	    Object.keys(option.data).map(function (key) {
	      formData.append(key, option.data[key]);
	    });
	  }
	
	  formData.append(option.filename, option.file);
	
	  xhr.onerror = function error(e) {
	    option.onError(e);
	  };
	
	  xhr.onload = function onload() {
	    // allow success when 2xx status
	    // see https://github.com/react-component/upload/issues/34
	    if (xhr.status < 200 || xhr.status >= 300) {
	      return option.onError(getError(option, xhr), getBody(xhr));
	    }
	
	    option.onSuccess(getBody(xhr), xhr);
	  };
	
	  xhr.open('post', option.action, true);
	
	  // Has to be after `.open()`. See https://github.com/enyo/dropzone/issues/179
	  if (option.withCredentials && 'withCredentials' in xhr) {
	    xhr.withCredentials = true;
	  }
	
	  var headers = option.headers || {};
	
	  // when set headers['X-Requested-With'] = null , can close default XHR header
	  // see https://github.com/react-component/upload/issues/33
	  if (headers['X-Requested-With'] !== null) {
	    xhr.setRequestHeader('X-Requested-With', 'XMLHttpRequest');
	  }
	
	  for (var h in headers) {
	    if (headers.hasOwnProperty(h) && headers[h] !== null) {
	      xhr.setRequestHeader(h, headers[h]);
	    }
	  }
	  xhr.send(formData);
	
	  return {
	    abort: function abort() {
	      xhr.abort();
	    }
	  };
	}
	module.exports = exports['default'];

/***/ }),
/* 788 */
35,
/* 789 */
/***/ (function(module, exports) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports['default'] = getScrollBarSize;
	var cached = void 0;
	
	function getScrollBarSize(fresh) {
	  if (fresh || cached === undefined) {
	    var inner = document.createElement('div');
	    inner.style.width = '100%';
	    inner.style.height = '200px';
	
	    var outer = document.createElement('div');
	    var outerStyle = outer.style;
	
	    outerStyle.position = 'absolute';
	    outerStyle.top = 0;
	    outerStyle.left = 0;
	    outerStyle.pointerEvents = 'none';
	    outerStyle.visibility = 'hidden';
	    outerStyle.width = '200px';
	    outerStyle.height = '150px';
	    outerStyle.overflow = 'hidden';
	
	    outer.appendChild(inner);
	
	    document.body.appendChild(outer);
	
	    var widthContained = inner.offsetWidth;
	    outer.style.overflow = 'scroll';
	    var widthScroll = inner.offsetWidth;
	
	    if (widthContained === widthScroll) {
	      widthScroll = outer.clientWidth;
	    }
	
	    document.body.removeChild(outer);
	
	    cached = widthContained - widthScroll;
	  }
	  return cached;
	}
	module.exports = exports['default'];

/***/ }),
/* 790 */
150,
/* 791 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _propTypes = __webpack_require__(6);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _reactDom = __webpack_require__(10);
	
	var _eventlistener = __webpack_require__(549);
	
	var _lodash = __webpack_require__(91);
	
	var _lodash2 = _interopRequireDefault(_lodash);
	
	var _lodash3 = __webpack_require__(580);
	
	var _lodash4 = _interopRequireDefault(_lodash3);
	
	var _parentScroll = __webpack_require__(794);
	
	var _parentScroll2 = _interopRequireDefault(_parentScroll);
	
	var _inViewport = __webpack_require__(793);
	
	var _inViewport2 = _interopRequireDefault(_inViewport);
	
	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; }
	
	var LazyLoad = function (_Component) {
	  _inherits(LazyLoad, _Component);
	
	  function LazyLoad(props) {
	    _classCallCheck(this, LazyLoad);
	
	    var _this = _possibleConstructorReturn(this, (LazyLoad.__proto__ || Object.getPrototypeOf(LazyLoad)).call(this, props));
	
	    _this.lazyLoadHandler = _this.lazyLoadHandler.bind(_this);
	
	    if (props.throttle > 0) {
	      if (props.debounce) {
	        _this.lazyLoadHandler = (0, _lodash2.default)(_this.lazyLoadHandler, props.throttle);
	      } else {
	        _this.lazyLoadHandler = (0, _lodash4.default)(_this.lazyLoadHandler, props.throttle);
	      }
	    }
	
	    _this.state = { visible: false };
	    return _this;
	  }
	
	  _createClass(LazyLoad, [{
	    key: 'componentDidMount',
	    value: function componentDidMount() {
	      this._mounted = true;
	      var eventNode = this.getEventNode();
	
	      this.lazyLoadHandler();
	
	      if (this.lazyLoadHandler.flush) {
	        this.lazyLoadHandler.flush();
	      }
	
	      (0, _eventlistener.add)(window, 'resize', this.lazyLoadHandler);
	      (0, _eventlistener.add)(eventNode, 'scroll', this.lazyLoadHandler);
	    }
	  }, {
	    key: 'componentWillReceiveProps',
	    value: function componentWillReceiveProps() {
	      if (!this.state.visible) {
	        this.lazyLoadHandler();
	      }
	    }
	  }, {
	    key: 'shouldComponentUpdate',
	    value: function shouldComponentUpdate(_nextProps, nextState) {
	      return nextState.visible;
	    }
	  }, {
	    key: 'componentWillUnmount',
	    value: function componentWillUnmount() {
	      this._mounted = false;
	      if (this.lazyLoadHandler.cancel) {
	        this.lazyLoadHandler.cancel();
	      }
	
	      this.detachListeners();
	    }
	  }, {
	    key: 'getEventNode',
	    value: function getEventNode() {
	      return (0, _parentScroll2.default)((0, _reactDom.findDOMNode)(this));
	    }
	  }, {
	    key: 'getOffset',
	    value: function getOffset() {
	      var _props = this.props,
	          offset = _props.offset,
	          offsetVertical = _props.offsetVertical,
	          offsetHorizontal = _props.offsetHorizontal,
	          offsetTop = _props.offsetTop,
	          offsetBottom = _props.offsetBottom,
	          offsetLeft = _props.offsetLeft,
	          offsetRight = _props.offsetRight,
	          threshold = _props.threshold;
	
	
	      var _offsetAll = threshold || offset;
	      var _offsetVertical = offsetVertical || _offsetAll;
	      var _offsetHorizontal = offsetHorizontal || _offsetAll;
	
	      return {
	        top: offsetTop || _offsetVertical,
	        bottom: offsetBottom || _offsetVertical,
	        left: offsetLeft || _offsetHorizontal,
	        right: offsetRight || _offsetHorizontal
	      };
	    }
	  }, {
	    key: 'lazyLoadHandler',
	    value: function lazyLoadHandler() {
	      if (!this._mounted) {
	        return;
	      }
	      var offset = this.getOffset();
	      var node = (0, _reactDom.findDOMNode)(this);
	      var eventNode = this.getEventNode();
	
	      if ((0, _inViewport2.default)(node, eventNode, offset)) {
	        var onContentVisible = this.props.onContentVisible;
	
	
	        this.setState({ visible: true }, function () {
	          if (onContentVisible) {
	            onContentVisible();
	          }
	        });
	        this.detachListeners();
	      }
	    }
	  }, {
	    key: 'detachListeners',
	    value: function detachListeners() {
	      var eventNode = this.getEventNode();
	
	      (0, _eventlistener.remove)(window, 'resize', this.lazyLoadHandler);
	      (0, _eventlistener.remove)(eventNode, 'scroll', this.lazyLoadHandler);
	    }
	  }, {
	    key: 'render',
	    value: function render() {
	      var _props2 = this.props,
	          children = _props2.children,
	          className = _props2.className,
	          height = _props2.height,
	          width = _props2.width;
	      var visible = this.state.visible;
	
	
	      var elStyles = { height: height, width: width };
	      var elClasses = 'LazyLoad' + (visible ? ' is-visible' : '') + (className ? ' ' + className : '');
	
	      return _react2.default.createElement(this.props.elementType, {
	        className: elClasses,
	        style: elStyles
	      }, visible && _react.Children.only(children));
	    }
	  }]);
	
	  return LazyLoad;
	}(_react.Component);
	
	exports.default = LazyLoad;
	
	
	LazyLoad.propTypes = {
	  children: _propTypes2.default.node.isRequired,
	  className: _propTypes2.default.string,
	  debounce: _propTypes2.default.bool,
	  elementType: _propTypes2.default.string,
	  height: _propTypes2.default.oneOfType([_propTypes2.default.string, _propTypes2.default.number]),
	  offset: _propTypes2.default.number,
	  offsetBottom: _propTypes2.default.number,
	  offsetHorizontal: _propTypes2.default.number,
	  offsetLeft: _propTypes2.default.number,
	  offsetRight: _propTypes2.default.number,
	  offsetTop: _propTypes2.default.number,
	  offsetVertical: _propTypes2.default.number,
	  threshold: _propTypes2.default.number,
	  throttle: _propTypes2.default.number,
	  width: _propTypes2.default.oneOfType([_propTypes2.default.string, _propTypes2.default.number]),
	  onContentVisible: _propTypes2.default.func
	};
	
	LazyLoad.defaultProps = {
	  elementType: 'div',
	  debounce: true,
	  offset: 0,
	  offsetBottom: 0,
	  offsetHorizontal: 0,
	  offsetLeft: 0,
	  offsetRight: 0,
	  offsetTop: 0,
	  offsetVertical: 0,
	  throttle: 250
	};

/***/ }),
/* 792 */
/***/ (function(module, exports) {

	"use strict";
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = getElementPosition;
	/*
	* Finds element's position relative to the whole document,
	* rather than to the viewport as it is the case with .getBoundingClientRect().
	*/
	function getElementPosition(element) {
	  var rect = element.getBoundingClientRect();
	
	  return {
	    top: rect.top + window.pageYOffset,
	    left: rect.left + window.pageXOffset
	  };
	}

/***/ }),
/* 793 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.default = inViewport;
	
	var _getElementPosition = __webpack_require__(792);
	
	var _getElementPosition2 = _interopRequireDefault(_getElementPosition);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
	
	var isHidden = function isHidden(element) {
	  return element.offsetParent === null;
	};
	
	function inViewport(element, container, customOffset) {
	  if (isHidden(element)) {
	    return false;
	  }
	
	  var top = void 0;
	  var bottom = void 0;
	  var left = void 0;
	  var right = void 0;
	
	  if (typeof container === 'undefined' || container === window) {
	    top = window.pageYOffset;
	    left = window.pageXOffset;
	    bottom = top + window.innerHeight;
	    right = left + window.innerWidth;
	  } else {
	    var containerPosition = (0, _getElementPosition2.default)(container);
	
	    top = containerPosition.top;
	    left = containerPosition.left;
	    bottom = top + container.offsetHeight;
	    right = left + container.offsetWidth;
	  }
	
	  var elementPosition = (0, _getElementPosition2.default)(element);
	
	  return top <= elementPosition.top + element.offsetHeight + customOffset.top && bottom >= elementPosition.top - customOffset.bottom && left <= elementPosition.left + element.offsetWidth + customOffset.left && right >= elementPosition.left - customOffset.right;
	}

/***/ }),
/* 794 */
/***/ (function(module, exports) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	var style = function style(element, prop) {
	  return typeof getComputedStyle !== 'undefined' ? getComputedStyle(element, null).getPropertyValue(prop) : element.style[prop];
	};
	
	var overflow = function overflow(element) {
	  return style(element, 'overflow') + style(element, 'overflow-y') + style(element, 'overflow-x');
	};
	
	var scrollParent = function scrollParent(element) {
	  if (!(element instanceof HTMLElement)) {
	    return window;
	  }
	
	  var parent = element;
	
	  while (parent) {
	    if (parent === document.body || parent === document.documentElement) {
	      break;
	    }
	
	    if (!parent.parentNode) {
	      break;
	    }
	
	    if (/(scroll|auto)/.test(overflow(parent))) {
	      return parent;
	    }
	
	    parent = parent.parentNode;
	  }
	
	  return window;
	};
	
	exports.default = scrollParent;

/***/ }),
/* 795 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	exports.__esModule = true;
	exports.NextArrow = exports.PrevArrow = 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 _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _helpers = __webpack_require__(154);
	
	var _helpers2 = _interopRequireDefault(_helpers);
	
	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; }
	
	var PrevArrow = exports.PrevArrow = function (_React$Component) {
	  _inherits(PrevArrow, _React$Component);
	
	  function PrevArrow() {
	    _classCallCheck(this, PrevArrow);
	
	    return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	  }
	
	  PrevArrow.prototype.clickHandler = function clickHandler(options, e) {
	    if (e) {
	      e.preventDefault();
	    }
	    this.props.clickHandler(options, e);
	  };
	
	  PrevArrow.prototype.render = function render() {
	    var prevClasses = { 'slick-arrow': true, 'slick-prev': true };
	    var prevHandler = this.clickHandler.bind(this, { message: 'previous' });
	
	    if (!this.props.infinite && (this.props.currentSlide === 0 || this.props.slideCount <= this.props.slidesToShow)) {
	      prevClasses['slick-disabled'] = true;
	      prevHandler = null;
	    }
	
	    var prevArrowProps = {
	      key: '0',
	      'data-role': 'none',
	      className: (0, _classnames2.default)(prevClasses),
	      style: { display: 'block' },
	      onClick: prevHandler
	    };
	    var customProps = {
	      currentSlide: this.props.currentSlide,
	      slideCount: this.props.slideCount
	    };
	    var prevArrow;
	
	    if (this.props.prevArrow) {
	      prevArrow = _react2.default.cloneElement(this.props.prevArrow, _extends({}, prevArrowProps, customProps));
	    } else {
	      prevArrow = _react2.default.createElement(
	        'button',
	        _extends({ key: '0', type: 'button' }, prevArrowProps),
	        ' Previous'
	      );
	    }
	
	    return prevArrow;
	  };
	
	  return PrevArrow;
	}(_react2.default.Component);
	
	var NextArrow = exports.NextArrow = function (_React$Component2) {
	  _inherits(NextArrow, _React$Component2);
	
	  function NextArrow() {
	    _classCallCheck(this, NextArrow);
	
	    return _possibleConstructorReturn(this, _React$Component2.apply(this, arguments));
	  }
	
	  NextArrow.prototype.clickHandler = function clickHandler(options, e) {
	    if (e) {
	      e.preventDefault();
	    }
	    this.props.clickHandler(options, e);
	  };
	
	  NextArrow.prototype.render = function render() {
	    var nextClasses = { 'slick-arrow': true, 'slick-next': true };
	    var nextHandler = this.clickHandler.bind(this, { message: 'next' });
	
	    if (!_helpers2.default.canGoNext(this.props)) {
	      nextClasses['slick-disabled'] = true;
	      nextHandler = null;
	    }
	
	    var nextArrowProps = {
	      key: '1',
	      'data-role': 'none',
	      className: (0, _classnames2.default)(nextClasses),
	      style: { display: 'block' },
	      onClick: nextHandler
	    };
	    var customProps = {
	      currentSlide: this.props.currentSlide,
	      slideCount: this.props.slideCount
	    };
	    var nextArrow;
	
	    if (this.props.nextArrow) {
	      nextArrow = _react2.default.cloneElement(this.props.nextArrow, _extends({}, nextArrowProps, customProps));
	    } else {
	      nextArrow = _react2.default.createElement(
	        'button',
	        _extends({ key: '1', type: 'button' }, nextArrowProps),
	        ' Next'
	      );
	    }
	
	    return nextArrow;
	  };
	
	  return NextArrow;
	}(_react2.default.Component);

/***/ }),
/* 796 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	exports.__esModule = true;
	exports.Dots = undefined;
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	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; }
	
	var getDotCount = function getDotCount(spec) {
	  var dots;
	  dots = Math.ceil(spec.slideCount / spec.slidesToScroll);
	  return dots;
	};
	
	var Dots = exports.Dots = function (_React$Component) {
	  _inherits(Dots, _React$Component);
	
	  function Dots() {
	    _classCallCheck(this, Dots);
	
	    return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	  }
	
	  Dots.prototype.clickHandler = function clickHandler(options, e) {
	    // In Autoplay the focus stays on clicked button even after transition
	    // to next slide. That only goes away by click somewhere outside
	    e.preventDefault();
	    this.props.clickHandler(options);
	  };
	
	  Dots.prototype.render = function render() {
	    var _this2 = this;
	
	    var dotCount = getDotCount({
	      slideCount: this.props.slideCount,
	      slidesToScroll: this.props.slidesToScroll
	    });
	
	    // Apply join & split to Array to pre-fill it for IE8
	    //
	    // Credit: http://stackoverflow.com/a/13735425/1849458
	    var dots = Array.apply(null, Array(dotCount + 1).join('0').split('')).map(function (x, i) {
	
	      var leftBound = i * _this2.props.slidesToScroll;
	      var rightBound = i * _this2.props.slidesToScroll + (_this2.props.slidesToScroll - 1);
	      var className = (0, _classnames2.default)({
	        'slick-active': _this2.props.currentSlide >= leftBound && _this2.props.currentSlide <= rightBound
	      });
	
	      var dotOptions = {
	        message: 'dots',
	        index: i,
	        slidesToScroll: _this2.props.slidesToScroll,
	        currentSlide: _this2.props.currentSlide
	      };
	
	      var onClick = _this2.clickHandler.bind(_this2, dotOptions);
	
	      return _react2.default.createElement(
	        'li',
	        { key: i, className: className },
	        _react2.default.cloneElement(_this2.props.customPaging(i), { onClick: onClick })
	      );
	    });
	
	    return _react2.default.createElement(
	      'ul',
	      { className: this.props.dotsClass, style: { display: 'block' } },
	      dots
	    );
	  };
	
	  return Dots;
	}(_react2.default.Component);

/***/ }),
/* 797 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	module.exports = __webpack_require__(801);

/***/ }),
/* 798 */
/***/ (function(module, exports) {

	"use strict";
	
	var initialState = {
	    animating: false,
	    dragging: false,
	    autoPlayTimer: null,
	    currentDirection: 0,
	    currentLeft: null,
	    currentSlide: 0,
	    direction: 1,
	    listWidth: null,
	    listHeight: null,
	    scrolling: false,
	    // loadIndex: 0,
	    slideCount: null,
	    slideWidth: null,
	    slideHeight: null,
	    swiping: false,
	    // sliding: false,
	    // slideOffset: 0,
	    swipeLeft: null,
	    touchObject: {
	        startX: 0,
	        startY: 0,
	        curX: 0,
	        curY: 0
	    },
	
	    lazyLoadedList: [],
	
	    // added for react
	    initialized: false,
	    edgeDragged: false,
	    swiped: false, // used by swipeEvent. differentites between touch and swipe.
	    trackStyle: {},
	    trackWidth: 0
	
	    // Removed
	    // transformsEnabled: false,
	    // $nextArrow: null,
	    // $prevArrow: null,
	    // $dots: null,
	    // $list: null,
	    // $slideTrack: null,
	    // $slides: null,
	};
	
	module.exports = initialState;

/***/ }),
/* 799 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	exports.__esModule = true;
	exports.InnerSlider = 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 _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _eventHandlers = __webpack_require__(800);
	
	var _eventHandlers2 = _interopRequireDefault(_eventHandlers);
	
	var _helpers = __webpack_require__(154);
	
	var _helpers2 = _interopRequireDefault(_helpers);
	
	var _initialState = __webpack_require__(798);
	
	var _initialState2 = _interopRequireDefault(_initialState);
	
	var _defaultProps = __webpack_require__(285);
	
	var _defaultProps2 = _interopRequireDefault(_defaultProps);
	
	var _createReactClass = __webpack_require__(14);
	
	var _createReactClass2 = _interopRequireDefault(_createReactClass);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	var _objectAssign = __webpack_require__(18);
	
	var _objectAssign2 = _interopRequireDefault(_objectAssign);
	
	var _track = __webpack_require__(802);
	
	var _dots = __webpack_require__(796);
	
	var _arrows = __webpack_require__(795);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
	
	var InnerSlider = exports.InnerSlider = (0, _createReactClass2.default)({
	  displayName: 'InnerSlider',
	
	  mixins: [_helpers2.default, _eventHandlers2.default],
	  list: null,
	  track: null,
	  listRefHandler: function listRefHandler(ref) {
	    this.list = ref;
	  },
	  trackRefHandler: function trackRefHandler(ref) {
	    this.track = ref;
	  },
	  getInitialState: function getInitialState() {
	    return _extends({}, _initialState2.default, {
	      currentSlide: this.props.initialSlide
	    });
	  },
	  getDefaultProps: function getDefaultProps() {
	    return _defaultProps2.default;
	  },
	  componentWillMount: function componentWillMount() {
	    if (this.props.init) {
	      this.props.init();
	    }
	    this.setState({
	      mounted: true
	    });
	    var lazyLoadedList = [];
	    for (var i = 0; i < _react2.default.Children.count(this.props.children); i++) {
	      if (i >= this.state.currentSlide && i < this.state.currentSlide + this.props.slidesToShow) {
	        lazyLoadedList.push(i);
	      }
	    }
	
	    if (this.props.lazyLoad && this.state.lazyLoadedList.length === 0) {
	      this.setState({
	        lazyLoadedList: lazyLoadedList
	      });
	    }
	  },
	  componentDidMount: function componentDidMount() {
	    // Hack for autoplay -- Inspect Later
	    this.initialize(this.props);
	    this.adaptHeight();
	
	    // To support server-side rendering
	    if (!window) {
	      return;
	    }
	    if (window.addEventListener) {
	      window.addEventListener('resize', this.onWindowResized);
	    } else {
	      window.attachEvent('onresize', this.onWindowResized);
	    }
	  },
	  componentWillUnmount: function componentWillUnmount() {
	    if (this.animationEndCallback) {
	      clearTimeout(this.animationEndCallback);
	    }
	    if (window.addEventListener) {
	      window.removeEventListener('resize', this.onWindowResized);
	    } else {
	      window.detachEvent('onresize', this.onWindowResized);
	    }
	    if (this.state.autoPlayTimer) {
	      clearInterval(this.state.autoPlayTimer);
	    }
	  },
	  componentWillReceiveProps: function componentWillReceiveProps(nextProps) {
	    if (this.props.slickGoTo != nextProps.slickGoTo) {
	      if (true) {
	        console.warn('react-slick deprecation warning: slickGoTo prop is deprecated and it will be removed in next release. Use slickGoTo method instead');
	      }
	      this.changeSlide({
	        message: 'index',
	        index: nextProps.slickGoTo,
	        currentSlide: this.state.currentSlide
	      });
	    } else if (this.state.currentSlide >= nextProps.children.length) {
	      this.update(nextProps);
	      this.changeSlide({
	        message: 'index',
	        index: nextProps.children.length - nextProps.slidesToShow,
	        currentSlide: this.state.currentSlide
	      });
	    } else {
	      this.update(nextProps);
	    }
	  },
	  componentDidUpdate: function componentDidUpdate() {
	    this.adaptHeight();
	  },
	  onWindowResized: function onWindowResized() {
	    this.update(this.props);
	    // animating state should be cleared while resizing, otherwise autoplay stops working
	    this.setState({
	      animating: false
	    });
	    clearTimeout(this.animationEndCallback);
	    delete this.animationEndCallback;
	  },
	  slickPrev: function slickPrev() {
	    this.changeSlide({ message: 'previous' });
	  },
	  slickNext: function slickNext() {
	    this.changeSlide({ message: 'next' });
	  },
	  slickGoTo: function slickGoTo(slide) {
	    slide = Number(slide);
	    !isNaN(slide) && this.changeSlide({
	      message: 'index',
	      index: slide,
	      currentSlide: this.state.currentSlide
	    });
	  },
	  render: function render() {
	    var className = (0, _classnames2.default)('slick-initialized', 'slick-slider', this.props.className, {
	      'slick-vertical': this.props.vertical
	    });
	
	    var trackProps = {
	      fade: this.props.fade,
	      cssEase: this.props.cssEase,
	      speed: this.props.speed,
	      infinite: this.props.infinite,
	      centerMode: this.props.centerMode,
	      focusOnSelect: this.props.focusOnSelect ? this.selectHandler : null,
	      currentSlide: this.state.currentSlide,
	      lazyLoad: this.props.lazyLoad,
	      lazyLoadedList: this.state.lazyLoadedList,
	      rtl: this.props.rtl,
	      slideWidth: this.state.slideWidth,
	      slidesToShow: this.props.slidesToShow,
	      slidesToScroll: this.props.slidesToScroll,
	      slideCount: this.state.slideCount,
	      trackStyle: this.state.trackStyle,
	      variableWidth: this.props.variableWidth
	    };
	
	    var dots;
	
	    if (this.props.dots === true && this.state.slideCount >= this.props.slidesToShow) {
	      var dotProps = {
	        dotsClass: this.props.dotsClass,
	        slideCount: this.state.slideCount,
	        slidesToShow: this.props.slidesToShow,
	        currentSlide: this.state.currentSlide,
	        slidesToScroll: this.props.slidesToScroll,
	        clickHandler: this.changeSlide,
	        children: this.props.children,
	        customPaging: this.props.customPaging
	      };
	
	      dots = _react2.default.createElement(_dots.Dots, dotProps);
	    }
	
	    var prevArrow, nextArrow;
	
	    var arrowProps = {
	      infinite: this.props.infinite,
	      centerMode: this.props.centerMode,
	      currentSlide: this.state.currentSlide,
	      slideCount: this.state.slideCount,
	      slidesToShow: this.props.slidesToShow,
	      prevArrow: this.props.prevArrow,
	      nextArrow: this.props.nextArrow,
	      clickHandler: this.changeSlide
	    };
	
	    if (this.props.arrows) {
	      prevArrow = _react2.default.createElement(_arrows.PrevArrow, arrowProps);
	      nextArrow = _react2.default.createElement(_arrows.NextArrow, arrowProps);
	    }
	
	    var verticalHeightStyle = null;
	
	    if (this.props.vertical) {
	      verticalHeightStyle = {
	        height: this.state.listHeight
	      };
	    }
	
	    var centerPaddingStyle = null;
	
	    if (this.props.vertical === false) {
	      if (this.props.centerMode === true) {
	        centerPaddingStyle = {
	          padding: '0px ' + this.props.centerPadding
	        };
	      }
	    } else {
	      if (this.props.centerMode === true) {
	        centerPaddingStyle = {
	          padding: this.props.centerPadding + ' 0px'
	        };
	      }
	    }
	
	    var listStyle = (0, _objectAssign2.default)({}, verticalHeightStyle, centerPaddingStyle);
	
	    return _react2.default.createElement(
	      'div',
	      {
	        className: className,
	        onMouseEnter: this.onInnerSliderEnter,
	        onMouseLeave: this.onInnerSliderLeave,
	        onMouseOver: this.onInnerSliderOver
	      },
	      prevArrow,
	      _react2.default.createElement(
	        'div',
	        {
	          ref: this.listRefHandler,
	          className: 'slick-list',
	          style: listStyle,
	          onMouseDown: this.swipeStart,
	          onMouseMove: this.state.dragging ? this.swipeMove : null,
	          onMouseUp: this.swipeEnd,
	          onMouseLeave: this.state.dragging ? this.swipeEnd : null,
	          onTouchStart: this.swipeStart,
	          onTouchMove: this.state.dragging ? this.swipeMove : null,
	          onTouchEnd: this.swipeEnd,
	          onTouchCancel: this.state.dragging ? this.swipeEnd : null,
	          onKeyDown: this.props.accessibility ? this.keyHandler : null },
	        _react2.default.createElement(
	          _track.Track,
	          _extends({ ref: this.trackRefHandler }, trackProps),
	          this.props.children
	        )
	      ),
	      nextArrow,
	      dots
	    );
	  }
	});

/***/ }),
/* 800 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	exports.__esModule = true;
	
	var _trackHelper = __webpack_require__(286);
	
	var _helpers = __webpack_require__(154);
	
	var _helpers2 = _interopRequireDefault(_helpers);
	
	var _objectAssign = __webpack_require__(18);
	
	var _objectAssign2 = _interopRequireDefault(_objectAssign);
	
	var _reactDom = __webpack_require__(10);
	
	var _reactDom2 = _interopRequireDefault(_reactDom);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
	
	var EventHandlers = {
	  // Event handler for previous and next
	  changeSlide: function changeSlide(options) {
	    var indexOffset, previousInt, slideOffset, unevenOffset, targetSlide;
	    var _props = this.props,
	        slidesToScroll = _props.slidesToScroll,
	        slidesToShow = _props.slidesToShow;
	    var _state = this.state,
	        slideCount = _state.slideCount,
	        currentSlide = _state.currentSlide;
	
	    unevenOffset = slideCount % slidesToScroll !== 0;
	    indexOffset = unevenOffset ? 0 : (slideCount - currentSlide) % slidesToScroll;
	
	    if (options.message === 'previous') {
	      slideOffset = indexOffset === 0 ? slidesToScroll : slidesToShow - indexOffset;
	      targetSlide = currentSlide - slideOffset;
	      if (this.props.lazyLoad) {
	        previousInt = currentSlide - slideOffset;
	        targetSlide = previousInt === -1 ? slideCount - 1 : previousInt;
	      }
	    } else if (options.message === 'next') {
	      slideOffset = indexOffset === 0 ? slidesToScroll : indexOffset;
	      targetSlide = currentSlide + slideOffset;
	      if (this.props.lazyLoad) {
	        targetSlide = (currentSlide + slidesToScroll) % slideCount + indexOffset;
	      }
	    } else if (options.message === 'dots' || options.message === 'children') {
	      // Click on dots
	      targetSlide = options.index * options.slidesToScroll;
	      if (targetSlide === options.currentSlide) {
	        return;
	      }
	    } else if (options.message === 'index') {
	      targetSlide = Number(options.index);
	      if (targetSlide === options.currentSlide) {
	        return;
	      }
	    }
	
	    this.slideHandler(targetSlide);
	  },
	
	  // Accessiblity handler for previous and next
	  keyHandler: function keyHandler(e) {
	    //Dont slide if the cursor is inside the form fields and arrow keys are pressed
	    if (!e.target.tagName.match('TEXTAREA|INPUT|SELECT')) {
	      if (e.keyCode === 37 && this.props.accessibility === true) {
	        this.changeSlide({
	          message: this.props.rtl === true ? 'next' : 'previous'
	        });
	      } else if (e.keyCode === 39 && this.props.accessibility === true) {
	        this.changeSlide({
	          message: this.props.rtl === true ? 'previous' : 'next'
	        });
	      }
	    }
	  },
	  // Focus on selecting a slide (click handler on track)
	  selectHandler: function selectHandler(options) {
	    this.changeSlide(options);
	  },
	  swipeStart: function swipeStart(e) {
	    var touches, posX, posY;
	
	    if (this.props.swipe === false || 'ontouchend' in document && this.props.swipe === false) {
	      return;
	    } else if (this.props.draggable === false && e.type.indexOf('mouse') !== -1) {
	      return;
	    }
	    posX = e.touches !== undefined ? e.touches[0].pageX : e.clientX;
	    posY = e.touches !== undefined ? e.touches[0].pageY : e.clientY;
	    this.setState({
	      dragging: true,
	      touchObject: {
	        startX: posX,
	        startY: posY,
	        curX: posX,
	        curY: posY
	      }
	    });
	  },
	  swipeMove: function swipeMove(e) {
	    if (!this.state.dragging) {
	      e.preventDefault();
	      return;
	    }
	    if (this.state.scrolling) {
	      return;
	    }
	    if (this.state.animating) {
	      e.preventDefault();
	      return;
	    }
	    if (this.props.vertical && this.props.swipeToSlide && this.props.verticalSwiping) {
	      e.preventDefault();
	    }
	    var swipeLeft;
	    var curLeft, positionOffset;
	    var touchObject = this.state.touchObject;
	
	    curLeft = (0, _trackHelper.getTrackLeft)((0, _objectAssign2.default)({
	      slideIndex: this.state.currentSlide,
	      trackRef: this.track
	    }, this.props, this.state));
	    touchObject.curX = e.touches ? e.touches[0].pageX : e.clientX;
	    touchObject.curY = e.touches ? e.touches[0].pageY : e.clientY;
	    touchObject.swipeLength = Math.round(Math.sqrt(Math.pow(touchObject.curX - touchObject.startX, 2)));
	    var verticalSwipeLength = Math.round(Math.sqrt(Math.pow(touchObject.curY - touchObject.startY, 2)));
	
	    if (!this.props.verticalSwiping && !this.state.swiping && verticalSwipeLength > 4) {
	      this.setState({
	        scrolling: true
	      });
	      return;
	    }
	
	    if (this.props.verticalSwiping) {
	      touchObject.swipeLength = verticalSwipeLength;
	    }
	
	    positionOffset = (this.props.rtl === false ? 1 : -1) * (touchObject.curX > touchObject.startX ? 1 : -1);
	
	    if (this.props.verticalSwiping) {
	      positionOffset = touchObject.curY > touchObject.startY ? 1 : -1;
	    }
	
	    var currentSlide = this.state.currentSlide;
	    var dotCount = Math.ceil(this.state.slideCount / this.props.slidesToScroll);
	    var swipeDirection = this.swipeDirection(this.state.touchObject);
	    var touchSwipeLength = touchObject.swipeLength;
	
	    if (this.props.infinite === false) {
	      if (currentSlide === 0 && swipeDirection === 'right' || currentSlide + 1 >= dotCount && swipeDirection === 'left') {
	        touchSwipeLength = touchObject.swipeLength * this.props.edgeFriction;
	
	        if (this.state.edgeDragged === false && this.props.edgeEvent) {
	          this.props.edgeEvent(swipeDirection);
	          this.setState({ edgeDragged: true });
	        }
	      }
	    }
	
	    if (this.state.swiped === false && this.props.swipeEvent) {
	      this.props.swipeEvent(swipeDirection);
	      this.setState({ swiped: true });
	    }
	
	    if (!this.props.vertical) {
	      swipeLeft = curLeft + touchSwipeLength * positionOffset;
	    } else {
	      swipeLeft = curLeft + touchSwipeLength * (this.state.listHeight / this.state.listWidth) * positionOffset;
	    }
	
	    if (this.props.verticalSwiping) {
	      swipeLeft = curLeft + touchSwipeLength * positionOffset;
	    }
	
	    this.setState({
	      touchObject: touchObject,
	      swipeLeft: swipeLeft,
	      trackStyle: (0, _trackHelper.getTrackCSS)((0, _objectAssign2.default)({ left: swipeLeft }, this.props, this.state))
	    });
	
	    if (Math.abs(touchObject.curX - touchObject.startX) < Math.abs(touchObject.curY - touchObject.startY) * 0.8) {
	      return;
	    }
	    if (touchObject.swipeLength > 4) {
	      this.setState({
	        swiping: true
	      });
	      e.preventDefault();
	    }
	  },
	  getNavigableIndexes: function getNavigableIndexes() {
	    var max = void 0;
	    var breakPoint = 0;
	    var counter = 0;
	    var indexes = [];
	
	    if (!this.props.infinite) {
	      max = this.state.slideCount;
	    } else {
	      breakPoint = this.props.slidesToShow * -1;
	      counter = this.props.slidesToShow * -1;
	      max = this.state.slideCount * 2;
	    }
	
	    while (breakPoint < max) {
	      indexes.push(breakPoint);
	      breakPoint = counter + this.props.slidesToScroll;
	
	      counter += this.props.slidesToScroll <= this.props.slidesToShow ? this.props.slidesToScroll : this.props.slidesToShow;
	    }
	
	    return indexes;
	  },
	  checkNavigable: function checkNavigable(index) {
	    var navigables = this.getNavigableIndexes();
	    var prevNavigable = 0;
	
	    if (index > navigables[navigables.length - 1]) {
	      index = navigables[navigables.length - 1];
	    } else {
	      for (var n in navigables) {
	        if (index < navigables[n]) {
	          index = prevNavigable;
	          break;
	        }
	
	        prevNavigable = navigables[n];
	      }
	    }
	
	    return index;
	  },
	  getSlideCount: function getSlideCount() {
	    var _this = this;
	
	    var centerOffset = this.props.centerMode ? this.state.slideWidth * Math.floor(this.props.slidesToShow / 2) : 0;
	
	    if (this.props.swipeToSlide) {
	      var swipedSlide = void 0;
	
	      var slickList = _reactDom2.default.findDOMNode(this.list);
	
	      var slides = slickList.querySelectorAll('.slick-slide');
	
	      Array.from(slides).every(function (slide) {
	        if (!_this.props.vertical) {
	          if (slide.offsetLeft - centerOffset + _this.getWidth(slide) / 2 > _this.state.swipeLeft * -1) {
	            swipedSlide = slide;
	            return false;
	          }
	        } else {
	          if (slide.offsetTop + _this.getHeight(slide) / 2 > _this.state.swipeLeft * -1) {
	            swipedSlide = slide;
	            return false;
	          }
	        }
	
	        return true;
	      });
	
	      var slidesTraversed = Math.abs(swipedSlide.dataset.index - this.state.currentSlide) || 1;
	
	      return slidesTraversed;
	    } else {
	      return this.props.slidesToScroll;
	    }
	  },
	
	  swipeEnd: function swipeEnd(e) {
	    if (!this.state.dragging) {
	      if (this.props.swipe) {
	        e.preventDefault();
	      }
	      return;
	    }
	    var touchObject = this.state.touchObject;
	    var minSwipe = this.state.listWidth / this.props.touchThreshold;
	    var swipeDirection = this.swipeDirection(touchObject);
	
	    if (this.props.verticalSwiping) {
	      minSwipe = this.state.listHeight / this.props.touchThreshold;
	    }
	
	    var wasScrolling = this.state.scrolling;
	    // reset the state of touch related state variables.
	    this.setState({
	      dragging: false,
	      edgeDragged: false,
	      scrolling: false,
	      swiping: false,
	      swiped: false,
	      swipeLeft: null,
	      touchObject: {}
	    });
	    if (wasScrolling) {
	      return;
	    }
	
	    // Fix for #13
	    if (!touchObject.swipeLength) {
	      return;
	    }
	    if (touchObject.swipeLength > minSwipe) {
	      e.preventDefault();
	
	      var slideCount = void 0,
	          newSlide = void 0;
	
	      switch (swipeDirection) {
	
	        case 'left':
	        case 'down':
	          newSlide = this.state.currentSlide + this.getSlideCount();
	          slideCount = this.props.swipeToSlide ? this.checkNavigable(newSlide) : newSlide;
	          this.state.currentDirection = 0;
	          break;
	
	        case 'right':
	        case 'up':
	          newSlide = this.state.currentSlide - this.getSlideCount();
	          slideCount = this.props.swipeToSlide ? this.checkNavigable(newSlide) : newSlide;
	          this.state.currentDirection = 1;
	          break;
	
	        default:
	          slideCount = this.state.currentSlide;
	
	      }
	
	      this.slideHandler(slideCount);
	    } else {
	      // Adjust the track back to it's original position.
	      var currentLeft = (0, _trackHelper.getTrackLeft)((0, _objectAssign2.default)({
	        slideIndex: this.state.currentSlide,
	        trackRef: this.track
	      }, this.props, this.state));
	
	      this.setState({
	        trackStyle: (0, _trackHelper.getTrackAnimateCSS)((0, _objectAssign2.default)({ left: currentLeft }, this.props, this.state))
	      });
	    }
	  },
	  onInnerSliderEnter: function onInnerSliderEnter(e) {
	    if (this.props.autoplay && this.props.pauseOnHover) {
	      this.pause();
	    }
	  },
	  onInnerSliderOver: function onInnerSliderOver(e) {
	    if (this.props.autoplay && this.props.pauseOnHover) {
	      this.pause();
	    }
	  },
	  onInnerSliderLeave: function onInnerSliderLeave(e) {
	    if (this.props.autoplay && this.props.pauseOnHover) {
	      this.autoPlay();
	    }
	  }
	};
	
	exports.default = EventHandlers;

/***/ }),
/* 801 */
/***/ (function(module, exports, __webpack_require__) {

	'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; };
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _innerSlider = __webpack_require__(799);
	
	var _objectAssign = __webpack_require__(18);
	
	var _objectAssign2 = _interopRequireDefault(_objectAssign);
	
	var _json2mq = __webpack_require__(575);
	
	var _json2mq2 = _interopRequireDefault(_json2mq);
	
	var _defaultProps = __webpack_require__(285);
	
	var _defaultProps2 = _interopRequireDefault(_defaultProps);
	
	var _canUseDom = __webpack_require__(421);
	
	var _canUseDom2 = _interopRequireDefault(_canUseDom);
	
	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; }
	
	var enquire = _canUseDom2.default && __webpack_require__(548);
	
	var Slider = function (_React$Component) {
	  _inherits(Slider, _React$Component);
	
	  function Slider(props) {
	    _classCallCheck(this, Slider);
	
	    var _this = _possibleConstructorReturn(this, _React$Component.call(this, props));
	
	    _this.state = {
	      breakpoint: null
	    };
	    _this._responsiveMediaHandlers = [];
	    _this.innerSliderRefHandler = _this.innerSliderRefHandler.bind(_this);
	    return _this;
	  }
	
	  Slider.prototype.innerSliderRefHandler = function innerSliderRefHandler(ref) {
	    this.innerSlider = ref;
	  };
	
	  Slider.prototype.media = function media(query, handler) {
	    enquire.register(query, handler);
	    this._responsiveMediaHandlers.push({ query: query, handler: handler });
	  };
	
	  Slider.prototype.componentWillMount = function componentWillMount() {
	    var _this2 = this;
	
	    if (this.props.responsive) {
	      var breakpoints = this.props.responsive.map(function (breakpt) {
	        return breakpt.breakpoint;
	      });
	      breakpoints.sort(function (x, y) {
	        return x - y;
	      });
	
	      breakpoints.forEach(function (breakpoint, index) {
	        var bQuery;
	        if (index === 0) {
	          bQuery = (0, _json2mq2.default)({ minWidth: 0, maxWidth: breakpoint });
	        } else {
	          bQuery = (0, _json2mq2.default)({ minWidth: breakpoints[index - 1], maxWidth: breakpoint });
	        }
	        _canUseDom2.default && _this2.media(bQuery, function () {
	          _this2.setState({ breakpoint: breakpoint });
	        });
	      });
	
	      // Register media query for full screen. Need to support resize from small to large
	      var query = (0, _json2mq2.default)({ minWidth: breakpoints.slice(-1)[0] });
	
	      _canUseDom2.default && this.media(query, function () {
	        _this2.setState({ breakpoint: null });
	      });
	    }
	  };
	
	  Slider.prototype.componentWillUnmount = function componentWillUnmount() {
	    this._responsiveMediaHandlers.forEach(function (obj) {
	      enquire.unregister(obj.query, obj.handler);
	    });
	  };
	
	  Slider.prototype.slickPrev = function slickPrev() {
	    this.innerSlider.slickPrev();
	  };
	
	  Slider.prototype.slickNext = function slickNext() {
	    this.innerSlider.slickNext();
	  };
	
	  Slider.prototype.slickGoTo = function slickGoTo(slide) {
	    this.innerSlider.slickGoTo(slide);
	  };
	
	  Slider.prototype.render = function render() {
	    var _this3 = this;
	
	    var settings;
	    var newProps;
	    if (this.state.breakpoint) {
	      newProps = this.props.responsive.filter(function (resp) {
	        return resp.breakpoint === _this3.state.breakpoint;
	      });
	      settings = newProps[0].settings === 'unslick' ? 'unslick' : (0, _objectAssign2.default)({}, this.props, newProps[0].settings);
	    } else {
	      settings = (0, _objectAssign2.default)({}, _defaultProps2.default, this.props);
	    }
	
	    var children = this.props.children;
	    if (!Array.isArray(children)) {
	      children = [children];
	    }
	
	    // Children may contain false or null, so we should filter them
	    children = children.filter(function (child) {
	      return !!child;
	    });
	
	    if (settings === 'unslick') {
	      // if 'unslick' responsive breakpoint setting used, just return the <Slider> tag nested HTML
	      return _react2.default.createElement(
	        'div',
	        { className: this.props.className + ' unslicked' },
	        children
	      );
	    } else {
	      return _react2.default.createElement(
	        _innerSlider.InnerSlider,
	        _extends({ ref: this.innerSliderRefHandler }, settings),
	        children
	      );
	    }
	  };
	
	  return Slider;
	}(_react2.default.Component);
	
	exports.default = Slider;

/***/ }),
/* 802 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	exports.__esModule = true;
	exports.Track = undefined;
	
	var _react = __webpack_require__(1);
	
	var _react2 = _interopRequireDefault(_react);
	
	var _objectAssign = __webpack_require__(18);
	
	var _objectAssign2 = _interopRequireDefault(_objectAssign);
	
	var _classnames = __webpack_require__(8);
	
	var _classnames2 = _interopRequireDefault(_classnames);
	
	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; }
	
	var getSlideClasses = function getSlideClasses(spec) {
	  var slickActive, slickCenter, slickCloned;
	  var centerOffset, index;
	
	  if (spec.rtl) {
	    index = spec.slideCount - 1 - spec.index;
	  } else {
	    index = spec.index;
	  }
	  slickCloned = index < 0 || index >= spec.slideCount;
	  if (spec.centerMode) {
	    centerOffset = Math.floor(spec.slidesToShow / 2);
	    slickCenter = (index - spec.currentSlide) % spec.slideCount === 0;
	    if (index > spec.currentSlide - centerOffset - 1 && index <= spec.currentSlide + centerOffset) {
	      slickActive = true;
	    }
	  } else {
	    slickActive = spec.currentSlide <= index && index < spec.currentSlide + spec.slidesToShow;
	  }
	  return (0, _classnames2.default)({
	    'slick-slide': true,
	    'slick-active': slickActive,
	    'slick-center': slickCenter,
	    'slick-cloned': slickCloned
	  });
	};
	
	var getSlideStyle = function getSlideStyle(spec) {
	  var style = {};
	
	  if (spec.variableWidth === undefined || spec.variableWidth === false) {
	    style.width = spec.slideWidth;
	  }
	
	  if (spec.fade) {
	    style.position = 'relative';
	    style.left = -spec.index * spec.slideWidth;
	    style.opacity = spec.currentSlide === spec.index ? 1 : 0;
	    style.transition = 'opacity ' + spec.speed + 'ms ' + spec.cssEase;
	    style.WebkitTransition = 'opacity ' + spec.speed + 'ms ' + spec.cssEase;
	  }
	
	  return style;
	};
	
	var getKey = function getKey(child, fallbackKey) {
	  // key could be a zero
	  return child.key === null || child.key === undefined ? fallbackKey : child.key;
	};
	
	var renderSlides = function renderSlides(spec) {
	  var key;
	  var slides = [];
	  var preCloneSlides = [];
	  var postCloneSlides = [];
	  var count = _react2.default.Children.count(spec.children);
	
	  _react2.default.Children.forEach(spec.children, function (elem, index) {
	    var child = void 0;
	    var childOnClickOptions = {
	      message: 'children',
	      index: index,
	      slidesToScroll: spec.slidesToScroll,
	      currentSlide: spec.currentSlide
	    };
	
	    if (!spec.lazyLoad | (spec.lazyLoad && spec.lazyLoadedList.indexOf(index) >= 0)) {
	      child = elem;
	    } else {
	      child = _react2.default.createElement('div', null);
	    }
	    var childStyle = getSlideStyle((0, _objectAssign2.default)({}, spec, { index: index }));
	    var slideClass = child.props.className || '';
	
	    var onClick = function onClick(e) {
	      child.props && child.props.onClick && child.props.onClick(e);
	      if (spec.focusOnSelect) {
	        spec.focusOnSelect(childOnClickOptions);
	      }
	    };
	
	    slides.push(_react2.default.cloneElement(child, {
	      key: 'original' + getKey(child, index),
	      'data-index': index,
	      className: (0, _classnames2.default)(getSlideClasses((0, _objectAssign2.default)({ index: index }, spec)), slideClass),
	      tabIndex: '-1',
	      style: (0, _objectAssign2.default)({ outline: 'none' }, child.props.style || {}, childStyle),
	      onClick: onClick
	    }));
	
	    // variableWidth doesn't wrap properly.
	    if (spec.infinite && spec.fade === false) {
	      var infiniteCount = spec.variableWidth ? spec.slidesToShow + 1 : spec.slidesToShow;
	
	      if (index >= count - infiniteCount) {
	        key = -(count - index);
	        preCloneSlides.push(_react2.default.cloneElement(child, {
	          key: 'precloned' + getKey(child, key),
	          'data-index': key,
	          className: (0, _classnames2.default)(getSlideClasses((0, _objectAssign2.default)({ index: key }, spec)), slideClass),
	          style: (0, _objectAssign2.default)({}, child.props.style || {}, childStyle),
	          onClick: onClick
	        }));
	      }
	
	      if (index < infiniteCount) {
	        key = count + index;
	        postCloneSlides.push(_react2.default.cloneElement(child, {
	          key: 'postcloned' + getKey(child, key),
	          'data-index': key,
	          className: (0, _classnames2.default)(getSlideClasses((0, _objectAssign2.default)({ index: key }, spec)), slideClass),
	          style: (0, _objectAssign2.default)({}, child.props.style || {}, childStyle),
	          onClick: onClick
	        }));
	      }
	    }
	  });
	
	  if (spec.rtl) {
	    return preCloneSlides.concat(slides, postCloneSlides).reverse();
	  } else {
	    return preCloneSlides.concat(slides, postCloneSlides);
	  }
	};
	
	var Track = exports.Track = function (_React$Component) {
	  _inherits(Track, _React$Component);
	
	  function Track() {
	    _classCallCheck(this, Track);
	
	    return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	  }
	
	  Track.prototype.render = function render() {
	    var slides = renderSlides.call(this, this.props);
	    return _react2.default.createElement(
	      'div',
	      { className: 'slick-track', style: this.props.trackStyle },
	      slides
	    );
	  };
	
	  return Track;
	}(_react2.default.Component);

/***/ }),
/* 803 */
/***/ (function(module, exports) {

	module.exports = function shallowEqualArrays(arrA, arrB) {
	  if (arrA === arrB) {
	    return true;
	  }
	
	  var len = arrA.length;
	
	  if (arrB.length !== len) {
	    return false;
	  }
	
	  for (var i = 0; i < len; i++) {
	    if (arrA[i] !== arrB[i]) {
	      return false;
	    }
	  }
	
	  return true;
	};


/***/ }),
/* 804 */
/***/ (function(module, exports) {

	var camel2hyphen = function (str) {
	  return str
	          .replace(/[A-Z]/g, function (match) {
	            return '-' + match.toLowerCase();
	          })
	          .toLowerCase();
	};
	
	module.exports = camel2hyphen;

/***/ }),
/* 805 */
/***/ (function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_RESULT__;/**
	 * UAParser.js v0.7.17
	 * Lightweight JavaScript-based User-Agent string parser
	 * https://github.com/faisalman/ua-parser-js
	 *
	 * Copyright © 2012-2016 Faisal Salman <fyzlman@gmail.com>
	 * Dual licensed under GPLv2 & MIT
	 */
	
	(function (window, undefined) {
	
	    'use strict';
	
	    //////////////
	    // Constants
	    /////////////
	
	
	    var LIBVERSION  = '0.7.17',
	        EMPTY       = '',
	        UNKNOWN     = '?',
	        FUNC_TYPE   = 'function',
	        UNDEF_TYPE  = 'undefined',
	        OBJ_TYPE    = 'object',
	        STR_TYPE    = 'string',
	        MAJOR       = 'major', // deprecated
	        MODEL       = 'model',
	        NAME        = 'name',
	        TYPE        = 'type',
	        VENDOR      = 'vendor',
	        VERSION     = 'version',
	        ARCHITECTURE= 'architecture',
	        CONSOLE     = 'console',
	        MOBILE      = 'mobile',
	        TABLET      = 'tablet',
	        SMARTTV     = 'smarttv',
	        WEARABLE    = 'wearable',
	        EMBEDDED    = 'embedded';
	
	
	    ///////////
	    // Helper
	    //////////
	
	
	    var util = {
	        extend : function (regexes, extensions) {
	            var margedRegexes = {};
	            for (var i in regexes) {
	                if (extensions[i] && extensions[i].length % 2 === 0) {
	                    margedRegexes[i] = extensions[i].concat(regexes[i]);
	                } else {
	                    margedRegexes[i] = regexes[i];
	                }
	            }
	            return margedRegexes;
	        },
	        has : function (str1, str2) {
	          if (typeof str1 === "string") {
	            return str2.toLowerCase().indexOf(str1.toLowerCase()) !== -1;
	          } else {
	            return false;
	          }
	        },
	        lowerize : function (str) {
	            return str.toLowerCase();
	        },
	        major : function (version) {
	            return typeof(version) === STR_TYPE ? version.replace(/[^\d\.]/g,'').split(".")[0] : undefined;
	        },
	        trim : function (str) {
	          return str.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, '');
	        }
	    };
	
	
	    ///////////////
	    // Map helper
	    //////////////
	
	
	    var mapper = {
	
	        rgx : function (ua, arrays) {
	
	            //var result = {},
	            var i = 0, j, k, p, q, matches, match;//, args = arguments;
	
	            /*// construct object barebones
	            for (p = 0; p < args[1].length; p++) {
	                q = args[1][p];
	                result[typeof q === OBJ_TYPE ? q[0] : q] = undefined;
	            }*/
	
	            // loop through all regexes maps
	            while (i < arrays.length && !matches) {
	
	                var regex = arrays[i],       // even sequence (0,2,4,..)
	                    props = arrays[i + 1];   // odd sequence (1,3,5,..)
	                j = k = 0;
	
	                // try matching uastring with regexes
	                while (j < regex.length && !matches) {
	
	                    matches = regex[j++].exec(ua);
	
	                    if (!!matches) {
	                        for (p = 0; p < props.length; p++) {
	                            match = matches[++k];
	                            q = props[p];
	                            // check if given property is actually array
	                            if (typeof q === OBJ_TYPE && q.length > 0) {
	                                if (q.length == 2) {
	                                    if (typeof q[1] == FUNC_TYPE) {
	                                        // assign modified match
	                                        this[q[0]] = q[1].call(this, match);
	                                    } else {
	                                        // assign given value, ignore regex match
	                                        this[q[0]] = q[1];
	                                    }
	                                } else if (q.length == 3) {
	                                    // check whether function or regex
	                                    if (typeof q[1] === FUNC_TYPE && !(q[1].exec && q[1].test)) {
	                                        // call function (usually string mapper)
	                                        this[q[0]] = match ? q[1].call(this, match, q[2]) : undefined;
	                                    } else {
	                                        // sanitize match using given regex
	                                        this[q[0]] = match ? match.replace(q[1], q[2]) : undefined;
	                                    }
	                                } else if (q.length == 4) {
	                                        this[q[0]] = match ? q[3].call(this, match.replace(q[1], q[2])) : undefined;
	                                }
	                            } else {
	                                this[q] = match ? match : undefined;
	                            }
	                        }
	                    }
	                }
	                i += 2;
	            }
	            // console.log(this);
	            //return this;
	        },
	
	        str : function (str, map) {
	
	            for (var i in map) {
	                // check if array
	                if (typeof map[i] === OBJ_TYPE && map[i].length > 0) {
	                    for (var j = 0; j < map[i].length; j++) {
	                        if (util.has(map[i][j], str)) {
	                            return (i === UNKNOWN) ? undefined : i;
	                        }
	                    }
	                } else if (util.has(map[i], str)) {
	                    return (i === UNKNOWN) ? undefined : i;
	                }
	            }
	            return str;
	        }
	    };
	
	
	    ///////////////
	    // String map
	    //////////////
	
	
	    var maps = {
	
	        browser : {
	            oldsafari : {
	                version : {
	                    '1.0'   : '/8',
	                    '1.2'   : '/1',
	                    '1.3'   : '/3',
	                    '2.0'   : '/412',
	                    '2.0.2' : '/416',
	                    '2.0.3' : '/417',
	                    '2.0.4' : '/419',
	                    '?'     : '/'
	                }
	            }
	        },
	
	        device : {
	            amazon : {
	                model : {
	                    'Fire Phone' : ['SD', 'KF']
	                }
	            },
	            sprint : {
	                model : {
	                    'Evo Shift 4G' : '7373KT'
	                },
	                vendor : {
	                    'HTC'       : 'APA',
	                    'Sprint'    : 'Sprint'
	                }
	            }
	        },
	
	        os : {
	            windows : {
	                version : {
	                    'ME'        : '4.90',
	                    'NT 3.11'   : 'NT3.51',
	                    'NT 4.0'    : 'NT4.0',
	                    '2000'      : 'NT 5.0',
	                    'XP'        : ['NT 5.1', 'NT 5.2'],
	                    'Vista'     : 'NT 6.0',
	                    '7'         : 'NT 6.1',
	                    '8'         : 'NT 6.2',
	                    '8.1'       : 'NT 6.3',
	                    '10'        : ['NT 6.4', 'NT 10.0'],
	                    'RT'        : 'ARM'
	                }
	            }
	        }
	    };
	
	
	    //////////////
	    // Regex map
	    /////////////
	
	
	    var regexes = {
	
	        browser : [[
	
	            // Presto based
	            /(opera\smini)\/([\w\.-]+)/i,                                       // Opera Mini
	            /(opera\s[mobiletab]+).+version\/([\w\.-]+)/i,                      // Opera Mobi/Tablet
	            /(opera).+version\/([\w\.]+)/i,                                     // Opera > 9.80
	            /(opera)[\/\s]+([\w\.]+)/i                                          // Opera < 9.80
	            ], [NAME, VERSION], [
	
	            /(opios)[\/\s]+([\w\.]+)/i                                          // Opera mini on iphone >= 8.0
	            ], [[NAME, 'Opera Mini'], VERSION], [
	
	            /\s(opr)\/([\w\.]+)/i                                               // Opera Webkit
	            ], [[NAME, 'Opera'], VERSION], [
	
	            // Mixed
	            /(kindle)\/([\w\.]+)/i,                                             // Kindle
	            /(lunascape|maxthon|netfront|jasmine|blazer)[\/\s]?([\w\.]+)*/i,
	                                                                                // Lunascape/Maxthon/Netfront/Jasmine/Blazer
	
	            // Trident based
	            /(avant\s|iemobile|slim|baidu)(?:browser)?[\/\s]?([\w\.]*)/i,
	                                                                                // Avant/IEMobile/SlimBrowser/Baidu
	            /(?:ms|\()(ie)\s([\w\.]+)/i,                                        // Internet Explorer
	
	            // Webkit/KHTML based
	            /(rekonq)\/([\w\.]+)*/i,                                            // Rekonq
	            /(chromium|flock|rockmelt|midori|epiphany|silk|skyfire|ovibrowser|bolt|iron|vivaldi|iridium|phantomjs|bowser)\/([\w\.-]+)/i
	                                                                                // Chromium/Flock/RockMelt/Midori/Epiphany/Silk/Skyfire/Bolt/Iron/Iridium/PhantomJS/Bowser
	            ], [NAME, VERSION], [
	
	            /(trident).+rv[:\s]([\w\.]+).+like\sgecko/i                         // IE11
	            ], [[NAME, 'IE'], VERSION], [
	
	            /(edge)\/((\d+)?[\w\.]+)/i                                          // Microsoft Edge
	            ], [NAME, VERSION], [
	
	            /(yabrowser)\/([\w\.]+)/i                                           // Yandex
	            ], [[NAME, 'Yandex'], VERSION], [
	
	            /(puffin)\/([\w\.]+)/i                                              // Puffin
	            ], [[NAME, 'Puffin'], VERSION], [
	
	            /((?:[\s\/])uc?\s?browser|(?:juc.+)ucweb)[\/\s]?([\w\.]+)/i
	                                                                                // UCBrowser
	            ], [[NAME, 'UCBrowser'], VERSION], [
	
	            /(comodo_dragon)\/([\w\.]+)/i                                       // Comodo Dragon
	            ], [[NAME, /_/g, ' '], VERSION], [
	
	            /(micromessenger)\/([\w\.]+)/i                                      // WeChat
	            ], [[NAME, 'WeChat'], VERSION], [
	
	            /(QQ)\/([\d\.]+)/i                                                  // QQ, aka ShouQ
	            ], [NAME, VERSION], [
	
	            /m?(qqbrowser)[\/\s]?([\w\.]+)/i                                    // QQBrowser
	            ], [NAME, VERSION], [
	
	            /xiaomi\/miuibrowser\/([\w\.]+)/i                                   // MIUI Browser
	            ], [VERSION, [NAME, 'MIUI Browser']], [
	
	            /;fbav\/([\w\.]+);/i                                                // Facebook App for iOS & Android
	            ], [VERSION, [NAME, 'Facebook']], [
	
	            /headlesschrome(?:\/([\w\.]+)|\s)/i                                 // Chrome Headless
	            ], [VERSION, [NAME, 'Chrome Headless']], [
	
	            /\swv\).+(chrome)\/([\w\.]+)/i                                      // Chrome WebView
	            ], [[NAME, /(.+)/, '$1 WebView'], VERSION], [
	
	            /((?:oculus|samsung)browser)\/([\w\.]+)/i
	            ], [[NAME, /(.+(?:g|us))(.+)/, '$1 $2'], VERSION], [                // Oculus / Samsung Browser
	
	            /android.+version\/([\w\.]+)\s+(?:mobile\s?safari|safari)*/i        // Android Browser
	            ], [VERSION, [NAME, 'Android Browser']], [
	
	            /(chrome|omniweb|arora|[tizenoka]{5}\s?browser)\/v?([\w\.]+)/i
	                                                                                // Chrome/OmniWeb/Arora/Tizen/Nokia
	            ], [NAME, VERSION], [
	
	            /(dolfin)\/([\w\.]+)/i                                              // Dolphin
	            ], [[NAME, 'Dolphin'], VERSION], [
	
	            /((?:android.+)crmo|crios)\/([\w\.]+)/i                             // Chrome for Android/iOS
	            ], [[NAME, 'Chrome'], VERSION], [
	
	            /(coast)\/([\w\.]+)/i                                               // Opera Coast
	            ], [[NAME, 'Opera Coast'], VERSION], [
	
	            /fxios\/([\w\.-]+)/i                                                // Firefox for iOS
	            ], [VERSION, [NAME, 'Firefox']], [
	
	            /version\/([\w\.]+).+?mobile\/\w+\s(safari)/i                       // Mobile Safari
	            ], [VERSION, [NAME, 'Mobile Safari']], [
	
	            /version\/([\w\.]+).+?(mobile\s?safari|safari)/i                    // Safari & Safari Mobile
	            ], [VERSION, NAME], [
	
	            /webkit.+?(gsa)\/([\w\.]+).+?(mobile\s?safari|safari)(\/[\w\.]+)/i  // Google Search Appliance on iOS
	            ], [[NAME, 'GSA'], VERSION], [
	
	            /webkit.+?(mobile\s?safari|safari)(\/[\w\.]+)/i                     // Safari < 3.0
	            ], [NAME, [VERSION, mapper.str, maps.browser.oldsafari.version]], [
	
	            /(konqueror)\/([\w\.]+)/i,                                          // Konqueror
	            /(webkit|khtml)\/([\w\.]+)/i
	            ], [NAME, VERSION], [
	
	            // Gecko based
	            /(navigator|netscape)\/([\w\.-]+)/i                                 // Netscape
	            ], [[NAME, 'Netscape'], VERSION], [
	            /(swiftfox)/i,                                                      // Swiftfox
	            /(icedragon|iceweasel|camino|chimera|fennec|maemo\sbrowser|minimo|conkeror)[\/\s]?([\w\.\+]+)/i,
	                                                                                // IceDragon/Iceweasel/Camino/Chimera/Fennec/Maemo/Minimo/Conkeror
	            /(firefox|seamonkey|k-meleon|icecat|iceape|firebird|phoenix)\/([\w\.-]+)/i,
	                                                                                // Firefox/SeaMonkey/K-Meleon/IceCat/IceApe/Firebird/Phoenix
	            /(mozilla)\/([\w\.]+).+rv\:.+gecko\/\d+/i,                          // Mozilla
	
	            // Other
	            /(polaris|lynx|dillo|icab|doris|amaya|w3m|netsurf|sleipnir)[\/\s]?([\w\.]+)/i,
	                                                                                // Polaris/Lynx/Dillo/iCab/Doris/Amaya/w3m/NetSurf/Sleipnir
	            /(links)\s\(([\w\.]+)/i,                                            // Links
	            /(gobrowser)\/?([\w\.]+)*/i,                                        // GoBrowser
	            /(ice\s?browser)\/v?([\w\._]+)/i,                                   // ICE Browser
	            /(mosaic)[\/\s]([\w\.]+)/i                                          // Mosaic
	            ], [NAME, VERSION]
	
	            /* /////////////////////
	            // Media players BEGIN
	            ////////////////////////
	
	            , [
	
	            /(apple(?:coremedia|))\/((\d+)[\w\._]+)/i,                          // Generic Apple CoreMedia
	            /(coremedia) v((\d+)[\w\._]+)/i
	            ], [NAME, VERSION], [
	
	            /(aqualung|lyssna|bsplayer)\/((\d+)?[\w\.-]+)/i                     // Aqualung/Lyssna/BSPlayer
	            ], [NAME, VERSION], [
	
	            /(ares|ossproxy)\s((\d+)[\w\.-]+)/i                                 // Ares/OSSProxy
	            ], [NAME, VERSION], [
	
	            /(audacious|audimusicstream|amarok|bass|core|dalvik|gnomemplayer|music on console|nsplayer|psp-internetradioplayer|videos)\/((\d+)[\w\.-]+)/i,
	                                                                                // Audacious/AudiMusicStream/Amarok/BASS/OpenCORE/Dalvik/GnomeMplayer/MoC
	                                                                                // NSPlayer/PSP-InternetRadioPlayer/Videos
	            /(clementine|music player daemon)\s((\d+)[\w\.-]+)/i,               // Clementine/MPD
	            /(lg player|nexplayer)\s((\d+)[\d\.]+)/i,
	            /player\/(nexplayer|lg player)\s((\d+)[\w\.-]+)/i                   // NexPlayer/LG Player
	            ], [NAME, VERSION], [
	            /(nexplayer)\s((\d+)[\w\.-]+)/i                                     // Nexplayer
	            ], [NAME, VERSION], [
	
	            /(flrp)\/((\d+)[\w\.-]+)/i                                          // Flip Player
	            ], [[NAME, 'Flip Player'], VERSION], [
	
	            /(fstream|nativehost|queryseekspider|ia-archiver|facebookexternalhit)/i
	                                                                                // FStream/NativeHost/QuerySeekSpider/IA Archiver/facebookexternalhit
	            ], [NAME], [
	
	            /(gstreamer) souphttpsrc (?:\([^\)]+\)){0,1} libsoup\/((\d+)[\w\.-]+)/i
	                                                                                // Gstreamer
	            ], [NAME, VERSION], [
	
	            /(htc streaming player)\s[\w_]+\s\/\s((\d+)[\d\.]+)/i,              // HTC Streaming Player
	            /(java|python-urllib|python-requests|wget|libcurl)\/((\d+)[\w\.-_]+)/i,
	                                                                                // Java/urllib/requests/wget/cURL
	            /(lavf)((\d+)[\d\.]+)/i                                             // Lavf (FFMPEG)
	            ], [NAME, VERSION], [
	
	            /(htc_one_s)\/((\d+)[\d\.]+)/i                                      // HTC One S
	            ], [[NAME, /_/g, ' '], VERSION], [
	
	            /(mplayer)(?:\s|\/)(?:(?:sherpya-){0,1}svn)(?:-|\s)(r\d+(?:-\d+[\w\.-]+){0,1})/i
	                                                                                // MPlayer SVN
	            ], [NAME, VERSION], [
	
	            /(mplayer)(?:\s|\/|[unkow-]+)((\d+)[\w\.-]+)/i                      // MPlayer
	            ], [NAME, VERSION], [
	
	            /(mplayer)/i,                                                       // MPlayer (no other info)
	            /(yourmuze)/i,                                                      // YourMuze
	            /(media player classic|nero showtime)/i                             // Media Player Classic/Nero ShowTime
	            ], [NAME], [
	
	            /(nero (?:home|scout))\/((\d+)[\w\.-]+)/i                           // Nero Home/Nero Scout
	            ], [NAME, VERSION], [
	
	            /(nokia\d+)\/((\d+)[\w\.-]+)/i                                      // Nokia
	            ], [NAME, VERSION], [
	
	            /\s(songbird)\/((\d+)[\w\.-]+)/i                                    // Songbird/Philips-Songbird
	            ], [NAME, VERSION], [
	
	            /(winamp)3 version ((\d+)[\w\.-]+)/i,                               // Winamp
	            /(winamp)\s((\d+)[\w\.-]+)/i,
	            /(winamp)mpeg\/((\d+)[\w\.-]+)/i
	            ], [NAME, VERSION], [
	
	            /(ocms-bot|tapinradio|tunein radio|unknown|winamp|inlight radio)/i  // OCMS-bot/tap in radio/tunein/unknown/winamp (no other info)
	                                                                                // inlight radio
	            ], [NAME], [
	
	            /(quicktime|rma|radioapp|radioclientapplication|soundtap|totem|stagefright|streamium)\/((\d+)[\w\.-]+)/i
	                                                                                // QuickTime/RealMedia/RadioApp/RadioClientApplication/
	                                                                                // SoundTap/Totem/Stagefright/Streamium
	            ], [NAME, VERSION], [
	
	            /(smp)((\d+)[\d\.]+)/i                                              // SMP
	            ], [NAME, VERSION], [
	
	            /(vlc) media player - version ((\d+)[\w\.]+)/i,                     // VLC Videolan
	            /(vlc)\/((\d+)[\w\.-]+)/i,
	            /(xbmc|gvfs|xine|xmms|irapp)\/((\d+)[\w\.-]+)/i,                    // XBMC/gvfs/Xine/XMMS/irapp
	            /(foobar2000)\/((\d+)[\d\.]+)/i,                                    // Foobar2000
	            /(itunes)\/((\d+)[\d\.]+)/i                                         // iTunes
	            ], [NAME, VERSION], [
	
	            /(wmplayer)\/((\d+)[\w\.-]+)/i,                                     // Windows Media Player
	            /(windows-media-player)\/((\d+)[\w\.-]+)/i
	            ], [[NAME, /-/g, ' '], VERSION], [
	
	            /windows\/((\d+)[\w\.-]+) upnp\/[\d\.]+ dlnadoc\/[\d\.]+ (home media server)/i
	                                                                                // Windows Media Server
	            ], [VERSION, [NAME, 'Windows']], [
	
	            /(com\.riseupradioalarm)\/((\d+)[\d\.]*)/i                          // RiseUP Radio Alarm
	            ], [NAME, VERSION], [
	
	            /(rad.io)\s((\d+)[\d\.]+)/i,                                        // Rad.io
	            /(radio.(?:de|at|fr))\s((\d+)[\d\.]+)/i
	            ], [[NAME, 'rad.io'], VERSION]
	
	            //////////////////////
	            // Media players END
	            ////////////////////*/
	
	        ],
	
	        cpu : [[
	
	            /(?:(amd|x(?:(?:86|64)[_-])?|wow|win)64)[;\)]/i                     // AMD64
	            ], [[ARCHITECTURE, 'amd64']], [
	
	            /(ia32(?=;))/i                                                      // IA32 (quicktime)
	            ], [[ARCHITECTURE, util.lowerize]], [
	
	            /((?:i[346]|x)86)[;\)]/i                                            // IA32
	            ], [[ARCHITECTURE, 'ia32']], [
	
	            // PocketPC mistakenly identified as PowerPC
	            /windows\s(ce|mobile);\sppc;/i
	            ], [[ARCHITECTURE, 'arm']], [
	
	            /((?:ppc|powerpc)(?:64)?)(?:\smac|;|\))/i                           // PowerPC
	            ], [[ARCHITECTURE, /ower/, '', util.lowerize]], [
	
	            /(sun4\w)[;\)]/i                                                    // SPARC
	            ], [[ARCHITECTURE, 'sparc']], [
	
	            /((?:avr32|ia64(?=;))|68k(?=\))|arm(?:64|(?=v\d+;))|(?=atmel\s)avr|(?:irix|mips|sparc)(?:64)?(?=;)|pa-risc)/i
	                                                                                // IA64, 68K, ARM/64, AVR/32, IRIX/64, MIPS/64, SPARC/64, PA-RISC
	            ], [[ARCHITECTURE, util.lowerize]]
	        ],
	
	        device : [[
	
	            /\((ipad|playbook);[\w\s\);-]+(rim|apple)/i                         // iPad/PlayBook
	            ], [MODEL, VENDOR, [TYPE, TABLET]], [
	
	            /applecoremedia\/[\w\.]+ \((ipad)/                                  // iPad
	            ], [MODEL, [VENDOR, 'Apple'], [TYPE, TABLET]], [
	
	            /(apple\s{0,1}tv)/i                                                 // Apple TV
	            ], [[MODEL, 'Apple TV'], [VENDOR, 'Apple']], [
	
	            /(archos)\s(gamepad2?)/i,                                           // Archos
	            /(hp).+(touchpad)/i,                                                // HP TouchPad
	            /(hp).+(tablet)/i,                                                  // HP Tablet
	            /(kindle)\/([\w\.]+)/i,                                             // Kindle
	            /\s(nook)[\w\s]+build\/(\w+)/i,                                     // Nook
	            /(dell)\s(strea[kpr\s\d]*[\dko])/i                                  // Dell Streak
	            ], [VENDOR, MODEL, [TYPE, TABLET]], [
	
	            /(kf[A-z]+)\sbuild\/[\w\.]+.*silk\//i                               // Kindle Fire HD
	            ], [MODEL, [VENDOR, 'Amazon'], [TYPE, TABLET]], [
	            /(sd|kf)[0349hijorstuw]+\sbuild\/[\w\.]+.*silk\//i                  // Fire Phone
	            ], [[MODEL, mapper.str, maps.device.amazon.model], [VENDOR, 'Amazon'], [TYPE, MOBILE]], [
	
	            /\((ip[honed|\s\w*]+);.+(apple)/i                                   // iPod/iPhone
	            ], [MODEL, VENDOR, [TYPE, MOBILE]], [
	            /\((ip[honed|\s\w*]+);/i                                            // iPod/iPhone
	            ], [MODEL, [VENDOR, 'Apple'], [TYPE, MOBILE]], [
	
	            /(blackberry)[\s-]?(\w+)/i,                                         // BlackBerry
	            /(blackberry|benq|palm(?=\-)|sonyericsson|acer|asus|dell|meizu|motorola|polytron)[\s_-]?([\w-]+)*/i,
	                                                                                // BenQ/Palm/Sony-Ericsson/Acer/Asus/Dell/Meizu/Motorola/Polytron
	            /(hp)\s([\w\s]+\w)/i,                                               // HP iPAQ
	            /(asus)-?(\w+)/i                                                    // Asus
	            ], [VENDOR, MODEL, [TYPE, MOBILE]], [
	            /\(bb10;\s(\w+)/i                                                   // BlackBerry 10
	            ], [MODEL, [VENDOR, 'BlackBerry'], [TYPE, MOBILE]], [
	                                                                                // Asus Tablets
	            /android.+(transfo[prime\s]{4,10}\s\w+|eeepc|slider\s\w+|nexus 7|padfone)/i
	            ], [MODEL, [VENDOR, 'Asus'], [TYPE, TABLET]], [
	
	            /(sony)\s(tablet\s[ps])\sbuild\//i,                                  // Sony
	            /(sony)?(?:sgp.+)\sbuild\//i
	            ], [[VENDOR, 'Sony'], [MODEL, 'Xperia Tablet'], [TYPE, TABLET]], [
	            /android.+\s([c-g]\d{4}|so[-l]\w+)\sbuild\//i
	            ], [MODEL, [VENDOR, 'Sony'], [TYPE, MOBILE]], [
	
	            /\s(ouya)\s/i,                                                      // Ouya
	            /(nintendo)\s([wids3u]+)/i                                          // Nintendo
	            ], [VENDOR, MODEL, [TYPE, CONSOLE]], [
	
	            /android.+;\s(shield)\sbuild/i                                      // Nvidia
	            ], [MODEL, [VENDOR, 'Nvidia'], [TYPE, CONSOLE]], [
	
	            /(playstation\s[34portablevi]+)/i                                   // Playstation
	            ], [MODEL, [VENDOR, 'Sony'], [TYPE, CONSOLE]], [
	
	            /(sprint\s(\w+))/i                                                  // Sprint Phones
	            ], [[VENDOR, mapper.str, maps.device.sprint.vendor], [MODEL, mapper.str, maps.device.sprint.model], [TYPE, MOBILE]], [
	
	            /(lenovo)\s?(S(?:5000|6000)+(?:[-][\w+]))/i                         // Lenovo tablets
	            ], [VENDOR, MODEL, [TYPE, TABLET]], [
	
	            /(htc)[;_\s-]+([\w\s]+(?=\))|\w+)*/i,                               // HTC
	            /(zte)-(\w+)*/i,                                                    // ZTE
	            /(alcatel|geeksphone|lenovo|nexian|panasonic|(?=;\s)sony)[_\s-]?([\w-]+)*/i
	                                                                                // Alcatel/GeeksPhone/Lenovo/Nexian/Panasonic/Sony
	            ], [VENDOR, [MODEL, /_/g, ' '], [TYPE, MOBILE]], [
	
	            /(nexus\s9)/i                                                       // HTC Nexus 9
	            ], [MODEL, [VENDOR, 'HTC'], [TYPE, TABLET]], [
	
	            /d\/huawei([\w\s-]+)[;\)]/i,
	            /(nexus\s6p)/i                                                      // Huawei
	            ], [MODEL, [VENDOR, 'Huawei'], [TYPE, MOBILE]], [
	
	            /(microsoft);\s(lumia[\s\w]+)/i                                     // Microsoft Lumia
	            ], [VENDOR, MODEL, [TYPE, MOBILE]], [
	
	            /[\s\(;](xbox(?:\sone)?)[\s\);]/i                                   // Microsoft Xbox
	            ], [MODEL, [VENDOR, 'Microsoft'], [TYPE, CONSOLE]], [
	            /(kin\.[onetw]{3})/i                                                // Microsoft Kin
	            ], [[MODEL, /\./g, ' '], [VENDOR, 'Microsoft'], [TYPE, MOBILE]], [
	
	                                                                                // Motorola
	            /\s(milestone|droid(?:[2-4x]|\s(?:bionic|x2|pro|razr))?(:?\s4g)?)[\w\s]+build\//i,
	            /mot[\s-]?(\w+)*/i,
	            /(XT\d{3,4}) build\//i,
	            /(nexus\s6)/i
	            ], [MODEL, [VENDOR, 'Motorola'], [TYPE, MOBILE]], [
	            /android.+\s(mz60\d|xoom[\s2]{0,2})\sbuild\//i
	            ], [MODEL, [VENDOR, 'Motorola'], [TYPE, TABLET]], [
	
	            /hbbtv\/\d+\.\d+\.\d+\s+\([\w\s]*;\s*(\w[^;]*);([^;]*)/i            // HbbTV devices
	            ], [[VENDOR, util.trim], [MODEL, util.trim], [TYPE, SMARTTV]], [
	
	            /hbbtv.+maple;(\d+)/i
	            ], [[MODEL, /^/, 'SmartTV'], [VENDOR, 'Samsung'], [TYPE, SMARTTV]], [
	
	            /\(dtv[\);].+(aquos)/i                                              // Sharp
	            ], [MODEL, [VENDOR, 'Sharp'], [TYPE, SMARTTV]], [
	
	            /android.+((sch-i[89]0\d|shw-m380s|gt-p\d{4}|gt-n\d+|sgh-t8[56]9|nexus 10))/i,
	            /((SM-T\w+))/i
	            ], [[VENDOR, 'Samsung'], MODEL, [TYPE, TABLET]], [                  // Samsung
	            /smart-tv.+(samsung)/i
	            ], [VENDOR, [TYPE, SMARTTV], MODEL], [
	            /((s[cgp]h-\w+|gt-\w+|galaxy\snexus|sm-\w[\w\d]+))/i,
	            /(sam[sung]*)[\s-]*(\w+-?[\w-]*)*/i,
	            /sec-((sgh\w+))/i
	            ], [[VENDOR, 'Samsung'], MODEL, [TYPE, MOBILE]], [
	
	            /sie-(\w+)*/i                                                       // Siemens
	            ], [MODEL, [VENDOR, 'Siemens'], [TYPE, MOBILE]], [
	
	            /(maemo|nokia).*(n900|lumia\s\d+)/i,                                // Nokia
	            /(nokia)[\s_-]?([\w-]+)*/i
	            ], [[VENDOR, 'Nokia'], MODEL, [TYPE, MOBILE]], [
	
	            /android\s3\.[\s\w;-]{10}(a\d{3})/i                                 // Acer
	            ], [MODEL, [VENDOR, 'Acer'], [TYPE, TABLET]], [
	
	            /android.+([vl]k\-?\d{3})\s+build/i                                 // LG Tablet
	            ], [MODEL, [VENDOR, 'LG'], [TYPE, TABLET]], [
	            /android\s3\.[\s\w;-]{10}(lg?)-([06cv9]{3,4})/i                     // LG Tablet
	            ], [[VENDOR, 'LG'], MODEL, [TYPE, TABLET]], [
	            /(lg) netcast\.tv/i                                                 // LG SmartTV
	            ], [VENDOR, MODEL, [TYPE, SMARTTV]], [
	            /(nexus\s[45])/i,                                                   // LG
	            /lg[e;\s\/-]+(\w+)*/i,
	            /android.+lg(\-?[\d\w]+)\s+build/i
	            ], [MODEL, [VENDOR, 'LG'], [TYPE, MOBILE]], [
	
	            /android.+(ideatab[a-z0-9\-\s]+)/i                                  // Lenovo
	            ], [MODEL, [VENDOR, 'Lenovo'], [TYPE, TABLET]], [
	
	            /linux;.+((jolla));/i                                               // Jolla
	            ], [VENDOR, MODEL, [TYPE, MOBILE]], [
	
	            /((pebble))app\/[\d\.]+\s/i                                         // Pebble
	            ], [VENDOR, MODEL, [TYPE, WEARABLE]], [
	
	            /android.+;\s(oppo)\s?([\w\s]+)\sbuild/i                            // OPPO
	            ], [VENDOR, MODEL, [TYPE, MOBILE]], [
	
	            /crkey/i                                                            // Google Chromecast
	            ], [[MODEL, 'Chromecast'], [VENDOR, 'Google']], [
	
	            /android.+;\s(glass)\s\d/i                                          // Google Glass
	            ], [MODEL, [VENDOR, 'Google'], [TYPE, WEARABLE]], [
	
	            /android.+;\s(pixel c)\s/i                                          // Google Pixel C
	            ], [MODEL, [VENDOR, 'Google'], [TYPE, TABLET]], [
	
	            /android.+;\s(pixel xl|pixel)\s/i                                   // Google Pixel
	            ], [MODEL, [VENDOR, 'Google'], [TYPE, MOBILE]], [
	
	            /android.+(\w+)\s+build\/hm\1/i,                                    // Xiaomi Hongmi 'numeric' models
	            /android.+(hm[\s\-_]*note?[\s_]*(?:\d\w)?)\s+build/i,               // Xiaomi Hongmi
	            /android.+(mi[\s\-_]*(?:one|one[\s_]plus|note lte)?[\s_]*(?:\d\w)?)\s+build/i,    // Xiaomi Mi
	            /android.+(redmi[\s\-_]*(?:note)?(?:[\s_]*[\w\s]+)?)\s+build/i      // Redmi Phones
	            ], [[MODEL, /_/g, ' '], [VENDOR, 'Xiaomi'], [TYPE, MOBILE]], [
	            /android.+(mi[\s\-_]*(?:pad)?(?:[\s_]*[\w\s]+)?)\s+build/i          // Mi Pad tablets
	            ],[[MODEL, /_/g, ' '], [VENDOR, 'Xiaomi'], [TYPE, TABLET]], [
	            /android.+;\s(m[1-5]\snote)\sbuild/i                                // Meizu Tablet
	            ], [MODEL, [VENDOR, 'Meizu'], [TYPE, TABLET]], [
	
	            /android.+a000(1)\s+build/i                                         // OnePlus
	            ], [MODEL, [VENDOR, 'OnePlus'], [TYPE, MOBILE]], [
	
	            /android.+[;\/]\s*(RCT[\d\w]+)\s+build/i                            // RCA Tablets
	            ], [MODEL, [VENDOR, 'RCA'], [TYPE, TABLET]], [
	
	            /android.+[;\/]\s*(Venue[\d\s]*)\s+build/i                          // Dell Venue Tablets
	            ], [MODEL, [VENDOR, 'Dell'], [TYPE, TABLET]], [
	
	            /android.+[;\/]\s*(Q[T|M][\d\w]+)\s+build/i                         // Verizon Tablet
	            ], [MODEL, [VENDOR, 'Verizon'], [TYPE, TABLET]], [
	
	            /android.+[;\/]\s+(Barnes[&\s]+Noble\s+|BN[RT])(V?.*)\s+build/i     // Barnes & Noble Tablet
	            ], [[VENDOR, 'Barnes & Noble'], MODEL, [TYPE, TABLET]], [
	
	            /android.+[;\/]\s+(TM\d{3}.*\b)\s+build/i                           // Barnes & Noble Tablet
	            ], [MODEL, [VENDOR, 'NuVision'], [TYPE, TABLET]], [
	
	            /android.+[;\/]\s*(zte)?.+(k\d{2})\s+build/i                        // ZTE K Series Tablet
	            ], [[VENDOR, 'ZTE'], MODEL, [TYPE, TABLET]], [
	
	            /android.+[;\/]\s*(gen\d{3})\s+build.*49h/i                         // Swiss GEN Mobile
	            ], [MODEL, [VENDOR, 'Swiss'], [TYPE, MOBILE]], [
	
	            /android.+[;\/]\s*(zur\d{3})\s+build/i                              // Swiss ZUR Tablet
	            ], [MODEL, [VENDOR, 'Swiss'], [TYPE, TABLET]], [
	
	            /android.+[;\/]\s*((Zeki)?TB.*\b)\s+build/i                         // Zeki Tablets
	            ], [MODEL, [VENDOR, 'Zeki'], [TYPE, TABLET]], [
	
	            /(android).+[;\/]\s+([YR]\d{2}x?.*)\s+build/i,
	            /android.+[;\/]\s+(Dragon[\-\s]+Touch\s+|DT)(.+)\s+build/i          // Dragon Touch Tablet
	            ], [[VENDOR, 'Dragon Touch'], MODEL, [TYPE, TABLET]], [
	
	            /android.+[;\/]\s*(NS-?.+)\s+build/i                                // Insignia Tablets
	            ], [MODEL, [VENDOR, 'Insignia'], [TYPE, TABLET]], [
	
	            /android.+[;\/]\s*((NX|Next)-?.+)\s+build/i                         // NextBook Tablets
	            ], [MODEL, [VENDOR, 'NextBook'], [TYPE, TABLET]], [
	
	            /android.+[;\/]\s*(Xtreme\_?)?(V(1[045]|2[015]|30|40|60|7[05]|90))\s+build/i
	            ], [[VENDOR, 'Voice'], MODEL, [TYPE, MOBILE]], [                    // Voice Xtreme Phones
	
	            /android.+[;\/]\s*(LVTEL\-?)?(V1[12])\s+build/i                     // LvTel Phones
	            ], [[VENDOR, 'LvTel'], MODEL, [TYPE, MOBILE]], [
	
	            /android.+[;\/]\s*(V(100MD|700NA|7011|917G).*\b)\s+build/i          // Envizen Tablets
	            ], [MODEL, [VENDOR, 'Envizen'], [TYPE, TABLET]], [
	
	            /android.+[;\/]\s*(Le[\s\-]+Pan)[\s\-]+(.*\b)\s+build/i             // Le Pan Tablets
	            ], [VENDOR, MODEL, [TYPE, TABLET]], [
	
	            /android.+[;\/]\s*(Trio[\s\-]*.*)\s+build/i                         // MachSpeed Tablets
	            ], [MODEL, [VENDOR, 'MachSpeed'], [TYPE, TABLET]], [
	
	            /android.+[;\/]\s*(Trinity)[\-\s]*(T\d{3})\s+build/i                // Trinity Tablets
	            ], [VENDOR, MODEL, [TYPE, TABLET]], [
	
	            /android.+[;\/]\s*TU_(1491)\s+build/i                               // Rotor Tablets
	            ], [MODEL, [VENDOR, 'Rotor'], [TYPE, TABLET]], [
	
	            /android.+(KS(.+))\s+build/i                                        // Amazon Kindle Tablets
	            ], [MODEL, [VENDOR, 'Amazon'], [TYPE, TABLET]], [
	
	            /android.+(Gigaset)[\s\-]+(Q.+)\s+build/i                           // Gigaset Tablets
	            ], [VENDOR, MODEL, [TYPE, TABLET]], [
	
	            /\s(tablet|tab)[;\/]/i,                                             // Unidentifiable Tablet
	            /\s(mobile)(?:[;\/]|\ssafari)/i                                     // Unidentifiable Mobile
	            ], [[TYPE, util.lowerize], VENDOR, MODEL], [
	
	            /(android.+)[;\/].+build/i                                          // Generic Android Device
	            ], [MODEL, [VENDOR, 'Generic']]
	
	
	        /*//////////////////////////
	            // TODO: move to string map
	            ////////////////////////////
	
	            /(C6603)/i                                                          // Sony Xperia Z C6603
	            ], [[MODEL, 'Xperia Z C6603'], [VENDOR, 'Sony'], [TYPE, MOBILE]], [
	            /(C6903)/i                                                          // Sony Xperia Z 1
	            ], [[MODEL, 'Xperia Z 1'], [VENDOR, 'Sony'], [TYPE, MOBILE]], [
	
	            /(SM-G900[F|H])/i                                                   // Samsung Galaxy S5
	            ], [[MODEL, 'Galaxy S5'], [VENDOR, 'Samsung'], [TYPE, MOBILE]], [
	            /(SM-G7102)/i                                                       // Samsung Galaxy Grand 2
	            ], [[MODEL, 'Galaxy Grand 2'], [VENDOR, 'Samsung'], [TYPE, MOBILE]], [
	            /(SM-G530H)/i                                                       // Samsung Galaxy Grand Prime
	            ], [[MODEL, 'Galaxy Grand Prime'], [VENDOR, 'Samsung'], [TYPE, MOBILE]], [
	            /(SM-G313HZ)/i                                                      // Samsung Galaxy V
	            ], [[MODEL, 'Galaxy V'], [VENDOR, 'Samsung'], [TYPE, MOBILE]], [
	            /(SM-T805)/i                                                        // Samsung Galaxy Tab S 10.5
	            ], [[MODEL, 'Galaxy Tab S 10.5'], [VENDOR, 'Samsung'], [TYPE, TABLET]], [
	            /(SM-G800F)/i                                                       // Samsung Galaxy S5 Mini
	            ], [[MODEL, 'Galaxy S5 Mini'], [VENDOR, 'Samsung'], [TYPE, MOBILE]], [
	            /(SM-T311)/i                                                        // Samsung Galaxy Tab 3 8.0
	            ], [[MODEL, 'Galaxy Tab 3 8.0'], [VENDOR, 'Samsung'], [TYPE, TABLET]], [
	
	            /(T3C)/i                                                            // Advan Vandroid T3C
	            ], [MODEL, [VENDOR, 'Advan'], [TYPE, TABLET]], [
	            /(ADVAN T1J\+)/i                                                    // Advan Vandroid T1J+
	            ], [[MODEL, 'Vandroid T1J+'], [VENDOR, 'Advan'], [TYPE, TABLET]], [
	            /(ADVAN S4A)/i                                                      // Advan Vandroid S4A
	            ], [[MODEL, 'Vandroid S4A'], [VENDOR, 'Advan'], [TYPE, MOBILE]], [
	
	            /(V972M)/i                                                          // ZTE V972M
	            ], [MODEL, [VENDOR, 'ZTE'], [TYPE, MOBILE]], [
	
	            /(i-mobile)\s(IQ\s[\d\.]+)/i                                        // i-mobile IQ
	            ], [VENDOR, MODEL, [TYPE, MOBILE]], [
	            /(IQ6.3)/i                                                          // i-mobile IQ IQ 6.3
	            ], [[MODEL, 'IQ 6.3'], [VENDOR, 'i-mobile'], [TYPE, MOBILE]], [
	            /(i-mobile)\s(i-style\s[\d\.]+)/i                                   // i-mobile i-STYLE
	            ], [VENDOR, MODEL, [TYPE, MOBILE]], [
	            /(i-STYLE2.1)/i                                                     // i-mobile i-STYLE 2.1
	            ], [[MODEL, 'i-STYLE 2.1'], [VENDOR, 'i-mobile'], [TYPE, MOBILE]], [
	
	            /(mobiistar touch LAI 512)/i                                        // mobiistar touch LAI 512
	            ], [[MODEL, 'Touch LAI 512'], [VENDOR, 'mobiistar'], [TYPE, MOBILE]], [
	
	            /////////////
	            // END TODO
	            ///////////*/
	
	        ],
	
	        engine : [[
	
	            /windows.+\sedge\/([\w\.]+)/i                                       // EdgeHTML
	            ], [VERSION, [NAME, 'EdgeHTML']], [
	
	            /(presto)\/([\w\.]+)/i,                                             // Presto
	            /(webkit|trident|netfront|netsurf|amaya|lynx|w3m)\/([\w\.]+)/i,     // WebKit/Trident/NetFront/NetSurf/Amaya/Lynx/w3m
	            /(khtml|tasman|links)[\/\s]\(?([\w\.]+)/i,                          // KHTML/Tasman/Links
	            /(icab)[\/\s]([23]\.[\d\.]+)/i                                      // iCab
	            ], [NAME, VERSION], [
	
	            /rv\:([\w\.]+).*(gecko)/i                                           // Gecko
	            ], [VERSION, NAME]
	        ],
	
	        os : [[
	
	            // Windows based
	            /microsoft\s(windows)\s(vista|xp)/i                                 // Windows (iTunes)
	            ], [NAME, VERSION], [
	            /(windows)\snt\s6\.2;\s(arm)/i,                                     // Windows RT
	            /(windows\sphone(?:\sos)*)[\s\/]?([\d\.\s]+\w)*/i,                  // Windows Phone
	            /(windows\smobile|windows)[\s\/]?([ntce\d\.\s]+\w)/i
	            ], [NAME, [VERSION, mapper.str, maps.os.windows.version]], [
	            /(win(?=3|9|n)|win\s9x\s)([nt\d\.]+)/i
	            ], [[NAME, 'Windows'], [VERSION, mapper.str, maps.os.windows.version]], [
	
	            // Mobile/Embedded OS
	            /\((bb)(10);/i                                                      // BlackBerry 10
	            ], [[NAME, 'BlackBerry'], VERSION], [
	            /(blackberry)\w*\/?([\w\.]+)*/i,                                    // Blackberry
	            /(tizen)[\/\s]([\w\.]+)/i,                                          // Tizen
	            /(android|webos|palm\sos|qnx|bada|rim\stablet\sos|meego|contiki)[\/\s-]?([\w\.]+)*/i,
	                                                                                // Android/WebOS/Palm/QNX/Bada/RIM/MeeGo/Contiki
	            /linux;.+(sailfish);/i                                              // Sailfish OS
	            ], [NAME, VERSION], [
	            /(symbian\s?os|symbos|s60(?=;))[\/\s-]?([\w\.]+)*/i                 // Symbian
	            ], [[NAME, 'Symbian'], VERSION], [
	            /\((series40);/i                                                    // Series 40
	            ], [NAME], [
	            /mozilla.+\(mobile;.+gecko.+firefox/i                               // Firefox OS
	            ], [[NAME, 'Firefox OS'], VERSION], [
	
	            // Console
	            /(nintendo|playstation)\s([wids34portablevu]+)/i,                   // Nintendo/Playstation
	
	            // GNU/Linux based
	            /(mint)[\/\s\(]?(\w+)*/i,                                           // Mint
	            /(mageia|vectorlinux)[;\s]/i,                                       // Mageia/VectorLinux
	            /(joli|[kxln]?ubuntu|debian|[open]*suse|gentoo|(?=\s)arch|slackware|fedora|mandriva|centos|pclinuxos|redhat|zenwalk|linpus)[\/\s-]?(?!chrom)([\w\.-]+)*/i,
	                                                                                // Joli/Ubuntu/Debian/SUSE/Gentoo/Arch/Slackware
	                                                                                // Fedora/Mandriva/CentOS/PCLinuxOS/RedHat/Zenwalk/Linpus
	            /(hurd|linux)\s?([\w\.]+)*/i,                                       // Hurd/Linux
	            /(gnu)\s?([\w\.]+)*/i                                               // GNU
	            ], [NAME, VERSION], [
	
	            /(cros)\s[\w]+\s([\w\.]+\w)/i                                       // Chromium OS
	            ], [[NAME, 'Chromium OS'], VERSION],[
	
	            // Solaris
	            /(sunos)\s?([\w\.]+\d)*/i                                           // Solaris
	            ], [[NAME, 'Solaris'], VERSION], [
	
	            // BSD based
	            /\s([frentopc-]{0,4}bsd|dragonfly)\s?([\w\.]+)*/i                   // FreeBSD/NetBSD/OpenBSD/PC-BSD/DragonFly
	            ], [NAME, VERSION],[
	
	            /(haiku)\s(\w+)/i                                                  // Haiku
	            ], [NAME, VERSION],[
	
	            /cfnetwork\/.+darwin/i,
	            /ip[honead]+(?:.*os\s([\w]+)\slike\smac|;\sopera)/i                 // iOS
	            ], [[VERSION, /_/g, '.'], [NAME, 'iOS']], [
	
	            /(mac\sos\sx)\s?([\w\s\.]+\w)*/i,
	            /(macintosh|mac(?=_powerpc)\s)/i                                    // Mac OS
	            ], [[NAME, 'Mac OS'], [VERSION, /_/g, '.']], [
	
	            // Other
	            /((?:open)?solaris)[\/\s-]?([\w\.]+)*/i,                            // Solaris
	            /(aix)\s((\d)(?=\.|\)|\s)[\w\.]*)*/i,                               // AIX
	            /(plan\s9|minix|beos|os\/2|amigaos|morphos|risc\sos|openvms)/i,
	                                                                                // Plan9/Minix/BeOS/OS2/AmigaOS/MorphOS/RISCOS/OpenVMS
	            /(unix)\s?([\w\.]+)*/i                                              // UNIX
	            ], [NAME, VERSION]
	        ]
	    };
	
	
	    /////////////////
	    // Constructor
	    ////////////////
	    /*
	    var Browser = function (name, version) {
	        this[NAME] = name;
	        this[VERSION] = version;
	    };
	    var CPU = function (arch) {
	        this[ARCHITECTURE] = arch;
	    };
	    var Device = function (vendor, model, type) {
	        this[VENDOR] = vendor;
	        this[MODEL] = model;
	        this[TYPE] = type;
	    };
	    var Engine = Browser;
	    var OS = Browser;
	    */
	    var UAParser = function (uastring, extensions) {
	
	        if (typeof uastring === 'object') {
	            extensions = uastring;
	            uastring = undefined;
	        }
	
	        if (!(this instanceof UAParser)) {
	            return new UAParser(uastring, extensions).getResult();
	        }
	
	        var ua = uastring || ((window && window.navigator && window.navigator.userAgent) ? window.navigator.userAgent : EMPTY);
	        var rgxmap = extensions ? util.extend(regexes, extensions) : regexes;
	        //var browser = new Browser();
	        //var cpu = new CPU();
	        //var device = new Device();
	        //var engine = new Engine();
	        //var os = new OS();
	
	        this.getBrowser = function () {
	            var browser = { name: undefined, version: undefined };
	            mapper.rgx.call(browser, ua, rgxmap.browser);
	            browser.major = util.major(browser.version); // deprecated
	            return browser;
	        };
	        this.getCPU = function () {
	            var cpu = { architecture: undefined };
	            mapper.rgx.call(cpu, ua, rgxmap.cpu);
	            return cpu;
	        };
	        this.getDevice = function () {
	            var device = { vendor: undefined, model: undefined, type: undefined };
	            mapper.rgx.call(device, ua, rgxmap.device);
	            return device;
	        };
	        this.getEngine = function () {
	            var engine = { name: undefined, version: undefined };
	            mapper.rgx.call(engine, ua, rgxmap.engine);
	            return engine;
	        };
	        this.getOS = function () {
	            var os = { name: undefined, version: undefined };
	            mapper.rgx.call(os, ua, rgxmap.os);
	            return os;
	        };
	        this.getResult = function () {
	            return {
	                ua      : this.getUA(),
	                browser : this.getBrowser(),
	                engine  : this.getEngine(),
	                os      : this.getOS(),
	                device  : this.getDevice(),
	                cpu     : this.getCPU()
	            };
	        };
	        this.getUA = function () {
	            return ua;
	        };
	        this.setUA = function (uastring) {
	            ua = uastring;
	            //browser = new Browser();
	            //cpu = new CPU();
	            //device = new Device();
	            //engine = new Engine();
	            //os = new OS();
	            return this;
	        };
	        return this;
	    };
	
	    UAParser.VERSION = LIBVERSION;
	    UAParser.BROWSER = {
	        NAME    : NAME,
	        MAJOR   : MAJOR, // deprecated
	        VERSION : VERSION
	    };
	    UAParser.CPU = {
	        ARCHITECTURE : ARCHITECTURE
	    };
	    UAParser.DEVICE = {
	        MODEL   : MODEL,
	        VENDOR  : VENDOR,
	        TYPE    : TYPE,
	        CONSOLE : CONSOLE,
	        MOBILE  : MOBILE,
	        SMARTTV : SMARTTV,
	        TABLET  : TABLET,
	        WEARABLE: WEARABLE,
	        EMBEDDED: EMBEDDED
	    };
	    UAParser.ENGINE = {
	        NAME    : NAME,
	        VERSION : VERSION
	    };
	    UAParser.OS = {
	        NAME    : NAME,
	        VERSION : VERSION
	    };
	    //UAParser.Utils = util;
	
	    ///////////
	    // Export
	    //////////
	
	
	    // check js environment
	    if (typeof(exports) !== UNDEF_TYPE) {
	        // nodejs env
	        if (typeof module !== UNDEF_TYPE && module.exports) {
	            exports = module.exports = UAParser;
	        }
	        // TODO: test!!!!!!!!
	        /*
	        if (require && require.main === module && process) {
	            // cli
	            var jsonize = function (arr) {
	                var res = [];
	                for (var i in arr) {
	                    res.push(new UAParser(arr[i]).getResult());
	                }
	                process.stdout.write(JSON.stringify(res, null, 2) + '\n');
	            };
	            if (process.stdin.isTTY) {
	                // via args
	                jsonize(process.argv.slice(2));
	            } else {
	                // via pipe
	                var str = '';
	                process.stdin.on('readable', function() {
	                    var read = process.stdin.read();
	                    if (read !== null) {
	                        str += read;
	                    }
	                });
	                process.stdin.on('end', function () {
	                    jsonize(str.replace(/\n$/, '').split('\n'));
	                });
	            }
	        }
	        */
	        exports.UAParser = UAParser;
	    } else {
	        // requirejs env (optional)
	        if ("function" === FUNC_TYPE && __webpack_require__(806)) {
	            !(__WEBPACK_AMD_DEFINE_RESULT__ = function () {
	                return UAParser;
	            }.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
	        } else if (window) {
	            // browser env
	            window.UAParser = UAParser;
	        }
	    }
	
	    // jQuery/Zepto specific (optional)
	    // Note:
	    //   In AMD env the global scope should be kept clean, but jQuery is an exception.
	    //   jQuery always exports to global scope, unless jQuery.noConflict(true) is used,
	    //   and we should catch that.
	    var $ = window && (window.jQuery || window.Zepto);
	    if (typeof $ !== UNDEF_TYPE) {
	        var parser = new UAParser();
	        $.ua = parser.getResult();
	        $.ua.get = function () {
	            return parser.getUA();
	        };
	        $.ua.set = function (uastring) {
	            parser.setUA(uastring);
	            var result = parser.getResult();
	            for (var prop in result) {
	                $.ua[prop] = result[prop];
	            }
	        };
	    }
	
	})(typeof window === 'object' ? window : this);


/***/ }),
/* 806 */
/***/ (function(module, exports) {

	/* WEBPACK VAR INJECTION */(function(__webpack_amd_options__) {module.exports = __webpack_amd_options__;
	
	/* WEBPACK VAR INJECTION */}.call(exports, {}))

/***/ }),
/* 807 */,
/* 808 */,
/* 809 */,
/* 810 */,
/* 811 */,
/* 812 */,
/* 813 */,
/* 814 */,
/* 815 */,
/* 816 */,
/* 817 */,
/* 818 */,
/* 819 */,
/* 820 */,
/* 821 */,
/* 822 */,
/* 823 */,
/* 824 */,
/* 825 */,
/* 826 */,
/* 827 */,
/* 828 */,
/* 829 */,
/* 830 */,
/* 831 */,
/* 832 */,
/* 833 */,
/* 834 */,
/* 835 */,
/* 836 */,
/* 837 */
[1080, 992],
/* 838 */
[1078, 550],
/* 839 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	__webpack_require__(17);
	
	__webpack_require__(1003);
	
	__webpack_require__(179);
	
	__webpack_require__(103);

/***/ }),
/* 840 */
[1078, 1004],
/* 841 */
[1078, 1005],
/* 842 */
[1078, 1010],
/* 843 */,
/* 844 */,
/* 845 */,
/* 846 */,
/* 847 */,
/* 848 */,
/* 849 */,
/* 850 */,
/* 851 */,
/* 852 */,
/* 853 */,
/* 854 */,
/* 855 */,
/* 856 */,
/* 857 */,
/* 858 */,
/* 859 */,
/* 860 */,
/* 861 */,
/* 862 */,
/* 863 */,
/* 864 */,
/* 865 */,
/* 866 */,
/* 867 */,
/* 868 */,
/* 869 */,
/* 870 */,
/* 871 */
[1079, 1016],
/* 872 */,
/* 873 */
/***/ (function(module, exports, __webpack_require__) {

	var map = {
		"./affix/style/index.tsx": 876,
		"./alert/style/index.tsx": 877,
		"./anchor/style/index.tsx": 878,
		"./auto-complete/style/index.tsx": 879,
		"./avatar/style/index.tsx": 880,
		"./back-top/style/index.tsx": 881,
		"./badge/style/index.tsx": 882,
		"./breadcrumb/style/index.tsx": 883,
		"./button/style/index.tsx": 161,
		"./calendar/style/index.tsx": 912,
		"./card/style/index.tsx": 913,
		"./carousel/style/index.tsx": 914,
		"./cascader/style/index.tsx": 915,
		"./checkbox/style/index.tsx": 165,
		"./col/style/index.tsx": 916,
		"./collapse/style/index.tsx": 917,
		"./date-picker/style/index.tsx": 919,
		"./dropdown/style/index.tsx": 837,
		"./form/style/index.tsx": 920,
		"./grid/style/index.tsx": 838,
		"./icon/style/index.tsx": 921,
		"./input-number/style/index.tsx": 922,
		"./input/style/index.tsx": 103,
		"./layout/style/index.tsx": 923,
		"./locale-provider/style/index.tsx": 949,
		"./mention/style/index.tsx": 955,
		"./menu/style/index.tsx": 956,
		"./message/style/index.tsx": 957,
		"./modal/style/index.tsx": 958,
		"./notification/style/index.tsx": 959,
		"./pagination/style/index.tsx": 839,
		"./popconfirm/style/index.tsx": 960,
		"./popover/style/index.tsx": 840,
		"./progress/style/index.tsx": 841,
		"./radio/style/index.tsx": 373,
		"./rate/style/index.tsx": 961,
		"./row/style/index.tsx": 962,
		"./select/style/index.tsx": 179,
		"./slider/style/index.tsx": 963,
		"./spin/style/index.tsx": 842,
		"./steps/style/index.tsx": 964,
		"./switch/style/index.tsx": 965,
		"./table/style/index.tsx": 966,
		"./tabs/style/index.tsx": 967,
		"./tag/style/index.tsx": 968,
		"./time-picker/style/index.tsx": 871,
		"./timeline/style/index.tsx": 970,
		"./tooltip/style/index.tsx": 288,
		"./transfer/style/index.tsx": 971,
		"./tree-select/style/index.tsx": 972,
		"./tree/style/index.tsx": 973,
		"./upload/style/index.tsx": 974,
		"./version/style/index.tsx": 975
	};
	function webpackContext(req) {
		return __webpack_require__(webpackContextResolve(req));
	};
	function webpackContextResolve(req) {
		return map[req] || (function() { throw new Error("Cannot find module '" + req + "'.") }());
	};
	webpackContext.keys = function webpackContextKeys() {
		return Object.keys(map);
	};
	webpackContext.resolve = webpackContextResolve;
	module.exports = webpackContext;
	webpackContext.id = 873;


/***/ }),
/* 874 */,
/* 875 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	/* eslint no-console:0 */
	function camelCase(name) {
	  return name.charAt(0).toUpperCase() + name.slice(1).replace(/-(\w)/g, function (m, n) {
	    return n.toUpperCase();
	  });
	}
	
	// Just import style for https://github.com/ant-design/ant-design/issues/3745
	var req = __webpack_require__(873);
	
	req.keys().forEach(function (mod) {
	  var v = req(mod);
	  if (v && v['default']) {
	    v = v['default'];
	  }
	  var match = mod.match(/^\.\/([^_][\w-]+)\/index\.tsx?$/);
	  if (match && match[1]) {
	    if (match[1] === 'message' || match[1] === 'notification') {
	      // message & notification should not be capitalized
	      exports[match[1]] = v;
	    } else {
	      exports[camelCase(match[1])] = v;
	    }
	  }
	});
	
	module.exports = __webpack_require__(350);

/***/ }),
/* 876 */
[1078, 976],
/* 877 */
[1078, 977],
/* 878 */
[1078, 978],
/* 879 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	__webpack_require__(17);
	
	__webpack_require__(979);
	
	__webpack_require__(179);

/***/ }),
/* 880 */
[1078, 980],
/* 881 */
[1078, 981],
/* 882 */
[1078, 982],
/* 883 */
[1078, 983],
/* 884 */,
/* 885 */,
/* 886 */,
/* 887 */,
/* 888 */,
/* 889 */,
/* 890 */,
/* 891 */,
/* 892 */,
/* 893 */,
/* 894 */,
/* 895 */,
/* 896 */,
/* 897 */,
/* 898 */,
/* 899 */,
/* 900 */,
/* 901 */,
/* 902 */,
/* 903 */,
/* 904 */,
/* 905 */,
/* 906 */,
/* 907 */,
/* 908 */,
/* 909 */,
/* 910 */,
/* 911 */,
/* 912 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	__webpack_require__(17);
	
	__webpack_require__(985);
	
	__webpack_require__(179);
	
	__webpack_require__(373);

/***/ }),
/* 913 */
[1078, 986],
/* 914 */
[1078, 987],
/* 915 */
[1079, 988],
/* 916 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	__webpack_require__(17);
	
	__webpack_require__(550);

/***/ }),
/* 917 */
[1078, 990],
/* 918 */,
/* 919 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	__webpack_require__(17);
	
	__webpack_require__(991);
	
	__webpack_require__(103);
	
	__webpack_require__(871);

/***/ }),
/* 920 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	__webpack_require__(17);
	
	__webpack_require__(993);
	
	__webpack_require__(838);

/***/ }),
/* 921 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';

	__webpack_require__(17);

/***/ }),
/* 922 */
[1078, 994],
/* 923 */
[1078, 996],
/* 924 */,
/* 925 */,
/* 926 */,
/* 927 */,
/* 928 */,
/* 929 */,
/* 930 */,
/* 931 */,
/* 932 */,
/* 933 */,
/* 934 */,
/* 935 */,
/* 936 */,
/* 937 */,
/* 938 */,
/* 939 */,
/* 940 */,
/* 941 */,
/* 942 */,
/* 943 */,
/* 944 */,
/* 945 */,
/* 946 */,
/* 947 */,
/* 948 */,
/* 949 */
[1081, 997],
/* 950 */,
/* 951 */,
/* 952 */,
/* 953 */,
/* 954 */,
/* 955 */
[1081, 998],
/* 956 */
[1082, 999],
/* 957 */
[1078, 1000],
/* 958 */
[1080, 1001],
/* 959 */
[1078, 1002],
/* 960 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	__webpack_require__(17);
	
	__webpack_require__(840);
	
	__webpack_require__(161);

/***/ }),
/* 961 */
[1078, 1007],
/* 962 */
916,
/* 963 */
[1082, 1009],
/* 964 */
[1078, 1011],
/* 965 */
[1078, 1012],
/* 966 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	__webpack_require__(17);
	
	__webpack_require__(1013);
	
	__webpack_require__(373);
	
	__webpack_require__(165);
	
	__webpack_require__(837);
	
	__webpack_require__(842);
	
	__webpack_require__(839);

/***/ }),
/* 967 */
[1078, 1014],
/* 968 */
[1078, 1015],
/* 969 */,
/* 970 */
[1078, 1017],
/* 971 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	__webpack_require__(17);
	
	__webpack_require__(1019);
	
	__webpack_require__(165);
	
	__webpack_require__(161);
	
	__webpack_require__(103);

/***/ }),
/* 972 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	__webpack_require__(17);
	
	__webpack_require__(1020);
	
	__webpack_require__(179);
	
	__webpack_require__(165);

/***/ }),
/* 973 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	__webpack_require__(17);
	
	__webpack_require__(1021);
	
	__webpack_require__(165);

/***/ }),
/* 974 */
/***/ (function(module, exports, __webpack_require__) {

	'use strict';
	
	__webpack_require__(17);
	
	__webpack_require__(1022);
	
	__webpack_require__(841);
	
	__webpack_require__(288);

/***/ }),
/* 975 */
921,
/* 976 */
17,
/* 977 */
17,
/* 978 */
17,
/* 979 */
17,
/* 980 */
17,
/* 981 */
17,
/* 982 */
17,
/* 983 */
17,
/* 984 */
17,
/* 985 */
17,
/* 986 */
17,
/* 987 */
17,
/* 988 */
17,
/* 989 */
17,
/* 990 */
17,
/* 991 */
17,
/* 992 */
17,
/* 993 */
17,
/* 994 */
17,
/* 995 */
17,
/* 996 */
17,
/* 997 */
17,
/* 998 */
17,
/* 999 */
17,
/* 1000 */
17,
/* 1001 */
17,
/* 1002 */
17,
/* 1003 */
17,
/* 1004 */
17,
/* 1005 */
17,
/* 1006 */
17,
/* 1007 */
17,
/* 1008 */
17,
/* 1009 */
17,
/* 1010 */
17,
/* 1011 */
17,
/* 1012 */
17,
/* 1013 */
17,
/* 1014 */
17,
/* 1015 */
17,
/* 1016 */
17,
/* 1017 */
17,
/* 1018 */
17,
/* 1019 */
17,
/* 1020 */
17,
/* 1021 */
17,
/* 1022 */
17,
/* 1023 */,
/* 1024 */,
/* 1025 */,
/* 1026 */,
/* 1027 */,
/* 1028 */,
/* 1029 */,
/* 1030 */,
/* 1031 */,
/* 1032 */,
/* 1033 */,
/* 1034 */,
/* 1035 */,
/* 1036 */,
/* 1037 */,
/* 1038 */,
/* 1039 */,
/* 1040 */,
/* 1041 */,
/* 1042 */,
/* 1043 */,
/* 1044 */,
/* 1045 */,
/* 1046 */,
/* 1047 */,
/* 1048 */,
/* 1049 */,
/* 1050 */,
/* 1051 */,
/* 1052 */,
/* 1053 */,
/* 1054 */,
/* 1055 */,
/* 1056 */,
/* 1057 */,
/* 1058 */,
/* 1059 */,
/* 1060 */,
/* 1061 */,
/* 1062 */,
/* 1063 */,
/* 1064 */,
/* 1065 */,
/* 1066 */,
/* 1067 */,
/* 1068 */,
/* 1069 */,
/* 1070 */,
/* 1071 */,
/* 1072 */,
/* 1073 */,
/* 1074 */,
/* 1075 */,
/* 1076 */,
/* 1077 */,
/* 1078 */
/***/ (function(module, exports, __webpack_require__, __webpack_module_template_argument_0__) {

	'use strict';
	
	__webpack_require__(17);
	
	__webpack_require__(__webpack_module_template_argument_0__);

/***/ }),
/* 1079 */
/***/ (function(module, exports, __webpack_require__, __webpack_module_template_argument_0__) {

	'use strict';
	
	__webpack_require__(17);
	
	__webpack_require__(__webpack_module_template_argument_0__);
	
	__webpack_require__(103);

/***/ }),
/* 1080 */
/***/ (function(module, exports, __webpack_require__, __webpack_module_template_argument_0__) {

	'use strict';
	
	__webpack_require__(17);
	
	__webpack_require__(__webpack_module_template_argument_0__);
	
	__webpack_require__(161);

/***/ }),
/* 1081 */
/***/ (function(module, exports, __webpack_require__, __webpack_module_template_argument_0__) {

	'use strict';

	__webpack_require__(__webpack_module_template_argument_0__);

/***/ }),
/* 1082 */
/***/ (function(module, exports, __webpack_require__, __webpack_module_template_argument_0__) {

	'use strict';
	
	__webpack_require__(17);
	
	__webpack_require__(__webpack_module_template_argument_0__);
	
	__webpack_require__(288);

/***/ })
/******/ ])))
});
;
//# sourceMappingURL=antd.js.map