docs: 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 _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__(3);
  	
  	var _react2 = _interopRequireDefault(_react);
  	
  	var _warning = __webpack_require__(210);
  	
  	var _warning2 = _interopRequireDefault(_warning);
  	
  	var _sleep = __webpack_require__(207);
  	
  	var _sleep2 = _interopRequireDefault(_sleep);
  	
  	var _i18n = __webpack_require__(211);
  	
  	var _i18n2 = _interopRequireDefault(_i18n);
  	
  	var _colors = __webpack_require__(208);
  	
  	var _colors2 = _interopRequireDefault(_colors);
  	
  	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  	
  	function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }
  	
  	function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }
  	
  	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; } /**
  	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * @since 2016-09-06 13:57
  	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * @author vivaxy
  	                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                */
  	
  	var AutoHideToast = function (_Component) {
  	    _inherits(AutoHideToast, _Component);
  	
  	    function AutoHideToast() {
  	        var _ref;
  	
  	        var _temp, _this, _ret;
  	
  	        _classCallCheck(this, AutoHideToast);
  	
  	        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
  	            args[_key] = arguments[_key];
  	        }
  	
  	        return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_ref = AutoHideToast.__proto__ || Object.getPrototypeOf(AutoHideToast)).call.apply(_ref, [this].concat(args))), _this), _this.state = {
  	            show: false
  	        }, _temp), _possibleConstructorReturn(_this, _ret);
  	    }
  	
  	    _createClass(AutoHideToast, [{
  	        key: 'componentWillMount',
  	        value: function componentWillMount() {
  	            this.setState({
  	                show: this.props.show
  	            });
  	        }
  	    }, {
  	        key: 'componentWillReceiveProps',
  	        value: function componentWillReceiveProps(nextProps) {
  	            if (nextProps.show) {
  	                if (this.state.show) {
  	                    this.clearTimeout();
  	                    // this.props.onAutoHide();
  	                }
  	                this.showToast();
  	            } else {
  	                if (this.state.show) {
  	                    this.clearTimeout();
  	                    this.hideToast();
  	                }
  	            }
  	        }
  	    }, {
  	        key: 'clearTimeout',
  	        value: function (_clearTimeout) {
  	            function clearTimeout() {
  	                return _clearTimeout.apply(this, arguments);
  	            }
  	
  	            clearTimeout.toString = function () {
  	                return _clearTimeout.toString();
  	            };
  	
  	            return clearTimeout;
  	        }(function () {
  	            clearTimeout(this._timeout);
  	            clearTimeout(this._animationTimeout);
  	        })
  	    }, {
  	        key: 'hideToast',
  	        value: function () {
  	            var _ref2 = _asyncToGenerator(regeneratorRuntime.mark(function _callee() {
  	                var _this2 = this;
  	
  	                return regeneratorRuntime.wrap(function _callee$(_context) {
  	                    while (1) {
  	                        switch (_context.prev = _context.next) {
  	                            case 0:
  	                                this._root.style.opacity = '0';
  	                                _context.next = 3;
  	                                return (0, _sleep2.default)(this.props.animationDuration, function (timer) {
  	                                    _this2._animationTimeout = timer;
  	                                });
  	
  	                            case 3:
  	                                this.setState({
  	                                    show: false
  	                                });
  	                                this.props.onAutoHide();
  	
  	                            case 5:
  	                            case 'end':
  	                                return _context.stop();
  	                        }
  	                    }
  	                }, _callee, this);
  	            }));
  	
  	            function hideToast() {
  	                return _ref2.apply(this, arguments);
  	            }
  	
  	            return hideToast;
  	        }()
  	    }, {
  	        key: 'showToast',
  	        value: function () {
  	            var _ref3 = _asyncToGenerator(regeneratorRuntime.mark(function _callee2() {
  	                var _this3 = this;
  	
  	                return regeneratorRuntime.wrap(function _callee2$(_context2) {
  	                    while (1) {
  	                        switch (_context2.prev = _context2.next) {
  	                            case 0:
  	                                this.setState({
  	                                    show: true
  	                                });
  	                                _context2.next = 3;
  	                                return (0, _sleep2.default)(0);
  	
  	                            case 3:
  	                                this._root.style.opacity = '1';
  	                                _context2.next = 6;
  	                                return (0, _sleep2.default)(this.props.autoHideDuration, function (timer) {
  	                                    _this3._timeout = timer;
  	                                });
  	
  	                            case 6:
  	                                _context2.next = 8;
  	                                return this.hideToast();
  	
  	                            case 8:
  	                            case 'end':
  	                                return _context2.stop();
  	                        }
  	                    }
  	                }, _callee2, this);
  	            }));
  	
  	            function showToast() {
  	                return _ref3.apply(this, arguments);
  	            }
  	
  	            return showToast;
  	        }()
  	    }, {
  	        key: 'render',
  	        value: function render() {
  	            var _this4 = this;
  	
  	            var TRANSFORM = 'translate3d(-50%, -50%, 0)';
  	
  	            var _props = this.props,
  	                children = _props.children,
  	                top = _props.top,
  	                style = _props.style,
  	                showProps = _props.show,
  	                autoHideDuration = _props.autoHideDuration,
  	                animationDuration = _props.animationDuration,
  	                onAutoHide = _props.onAutoHide,
  	                otherProps = _objectWithoutProperties(_props, ['children', 'top', 'style', 'show', 'autoHideDuration', 'animationDuration', 'onAutoHide']);
  	
  	            var defaultStyle = {
  	                display: 'none',
  	                position: 'fixed',
  	                left: '50%',
  	                transform: TRANSFORM,
  	                WebkitTransform: TRANSFORM,
  	                backgroundColor: 'rgba(0, 0, 0, 0.5)',
  	                borderRadius: '4px',
  	                zIndex: '999',
  	                opacity: '0',
  	                padding: '8px 12px',
  	                WebkitTransition: 'opacity ' + animationDuration + 'ms',
  	                transition: 'opacity ' + animationDuration + 'ms',
  	                color: _colors2.default.WHITE,
  	                fontSize: '14px'
  	            };
  	
  	            var show = this.state.show;
  	
  	
  	            var computedStyle = _extends({}, defaultStyle, {
  	                top: top + '%'
  	            }, style);
  	
  	            if (show) {
  	                computedStyle.display = 'block';
  	            }
  	
  	            return _react2.default.createElement(
  	                'div',
  	                _extends({ style: computedStyle }, otherProps, { ref: function ref(_ref4) {
  	                        _this4._root = _ref4;
  	                    } }),
  	                children
  	            );
  	        }
  	    }]);
  	
  	    return AutoHideToast;
  	}(_react.Component);
  	
  	AutoHideToast.propTypes = {
  	    animationDuration: _react.PropTypes.number,
  	    show: _react.PropTypes.bool,
  	    autoHideDuration: _react.PropTypes.number,
  	    top: _react.PropTypes.number,
  	    onAutoHide: _react.PropTypes.func
  	};
  	AutoHideToast.defaultProps = {
  	    show: false,
  	    animationDuration: 300,
  	    autoHideDuration: 3000,
  	    top: 50,
  	    onAutoHide: function onAutoHide() {}
  	};
  	exports.default = AutoHideToast;
  
  /***/ }