From b5c7d1ef89ecfa7b7d38b8b3a345242378c73a26 Mon Sep 17 00:00:00 2001 From: Alexandru Naiman Date: Tue, 19 Jun 2018 01:36:51 +0300 Subject: [PATCH 1/6] check if the content and the wrapper exists before computing the sizes of the container avoiding componentDidMount errors when calling scrollToBottom/refresh --- src/js/ScrollArea.jsx | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/js/ScrollArea.jsx b/src/js/ScrollArea.jsx index ffe3484..e0c5526 100644 --- a/src/js/ScrollArea.jsx +++ b/src/js/ScrollArea.jsx @@ -370,10 +370,10 @@ export default class ScrollArea extends React.Component { } computeSizes() { - let realHeight = this.content.offsetHeight; - let containerHeight = this.wrapper.offsetHeight; - let realWidth = this.content.offsetWidth; - let containerWidth = this.wrapper.offsetWidth; + let realHeight = (this.content) ? this.content.offsetHeight : 0; + let containerHeight = (this.wrapper) ? this.wrapper.offsetHeight : 0; + let realWidth = (this.content) ? this.content.offsetWidth : 0; + let containerWidth = (this.content) ? this.wrapper.offsetWidth : 0; return { realHeight: realHeight, From 89e41a650d3c2350bb5aa8444786932bd0ad86bd Mon Sep 17 00:00:00 2001 From: Alexandru Naiman Date: Wed, 20 Jun 2018 11:41:11 +0300 Subject: [PATCH 2/6] check if the content and the wrapper exists before computing the sizes of the container avoiding componentDidMount errors when calling scrollToBottom/refresh --- dist/css/scrollArea.css | 59 + dist/no-css.js | 3823 +++++++++++++++++++++++++++++++++++ dist/scrollArea.js | 4173 +++++++++++++++++++++++++++++++++++++++ 3 files changed, 8055 insertions(+) create mode 100644 dist/css/scrollArea.css create mode 100644 dist/no-css.js create mode 100644 dist/scrollArea.js diff --git a/dist/css/scrollArea.css b/dist/css/scrollArea.css new file mode 100644 index 0000000..4a39fe6 --- /dev/null +++ b/dist/css/scrollArea.css @@ -0,0 +1,59 @@ +.scrollarea-content { + margin: 0; + padding: 0; + overflow: hidden; + position: relative; +} +.scrollarea-content:focus { + outline: 0; +} +.scrollarea { + position: relative; + overflow: hidden; +} +.scrollarea .scrollbar-container { + position: absolute; + background: none; + opacity: .1; + z-index: 9999; + -webkit-transition: all .4s; + -moz-transition: all .4s; + -ms-transition: all .4s; + -o-transition: all .4s; + transition: all .4s; +} +.scrollarea .scrollbar-container.horizontal { + width: 100%; + height: 10px; + left: 0; + bottom: 0; +} +.scrollarea .scrollbar-container.horizontal .scrollbar { + width: 20px; + height: 8px; + background: black; + margin-top: 1px; +} +.scrollarea .scrollbar-container.vertical { + width: 10px; + height: 100%; + right: 0; + top: 0; +} +.scrollarea .scrollbar-container.vertical .scrollbar { + width: 8px; + height: 20px; + background: black; + margin-left: 1px; +} +.scrollarea .scrollbar-container:hover { + background: gray; + opacity: .6 !important; +} +.scrollarea .scrollbar-container.active { + background: gray; + opacity: .6 !important; +} +.scrollarea:hover .scrollbar-container { + opacity: .3; +} diff --git a/dist/no-css.js b/dist/no-css.js new file mode 100644 index 0000000..62acd05 --- /dev/null +++ b/dist/no-css.js @@ -0,0 +1,3823 @@ +(function webpackUniversalModuleDefinition(root, factory) { + if(typeof exports === 'object' && typeof module === 'object') + module.exports = factory(require("react")); + else if(typeof define === 'function' && define.amd) + define(["react"], factory); + else if(typeof exports === 'object') + exports["ScrollArea"] = factory(require("react")); + else + root["ScrollArea"] = factory(root["React"]); +})(this, function(__WEBPACK_EXTERNAL_MODULE_2__) { +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); +/******/ }) +/************************************************************************/ +/******/ ([ +/* 0 */ +/***/ (function(module, exports, __webpack_require__) { + + 'use strict'; + + Object.defineProperty(exports, "__esModule", { + value: true + }); + + var _ScrollArea = __webpack_require__(1); + + var _ScrollArea2 = _interopRequireDefault(_ScrollArea); + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + + exports.default = _ScrollArea2.default; + +/***/ }), +/* 1 */ +/***/ (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 _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__(2); + + var _react2 = _interopRequireDefault(_react); + + var _propTypes = __webpack_require__(3); + + var _propTypes2 = _interopRequireDefault(_propTypes); + + var _lineHeight2 = __webpack_require__(10); + + var _lineHeight3 = _interopRequireDefault(_lineHeight2); + + var _reactMotion = __webpack_require__(12); + + var _utils = __webpack_require__(27); + + var _Scrollbar = __webpack_require__(28); + + var _Scrollbar2 = _interopRequireDefault(_Scrollbar); + + 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 eventTypes = { + wheel: 'wheel', + api: 'api', + touch: 'touch', + touchEnd: 'touchEnd', + mousemove: 'mousemove', + keyPress: 'keypress' + }; + + var ScrollArea = function (_React$Component) { + _inherits(ScrollArea, _React$Component); + + function ScrollArea(props) { + _classCallCheck(this, ScrollArea); + + var _this = _possibleConstructorReturn(this, (ScrollArea.__proto__ || Object.getPrototypeOf(ScrollArea)).call(this, props)); + + _this.state = { + topPosition: 0, + leftPosition: 0, + realHeight: 0, + containerHeight: 0, + realWidth: 0, + containerWidth: 0 + }; + + _this.scrollArea = { + refresh: function refresh() { + _this.setSizesToState(); + }, + scrollTop: function scrollTop() { + _this.scrollTop(); + }, + scrollBottom: function scrollBottom() { + _this.scrollBottom(); + }, + scrollYTo: function scrollYTo(position) { + _this.scrollYTo(position); + }, + scrollLeft: function scrollLeft() { + _this.scrollLeft(); + }, + scrollRight: function scrollRight() { + _this.scrollRight(); + }, + scrollXTo: function scrollXTo(position) { + _this.scrollXTo(position); + } + }; + + _this.evntsPreviousValues = { + clientX: 0, + clientY: 0, + deltaX: 0, + deltaY: 0 + }; + + _this.bindedHandleWindowResize = _this.handleWindowResize.bind(_this); + return _this; + } + + _createClass(ScrollArea, [{ + key: 'getChildContext', + value: function getChildContext() { + return { + scrollArea: this.scrollArea + }; + } + }, { + key: 'componentDidMount', + value: function componentDidMount() { + if (this.props.contentWindow) { + this.props.contentWindow.addEventListener("resize", this.bindedHandleWindowResize); + } + this.lineHeightPx = (0, _lineHeight3.default)((0, _utils.findDOMNode)(this.content)); + this.setSizesToState(); + } + }, { + key: 'componentWillUnmount', + value: function componentWillUnmount() { + if (this.props.contentWindow) { + this.props.contentWindow.removeEventListener("resize", this.bindedHandleWindowResize); + } + } + }, { + key: 'componentDidUpdate', + value: function componentDidUpdate() { + this.setSizesToState(); + } + }, { + key: 'render', + value: function render() { + var _this2 = this; + + var _props = this.props, + children = _props.children, + className = _props.className, + contentClassName = _props.contentClassName, + ownerDocument = _props.ownerDocument; + + var withMotion = this.props.smoothScrolling && (this.state.eventType === eventTypes.wheel || this.state.eventType === eventTypes.api || this.state.eventType === eventTypes.touchEnd || this.state.eventType === eventTypes.keyPress); + + var scrollbarY = this.canScrollY() ? _react2.default.createElement(_Scrollbar2.default, { + ownerDocument: ownerDocument, + realSize: this.state.realHeight, + containerSize: this.state.containerHeight, + position: this.state.topPosition, + onMove: this.handleScrollbarMove.bind(this), + onPositionChange: this.handleScrollbarYPositionChange.bind(this), + containerStyle: this.props.verticalContainerStyle, + scrollbarStyle: this.props.verticalScrollbarStyle, + smoothScrolling: withMotion, + minScrollSize: this.props.minScrollSize, + onFocus: this.focusContent.bind(this), + type: 'vertical' }) : null; + + var scrollbarX = this.canScrollX() ? _react2.default.createElement(_Scrollbar2.default, { + ownerDocument: ownerDocument, + realSize: this.state.realWidth, + containerSize: this.state.containerWidth, + position: this.state.leftPosition, + onMove: this.handleScrollbarMove.bind(this), + onPositionChange: this.handleScrollbarXPositionChange.bind(this), + containerStyle: this.props.horizontalContainerStyle, + scrollbarStyle: this.props.horizontalScrollbarStyle, + smoothScrolling: withMotion, + minScrollSize: this.props.minScrollSize, + onFocus: this.focusContent.bind(this), + type: 'horizontal' }) : null; + + if (typeof children === 'function') { + (0, _utils.warnAboutFunctionChild)(); + children = children(); + } else { + (0, _utils.warnAboutElementChild)(); + } + + var classes = 'scrollarea ' + (className || ''); + var contentClasses = 'scrollarea-content ' + (contentClassName || ''); + + var contentStyle = { + marginTop: -this.state.topPosition, + marginLeft: -this.state.leftPosition + }; + var springifiedContentStyle = withMotion ? (0, _utils.modifyObjValues)(contentStyle, function (x) { + return (0, _reactMotion.spring)(x); + }) : contentStyle; + + return _react2.default.createElement( + _reactMotion.Motion, + { style: springifiedContentStyle }, + function (style) { + return _react2.default.createElement( + 'div', + { + ref: function ref(x) { + return _this2.wrapper = x; + }, + className: classes, + style: _this2.props.style, + onWheel: _this2.handleWheel.bind(_this2) + }, + _react2.default.createElement( + 'div', + { + ref: function ref(x) { + return _this2.content = x; + }, + style: _extends({}, _this2.props.contentStyle, style), + className: contentClasses, + onTouchStart: _this2.handleTouchStart.bind(_this2), + onTouchMove: _this2.handleTouchMove.bind(_this2), + onTouchEnd: _this2.handleTouchEnd.bind(_this2), + onKeyDown: _this2.handleKeyDown.bind(_this2), + tabIndex: _this2.props.focusableTabIndex + }, + children + ), + scrollbarY, + scrollbarX + ); + } + ); + } + }, { + key: 'setStateFromEvent', + value: function setStateFromEvent(newState, eventType) { + if (this.props.onScroll) { + this.props.onScroll(newState); + } + this.setState(_extends({}, newState, { eventType: eventType })); + } + }, { + key: 'handleTouchStart', + value: function handleTouchStart(e) { + var touches = e.touches; + + if (touches.length === 1) { + var _touches$ = touches[0], + clientX = _touches$.clientX, + clientY = _touches$.clientY; + + this.eventPreviousValues = _extends({}, this.eventPreviousValues, { + clientY: clientY, + clientX: clientX, + timestamp: Date.now() + }); + } + } + }, { + key: 'handleTouchMove', + value: function handleTouchMove(e) { + if (this.canScroll()) { + e.preventDefault(); + e.stopPropagation(); + } + + var touches = e.touches; + + if (touches.length === 1) { + var _touches$2 = touches[0], + clientX = _touches$2.clientX, + clientY = _touches$2.clientY; + + + var deltaY = this.eventPreviousValues.clientY - clientY; + var deltaX = this.eventPreviousValues.clientX - clientX; + + this.eventPreviousValues = _extends({}, this.eventPreviousValues, { + deltaY: deltaY, + deltaX: deltaX, + clientY: clientY, + clientX: clientX, + timestamp: Date.now() + }); + + this.setStateFromEvent(this.composeNewState(-deltaX, -deltaY)); + } + } + }, { + key: 'handleTouchEnd', + value: function handleTouchEnd(e) { + var _eventPreviousValues = this.eventPreviousValues, + deltaX = _eventPreviousValues.deltaX, + deltaY = _eventPreviousValues.deltaY, + timestamp = _eventPreviousValues.timestamp; + + if (typeof deltaX === 'undefined') deltaX = 0; + if (typeof deltaY === 'undefined') deltaY = 0; + if (Date.now() - timestamp < 200) { + this.setStateFromEvent(this.composeNewState(-deltaX * 10, -deltaY * 10), eventTypes.touchEnd); + } + + this.eventPreviousValues = _extends({}, this.eventPreviousValues, { + deltaY: 0, + deltaX: 0 + }); + } + }, { + key: 'handleScrollbarMove', + value: function handleScrollbarMove(deltaY, deltaX) { + this.setStateFromEvent(this.composeNewState(deltaX, deltaY)); + } + }, { + key: 'handleScrollbarXPositionChange', + value: function handleScrollbarXPositionChange(position) { + this.scrollXTo(position); + } + }, { + key: 'handleScrollbarYPositionChange', + value: function handleScrollbarYPositionChange(position) { + this.scrollYTo(position); + } + }, { + key: 'handleWheel', + value: function handleWheel(e) { + var deltaY = e.deltaY; + var deltaX = e.deltaX; + + if (this.props.swapWheelAxes) { + var _ref = [deltaX, deltaY]; + deltaY = _ref[0]; + deltaX = _ref[1]; + } + + /* + * WheelEvent.deltaMode can differ between browsers and must be normalized + * e.deltaMode === 0: The delta values are specified in pixels + * e.deltaMode === 1: The delta values are specified in lines + * https://developer.mozilla.org/en-US/docs/Web/API/WheelEvent/deltaMode + */ + if (e.deltaMode === 1) { + deltaY = deltaY * this.lineHeightPx; + deltaX = deltaX * this.lineHeightPx; + } + + deltaY = deltaY * this.props.speed; + deltaX = deltaX * this.props.speed; + + var newState = this.composeNewState(-deltaX, -deltaY); + + if (newState.topPosition && this.state.topPosition !== newState.topPosition || newState.leftPosition && this.state.leftPosition !== newState.leftPosition || this.props.stopScrollPropagation) { + e.preventDefault(); + e.stopPropagation(); + } + + this.setStateFromEvent(newState, eventTypes.wheel); + this.focusContent(); + } + }, { + key: 'handleKeyDown', + value: function handleKeyDown(e) { + // only handle if scroll area is in focus + if (e.target.tagName.toLowerCase() !== 'input' && e.target.tagName.toLowerCase() !== 'textarea' && !e.target.isContentEditable) { + var deltaY = 0; + var deltaX = 0; + var _lineHeight = this.lineHeightPx ? this.lineHeightPx : 10; + + switch (e.keyCode) { + case 33: + // page up + deltaY = this.state.containerHeight - _lineHeight; + break; + case 34: + // page down + deltaY = -this.state.containerHeight + _lineHeight; + break; + case 37: + // left + deltaX = _lineHeight; + break; + case 38: + // up + deltaY = _lineHeight; + break; + case 39: + // right + deltaX = -_lineHeight; + break; + case 40: + // down + deltaY = -_lineHeight; + break; + } + + // only compose new state if key code matches those above + if (deltaY !== 0 || deltaX !== 0) { + var newState = this.composeNewState(deltaX, deltaY); + + e.preventDefault(); + e.stopPropagation(); + + this.setStateFromEvent(newState, eventTypes.keyPress); + } + } + } + }, { + key: 'handleWindowResize', + value: function handleWindowResize() { + var newState = this.computeSizes(); + newState = this.getModifiedPositionsIfNeeded(newState); + this.setStateFromEvent(newState); + } + }, { + key: 'composeNewState', + value: function composeNewState(deltaX, deltaY) { + var newState = this.computeSizes(); + + if (this.canScrollY(newState)) { + newState.topPosition = this.computeTopPosition(deltaY, newState); + } else { + newState.topPosition = 0; + } + if (this.canScrollX(newState)) { + newState.leftPosition = this.computeLeftPosition(deltaX, newState); + } + + return newState; + } + }, { + key: 'computeTopPosition', + value: function computeTopPosition(deltaY, sizes) { + var newTopPosition = this.state.topPosition - deltaY; + return this.normalizeTopPosition(newTopPosition, sizes); + } + }, { + key: 'computeLeftPosition', + value: function computeLeftPosition(deltaX, sizes) { + var newLeftPosition = this.state.leftPosition - deltaX; + return this.normalizeLeftPosition(newLeftPosition, sizes); + } + }, { + key: 'normalizeTopPosition', + value: function normalizeTopPosition(newTopPosition, sizes) { + if (newTopPosition > sizes.realHeight - sizes.containerHeight) { + newTopPosition = sizes.realHeight - sizes.containerHeight; + } + if (newTopPosition < 0) { + newTopPosition = 0; + } + return newTopPosition; + } + }, { + key: 'normalizeLeftPosition', + value: function normalizeLeftPosition(newLeftPosition, sizes) { + if (newLeftPosition > sizes.realWidth - sizes.containerWidth) { + newLeftPosition = sizes.realWidth - sizes.containerWidth; + } else if (newLeftPosition < 0) { + newLeftPosition = 0; + } + + return newLeftPosition; + } + }, { + key: 'computeSizes', + value: function computeSizes() { + var realHeight = this.content ? this.content.offsetHeight : 0; + var containerHeight = this.wrapper ? this.wrapper.offsetHeight : 0; + var realWidth = this.content ? this.content.offsetWidth : 0; + var containerWidth = this.content ? this.wrapper.offsetWidth : 0; + + return { + realHeight: realHeight, + containerHeight: containerHeight, + realWidth: realWidth, + containerWidth: containerWidth + }; + } + }, { + key: 'setSizesToState', + value: function setSizesToState() { + var sizes = this.computeSizes(); + if (sizes.realHeight !== this.state.realHeight || sizes.realWidth !== this.state.realWidth) { + this.setStateFromEvent(this.getModifiedPositionsIfNeeded(sizes)); + } + } + }, { + key: 'scrollTop', + value: function scrollTop() { + this.scrollYTo(0); + } + }, { + key: 'scrollBottom', + value: function scrollBottom() { + this.scrollYTo(this.state.realHeight - this.state.containerHeight); + } + }, { + key: 'scrollLeft', + value: function scrollLeft() { + this.scrollXTo(0); + } + }, { + key: 'scrollRight', + value: function scrollRight() { + this.scrollXTo(this.state.realWidth - this.state.containerWidth); + } + }, { + key: 'scrollYTo', + value: function scrollYTo(topPosition) { + if (this.canScrollY()) { + var position = this.normalizeTopPosition(topPosition, this.computeSizes()); + this.setStateFromEvent({ topPosition: position }, eventTypes.api); + } + } + }, { + key: 'scrollXTo', + value: function scrollXTo(leftPosition) { + if (this.canScrollX()) { + var position = this.normalizeLeftPosition(leftPosition, this.computeSizes()); + this.setStateFromEvent({ leftPosition: position }, eventTypes.api); + } + } + }, { + key: 'canScrollY', + value: function canScrollY() { + var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.state; + + var scrollableY = state.realHeight > state.containerHeight; + return scrollableY && this.props.vertical; + } + }, { + key: 'canScrollX', + value: function canScrollX() { + var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.state; + + var scrollableX = state.realWidth > state.containerWidth; + return scrollableX && this.props.horizontal; + } + }, { + key: 'canScroll', + value: function canScroll() { + var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.state; + + return this.canScrollY(state) || this.canScrollX(state); + } + }, { + key: 'getModifiedPositionsIfNeeded', + value: function getModifiedPositionsIfNeeded(newState) { + var bottomPosition = newState.realHeight - newState.containerHeight; + if (this.state.topPosition >= bottomPosition) { + newState.topPosition = this.canScrollY(newState) ? (0, _utils.positiveOrZero)(bottomPosition) : 0; + } + + var rightPosition = newState.realWidth - newState.containerWidth; + if (this.state.leftPosition >= rightPosition) { + newState.leftPosition = this.canScrollX(newState) ? (0, _utils.positiveOrZero)(rightPosition) : 0; + } + + return newState; + } + }, { + key: 'focusContent', + value: function focusContent() { + if (this.content) { + (0, _utils.findDOMNode)(this.content).focus(); + } + } + }]); + + return ScrollArea; + }(_react2.default.Component); + + exports.default = ScrollArea; + + + ScrollArea.childContextTypes = { + scrollArea: _propTypes2.default.object + }; + + ScrollArea.propTypes = { + className: _propTypes2.default.string, + style: _propTypes2.default.object, + speed: _propTypes2.default.number, + contentClassName: _propTypes2.default.string, + contentStyle: _propTypes2.default.object, + vertical: _propTypes2.default.bool, + verticalContainerStyle: _propTypes2.default.object, + verticalScrollbarStyle: _propTypes2.default.object, + horizontal: _propTypes2.default.bool, + horizontalContainerStyle: _propTypes2.default.object, + horizontalScrollbarStyle: _propTypes2.default.object, + onScroll: _propTypes2.default.func, + contentWindow: _propTypes2.default.any, + ownerDocument: _propTypes2.default.any, + smoothScrolling: _propTypes2.default.bool, + minScrollSize: _propTypes2.default.number, + swapWheelAxes: _propTypes2.default.bool, + stopScrollPropagation: _propTypes2.default.bool, + focusableTabIndex: _propTypes2.default.number + }; + + ScrollArea.defaultProps = { + speed: 1, + vertical: true, + horizontal: true, + smoothScrolling: false, + swapWheelAxes: false, + contentWindow: (typeof window === 'undefined' ? 'undefined' : _typeof(window)) === "object" ? window : undefined, + ownerDocument: (typeof document === 'undefined' ? 'undefined' : _typeof(document)) === "object" ? document : undefined, + focusableTabIndex: 1 + }; + +/***/ }), +/* 2 */ +/***/ (function(module, exports) { + + module.exports = __WEBPACK_EXTERNAL_MODULE_2__; + +/***/ }), +/* 3 */ +/***/ (function(module, exports, __webpack_require__) { + + /* WEBPACK VAR INJECTION */(function(process) {/** + * 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 (process.env.NODE_ENV !== 'production') { + 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__(5)(isValidElement, throwOnDirectAccess); + } else { + // By explicitly using `prop-types` you are opting into new production behavior. + // http://fb.me/prop-types-in-prod + module.exports = __webpack_require__(9)(); + } + + /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4))) + +/***/ }), +/* 4 */ +/***/ (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; }; + + +/***/ }), +/* 5 */ +/***/ (function(module, exports, __webpack_require__) { + + /* WEBPACK VAR INJECTION */(function(process) {/** + * 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__(6); + + var ReactPropTypesSecret = __webpack_require__(7); + var checkPropTypes = __webpack_require__(8); + + var printWarning = function() {}; + + if (process.env.NODE_ENV !== 'production') { + printWarning = function(text) { + var message = 'Warning: ' + text; + 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) {} + }; + } + + function emptyFunctionThatReturnsNull() { + return null; + } + + 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 = '<>'; + + // 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 (process.env.NODE_ENV !== 'production') { + 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 + var err = new Error( + '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' + ); + err.name = 'Invariant Violation'; + throw err; + } else if (process.env.NODE_ENV !== '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 + ) { + printWarning( + 'You are manually calling a React.PropTypes validation ' + + 'function for the `' + propFullName + '` prop on `' + componentName + '`. 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.' + ); + 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(emptyFunctionThatReturnsNull); + } + + 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)) { + process.env.NODE_ENV !== 'production' ? printWarning('Invalid argument supplied to oneOf, expected an instance of array.') : void 0; + return emptyFunctionThatReturnsNull; + } + + 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)) { + process.env.NODE_ENV !== 'production' ? printWarning('Invalid argument supplied to oneOfType, expected an instance of array.') : void 0; + return emptyFunctionThatReturnsNull; + } + + for (var i = 0; i < arrayOfTypeCheckers.length; i++) { + var checker = arrayOfTypeCheckers[i]; + if (typeof checker !== 'function') { + printWarning( + 'Invalid argument supplied to oneOfType. Expected an array of check functions, but ' + + 'received ' + getPostfixForTypeWarning(checker) + ' at index ' + i + '.' + ); + return emptyFunctionThatReturnsNull; + } + } + + 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; + }; + + /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4))) + +/***/ }), +/* 6 */ +/***/ (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; + }; + + +/***/ }), +/* 7 */ +/***/ (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; + + +/***/ }), +/* 8 */ +/***/ (function(module, exports, __webpack_require__) { + + /* WEBPACK VAR INJECTION */(function(process) {/** + * 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 printWarning = function() {}; + + if (process.env.NODE_ENV !== 'production') { + var ReactPropTypesSecret = __webpack_require__(7); + var loggedTypeFailures = {}; + + printWarning = function(text) { + var message = 'Warning: ' + text; + 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) {} + }; + } + + /** + * 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 (process.env.NODE_ENV !== 'production') { + 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. + if (typeof typeSpecs[typeSpecName] !== 'function') { + var err = Error( + (componentName || 'React class') + ': ' + location + ' type `' + typeSpecName + '` is invalid; ' + + 'it must be a function, usually from the `prop-types` package, but received `' + typeof typeSpecs[typeSpecName] + '`.' + ); + err.name = 'Invariant Violation'; + throw err; + } + error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret); + } catch (ex) { + error = ex; + } + if (error && !(error instanceof Error)) { + printWarning( + (componentName || 'React class') + ': type specification of ' + + location + ' `' + typeSpecName + '` is invalid; the type checker ' + + 'function must return `null` or an `Error` but returned a ' + typeof error + '. ' + + 'You may have forgotten to pass an argument to the type checker ' + + 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' + + 'shape all require an argument).' + ) + + } + 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() : ''; + + printWarning( + 'Failed ' + location + ' type: ' + error.message + (stack != null ? stack : '') + ); + } + } + } + } + } + + module.exports = checkPropTypes; + + /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4))) + +/***/ }), +/* 9 */ +/***/ (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 ReactPropTypesSecret = __webpack_require__(7); + + function emptyFunction() {} + + module.exports = function() { + function shim(props, propName, componentName, location, propFullName, secret) { + if (secret === ReactPropTypesSecret) { + // It is still safe when called from React. + return; + } + var err = new Error( + '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' + ); + err.name = 'Invariant Violation'; + throw err; + }; + shim.isRequired = shim; + function getShim() { + return shim; + }; + // Important! + // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`. + var ReactPropTypes = { + array: shim, + bool: shim, + func: shim, + number: shim, + object: shim, + string: shim, + symbol: shim, + + any: shim, + arrayOf: getShim, + element: shim, + instanceOf: getShim, + node: shim, + objectOf: getShim, + oneOf: getShim, + oneOfType: getShim, + shape: getShim, + exact: getShim + }; + + ReactPropTypes.checkPropTypes = emptyFunction; + ReactPropTypes.PropTypes = ReactPropTypes; + + return ReactPropTypes; + }; + + +/***/ }), +/* 10 */ +/***/ (function(module, exports, __webpack_require__) { + + // Load in dependencies + var computedStyle = __webpack_require__(11); + + /** + * Calculate the `line-height` of a given node + * @param {HTMLElement} node Element to calculate line height of. Must be in the DOM. + * @returns {Number} `line-height` of the element in pixels + */ + function lineHeight(node) { + // Grab the line-height via style + var lnHeightStr = computedStyle(node, 'line-height'), + lnHeight = parseFloat(lnHeightStr, 10); + + // If the lineHeight did not contain a unit (i.e. it was numeric), convert it to ems (e.g. '2.3' === '2.3em') + if (lnHeightStr === lnHeight + '') { + // Save the old lineHeight style and update the em unit to the element + var _lnHeightStyle = node.style.lineHeight; + node.style.lineHeight = lnHeightStr + 'em'; + + // Calculate the em based height + lnHeightStr = computedStyle(node, 'line-height'); + lnHeight = parseFloat(lnHeightStr, 10); + + // Revert the lineHeight style + if (_lnHeightStyle) { + node.style.lineHeight = _lnHeightStyle; + } else { + delete node.style.lineHeight; + } + } + + // If the lineHeight is in `pt`, convert it to pixels (4px for 3pt) + // DEV: `em` units are converted to `pt` in IE6 + // Conversion ratio from https://developer.mozilla.org/en-US/docs/Web/CSS/length + if (lnHeightStr.indexOf('pt') !== -1) { + lnHeight *= 4; + lnHeight /= 3; + } else if (lnHeightStr.indexOf('mm') !== -1) { + // Otherwise, if the lineHeight is in `mm`, convert it to pixels (96px for 25.4mm) + lnHeight *= 96; + lnHeight /= 25.4; + } else if (lnHeightStr.indexOf('cm') !== -1) { + // Otherwise, if the lineHeight is in `cm`, convert it to pixels (96px for 2.54cm) + lnHeight *= 96; + lnHeight /= 2.54; + } else if (lnHeightStr.indexOf('in') !== -1) { + // Otherwise, if the lineHeight is in `in`, convert it to pixels (96px for 1in) + lnHeight *= 96; + } else if (lnHeightStr.indexOf('pc') !== -1) { + // Otherwise, if the lineHeight is in `pc`, convert it to pixels (12pt for 1pc) + lnHeight *= 16; + } + + // Continue our computation + lnHeight = Math.round(lnHeight); + + // If the line-height is "normal", calculate by font-size + if (lnHeightStr === 'normal') { + // Create a temporary node + var nodeName = node.nodeName, + _node = document.createElement(nodeName); + _node.innerHTML = ' '; + + // Set the font-size of the element + var fontSizeStr = computedStyle(node, 'font-size'); + _node.style.fontSize = fontSizeStr; + + // Append it to the body + var body = document.body; + body.appendChild(_node); + + // Assume the line height of the element is the height + var height = _node.offsetHeight; + lnHeight = height; + + // Remove our child from the DOM + body.removeChild(_node); + } + + // Return the calculated height + return lnHeight; + } + + // Export lineHeight + module.exports = lineHeight; + +/***/ }), +/* 11 */ +/***/ (function(module, exports) { + + // This code has been refactored for 140 bytes + // You can see the original here: https://github.com/twolfson/computedStyle/blob/04cd1da2e30fa45844f95f5cb1ac898e9b9ef050/lib/computedStyle.js + var computedStyle = function (el, prop, getComputedStyle) { + getComputedStyle = window.getComputedStyle; + + // In one fell swoop + return ( + // 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 + )[ + // 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(); + }) + ]; + }; + + module.exports = computedStyle; + + +/***/ }), +/* 12 */ +/***/ (function(module, exports, __webpack_require__) { + + 'use strict'; + + exports.__esModule = true; + + function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; } + + var _Motion = __webpack_require__(13); + + exports.Motion = _interopRequire(_Motion); + + var _StaggeredMotion = __webpack_require__(21); + + exports.StaggeredMotion = _interopRequire(_StaggeredMotion); + + var _TransitionMotion = __webpack_require__(22); + + exports.TransitionMotion = _interopRequire(_TransitionMotion); + + var _spring = __webpack_require__(24); + + exports.spring = _interopRequire(_spring); + + var _presets = __webpack_require__(25); + + exports.presets = _interopRequire(_presets); + + var _stripStyle = __webpack_require__(15); + + exports.stripStyle = _interopRequire(_stripStyle); + + // deprecated, dummy warning function + + var _reorderKeys = __webpack_require__(26); + + exports.reorderKeys = _interopRequire(_reorderKeys); + +/***/ }), +/* 13 */ +/***/ (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 _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; }; })(); + + 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 _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 _mapToZero = __webpack_require__(14); + + var _mapToZero2 = _interopRequireDefault(_mapToZero); + + var _stripStyle = __webpack_require__(15); + + var _stripStyle2 = _interopRequireDefault(_stripStyle); + + var _stepper3 = __webpack_require__(16); + + var _stepper4 = _interopRequireDefault(_stepper3); + + var _performanceNow = __webpack_require__(17); + + var _performanceNow2 = _interopRequireDefault(_performanceNow); + + var _raf = __webpack_require__(18); + + var _raf2 = _interopRequireDefault(_raf); + + var _shouldStopAnimation = __webpack_require__(20); + + var _shouldStopAnimation2 = _interopRequireDefault(_shouldStopAnimation); + + var _react = __webpack_require__(2); + + var _react2 = _interopRequireDefault(_react); + + var _propTypes = __webpack_require__(3); + + var _propTypes2 = _interopRequireDefault(_propTypes); + + var msPerFrame = 1000 / 60; + + var Motion = (function (_React$Component) { + _inherits(Motion, _React$Component); + + _createClass(Motion, null, [{ + key: 'propTypes', + value: { + // TOOD: warn against putting a config in here + defaultStyle: _propTypes2['default'].objectOf(_propTypes2['default'].number), + style: _propTypes2['default'].objectOf(_propTypes2['default'].oneOfType([_propTypes2['default'].number, _propTypes2['default'].object])).isRequired, + children: _propTypes2['default'].func.isRequired, + onRest: _propTypes2['default'].func + }, + enumerable: true + }]); + + function Motion(props) { + var _this = this; + + _classCallCheck(this, Motion); + + _React$Component.call(this, props); + this.wasAnimating = false; + this.animationID = null; + this.prevTime = 0; + this.accumulatedTime = 0; + this.unreadPropStyle = null; + + this.clearUnreadPropStyle = function (destStyle) { + var dirty = false; + var _state = _this.state; + var currentStyle = _state.currentStyle; + var currentVelocity = _state.currentVelocity; + var lastIdealStyle = _state.lastIdealStyle; + var lastIdealVelocity = _state.lastIdealVelocity; + + for (var key in destStyle) { + if (!Object.prototype.hasOwnProperty.call(destStyle, key)) { + continue; + } + + var styleValue = destStyle[key]; + if (typeof styleValue === 'number') { + if (!dirty) { + dirty = true; + currentStyle = _extends({}, currentStyle); + currentVelocity = _extends({}, currentVelocity); + lastIdealStyle = _extends({}, lastIdealStyle); + lastIdealVelocity = _extends({}, lastIdealVelocity); + } + + currentStyle[key] = styleValue; + currentVelocity[key] = 0; + lastIdealStyle[key] = styleValue; + lastIdealVelocity[key] = 0; + } + } + + if (dirty) { + _this.setState({ currentStyle: currentStyle, currentVelocity: currentVelocity, lastIdealStyle: lastIdealStyle, lastIdealVelocity: lastIdealVelocity }); + } + }; + + this.startAnimationIfNecessary = function () { + // TODO: when config is {a: 10} and dest is {a: 10} do we raf once and + // call cb? No, otherwise accidental parent rerender causes cb trigger + _this.animationID = _raf2['default'](function (timestamp) { + // check if we need to animate in the first place + var propsStyle = _this.props.style; + if (_shouldStopAnimation2['default'](_this.state.currentStyle, propsStyle, _this.state.currentVelocity)) { + if (_this.wasAnimating && _this.props.onRest) { + _this.props.onRest(); + } + + // no need to cancel animationID here; shouldn't have any in flight + _this.animationID = null; + _this.wasAnimating = false; + _this.accumulatedTime = 0; + return; + } + + _this.wasAnimating = true; + + var currentTime = timestamp || _performanceNow2['default'](); + var timeDelta = currentTime - _this.prevTime; + _this.prevTime = currentTime; + _this.accumulatedTime = _this.accumulatedTime + timeDelta; + // more than 10 frames? prolly switched browser tab. Restart + if (_this.accumulatedTime > msPerFrame * 10) { + _this.accumulatedTime = 0; + } + + if (_this.accumulatedTime === 0) { + // no need to cancel animationID here; shouldn't have any in flight + _this.animationID = null; + _this.startAnimationIfNecessary(); + return; + } + + var currentFrameCompletion = (_this.accumulatedTime - Math.floor(_this.accumulatedTime / msPerFrame) * msPerFrame) / msPerFrame; + var framesToCatchUp = Math.floor(_this.accumulatedTime / msPerFrame); + + var newLastIdealStyle = {}; + var newLastIdealVelocity = {}; + var newCurrentStyle = {}; + var newCurrentVelocity = {}; + + for (var key in propsStyle) { + if (!Object.prototype.hasOwnProperty.call(propsStyle, key)) { + continue; + } + + var styleValue = propsStyle[key]; + if (typeof styleValue === 'number') { + newCurrentStyle[key] = styleValue; + newCurrentVelocity[key] = 0; + newLastIdealStyle[key] = styleValue; + newLastIdealVelocity[key] = 0; + } else { + var newLastIdealStyleValue = _this.state.lastIdealStyle[key]; + var newLastIdealVelocityValue = _this.state.lastIdealVelocity[key]; + for (var i = 0; i < framesToCatchUp; i++) { + var _stepper = _stepper4['default'](msPerFrame / 1000, newLastIdealStyleValue, newLastIdealVelocityValue, styleValue.val, styleValue.stiffness, styleValue.damping, styleValue.precision); + + newLastIdealStyleValue = _stepper[0]; + newLastIdealVelocityValue = _stepper[1]; + } + + var _stepper2 = _stepper4['default'](msPerFrame / 1000, newLastIdealStyleValue, newLastIdealVelocityValue, styleValue.val, styleValue.stiffness, styleValue.damping, styleValue.precision); + + var nextIdealX = _stepper2[0]; + var nextIdealV = _stepper2[1]; + + newCurrentStyle[key] = newLastIdealStyleValue + (nextIdealX - newLastIdealStyleValue) * currentFrameCompletion; + newCurrentVelocity[key] = newLastIdealVelocityValue + (nextIdealV - newLastIdealVelocityValue) * currentFrameCompletion; + newLastIdealStyle[key] = newLastIdealStyleValue; + newLastIdealVelocity[key] = newLastIdealVelocityValue; + } + } + + _this.animationID = null; + // the amount we're looped over above + _this.accumulatedTime -= framesToCatchUp * msPerFrame; + + _this.setState({ + currentStyle: newCurrentStyle, + currentVelocity: newCurrentVelocity, + lastIdealStyle: newLastIdealStyle, + lastIdealVelocity: newLastIdealVelocity + }); + + _this.unreadPropStyle = null; + + _this.startAnimationIfNecessary(); + }); + }; + + this.state = this.defaultState(); + } + + Motion.prototype.defaultState = function defaultState() { + var _props = this.props; + var defaultStyle = _props.defaultStyle; + var style = _props.style; + + var currentStyle = defaultStyle || _stripStyle2['default'](style); + var currentVelocity = _mapToZero2['default'](currentStyle); + return { + currentStyle: currentStyle, + currentVelocity: currentVelocity, + lastIdealStyle: currentStyle, + lastIdealVelocity: currentVelocity + }; + }; + + // it's possible that currentStyle's value is stale: if props is immediately + // changed from 0 to 400 to spring(0) again, the async currentStyle is still + // at 0 (didn't have time to tick and interpolate even once). If we naively + // compare currentStyle with destVal it'll be 0 === 0 (no animation, stop). + // In reality currentStyle should be 400 + + Motion.prototype.componentDidMount = function componentDidMount() { + this.prevTime = _performanceNow2['default'](); + this.startAnimationIfNecessary(); + }; + + Motion.prototype.componentWillReceiveProps = function componentWillReceiveProps(props) { + if (this.unreadPropStyle != null) { + // previous props haven't had the chance to be set yet; set them here + this.clearUnreadPropStyle(this.unreadPropStyle); + } + + this.unreadPropStyle = props.style; + if (this.animationID == null) { + this.prevTime = _performanceNow2['default'](); + this.startAnimationIfNecessary(); + } + }; + + Motion.prototype.componentWillUnmount = function componentWillUnmount() { + if (this.animationID != null) { + _raf2['default'].cancel(this.animationID); + this.animationID = null; + } + }; + + Motion.prototype.render = function render() { + var renderedChildren = this.props.children(this.state.currentStyle); + return renderedChildren && _react2['default'].Children.only(renderedChildren); + }; + + return Motion; + })(_react2['default'].Component); + + exports['default'] = Motion; + module.exports = exports['default']; + + // after checking for unreadPropStyle != null, we manually go set the + // non-interpolating values (those that are a number, without a spring + // config) + +/***/ }), +/* 14 */ +/***/ (function(module, exports) { + + + + // currently used to initiate the velocity style object to 0 + 'use strict'; + + exports.__esModule = true; + exports['default'] = mapToZero; + + function mapToZero(obj) { + var ret = {}; + for (var key in obj) { + if (Object.prototype.hasOwnProperty.call(obj, key)) { + ret[key] = 0; + } + } + return ret; + } + + module.exports = exports['default']; + +/***/ }), +/* 15 */ +/***/ (function(module, exports) { + + + // turn {x: {val: 1, stiffness: 1, damping: 2}, y: 2} generated by + // `{x: spring(1, {stiffness: 1, damping: 2}), y: 2}` into {x: 1, y: 2} + + 'use strict'; + + exports.__esModule = true; + exports['default'] = stripStyle; + + function stripStyle(style) { + var ret = {}; + for (var key in style) { + if (!Object.prototype.hasOwnProperty.call(style, key)) { + continue; + } + ret[key] = typeof style[key] === 'number' ? style[key] : style[key].val; + } + return ret; + } + + module.exports = exports['default']; + +/***/ }), +/* 16 */ +/***/ (function(module, exports) { + + + + // stepper is used a lot. Saves allocation to return the same array wrapper. + // This is fine and danger-free against mutations because the callsite + // immediately destructures it and gets the numbers inside without passing the + "use strict"; + + exports.__esModule = true; + exports["default"] = stepper; + + var reusedTuple = [0, 0]; + + function stepper(secondPerFrame, x, v, destX, k, b, precision) { + // Spring stiffness, in kg / s^2 + + // for animations, destX is really spring length (spring at rest). initial + // position is considered as the stretched/compressed position of a spring + var Fspring = -k * (x - destX); + + // Damping, in kg / s + var Fdamper = -b * v; + + // usually we put mass here, but for animation purposes, specifying mass is a + // bit redundant. you could simply adjust k and b accordingly + // let a = (Fspring + Fdamper) / mass; + var a = Fspring + Fdamper; + + var newV = v + a * secondPerFrame; + var newX = x + newV * secondPerFrame; + + if (Math.abs(newV) < precision && Math.abs(newX - destX) < precision) { + reusedTuple[0] = destX; + reusedTuple[1] = 0; + return reusedTuple; + } + + reusedTuple[0] = newX; + reusedTuple[1] = newV; + return reusedTuple; + } + + module.exports = exports["default"]; + // array reference around. + +/***/ }), +/* 17 */ +/***/ (function(module, exports, __webpack_require__) { + + /* WEBPACK VAR INJECTION */(function(process) {// Generated by CoffeeScript 1.7.1 + (function() { + var getNanoSeconds, hrtime, loadTime; + + if ((typeof performance !== "undefined" && performance !== null) && performance.now) { + module.exports = function() { + return performance.now(); + }; + } else if ((typeof process !== "undefined" && process !== null) && process.hrtime) { + module.exports = function() { + return (getNanoSeconds() - loadTime) / 1e6; + }; + hrtime = process.hrtime; + getNanoSeconds = function() { + var hr; + hr = hrtime(); + return hr[0] * 1e9 + hr[1]; + }; + loadTime = getNanoSeconds(); + } else if (Date.now) { + module.exports = function() { + return Date.now() - loadTime; + }; + loadTime = Date.now(); + } else { + module.exports = function() { + return new Date().getTime() - loadTime; + }; + loadTime = new Date().getTime(); + } + + }).call(this); + + /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4))) + +/***/ }), +/* 18 */ +/***/ (function(module, exports, __webpack_require__) { + + /* WEBPACK VAR INJECTION */(function(global) {var now = __webpack_require__(19) + , root = typeof window === 'undefined' ? global : window + , vendors = ['moz', 'webkit'] + , suffix = 'AnimationFrame' + , raf = root['request' + suffix] + , caf = root['cancel' + suffix] || root['cancelRequest' + suffix] + + for(var i = 0; !raf && i < vendors.length; i++) { + raf = root[vendors[i] + 'Request' + suffix] + caf = root[vendors[i] + 'Cancel' + suffix] + || root[vendors[i] + 'CancelRequest' + suffix] + } + + // Some versions of FF have rAF but not cAF + if(!raf || !caf) { + var last = 0 + , id = 0 + , queue = [] + , frameDuration = 1000 / 60 + + raf = function(callback) { + if(queue.length === 0) { + var _now = now() + , next = Math.max(0, frameDuration - (_now - last)) + last = next + _now + setTimeout(function() { + var cp = queue.slice(0) + // Clear queue here to prevent + // callbacks from appending listeners + // to the current frame's queue + queue.length = 0 + for(var i = 0; i < cp.length; i++) { + if(!cp[i].cancelled) { + try{ + cp[i].callback(last) + } catch(e) { + setTimeout(function() { throw e }, 0) + } + } + } + }, Math.round(next)) + } + queue.push({ + handle: ++id, + callback: callback, + cancelled: false + }) + return id + } + + caf = function(handle) { + for(var i = 0; i < queue.length; i++) { + if(queue[i].handle === handle) { + queue[i].cancelled = true + } + } + } + } + + module.exports = function(fn) { + // Wrap in a new function to prevent + // `cancel` potentially being assigned + // to the native rAF function + return raf.call(root, fn) + } + module.exports.cancel = function() { + caf.apply(root, arguments) + } + module.exports.polyfill = function(object) { + if (!object) { + object = root; + } + object.requestAnimationFrame = raf + object.cancelAnimationFrame = caf + } + + /* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()))) + +/***/ }), +/* 19 */ +/***/ (function(module, exports, __webpack_require__) { + + /* WEBPACK VAR INJECTION */(function(process) {// Generated by CoffeeScript 1.12.2 + (function() { + var getNanoSeconds, hrtime, loadTime, moduleLoadTime, nodeLoadTime, upTime; + + if ((typeof performance !== "undefined" && performance !== null) && performance.now) { + module.exports = function() { + return performance.now(); + }; + } else if ((typeof process !== "undefined" && process !== null) && process.hrtime) { + module.exports = function() { + return (getNanoSeconds() - nodeLoadTime) / 1e6; + }; + hrtime = process.hrtime; + getNanoSeconds = function() { + var hr; + hr = hrtime(); + return hr[0] * 1e9 + hr[1]; + }; + moduleLoadTime = getNanoSeconds(); + upTime = process.uptime() * 1e9; + nodeLoadTime = moduleLoadTime - upTime; + } else if (Date.now) { + module.exports = function() { + return Date.now() - loadTime; + }; + loadTime = Date.now(); + } else { + module.exports = function() { + return new Date().getTime() - loadTime; + }; + loadTime = new Date().getTime(); + } + + }).call(this); + + //# sourceMappingURL=performance-now.js.map + + /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4))) + +/***/ }), +/* 20 */ +/***/ (function(module, exports) { + + + + // usage assumption: currentStyle values have already been rendered but it says + // nothing of whether currentStyle is stale (see unreadPropStyle) + 'use strict'; + + exports.__esModule = true; + exports['default'] = shouldStopAnimation; + + function shouldStopAnimation(currentStyle, style, currentVelocity) { + for (var key in style) { + if (!Object.prototype.hasOwnProperty.call(style, key)) { + continue; + } + + if (currentVelocity[key] !== 0) { + return false; + } + + var styleValue = typeof style[key] === 'number' ? style[key] : style[key].val; + // stepper will have already taken care of rounding precision errors, so + // won't have such thing as 0.9999 !=== 1 + if (currentStyle[key] !== styleValue) { + return false; + } + } + + return true; + } + + module.exports = exports['default']; + +/***/ }), +/* 21 */ +/***/ (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 _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; }; })(); + + 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 _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 _mapToZero = __webpack_require__(14); + + var _mapToZero2 = _interopRequireDefault(_mapToZero); + + var _stripStyle = __webpack_require__(15); + + var _stripStyle2 = _interopRequireDefault(_stripStyle); + + var _stepper3 = __webpack_require__(16); + + var _stepper4 = _interopRequireDefault(_stepper3); + + var _performanceNow = __webpack_require__(17); + + var _performanceNow2 = _interopRequireDefault(_performanceNow); + + var _raf = __webpack_require__(18); + + var _raf2 = _interopRequireDefault(_raf); + + var _shouldStopAnimation = __webpack_require__(20); + + var _shouldStopAnimation2 = _interopRequireDefault(_shouldStopAnimation); + + var _react = __webpack_require__(2); + + var _react2 = _interopRequireDefault(_react); + + var _propTypes = __webpack_require__(3); + + var _propTypes2 = _interopRequireDefault(_propTypes); + + var msPerFrame = 1000 / 60; + + function shouldStopAnimationAll(currentStyles, styles, currentVelocities) { + for (var i = 0; i < currentStyles.length; i++) { + if (!_shouldStopAnimation2['default'](currentStyles[i], styles[i], currentVelocities[i])) { + return false; + } + } + return true; + } + + var StaggeredMotion = (function (_React$Component) { + _inherits(StaggeredMotion, _React$Component); + + _createClass(StaggeredMotion, null, [{ + key: 'propTypes', + value: { + // TOOD: warn against putting a config in here + defaultStyles: _propTypes2['default'].arrayOf(_propTypes2['default'].objectOf(_propTypes2['default'].number)), + styles: _propTypes2['default'].func.isRequired, + children: _propTypes2['default'].func.isRequired + }, + enumerable: true + }]); + + function StaggeredMotion(props) { + var _this = this; + + _classCallCheck(this, StaggeredMotion); + + _React$Component.call(this, props); + this.animationID = null; + this.prevTime = 0; + this.accumulatedTime = 0; + this.unreadPropStyles = null; + + this.clearUnreadPropStyle = function (unreadPropStyles) { + var _state = _this.state; + var currentStyles = _state.currentStyles; + var currentVelocities = _state.currentVelocities; + var lastIdealStyles = _state.lastIdealStyles; + var lastIdealVelocities = _state.lastIdealVelocities; + + var someDirty = false; + for (var i = 0; i < unreadPropStyles.length; i++) { + var unreadPropStyle = unreadPropStyles[i]; + var dirty = false; + + for (var key in unreadPropStyle) { + if (!Object.prototype.hasOwnProperty.call(unreadPropStyle, key)) { + continue; + } + + var styleValue = unreadPropStyle[key]; + if (typeof styleValue === 'number') { + if (!dirty) { + dirty = true; + someDirty = true; + currentStyles[i] = _extends({}, currentStyles[i]); + currentVelocities[i] = _extends({}, currentVelocities[i]); + lastIdealStyles[i] = _extends({}, lastIdealStyles[i]); + lastIdealVelocities[i] = _extends({}, lastIdealVelocities[i]); + } + currentStyles[i][key] = styleValue; + currentVelocities[i][key] = 0; + lastIdealStyles[i][key] = styleValue; + lastIdealVelocities[i][key] = 0; + } + } + } + + if (someDirty) { + _this.setState({ currentStyles: currentStyles, currentVelocities: currentVelocities, lastIdealStyles: lastIdealStyles, lastIdealVelocities: lastIdealVelocities }); + } + }; + + this.startAnimationIfNecessary = function () { + // TODO: when config is {a: 10} and dest is {a: 10} do we raf once and + // call cb? No, otherwise accidental parent rerender causes cb trigger + _this.animationID = _raf2['default'](function (timestamp) { + var destStyles = _this.props.styles(_this.state.lastIdealStyles); + + // check if we need to animate in the first place + if (shouldStopAnimationAll(_this.state.currentStyles, destStyles, _this.state.currentVelocities)) { + // no need to cancel animationID here; shouldn't have any in flight + _this.animationID = null; + _this.accumulatedTime = 0; + return; + } + + var currentTime = timestamp || _performanceNow2['default'](); + var timeDelta = currentTime - _this.prevTime; + _this.prevTime = currentTime; + _this.accumulatedTime = _this.accumulatedTime + timeDelta; + // more than 10 frames? prolly switched browser tab. Restart + if (_this.accumulatedTime > msPerFrame * 10) { + _this.accumulatedTime = 0; + } + + if (_this.accumulatedTime === 0) { + // no need to cancel animationID here; shouldn't have any in flight + _this.animationID = null; + _this.startAnimationIfNecessary(); + return; + } + + var currentFrameCompletion = (_this.accumulatedTime - Math.floor(_this.accumulatedTime / msPerFrame) * msPerFrame) / msPerFrame; + var framesToCatchUp = Math.floor(_this.accumulatedTime / msPerFrame); + + var newLastIdealStyles = []; + var newLastIdealVelocities = []; + var newCurrentStyles = []; + var newCurrentVelocities = []; + + for (var i = 0; i < destStyles.length; i++) { + var destStyle = destStyles[i]; + var newCurrentStyle = {}; + var newCurrentVelocity = {}; + var newLastIdealStyle = {}; + var newLastIdealVelocity = {}; + + for (var key in destStyle) { + if (!Object.prototype.hasOwnProperty.call(destStyle, key)) { + continue; + } + + var styleValue = destStyle[key]; + if (typeof styleValue === 'number') { + newCurrentStyle[key] = styleValue; + newCurrentVelocity[key] = 0; + newLastIdealStyle[key] = styleValue; + newLastIdealVelocity[key] = 0; + } else { + var newLastIdealStyleValue = _this.state.lastIdealStyles[i][key]; + var newLastIdealVelocityValue = _this.state.lastIdealVelocities[i][key]; + for (var j = 0; j < framesToCatchUp; j++) { + var _stepper = _stepper4['default'](msPerFrame / 1000, newLastIdealStyleValue, newLastIdealVelocityValue, styleValue.val, styleValue.stiffness, styleValue.damping, styleValue.precision); + + newLastIdealStyleValue = _stepper[0]; + newLastIdealVelocityValue = _stepper[1]; + } + + var _stepper2 = _stepper4['default'](msPerFrame / 1000, newLastIdealStyleValue, newLastIdealVelocityValue, styleValue.val, styleValue.stiffness, styleValue.damping, styleValue.precision); + + var nextIdealX = _stepper2[0]; + var nextIdealV = _stepper2[1]; + + newCurrentStyle[key] = newLastIdealStyleValue + (nextIdealX - newLastIdealStyleValue) * currentFrameCompletion; + newCurrentVelocity[key] = newLastIdealVelocityValue + (nextIdealV - newLastIdealVelocityValue) * currentFrameCompletion; + newLastIdealStyle[key] = newLastIdealStyleValue; + newLastIdealVelocity[key] = newLastIdealVelocityValue; + } + } + + newCurrentStyles[i] = newCurrentStyle; + newCurrentVelocities[i] = newCurrentVelocity; + newLastIdealStyles[i] = newLastIdealStyle; + newLastIdealVelocities[i] = newLastIdealVelocity; + } + + _this.animationID = null; + // the amount we're looped over above + _this.accumulatedTime -= framesToCatchUp * msPerFrame; + + _this.setState({ + currentStyles: newCurrentStyles, + currentVelocities: newCurrentVelocities, + lastIdealStyles: newLastIdealStyles, + lastIdealVelocities: newLastIdealVelocities + }); + + _this.unreadPropStyles = null; + + _this.startAnimationIfNecessary(); + }); + }; + + this.state = this.defaultState(); + } + + StaggeredMotion.prototype.defaultState = function defaultState() { + var _props = this.props; + var defaultStyles = _props.defaultStyles; + var styles = _props.styles; + + var currentStyles = defaultStyles || styles().map(_stripStyle2['default']); + var currentVelocities = currentStyles.map(function (currentStyle) { + return _mapToZero2['default'](currentStyle); + }); + return { + currentStyles: currentStyles, + currentVelocities: currentVelocities, + lastIdealStyles: currentStyles, + lastIdealVelocities: currentVelocities + }; + }; + + StaggeredMotion.prototype.componentDidMount = function componentDidMount() { + this.prevTime = _performanceNow2['default'](); + this.startAnimationIfNecessary(); + }; + + StaggeredMotion.prototype.componentWillReceiveProps = function componentWillReceiveProps(props) { + if (this.unreadPropStyles != null) { + // previous props haven't had the chance to be set yet; set them here + this.clearUnreadPropStyle(this.unreadPropStyles); + } + + this.unreadPropStyles = props.styles(this.state.lastIdealStyles); + if (this.animationID == null) { + this.prevTime = _performanceNow2['default'](); + this.startAnimationIfNecessary(); + } + }; + + StaggeredMotion.prototype.componentWillUnmount = function componentWillUnmount() { + if (this.animationID != null) { + _raf2['default'].cancel(this.animationID); + this.animationID = null; + } + }; + + StaggeredMotion.prototype.render = function render() { + var renderedChildren = this.props.children(this.state.currentStyles); + return renderedChildren && _react2['default'].Children.only(renderedChildren); + }; + + return StaggeredMotion; + })(_react2['default'].Component); + + exports['default'] = StaggeredMotion; + module.exports = exports['default']; + + // it's possible that currentStyle's value is stale: if props is immediately + // changed from 0 to 400 to spring(0) again, the async currentStyle is still + // at 0 (didn't have time to tick and interpolate even once). If we naively + // compare currentStyle with destVal it'll be 0 === 0 (no animation, stop). + // In reality currentStyle should be 400 + + // after checking for unreadPropStyles != null, we manually go set the + // non-interpolating values (those that are a number, without a spring + // config) + +/***/ }), +/* 22 */ +/***/ (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 _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; }; })(); + + 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 _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 _mapToZero = __webpack_require__(14); + + var _mapToZero2 = _interopRequireDefault(_mapToZero); + + var _stripStyle = __webpack_require__(15); + + var _stripStyle2 = _interopRequireDefault(_stripStyle); + + var _stepper3 = __webpack_require__(16); + + var _stepper4 = _interopRequireDefault(_stepper3); + + var _mergeDiff = __webpack_require__(23); + + var _mergeDiff2 = _interopRequireDefault(_mergeDiff); + + var _performanceNow = __webpack_require__(17); + + var _performanceNow2 = _interopRequireDefault(_performanceNow); + + var _raf = __webpack_require__(18); + + var _raf2 = _interopRequireDefault(_raf); + + var _shouldStopAnimation = __webpack_require__(20); + + var _shouldStopAnimation2 = _interopRequireDefault(_shouldStopAnimation); + + var _react = __webpack_require__(2); + + var _react2 = _interopRequireDefault(_react); + + var _propTypes = __webpack_require__(3); + + var _propTypes2 = _interopRequireDefault(_propTypes); + + var msPerFrame = 1000 / 60; + + // the children function & (potential) styles function asks as param an + // Array, where each TransitionPlainStyle is of the format + // {key: string, data?: any, style: PlainStyle}. However, the way we keep + // internal states doesn't contain such a data structure (check the state and + // TransitionMotionState). So when children function and others ask for such + // data we need to generate them on the fly by combining mergedPropsStyles and + // currentStyles/lastIdealStyles + function rehydrateStyles(mergedPropsStyles, unreadPropStyles, plainStyles) { + // Copy the value to a `const` so that Flow understands that the const won't + // change and will be non-nullable in the callback below. + var cUnreadPropStyles = unreadPropStyles; + if (cUnreadPropStyles == null) { + return mergedPropsStyles.map(function (mergedPropsStyle, i) { + return { + key: mergedPropsStyle.key, + data: mergedPropsStyle.data, + style: plainStyles[i] + }; + }); + } + return mergedPropsStyles.map(function (mergedPropsStyle, i) { + for (var j = 0; j < cUnreadPropStyles.length; j++) { + if (cUnreadPropStyles[j].key === mergedPropsStyle.key) { + return { + key: cUnreadPropStyles[j].key, + data: cUnreadPropStyles[j].data, + style: plainStyles[i] + }; + } + } + return { key: mergedPropsStyle.key, data: mergedPropsStyle.data, style: plainStyles[i] }; + }); + } + + function shouldStopAnimationAll(currentStyles, destStyles, currentVelocities, mergedPropsStyles) { + if (mergedPropsStyles.length !== destStyles.length) { + return false; + } + + for (var i = 0; i < mergedPropsStyles.length; i++) { + if (mergedPropsStyles[i].key !== destStyles[i].key) { + return false; + } + } + + // we have the invariant that mergedPropsStyles and + // currentStyles/currentVelocities/last* are synced in terms of cells, see + // mergeAndSync comment for more info + for (var i = 0; i < mergedPropsStyles.length; i++) { + if (!_shouldStopAnimation2['default'](currentStyles[i], destStyles[i].style, currentVelocities[i])) { + return false; + } + } + + return true; + } + + // core key merging logic + + // things to do: say previously merged style is {a, b}, dest style (prop) is {b, + // c}, previous current (interpolating) style is {a, b} + // **invariant**: current[i] corresponds to merged[i] in terms of key + + // steps: + // turn merged style into {a?, b, c} + // add c, value of c is destStyles.c + // maybe remove a, aka call willLeave(a), then merged is either {b, c} or {a, b, c} + // turn current (interpolating) style from {a, b} into {a?, b, c} + // maybe remove a + // certainly add c, value of c is willEnter(c) + // loop over merged and construct new current + // dest doesn't change, that's owner's + function mergeAndSync(willEnter, willLeave, didLeave, oldMergedPropsStyles, destStyles, oldCurrentStyles, oldCurrentVelocities, oldLastIdealStyles, oldLastIdealVelocities) { + var newMergedPropsStyles = _mergeDiff2['default'](oldMergedPropsStyles, destStyles, function (oldIndex, oldMergedPropsStyle) { + var leavingStyle = willLeave(oldMergedPropsStyle); + if (leavingStyle == null) { + didLeave({ key: oldMergedPropsStyle.key, data: oldMergedPropsStyle.data }); + return null; + } + if (_shouldStopAnimation2['default'](oldCurrentStyles[oldIndex], leavingStyle, oldCurrentVelocities[oldIndex])) { + didLeave({ key: oldMergedPropsStyle.key, data: oldMergedPropsStyle.data }); + return null; + } + return { key: oldMergedPropsStyle.key, data: oldMergedPropsStyle.data, style: leavingStyle }; + }); + + var newCurrentStyles = []; + var newCurrentVelocities = []; + var newLastIdealStyles = []; + var newLastIdealVelocities = []; + for (var i = 0; i < newMergedPropsStyles.length; i++) { + var newMergedPropsStyleCell = newMergedPropsStyles[i]; + var foundOldIndex = null; + for (var j = 0; j < oldMergedPropsStyles.length; j++) { + if (oldMergedPropsStyles[j].key === newMergedPropsStyleCell.key) { + foundOldIndex = j; + break; + } + } + // TODO: key search code + if (foundOldIndex == null) { + var plainStyle = willEnter(newMergedPropsStyleCell); + newCurrentStyles[i] = plainStyle; + newLastIdealStyles[i] = plainStyle; + + var velocity = _mapToZero2['default'](newMergedPropsStyleCell.style); + newCurrentVelocities[i] = velocity; + newLastIdealVelocities[i] = velocity; + } else { + newCurrentStyles[i] = oldCurrentStyles[foundOldIndex]; + newLastIdealStyles[i] = oldLastIdealStyles[foundOldIndex]; + newCurrentVelocities[i] = oldCurrentVelocities[foundOldIndex]; + newLastIdealVelocities[i] = oldLastIdealVelocities[foundOldIndex]; + } + } + + return [newMergedPropsStyles, newCurrentStyles, newCurrentVelocities, newLastIdealStyles, newLastIdealVelocities]; + } + + var TransitionMotion = (function (_React$Component) { + _inherits(TransitionMotion, _React$Component); + + _createClass(TransitionMotion, null, [{ + key: 'propTypes', + value: { + defaultStyles: _propTypes2['default'].arrayOf(_propTypes2['default'].shape({ + key: _propTypes2['default'].string.isRequired, + data: _propTypes2['default'].any, + style: _propTypes2['default'].objectOf(_propTypes2['default'].number).isRequired + })), + styles: _propTypes2['default'].oneOfType([_propTypes2['default'].func, _propTypes2['default'].arrayOf(_propTypes2['default'].shape({ + key: _propTypes2['default'].string.isRequired, + data: _propTypes2['default'].any, + style: _propTypes2['default'].objectOf(_propTypes2['default'].oneOfType([_propTypes2['default'].number, _propTypes2['default'].object])).isRequired + }))]).isRequired, + children: _propTypes2['default'].func.isRequired, + willEnter: _propTypes2['default'].func, + willLeave: _propTypes2['default'].func, + didLeave: _propTypes2['default'].func + }, + enumerable: true + }, { + key: 'defaultProps', + value: { + willEnter: function willEnter(styleThatEntered) { + return _stripStyle2['default'](styleThatEntered.style); + }, + // recall: returning null makes the current unmounting TransitionStyle + // disappear immediately + willLeave: function willLeave() { + return null; + }, + didLeave: function didLeave() {} + }, + enumerable: true + }]); + + function TransitionMotion(props) { + var _this = this; + + _classCallCheck(this, TransitionMotion); + + _React$Component.call(this, props); + this.unmounting = false; + this.animationID = null; + this.prevTime = 0; + this.accumulatedTime = 0; + this.unreadPropStyles = null; + + this.clearUnreadPropStyle = function (unreadPropStyles) { + var _mergeAndSync = mergeAndSync(_this.props.willEnter, _this.props.willLeave, _this.props.didLeave, _this.state.mergedPropsStyles, unreadPropStyles, _this.state.currentStyles, _this.state.currentVelocities, _this.state.lastIdealStyles, _this.state.lastIdealVelocities); + + var mergedPropsStyles = _mergeAndSync[0]; + var currentStyles = _mergeAndSync[1]; + var currentVelocities = _mergeAndSync[2]; + var lastIdealStyles = _mergeAndSync[3]; + var lastIdealVelocities = _mergeAndSync[4]; + + for (var i = 0; i < unreadPropStyles.length; i++) { + var unreadPropStyle = unreadPropStyles[i].style; + var dirty = false; + + for (var key in unreadPropStyle) { + if (!Object.prototype.hasOwnProperty.call(unreadPropStyle, key)) { + continue; + } + + var styleValue = unreadPropStyle[key]; + if (typeof styleValue === 'number') { + if (!dirty) { + dirty = true; + currentStyles[i] = _extends({}, currentStyles[i]); + currentVelocities[i] = _extends({}, currentVelocities[i]); + lastIdealStyles[i] = _extends({}, lastIdealStyles[i]); + lastIdealVelocities[i] = _extends({}, lastIdealVelocities[i]); + mergedPropsStyles[i] = { + key: mergedPropsStyles[i].key, + data: mergedPropsStyles[i].data, + style: _extends({}, mergedPropsStyles[i].style) + }; + } + currentStyles[i][key] = styleValue; + currentVelocities[i][key] = 0; + lastIdealStyles[i][key] = styleValue; + lastIdealVelocities[i][key] = 0; + mergedPropsStyles[i].style[key] = styleValue; + } + } + } + + // unlike the other 2 components, we can't detect staleness and optionally + // opt out of setState here. each style object's data might contain new + // stuff we're not/cannot compare + _this.setState({ + currentStyles: currentStyles, + currentVelocities: currentVelocities, + mergedPropsStyles: mergedPropsStyles, + lastIdealStyles: lastIdealStyles, + lastIdealVelocities: lastIdealVelocities + }); + }; + + this.startAnimationIfNecessary = function () { + if (_this.unmounting) { + return; + } + + // TODO: when config is {a: 10} and dest is {a: 10} do we raf once and + // call cb? No, otherwise accidental parent rerender causes cb trigger + _this.animationID = _raf2['default'](function (timestamp) { + // https://github.com/chenglou/react-motion/pull/420 + // > if execution passes the conditional if (this.unmounting), then + // executes async defaultRaf and after that component unmounts and after + // that the callback of defaultRaf is called, then setState will be called + // on unmounted component. + if (_this.unmounting) { + return; + } + + var propStyles = _this.props.styles; + var destStyles = typeof propStyles === 'function' ? propStyles(rehydrateStyles(_this.state.mergedPropsStyles, _this.unreadPropStyles, _this.state.lastIdealStyles)) : propStyles; + + // check if we need to animate in the first place + if (shouldStopAnimationAll(_this.state.currentStyles, destStyles, _this.state.currentVelocities, _this.state.mergedPropsStyles)) { + // no need to cancel animationID here; shouldn't have any in flight + _this.animationID = null; + _this.accumulatedTime = 0; + return; + } + + var currentTime = timestamp || _performanceNow2['default'](); + var timeDelta = currentTime - _this.prevTime; + _this.prevTime = currentTime; + _this.accumulatedTime = _this.accumulatedTime + timeDelta; + // more than 10 frames? prolly switched browser tab. Restart + if (_this.accumulatedTime > msPerFrame * 10) { + _this.accumulatedTime = 0; + } + + if (_this.accumulatedTime === 0) { + // no need to cancel animationID here; shouldn't have any in flight + _this.animationID = null; + _this.startAnimationIfNecessary(); + return; + } + + var currentFrameCompletion = (_this.accumulatedTime - Math.floor(_this.accumulatedTime / msPerFrame) * msPerFrame) / msPerFrame; + var framesToCatchUp = Math.floor(_this.accumulatedTime / msPerFrame); + + var _mergeAndSync2 = mergeAndSync(_this.props.willEnter, _this.props.willLeave, _this.props.didLeave, _this.state.mergedPropsStyles, destStyles, _this.state.currentStyles, _this.state.currentVelocities, _this.state.lastIdealStyles, _this.state.lastIdealVelocities); + + var newMergedPropsStyles = _mergeAndSync2[0]; + var newCurrentStyles = _mergeAndSync2[1]; + var newCurrentVelocities = _mergeAndSync2[2]; + var newLastIdealStyles = _mergeAndSync2[3]; + var newLastIdealVelocities = _mergeAndSync2[4]; + + for (var i = 0; i < newMergedPropsStyles.length; i++) { + var newMergedPropsStyle = newMergedPropsStyles[i].style; + var newCurrentStyle = {}; + var newCurrentVelocity = {}; + var newLastIdealStyle = {}; + var newLastIdealVelocity = {}; + + for (var key in newMergedPropsStyle) { + if (!Object.prototype.hasOwnProperty.call(newMergedPropsStyle, key)) { + continue; + } + + var styleValue = newMergedPropsStyle[key]; + if (typeof styleValue === 'number') { + newCurrentStyle[key] = styleValue; + newCurrentVelocity[key] = 0; + newLastIdealStyle[key] = styleValue; + newLastIdealVelocity[key] = 0; + } else { + var newLastIdealStyleValue = newLastIdealStyles[i][key]; + var newLastIdealVelocityValue = newLastIdealVelocities[i][key]; + for (var j = 0; j < framesToCatchUp; j++) { + var _stepper = _stepper4['default'](msPerFrame / 1000, newLastIdealStyleValue, newLastIdealVelocityValue, styleValue.val, styleValue.stiffness, styleValue.damping, styleValue.precision); + + newLastIdealStyleValue = _stepper[0]; + newLastIdealVelocityValue = _stepper[1]; + } + + var _stepper2 = _stepper4['default'](msPerFrame / 1000, newLastIdealStyleValue, newLastIdealVelocityValue, styleValue.val, styleValue.stiffness, styleValue.damping, styleValue.precision); + + var nextIdealX = _stepper2[0]; + var nextIdealV = _stepper2[1]; + + newCurrentStyle[key] = newLastIdealStyleValue + (nextIdealX - newLastIdealStyleValue) * currentFrameCompletion; + newCurrentVelocity[key] = newLastIdealVelocityValue + (nextIdealV - newLastIdealVelocityValue) * currentFrameCompletion; + newLastIdealStyle[key] = newLastIdealStyleValue; + newLastIdealVelocity[key] = newLastIdealVelocityValue; + } + } + + newLastIdealStyles[i] = newLastIdealStyle; + newLastIdealVelocities[i] = newLastIdealVelocity; + newCurrentStyles[i] = newCurrentStyle; + newCurrentVelocities[i] = newCurrentVelocity; + } + + _this.animationID = null; + // the amount we're looped over above + _this.accumulatedTime -= framesToCatchUp * msPerFrame; + + _this.setState({ + currentStyles: newCurrentStyles, + currentVelocities: newCurrentVelocities, + lastIdealStyles: newLastIdealStyles, + lastIdealVelocities: newLastIdealVelocities, + mergedPropsStyles: newMergedPropsStyles + }); + + _this.unreadPropStyles = null; + + _this.startAnimationIfNecessary(); + }); + }; + + this.state = this.defaultState(); + } + + TransitionMotion.prototype.defaultState = function defaultState() { + var _props = this.props; + var defaultStyles = _props.defaultStyles; + var styles = _props.styles; + var willEnter = _props.willEnter; + var willLeave = _props.willLeave; + var didLeave = _props.didLeave; + + var destStyles = typeof styles === 'function' ? styles(defaultStyles) : styles; + + // this is special. for the first time around, we don't have a comparison + // between last (no last) and current merged props. we'll compute last so: + // say default is {a, b} and styles (dest style) is {b, c}, we'll + // fabricate last as {a, b} + var oldMergedPropsStyles = undefined; + if (defaultStyles == null) { + oldMergedPropsStyles = destStyles; + } else { + oldMergedPropsStyles = defaultStyles.map(function (defaultStyleCell) { + // TODO: key search code + for (var i = 0; i < destStyles.length; i++) { + if (destStyles[i].key === defaultStyleCell.key) { + return destStyles[i]; + } + } + return defaultStyleCell; + }); + } + var oldCurrentStyles = defaultStyles == null ? destStyles.map(function (s) { + return _stripStyle2['default'](s.style); + }) : defaultStyles.map(function (s) { + return _stripStyle2['default'](s.style); + }); + var oldCurrentVelocities = defaultStyles == null ? destStyles.map(function (s) { + return _mapToZero2['default'](s.style); + }) : defaultStyles.map(function (s) { + return _mapToZero2['default'](s.style); + }); + + var _mergeAndSync3 = mergeAndSync( + // Because this is an old-style createReactClass component, Flow doesn't + // understand that the willEnter and willLeave props have default values + // and will always be present. + willEnter, willLeave, didLeave, oldMergedPropsStyles, destStyles, oldCurrentStyles, oldCurrentVelocities, oldCurrentStyles, // oldLastIdealStyles really + oldCurrentVelocities); + + var mergedPropsStyles = _mergeAndSync3[0]; + var currentStyles = _mergeAndSync3[1]; + var currentVelocities = _mergeAndSync3[2]; + var lastIdealStyles = _mergeAndSync3[3]; + var lastIdealVelocities = _mergeAndSync3[4]; + // oldLastIdealVelocities really + + return { + currentStyles: currentStyles, + currentVelocities: currentVelocities, + lastIdealStyles: lastIdealStyles, + lastIdealVelocities: lastIdealVelocities, + mergedPropsStyles: mergedPropsStyles + }; + }; + + // after checking for unreadPropStyles != null, we manually go set the + // non-interpolating values (those that are a number, without a spring + // config) + + TransitionMotion.prototype.componentDidMount = function componentDidMount() { + this.prevTime = _performanceNow2['default'](); + this.startAnimationIfNecessary(); + }; + + TransitionMotion.prototype.componentWillReceiveProps = function componentWillReceiveProps(props) { + if (this.unreadPropStyles) { + // previous props haven't had the chance to be set yet; set them here + this.clearUnreadPropStyle(this.unreadPropStyles); + } + + var styles = props.styles; + if (typeof styles === 'function') { + this.unreadPropStyles = styles(rehydrateStyles(this.state.mergedPropsStyles, this.unreadPropStyles, this.state.lastIdealStyles)); + } else { + this.unreadPropStyles = styles; + } + + if (this.animationID == null) { + this.prevTime = _performanceNow2['default'](); + this.startAnimationIfNecessary(); + } + }; + + TransitionMotion.prototype.componentWillUnmount = function componentWillUnmount() { + this.unmounting = true; + if (this.animationID != null) { + _raf2['default'].cancel(this.animationID); + this.animationID = null; + } + }; + + TransitionMotion.prototype.render = function render() { + var hydratedStyles = rehydrateStyles(this.state.mergedPropsStyles, this.unreadPropStyles, this.state.currentStyles); + var renderedChildren = this.props.children(hydratedStyles); + return renderedChildren && _react2['default'].Children.only(renderedChildren); + }; + + return TransitionMotion; + })(_react2['default'].Component); + + exports['default'] = TransitionMotion; + module.exports = exports['default']; + + // list of styles, each containing interpolating values. Part of what's passed + // to children function. Notice that this is + // Array, without the wrapper that is {key: ..., + // data: ... style: ActualInterpolatingStyleObject}. Only mergedPropsStyles + // contains the key & data info (so that we only have a single source of truth + // for these, and to save space). Check the comment for `rehydrateStyles` to + // see how we regenerate the entirety of what's passed to children function + + // the array that keeps track of currently rendered stuff! Including stuff + // that you've unmounted but that's still animating. This is where it lives + + // it's possible that currentStyle's value is stale: if props is immediately + // changed from 0 to 400 to spring(0) again, the async currentStyle is still + // at 0 (didn't have time to tick and interpolate even once). If we naively + // compare currentStyle with destVal it'll be 0 === 0 (no animation, stop). + // In reality currentStyle should be 400 + +/***/ }), +/* 23 */ +/***/ (function(module, exports) { + + + + // core keys merging algorithm. If previous render's keys are [a, b], and the + // next render's [c, b, d], what's the final merged keys and ordering? + + // - c and a must both be before b + // - b before d + // - ordering between a and c ambiguous + + // this reduces to merging two partially ordered lists (e.g. lists where not + // every item has a definite ordering, like comparing a and c above). For the + // ambiguous ordering we deterministically choose to place the next render's + // item after the previous'; so c after a + + // this is called a topological sorting. Except the existing algorithms don't + // work well with js bc of the amount of allocation, and isn't optimized for our + // current use-case bc the runtime is linear in terms of edges (see wiki for + // meaning), which is huge when two lists have many common elements + 'use strict'; + + exports.__esModule = true; + exports['default'] = mergeDiff; + + function mergeDiff(prev, next, onRemove) { + // bookkeeping for easier access of a key's index below. This is 2 allocations + + // potentially triggering chrome hash map mode for objs (so it might be faster + + var prevKeyIndex = {}; + for (var i = 0; i < prev.length; i++) { + prevKeyIndex[prev[i].key] = i; + } + var nextKeyIndex = {}; + for (var i = 0; i < next.length; i++) { + nextKeyIndex[next[i].key] = i; + } + + // first, an overly elaborate way of merging prev and next, eliminating + // duplicates (in terms of keys). If there's dupe, keep the item in next). + // This way of writing it saves allocations + var ret = []; + for (var i = 0; i < next.length; i++) { + ret[i] = next[i]; + } + for (var i = 0; i < prev.length; i++) { + if (!Object.prototype.hasOwnProperty.call(nextKeyIndex, prev[i].key)) { + // this is called my TM's `mergeAndSync`, which calls willLeave. We don't + // merge in keys that the user desires to kill + var fill = onRemove(i, prev[i]); + if (fill != null) { + ret.push(fill); + } + } + } + + // now all the items all present. Core sorting logic to have the right order + return ret.sort(function (a, b) { + var nextOrderA = nextKeyIndex[a.key]; + var nextOrderB = nextKeyIndex[b.key]; + var prevOrderA = prevKeyIndex[a.key]; + var prevOrderB = prevKeyIndex[b.key]; + + if (nextOrderA != null && nextOrderB != null) { + // both keys in next + return nextKeyIndex[a.key] - nextKeyIndex[b.key]; + } else if (prevOrderA != null && prevOrderB != null) { + // both keys in prev + return prevKeyIndex[a.key] - prevKeyIndex[b.key]; + } else if (nextOrderA != null) { + // key a in next, key b in prev + + // how to determine the order between a and b? We find a "pivot" (term + // abuse), a key present in both prev and next, that is sandwiched between + // a and b. In the context of our above example, if we're comparing a and + // d, b's (the only) pivot + for (var i = 0; i < next.length; i++) { + var pivot = next[i].key; + if (!Object.prototype.hasOwnProperty.call(prevKeyIndex, pivot)) { + continue; + } + + if (nextOrderA < nextKeyIndex[pivot] && prevOrderB > prevKeyIndex[pivot]) { + return -1; + } else if (nextOrderA > nextKeyIndex[pivot] && prevOrderB < prevKeyIndex[pivot]) { + return 1; + } + } + // pluggable. default to: next bigger than prev + return 1; + } + // prevOrderA, nextOrderB + for (var i = 0; i < next.length; i++) { + var pivot = next[i].key; + if (!Object.prototype.hasOwnProperty.call(prevKeyIndex, pivot)) { + continue; + } + if (nextOrderB < nextKeyIndex[pivot] && prevOrderA > prevKeyIndex[pivot]) { + return 1; + } else if (nextOrderB > nextKeyIndex[pivot] && prevOrderA < prevKeyIndex[pivot]) { + return -1; + } + } + // pluggable. default to: next bigger than prev + return -1; + }); + } + + module.exports = exports['default']; + // to loop through and find a key's index each time), but I no longer care + +/***/ }), +/* 24 */ +/***/ (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; }; + + exports['default'] = spring; + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + var _presets = __webpack_require__(25); + + var _presets2 = _interopRequireDefault(_presets); + + var defaultConfig = _extends({}, _presets2['default'].noWobble, { + precision: 0.01 + }); + + function spring(val, config) { + return _extends({}, defaultConfig, config, { val: val }); + } + + module.exports = exports['default']; + +/***/ }), +/* 25 */ +/***/ (function(module, exports) { + + "use strict"; + + exports.__esModule = true; + exports["default"] = { + noWobble: { stiffness: 170, damping: 26 }, // the default, if nothing provided + gentle: { stiffness: 120, damping: 14 }, + wobbly: { stiffness: 180, damping: 12 }, + stiff: { stiffness: 210, damping: 20 } + }; + module.exports = exports["default"]; + +/***/ }), +/* 26 */ +/***/ (function(module, exports, __webpack_require__) { + + /* WEBPACK VAR INJECTION */(function(process) {'use strict'; + + exports.__esModule = true; + exports['default'] = reorderKeys; + + var hasWarned = false; + + function reorderKeys() { + if (process.env.NODE_ENV === 'development') { + if (!hasWarned) { + hasWarned = true; + console.error('`reorderKeys` has been removed, since it is no longer needed for TransitionMotion\'s new styles array API.'); + } + } + } + + module.exports = exports['default']; + /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4))) + +/***/ }), +/* 27 */ +/***/ (function(module, exports, __webpack_require__) { + + 'use strict'; + + Object.defineProperty(exports, "__esModule", { + value: true + }); + exports.findDOMNode = findDOMNode; + exports.warnAboutFunctionChild = warnAboutFunctionChild; + exports.warnAboutElementChild = warnAboutElementChild; + exports.positiveOrZero = positiveOrZero; + exports.modifyObjValues = modifyObjValues; + exports.isReact13 = isReact13; + + var _react = __webpack_require__(2); + + var _react2 = _interopRequireDefault(_react); + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + + var react13 = isReact13(_react2.default); + var didWarnAboutChild = false; + + function findDOMNode(component) { + if (!react13) { + return component; + } else { + return _react2.default.findDOMNode(component); + } + } + + function warnAboutFunctionChild() { + if (didWarnAboutChild || react13) { + return; + } + + didWarnAboutChild = true; + console.error('With React 0.14 and later versions, you no longer need to wrap child into a function.'); + } + + function warnAboutElementChild() { + if (didWarnAboutChild || !react13) { + return; + } + + didWarnAboutChild = true; + console.error('With React 0.13, you need to wrap child into a function.'); + } + + function positiveOrZero(number) { + return number < 0 ? 0 : number; + } + + function modifyObjValues(obj) { + var modifier = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function (x) { + return x; + }; + + var modifiedObj = {}; + for (var key in obj) { + if (obj.hasOwnProperty(key)) modifiedObj[key] = modifier(obj[key]); + } + + return modifiedObj; + } + + function isReact13(React) { + var version = React.version; + + if (typeof version !== 'string') { + return true; + } + + var parts = version.split('.'); + var major = parseInt(parts[0], 10); + var minor = parseInt(parts[1], 10); + + return major === 0 && minor === 13; + } + +/***/ }), +/* 28 */ +/***/ (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__(2); + + var _react2 = _interopRequireDefault(_react); + + var _propTypes = __webpack_require__(3); + + var _propTypes2 = _interopRequireDefault(_propTypes); + + var _reactMotion = __webpack_require__(12); + + var _utils = __webpack_require__(27); + + 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 ScrollBar = function (_React$Component) { + _inherits(ScrollBar, _React$Component); + + function ScrollBar(props) { + _classCallCheck(this, ScrollBar); + + var _this = _possibleConstructorReturn(this, (ScrollBar.__proto__ || Object.getPrototypeOf(ScrollBar)).call(this, props)); + + var newState = _this.calculateState(props); + _this.state = { + position: newState.position, + scrollSize: newState.scrollSize, + isDragging: false, + lastClientPosition: 0 + }; + + if (props.type === 'vertical') { + _this.bindedHandleMouseMove = _this.handleMouseMoveForVertical.bind(_this); + } else { + _this.bindedHandleMouseMove = _this.handleMouseMoveForHorizontal.bind(_this); + } + + _this.bindedHandleMouseUp = _this.handleMouseUp.bind(_this); + return _this; + } + + _createClass(ScrollBar, [{ + key: 'componentDidMount', + value: function componentDidMount() { + if (this.props.ownerDocument) { + this.props.ownerDocument.addEventListener("mousemove", this.bindedHandleMouseMove); + this.props.ownerDocument.addEventListener("mouseup", this.bindedHandleMouseUp); + } + } + }, { + key: 'componentWillReceiveProps', + value: function componentWillReceiveProps(nextProps) { + this.setState(this.calculateState(nextProps)); + } + }, { + key: 'componentWillUnmount', + value: function componentWillUnmount() { + if (this.props.ownerDocument) { + this.props.ownerDocument.removeEventListener("mousemove", this.bindedHandleMouseMove); + this.props.ownerDocument.removeEventListener("mouseup", this.bindedHandleMouseUp); + } + } + }, { + key: 'calculateFractionalPosition', + value: function calculateFractionalPosition(realContentSize, containerSize, contentPosition) { + var relativeSize = realContentSize - containerSize; + + return 1 - (relativeSize - contentPosition) / relativeSize; + } + }, { + key: 'calculateState', + value: function calculateState(props) { + var fractionalPosition = this.calculateFractionalPosition(props.realSize, props.containerSize, props.position); + var proportionalToPageScrollSize = props.containerSize * props.containerSize / props.realSize; + var scrollSize = proportionalToPageScrollSize < props.minScrollSize ? props.minScrollSize : proportionalToPageScrollSize; + + var scrollPosition = (props.containerSize - scrollSize) * fractionalPosition; + return { + scrollSize: scrollSize, + position: Math.round(scrollPosition) + }; + } + }, { + key: 'render', + value: function render() { + var _this2 = this; + + var _props = this.props, + smoothScrolling = _props.smoothScrolling, + isDragging = _props.isDragging, + type = _props.type, + scrollbarStyle = _props.scrollbarStyle, + containerStyle = _props.containerStyle; + + var isVoriziontal = type === 'horizontal'; + var isVertical = type === 'vertical'; + var scrollStyles = this.createScrollStyles(); + var springifiedScrollStyles = smoothScrolling ? (0, _utils.modifyObjValues)(scrollStyles, function (x) { + return (0, _reactMotion.spring)(x); + }) : scrollStyles; + + var scrollbarClasses = 'scrollbar-container ' + (isDragging ? 'active' : '') + ' ' + (isVoriziontal ? 'horizontal' : '') + ' ' + (isVertical ? 'vertical' : ''); + + return _react2.default.createElement( + _reactMotion.Motion, + { style: springifiedScrollStyles }, + function (style) { + return _react2.default.createElement( + 'div', + { + className: scrollbarClasses, + style: containerStyle, + onMouseDown: _this2.handleScrollBarContainerClick.bind(_this2), + ref: function ref(x) { + return _this2.scrollbarContainer = x; + } + }, + _react2.default.createElement('div', { + className: 'scrollbar', + style: _extends({}, scrollbarStyle, style), + onMouseDown: _this2.handleMouseDown.bind(_this2) + }) + ); + } + ); + } + }, { + key: 'handleScrollBarContainerClick', + value: function handleScrollBarContainerClick(e) { + e.preventDefault(); + var multiplier = this.computeMultiplier(); + var clientPosition = this.isVertical() ? e.clientY : e.clientX; + + var _scrollbarContainer$g = this.scrollbarContainer.getBoundingClientRect(), + top = _scrollbarContainer$g.top, + left = _scrollbarContainer$g.left; + + var clientScrollPosition = this.isVertical() ? top : left; + + var position = clientPosition - clientScrollPosition; + var proportionalToPageScrollSize = this.props.containerSize * this.props.containerSize / this.props.realSize; + + this.setState({ isDragging: true, lastClientPosition: clientPosition }); + this.props.onPositionChange((position - proportionalToPageScrollSize / 2) / multiplier); + } + }, { + key: 'handleMouseMoveForHorizontal', + value: function handleMouseMoveForHorizontal(e) { + var multiplier = this.computeMultiplier(); + + if (this.state.isDragging) { + e.preventDefault(); + var deltaX = this.state.lastClientPosition - e.clientX; + this.setState({ lastClientPosition: e.clientX }); + this.props.onMove(0, deltaX / multiplier); + } + } + }, { + key: 'handleMouseMoveForVertical', + value: function handleMouseMoveForVertical(e) { + var multiplier = this.computeMultiplier(); + + if (this.state.isDragging) { + e.preventDefault(); + var deltaY = this.state.lastClientPosition - e.clientY; + this.setState({ lastClientPosition: e.clientY }); + this.props.onMove(deltaY / multiplier, 0); + } + } + }, { + key: 'handleMouseDown', + value: function handleMouseDown(e) { + e.preventDefault(); + e.stopPropagation(); + var lastClientPosition = this.isVertical() ? e.clientY : e.clientX; + this.setState({ isDragging: true, lastClientPosition: lastClientPosition }); + + this.props.onFocus(); + } + }, { + key: 'handleMouseUp', + value: function handleMouseUp(e) { + if (this.state.isDragging) { + e.preventDefault(); + this.setState({ isDragging: false }); + } + } + }, { + key: 'createScrollStyles', + value: function createScrollStyles() { + if (this.props.type === 'vertical') { + return { + height: this.state.scrollSize, + marginTop: this.state.position + }; + } else { + return { + width: this.state.scrollSize, + marginLeft: this.state.position + }; + } + } + }, { + key: 'computeMultiplier', + value: function computeMultiplier() { + return this.props.containerSize / this.props.realSize; + } + }, { + key: 'isVertical', + value: function isVertical() { + return this.props.type === 'vertical'; + } + }]); + + return ScrollBar; + }(_react2.default.Component); + + ScrollBar.propTypes = { + onMove: _propTypes2.default.func, + onPositionChange: _propTypes2.default.func, + onFocus: _propTypes2.default.func, + realSize: _propTypes2.default.number, + containerSize: _propTypes2.default.number, + position: _propTypes2.default.number, + containerStyle: _propTypes2.default.object, + scrollbarStyle: _propTypes2.default.object, + type: _propTypes2.default.oneOf(['vertical', 'horizontal']), + ownerDocument: _propTypes2.default.any, + smoothScrolling: _propTypes2.default.bool, + minScrollSize: _propTypes2.default.number + }; + + ScrollBar.defaultProps = { + type: 'vertical', + smoothScrolling: false + }; + + exports.default = ScrollBar; + +/***/ }) +/******/ ]) +}); +; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["webpack:///webpack/universalModuleDefinition","webpack:///webpack/bootstrap b22566d5aa23f30bc952","webpack:///./src/js/ScrollAreaWithoutCss.js","webpack:///./src/js/ScrollArea.jsx","webpack:///external {\"root\":\"React\",\"commonjs2\":\"react\",\"commonjs\":\"react\",\"amd\":\"react\"}","webpack:///./~/prop-types/index.js","webpack:///./~/process/browser.js","webpack:///./~/prop-types/factoryWithTypeCheckers.js","webpack:///./~/object-assign/index.js","webpack:///./~/prop-types/lib/ReactPropTypesSecret.js","webpack:///./~/prop-types/checkPropTypes.js","webpack:///./~/prop-types/factoryWithThrowingShims.js","webpack:///./~/line-height/lib/line-height.js","webpack:///./~/line-height/~/computed-style/dist/computedStyle.commonjs.js","webpack:///./~/react-motion/lib/react-motion.js","webpack:///./~/react-motion/lib/Motion.js","webpack:///./~/react-motion/lib/mapToZero.js","webpack:///./~/react-motion/lib/stripStyle.js","webpack:///./~/react-motion/lib/stepper.js","webpack:///./~/performance-now/lib/performance-now.js","webpack:///./~/raf/index.js","webpack:///./~/raf/~/performance-now/lib/performance-now.js","webpack:///./~/react-motion/lib/shouldStopAnimation.js","webpack:///./~/react-motion/lib/StaggeredMotion.js","webpack:///./~/react-motion/lib/TransitionMotion.js","webpack:///./~/react-motion/lib/mergeDiff.js","webpack:///./~/react-motion/lib/spring.js","webpack:///./~/react-motion/lib/presets.js","webpack:///./~/react-motion/lib/reorderKeys.js","webpack:///./src/js/utils.js","webpack:///./src/js/Scrollbar.jsx"],"names":["ScrollArea","eventTypes","wheel","api","touch","touchEnd","mousemove","keyPress","props","state","topPosition","leftPosition","realHeight","containerHeight","realWidth","containerWidth","scrollArea","refresh","setSizesToState","scrollTop","scrollBottom","scrollYTo","position","scrollLeft","scrollRight","scrollXTo","evntsPreviousValues","clientX","clientY","deltaX","deltaY","bindedHandleWindowResize","handleWindowResize","bind","contentWindow","addEventListener","lineHeightPx","content","removeEventListener","children","className","contentClassName","ownerDocument","withMotion","smoothScrolling","eventType","scrollbarY","canScrollY","handleScrollbarMove","handleScrollbarYPositionChange","verticalContainerStyle","verticalScrollbarStyle","minScrollSize","focusContent","scrollbarX","canScrollX","handleScrollbarXPositionChange","horizontalContainerStyle","horizontalScrollbarStyle","classes","contentClasses","contentStyle","marginTop","marginLeft","springifiedContentStyle","x","wrapper","style","handleWheel","handleTouchStart","handleTouchMove","handleTouchEnd","handleKeyDown","focusableTabIndex","newState","onScroll","setState","e","touches","length","eventPreviousValues","timestamp","Date","now","canScroll","preventDefault","stopPropagation","setStateFromEvent","composeNewState","swapWheelAxes","deltaMode","speed","stopScrollPropagation","target","tagName","toLowerCase","isContentEditable","lineHeight","keyCode","computeSizes","getModifiedPositionsIfNeeded","computeTopPosition","computeLeftPosition","sizes","newTopPosition","normalizeTopPosition","newLeftPosition","normalizeLeftPosition","offsetHeight","offsetWidth","scrollableY","vertical","scrollableX","horizontal","bottomPosition","rightPosition","focus","React","Component","childContextTypes","PropTypes","object","propTypes","string","number","bool","func","any","defaultProps","window","undefined","document","findDOMNode","warnAboutFunctionChild","warnAboutElementChild","positiveOrZero","modifyObjValues","isReact13","react13","didWarnAboutChild","component","console","error","obj","modifier","modifiedObj","key","hasOwnProperty","version","parts","split","major","parseInt","minor","ScrollBar","calculateState","scrollSize","isDragging","lastClientPosition","type","bindedHandleMouseMove","handleMouseMoveForVertical","handleMouseMoveForHorizontal","bindedHandleMouseUp","handleMouseUp","nextProps","realContentSize","containerSize","contentPosition","relativeSize","fractionalPosition","calculateFractionalPosition","realSize","proportionalToPageScrollSize","scrollPosition","Math","round","scrollbarStyle","containerStyle","isVoriziontal","isVertical","scrollStyles","createScrollStyles","springifiedScrollStyles","scrollbarClasses","handleScrollBarContainerClick","scrollbarContainer","handleMouseDown","multiplier","computeMultiplier","clientPosition","getBoundingClientRect","top","left","clientScrollPosition","onPositionChange","onMove","onFocus","height","width","oneOf"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AACD,O;ACVA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,uBAAe;AACf;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;;AAGA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;;;;;;;;;;;;ACtCA;;;;;;mBAEeA,oB;;;;;;;;;;;;;;;;;;ACFf;;;;AACA;;;;AACA;;;;AACA;;AAEA;;AAGA;;;;;;;;;;;;AAEA,KAAMC,aAAa;AACfC,YAAO,OADQ;AAEfC,UAAK,KAFU;AAGfC,YAAO,OAHQ;AAIfC,eAAU,UAJK;AAKfC,gBAAW,WALI;AAMfC,eAAU;AANK,EAAnB;;KASqBP,U;;;AACjB,yBAAYQ,KAAZ,EAAmB;AAAA;;AAAA,6HACTA,KADS;;AAEf,eAAKC,KAAL,GAAa;AACTC,0BAAa,CADJ;AAETC,2BAAc,CAFL;AAGTC,yBAAY,CAHH;AAITC,8BAAiB,CAJR;AAKTC,wBAAW,CALF;AAMTC,6BAAgB;AANP,UAAb;;AASA,eAAKC,UAAL,GAAkB;AACdC,sBAAS,mBAAM;AACX,uBAAKC,eAAL;AACH,cAHa;AAIdC,wBAAW,qBAAM;AACb,uBAAKA,SAAL;AACH,cANa;AAOdC,2BAAc,wBAAM;AAChB,uBAAKA,YAAL;AACH,cATa;AAUdC,wBAAW,mBAACC,QAAD,EAAc;AACrB,uBAAKD,SAAL,CAAeC,QAAf;AACH,cAZa;AAadC,yBAAY,sBAAM;AACd,uBAAKA,UAAL;AACH,cAfa;AAgBdC,0BAAa,uBAAM;AACf,uBAAKA,WAAL;AACH,cAlBa;AAmBdC,wBAAW,mBAACH,QAAD,EAAc;AACrB,uBAAKG,SAAL,CAAeH,QAAf;AACH;AArBa,UAAlB;;AAwBA,eAAKI,mBAAL,GAA2B;AACvBC,sBAAS,CADc;AAEvBC,sBAAS,CAFc;AAGvBC,qBAAQ,CAHe;AAIvBC,qBAAQ;AAJe,UAA3B;;AAOA,eAAKC,wBAAL,GAAgC,MAAKC,kBAAL,CAAwBC,IAAxB,OAAhC;AA1Ce;AA2ClB;;;;2CAEiB;AACd,oBAAO;AACHjB,6BAAY,KAAKA;AADd,cAAP;AAGH;;;6CAEmB;AAChB,iBAAI,KAAKR,KAAL,CAAW0B,aAAf,EAA8B;AAC1B,sBAAK1B,KAAL,CAAW0B,aAAX,CAAyBC,gBAAzB,CAA0C,QAA1C,EAAoD,KAAKJ,wBAAzD;AACH;AACD,kBAAKK,YAAL,GAAoB,0BAAW,wBAAY,KAAKC,OAAjB,CAAX,CAApB;AACA,kBAAKnB,eAAL;AACH;;;gDAEsB;AACnB,iBAAI,KAAKV,KAAL,CAAW0B,aAAf,EAA8B;AAC1B,sBAAK1B,KAAL,CAAW0B,aAAX,CAAyBI,mBAAzB,CAA6C,QAA7C,EAAuD,KAAKP,wBAA5D;AACH;AACJ;;;8CAEoB;AACjB,kBAAKb,eAAL;AACH;;;kCAEQ;AAAA;;AAAA,0BACwD,KAAKV,KAD7D;AAAA,iBACA+B,QADA,UACAA,QADA;AAAA,iBACUC,SADV,UACUA,SADV;AAAA,iBACqBC,gBADrB,UACqBA,gBADrB;AAAA,iBACuCC,aADvC,UACuCA,aADvC;;AAEL,iBAAIC,aAAa,KAAKnC,KAAL,CAAWoC,eAAX,KACZ,KAAKnC,KAAL,CAAWoC,SAAX,KAAyB5C,WAAWC,KAApC,IAA6C,KAAKO,KAAL,CAAWoC,SAAX,KAAyB5C,WAAWE,GAAjF,IAAwF,KAAKM,KAAL,CAAWoC,SAAX,KAAyB5C,WAAWI,QAA5H,IACD,KAAKI,KAAL,CAAWoC,SAAX,KAAyB5C,WAAWM,QAFvB,CAAjB;;AAIA,iBAAIuC,aAAa,KAAKC,UAAL,KACb,8BAAC,mBAAD;AACI,gCAAeL,aADnB;AAEI,2BAAU,KAAKjC,KAAL,CAAWG,UAFzB;AAGI,gCAAe,KAAKH,KAAL,CAAWI,eAH9B;AAII,2BAAU,KAAKJ,KAAL,CAAWC,WAJzB;AAKI,yBAAQ,KAAKsC,mBAAL,CAAyBf,IAAzB,CAA8B,IAA9B,CALZ;AAMI,mCAAkB,KAAKgB,8BAAL,CAAoChB,IAApC,CAAyC,IAAzC,CANtB;AAOI,iCAAgB,KAAKzB,KAAL,CAAW0C,sBAP/B;AAQI,iCAAgB,KAAK1C,KAAL,CAAW2C,sBAR/B;AASI,kCAAiBR,UATrB;AAUI,gCAAe,KAAKnC,KAAL,CAAW4C,aAV9B;AAWI,0BAAS,KAAKC,YAAL,CAAkBpB,IAAlB,CAAuB,IAAvB,CAXb;AAYI,uBAAK,UAZT,GADa,GAcb,IAdJ;;AAgBA,iBAAIqB,aAAa,KAAKC,UAAL,KACb,8BAAC,mBAAD;AACI,gCAAeb,aADnB;AAEI,2BAAU,KAAKjC,KAAL,CAAWK,SAFzB;AAGI,gCAAe,KAAKL,KAAL,CAAWM,cAH9B;AAII,2BAAU,KAAKN,KAAL,CAAWE,YAJzB;AAKI,yBAAQ,KAAKqC,mBAAL,CAAyBf,IAAzB,CAA8B,IAA9B,CALZ;AAMI,mCAAkB,KAAKuB,8BAAL,CAAoCvB,IAApC,CAAyC,IAAzC,CANtB;AAOI,iCAAgB,KAAKzB,KAAL,CAAWiD,wBAP/B;AAQI,iCAAgB,KAAKjD,KAAL,CAAWkD,wBAR/B;AASI,kCAAiBf,UATrB;AAUI,gCAAe,KAAKnC,KAAL,CAAW4C,aAV9B;AAWI,0BAAS,KAAKC,YAAL,CAAkBpB,IAAlB,CAAuB,IAAvB,CAXb;AAYI,uBAAK,YAZT,GADa,GAcb,IAdJ;;AAgBA,iBAAI,OAAOM,QAAP,KAAoB,UAAxB,EAAoC;AAChC;AACAA,4BAAWA,UAAX;AACH,cAHD,MAGO;AACH;AACH;;AAED,iBAAIoB,UAAU,iBAAiBnB,aAAa,EAA9B,CAAd;AACA,iBAAIoB,iBAAiB,yBAAyBnB,oBAAoB,EAA7C,CAArB;;AAEA,iBAAIoB,eAAe;AACfC,4BAAW,CAAC,KAAKrD,KAAL,CAAWC,WADR;AAEfqD,6BAAY,CAAC,KAAKtD,KAAL,CAAWE;AAFT,cAAnB;AAIA,iBAAIqD,0BAA0BrB,aAAa,4BAAgBkB,YAAhB,EAA8B;AAAA,wBAAK,yBAAOI,CAAP,CAAL;AAAA,cAA9B,CAAb,GAA6DJ,YAA3F;;AAEA,oBACI;AAAC,oCAAD;AAAA,mBAAQ,OAAOG,uBAAf;AACM;AAAA,4BACE;AAAA;AAAA;AACI,kCAAK;AAAA,wCAAK,OAAKE,OAAL,GAAeD,CAApB;AAAA,8BADT;AAEI,wCAAWN,OAFf;AAGI,oCAAO,OAAKnD,KAAL,CAAW2D,KAHtB;AAII,sCAAS,OAAKC,WAAL,CAAiBnC,IAAjB,CAAsB,MAAtB;AAJb;AAMI;AAAA;AAAA;AACI,sCAAK;AAAA,4CAAK,OAAKI,OAAL,GAAe4B,CAApB;AAAA,kCADT;AAEI,qDAAY,OAAKzD,KAAL,CAAWqD,YAAvB,EAAwCM,KAAxC,CAFJ;AAGI,4CAAWP,cAHf;AAII,+CAAc,OAAKS,gBAAL,CAAsBpC,IAAtB,CAA2B,MAA3B,CAJlB;AAKI,8CAAa,OAAKqC,eAAL,CAAqBrC,IAArB,CAA0B,MAA1B,CALjB;AAMI,6CAAY,OAAKsC,cAAL,CAAoBtC,IAApB,CAAyB,MAAzB,CANhB;AAOI,4CAAW,OAAKuC,aAAL,CAAmBvC,IAAnB,CAAwB,MAAxB,CAPf;AAQI,2CAAU,OAAKzB,KAAL,CAAWiE;AARzB;AAUKlC;AAVL,0BANJ;AAkBKO,mCAlBL;AAmBKQ;AAnBL,sBADF;AAAA;AADN,cADJ;AA2BH;;;2CAEiBoB,Q,EAAU7B,S,EAAW;AACnC,iBAAI,KAAKrC,KAAL,CAAWmE,QAAf,EAAyB;AACrB,sBAAKnE,KAAL,CAAWmE,QAAX,CAAoBD,QAApB;AACH;AACD,kBAAKE,QAAL,cAAkBF,QAAlB,IAA4B7B,oBAA5B;AACH;;;0CAEgBgC,C,EAAG;AAAA,iBACXC,OADW,GACAD,CADA,CACXC,OADW;;AAEhB,iBAAIA,QAAQC,MAAR,KAAmB,CAAvB,EAA0B;AAAA,iCACGD,QAAQ,CAAR,CADH;AAAA,qBACjBnD,OADiB,aACjBA,OADiB;AAAA,qBACRC,OADQ,aACRA,OADQ;;AAEtB,sBAAKoD,mBAAL,gBACO,KAAKA,mBADZ;AAEIpD,qCAFJ;AAGID,qCAHJ;AAIIsD,gCAAWC,KAAKC,GAAL;AAJf;AAMH;AACJ;;;yCAEeN,C,EAAG;AACf,iBAAI,KAAKO,SAAL,EAAJ,EAAsB;AAClBP,mBAAEQ,cAAF;AACAR,mBAAES,eAAF;AACH;;AAJc,iBAMVR,OANU,GAMCD,CAND,CAMVC,OANU;;AAOf,iBAAIA,QAAQC,MAAR,KAAmB,CAAvB,EAA0B;AAAA,kCACGD,QAAQ,CAAR,CADH;AAAA,qBACjBnD,OADiB,cACjBA,OADiB;AAAA,qBACRC,OADQ,cACRA,OADQ;;;AAGtB,qBAAIE,SAAS,KAAKkD,mBAAL,CAAyBpD,OAAzB,GAAmCA,OAAhD;AACA,qBAAIC,SAAS,KAAKmD,mBAAL,CAAyBrD,OAAzB,GAAmCA,OAAhD;;AAEA,sBAAKqD,mBAAL,gBACO,KAAKA,mBADZ;AAEIlD,mCAFJ;AAGID,mCAHJ;AAIID,qCAJJ;AAKID,qCALJ;AAMIsD,gCAAWC,KAAKC,GAAL;AANf;;AASA,sBAAKI,iBAAL,CAAuB,KAAKC,eAAL,CAAqB,CAAC3D,MAAtB,EAA8B,CAACC,MAA/B,CAAvB;AACH;AACJ;;;wCAEc+C,C,EAAG;AAAA,wCACoB,KAAKG,mBADzB;AAAA,iBACTnD,MADS,wBACTA,MADS;AAAA,iBACDC,MADC,wBACDA,MADC;AAAA,iBACOmD,SADP,wBACOA,SADP;;AAEd,iBAAI,OAAOpD,MAAP,KAAkB,WAAtB,EAAmCA,SAAS,CAAT;AACnC,iBAAI,OAAOC,MAAP,KAAkB,WAAtB,EAAmCA,SAAS,CAAT;AACnC,iBAAIoD,KAAKC,GAAL,KAAaF,SAAb,GAAyB,GAA7B,EAAkC;AAC9B,sBAAKM,iBAAL,CAAuB,KAAKC,eAAL,CAAqB,CAAC3D,MAAD,GAAU,EAA/B,EAAmC,CAACC,MAAD,GAAU,EAA7C,CAAvB,EAAyE7B,WAAWI,QAApF;AACH;;AAED,kBAAK2E,mBAAL,gBACO,KAAKA,mBADZ;AAEIlD,yBAAQ,CAFZ;AAGID,yBAAQ;AAHZ;AAKH;;;6CAEmBC,M,EAAQD,M,EAAQ;AAChC,kBAAK0D,iBAAL,CAAuB,KAAKC,eAAL,CAAqB3D,MAArB,EAA6BC,MAA7B,CAAvB;AACH;;;wDAE8BR,Q,EAAU;AACrC,kBAAKG,SAAL,CAAeH,QAAf;AACH;;;wDAE8BA,Q,EAAU;AACrC,kBAAKD,SAAL,CAAeC,QAAf;AACH;;;qCAEWuD,C,EAAG;AACX,iBAAI/C,SAAS+C,EAAE/C,MAAf;AACA,iBAAID,SAASgD,EAAEhD,MAAf;;AAEA,iBAAI,KAAKrB,KAAL,CAAWiF,aAAf,EAA8B;AAAA,4BACP,CAAC5D,MAAD,EAASC,MAAT,CADO;AACzBA,uBADyB;AACjBD,uBADiB;AAE7B;;AAED;;;;;;AAMA,iBAAIgD,EAAEa,SAAF,KAAgB,CAApB,EAAuB;AACnB5D,0BAASA,SAAS,KAAKM,YAAvB;AACAP,0BAASA,SAAS,KAAKO,YAAvB;AACH;;AAEDN,sBAASA,SAAS,KAAKtB,KAAL,CAAWmF,KAA7B;AACA9D,sBAASA,SAAS,KAAKrB,KAAL,CAAWmF,KAA7B;;AAEA,iBAAIjB,WAAW,KAAKc,eAAL,CAAqB,CAAC3D,MAAtB,EAA8B,CAACC,MAA/B,CAAf;;AAEA,iBAAK4C,SAAShE,WAAT,IAAwB,KAAKD,KAAL,CAAWC,WAAX,KAA2BgE,SAAShE,WAA7D,IACCgE,SAAS/D,YAAT,IAAyB,KAAKF,KAAL,CAAWE,YAAX,KAA4B+D,SAAS/D,YAD/D,IAEA,KAAKH,KAAL,CAAWoF,qBAFf,EAEsC;AAClCf,mBAAEQ,cAAF;AACAR,mBAAES,eAAF;AACH;;AAED,kBAAKC,iBAAL,CAAuBb,QAAvB,EAAiCzE,WAAWC,KAA5C;AACA,kBAAKmD,YAAL;AACH;;;uCAEawB,C,EAAG;AACb;AACA,iBAAIA,EAAEgB,MAAF,CAASC,OAAT,CAAiBC,WAAjB,OAAmC,OAAnC,IAA8ClB,EAAEgB,MAAF,CAASC,OAAT,CAAiBC,WAAjB,OAAmC,UAAjF,IAA+F,CAAClB,EAAEgB,MAAF,CAASG,iBAA7G,EAAgI;AAC5H,qBAAIlE,SAAS,CAAb;AACA,qBAAID,SAAS,CAAb;AACA,qBAAIoE,cAAa,KAAK7D,YAAL,GAAoB,KAAKA,YAAzB,GAAwC,EAAzD;;AAEA,yBAAQyC,EAAEqB,OAAV;AACI,0BAAK,EAAL;AAAS;AACLpE,kCAAS,KAAKrB,KAAL,CAAWI,eAAX,GAA6BoF,WAAtC;AACA;AACJ,0BAAK,EAAL;AAAS;AACLnE,kCAAS,CAAC,KAAKrB,KAAL,CAAWI,eAAZ,GAA8BoF,WAAvC;AACA;AACJ,0BAAK,EAAL;AAAS;AACLpE,kCAASoE,WAAT;AACA;AACJ,0BAAK,EAAL;AAAS;AACLnE,kCAASmE,WAAT;AACA;AACJ,0BAAK,EAAL;AAAS;AACLpE,kCAAS,CAACoE,WAAV;AACA;AACJ,0BAAK,EAAL;AAAS;AACLnE,kCAAS,CAACmE,WAAV;AACA;AAlBR;;AAqBA;AACA,qBAAInE,WAAW,CAAX,IAAgBD,WAAW,CAA/B,EAAkC;AAC9B,yBAAI6C,WAAW,KAAKc,eAAL,CAAqB3D,MAArB,EAA6BC,MAA7B,CAAf;;AAEA+C,uBAAEQ,cAAF;AACAR,uBAAES,eAAF;;AAEA,0BAAKC,iBAAL,CAAuBb,QAAvB,EAAiCzE,WAAWM,QAA5C;AACH;AACJ;AACJ;;;8CAEoB;AACjB,iBAAImE,WAAW,KAAKyB,YAAL,EAAf;AACAzB,wBAAW,KAAK0B,4BAAL,CAAkC1B,QAAlC,CAAX;AACA,kBAAKa,iBAAL,CAAuBb,QAAvB;AACH;;;yCAEe7C,M,EAAQC,M,EAAQ;AAC5B,iBAAI4C,WAAW,KAAKyB,YAAL,EAAf;;AAEA,iBAAI,KAAKpD,UAAL,CAAgB2B,QAAhB,CAAJ,EAA+B;AAC3BA,0BAAShE,WAAT,GAAuB,KAAK2F,kBAAL,CAAwBvE,MAAxB,EAAgC4C,QAAhC,CAAvB;AACH,cAFD,MAEO;AACLA,0BAAShE,WAAT,GAAuB,CAAvB;AACD;AACD,iBAAI,KAAK6C,UAAL,CAAgBmB,QAAhB,CAAJ,EAA+B;AAC3BA,0BAAS/D,YAAT,GAAwB,KAAK2F,mBAAL,CAAyBzE,MAAzB,EAAiC6C,QAAjC,CAAxB;AACH;;AAED,oBAAOA,QAAP;AACH;;;4CAEkB5C,M,EAAQyE,K,EAAO;AAC9B,iBAAIC,iBAAiB,KAAK/F,KAAL,CAAWC,WAAX,GAAyBoB,MAA9C;AACA,oBAAO,KAAK2E,oBAAL,CAA0BD,cAA1B,EAA0CD,KAA1C,CAAP;AACH;;;6CAEmB1E,M,EAAQ0E,K,EAAO;AAC/B,iBAAIG,kBAAkB,KAAKjG,KAAL,CAAWE,YAAX,GAA0BkB,MAAhD;AACA,oBAAO,KAAK8E,qBAAL,CAA2BD,eAA3B,EAA4CH,KAA5C,CAAP;AACH;;;8CAEoBC,c,EAAgBD,K,EAAO;AACxC,iBAAIC,iBAAiBD,MAAM3F,UAAN,GAAmB2F,MAAM1F,eAA9C,EAA+D;AAC3D2F,kCAAiBD,MAAM3F,UAAN,GAAmB2F,MAAM1F,eAA1C;AACH;AACD,iBAAI2F,iBAAiB,CAArB,EAAwB;AACpBA,kCAAiB,CAAjB;AACH;AACD,oBAAOA,cAAP;AACH;;;+CAEqBE,e,EAAiBH,K,EAAO;AAC1C,iBAAIG,kBAAkBH,MAAMzF,SAAN,GAAkByF,MAAMxF,cAA9C,EAA8D;AAC1D2F,mCAAkBH,MAAMzF,SAAN,GAAkByF,MAAMxF,cAA1C;AACH,cAFD,MAEO,IAAI2F,kBAAkB,CAAtB,EAAyB;AAC5BA,mCAAkB,CAAlB;AACH;;AAED,oBAAOA,eAAP;AACH;;;wCAEc;AACX,iBAAI9F,aAAc,KAAKyB,OAAN,GAAiB,KAAKA,OAAL,CAAauE,YAA9B,GAA6C,CAA9D;AACA,iBAAI/F,kBAAmB,KAAKqD,OAAN,GAAiB,KAAKA,OAAL,CAAa0C,YAA9B,GAA6C,CAAnE;AACA,iBAAI9F,YAAa,KAAKuB,OAAN,GAAiB,KAAKA,OAAL,CAAawE,WAA9B,GAA4C,CAA5D;AACA,iBAAI9F,iBAAkB,KAAKsB,OAAN,GAAiB,KAAK6B,OAAL,CAAa2C,WAA9B,GAA4C,CAAjE;;AAEA,oBAAO;AACHjG,6BAAYA,UADT;AAEHC,kCAAiBA,eAFd;AAGHC,4BAAWA,SAHR;AAIHC,iCAAgBA;AAJb,cAAP;AAMH;;;2CAEiB;AACd,iBAAIwF,QAAQ,KAAKJ,YAAL,EAAZ;AACA,iBAAII,MAAM3F,UAAN,KAAqB,KAAKH,KAAL,CAAWG,UAAhC,IAA8C2F,MAAMzF,SAAN,KAAoB,KAAKL,KAAL,CAAWK,SAAjF,EAA4F;AACxF,sBAAKyE,iBAAL,CAAuB,KAAKa,4BAAL,CAAkCG,KAAlC,CAAvB;AACH;AACJ;;;qCAEW;AACR,kBAAKlF,SAAL,CAAe,CAAf;AACH;;;wCAEc;AACX,kBAAKA,SAAL,CAAgB,KAAKZ,KAAL,CAAWG,UAAX,GAAwB,KAAKH,KAAL,CAAWI,eAAnD;AACH;;;sCAEY;AACT,kBAAKY,SAAL,CAAe,CAAf;AACH;;;uCAEa;AACV,kBAAKA,SAAL,CAAgB,KAAKhB,KAAL,CAAWK,SAAX,GAAuB,KAAKL,KAAL,CAAWM,cAAlD;AACH;;;mCAESL,W,EAAa;AACnB,iBAAI,KAAKqC,UAAL,EAAJ,EAAuB;AACnB,qBAAIzB,WAAW,KAAKmF,oBAAL,CAA0B/F,WAA1B,EAAuC,KAAKyF,YAAL,EAAvC,CAAf;AACA,sBAAKZ,iBAAL,CAAuB,EAAC7E,aAAaY,QAAd,EAAvB,EAAgDrB,WAAWE,GAA3D;AACH;AACJ;;;mCAESQ,Y,EAAc;AACpB,iBAAI,KAAK4C,UAAL,EAAJ,EAAuB;AACnB,qBAAIjC,WAAW,KAAKqF,qBAAL,CAA2BhG,YAA3B,EAAyC,KAAKwF,YAAL,EAAzC,CAAf;AACA,sBAAKZ,iBAAL,CAAuB,EAAC5E,cAAcW,QAAf,EAAvB,EAAiDrB,WAAWE,GAA5D;AACH;AACJ;;;sCAE8B;AAAA,iBAApBM,KAAoB,uEAAZ,KAAKA,KAAO;;AAC3B,iBAAIqG,cAAcrG,MAAMG,UAAN,GAAmBH,MAAMI,eAA3C;AACA,oBAAOiG,eAAe,KAAKtG,KAAL,CAAWuG,QAAjC;AACH;;;sCAE8B;AAAA,iBAApBtG,KAAoB,uEAAZ,KAAKA,KAAO;;AAC3B,iBAAIuG,cAAcvG,MAAMK,SAAN,GAAkBL,MAAMM,cAA1C;AACA,oBAAOiG,eAAe,KAAKxG,KAAL,CAAWyG,UAAjC;AACH;;;qCAE6B;AAAA,iBAApBxG,KAAoB,uEAAZ,KAAKA,KAAO;;AAC1B,oBAAO,KAAKsC,UAAL,CAAgBtC,KAAhB,KAA0B,KAAK8C,UAAL,CAAgB9C,KAAhB,CAAjC;AACH;;;sDAE4BiE,Q,EAAU;AACnC,iBAAIwC,iBAAiBxC,SAAS9D,UAAT,GAAsB8D,SAAS7D,eAApD;AACA,iBAAI,KAAKJ,KAAL,CAAWC,WAAX,IAA0BwG,cAA9B,EAA8C;AAC1CxC,0BAAShE,WAAT,GAAuB,KAAKqC,UAAL,CAAgB2B,QAAhB,IAA4B,2BAAewC,cAAf,CAA5B,GAA6D,CAApF;AACH;;AAED,iBAAIC,gBAAgBzC,SAAS5D,SAAT,GAAqB4D,SAAS3D,cAAlD;AACA,iBAAI,KAAKN,KAAL,CAAWE,YAAX,IAA2BwG,aAA/B,EAA8C;AAC1CzC,0BAAS/D,YAAT,GAAwB,KAAK4C,UAAL,CAAgBmB,QAAhB,IAA4B,2BAAeyC,aAAf,CAA5B,GAA4D,CAApF;AACH;;AAED,oBAAOzC,QAAP;AACH;;;wCAEc;AACX,iBAAG,KAAKrC,OAAR,EAAiB;AACb,yCAAY,KAAKA,OAAjB,EAA0B+E,KAA1B;AACH;AACJ;;;;GAnbmCC,gBAAMC,S;;mBAAzBtH,U;;;AAsbrBA,YAAWuH,iBAAX,GAA+B;AAC3BvG,iBAAYwG,oBAAUC;AADK,EAA/B;;AAIAzH,YAAW0H,SAAX,GAAuB;AACnBlF,gBAAWgF,oBAAUG,MADF;AAEnBxD,YAAOqD,oBAAUC,MAFE;AAGnB9B,YAAO6B,oBAAUI,MAHE;AAInBnF,uBAAkB+E,oBAAUG,MAJT;AAKnB9D,mBAAc2D,oBAAUC,MALL;AAMnBV,eAAUS,oBAAUK,IAND;AAOnB3E,6BAAwBsE,oBAAUC,MAPf;AAQnBtE,6BAAwBqE,oBAAUC,MARf;AASnBR,iBAAYO,oBAAUK,IATH;AAUnBpE,+BAA0B+D,oBAAUC,MAVjB;AAWnB/D,+BAA0B8D,oBAAUC,MAXjB;AAYnB9C,eAAU6C,oBAAUM,IAZD;AAanB5F,oBAAesF,oBAAUO,GAbN;AAcnBrF,oBAAe8E,oBAAUO,GAdN;AAenBnF,sBAAiB4E,oBAAUK,IAfR;AAgBnBzE,oBAAeoE,oBAAUI,MAhBN;AAiBnBnC,oBAAe+B,oBAAUK,IAjBN;AAkBnBjC,4BAAuB4B,oBAAUK,IAlBd;AAmBnBpD,wBAAmB+C,oBAAUI;AAnBV,EAAvB;;AAsBA5H,YAAWgI,YAAX,GAA0B;AACtBrC,YAAO,CADe;AAEtBoB,eAAU,IAFY;AAGtBE,iBAAY,IAHU;AAItBrE,sBAAiB,KAJK;AAKtB6C,oBAAe,KALO;AAMtBvD,oBAAgB,QAAO+F,MAAP,yCAAOA,MAAP,OAAkB,QAAnB,GAA+BA,MAA/B,GAAwCC,SANjC;AAOtBxF,oBAAgB,QAAOyF,QAAP,yCAAOA,QAAP,OAAoB,QAArB,GAAiCA,QAAjC,GAA4CD,SAPrC;AAQtBzD,wBAAmB;AARG,EAA1B,C;;;;;;ACneA,gD;;;;;;ACAA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,EAAC;AACD;AACA;AACA;AACA;;;;;;;;AC3BA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAS;AACT;AACA;AACA,MAAK;AACL;AACA;AACA;AACA;AACA;AACA,UAAS;AACT;AACA;AACA,MAAK;AACL;AACA;AACA,EAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA;AACA,UAAS;AACT;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA;AACA,UAAS;AACT;AACA;AACA;AACA;AACA;;;;AAIA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,wBAAuB,sBAAsB;AAC7C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAqB;AACrB;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,sCAAqC;;AAErC;AACA;AACA;;AAEA,4BAA2B;AAC3B;AACA;AACA;AACA,6BAA4B,UAAU;;;;;;;ACvLtC;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,2CAA0C;;AAE1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAa,QAAQ;AACrB,eAAc;AACd;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAU;AACV,8BAA6B;AAC7B,SAAQ;AACR;AACA;AACA;AACA;AACA,gCAA+B,KAAK;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAS;AACT,6BAA4B;AAC5B,QAAO;AACP;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAO;AACP;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAqB,sBAAsB;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,sBAAqB,2BAA2B;AAChD;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA,oBAAmB,gCAAgC;AACnD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,sBAAqB,gCAAgC;AACrD;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA6B;AAC7B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAW;AACX;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAS;AACT;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAO;AACP;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;;;;;;;AC1iBA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA,iCAAgC;AAChC;AACA;AACA;AACA;;AAEA;AACA;AACA,kBAAiB,QAAQ;AACzB;AACA;AACA;AACA;AACA,IAAG;AACH;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,IAAG;AACH,mCAAkC;AAClC;AACA;AACA;;AAEA;AACA,GAAE;AACF;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA,iBAAgB,sBAAsB;AACtC;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,mBAAkB,oBAAoB;AACtC;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;;;;;;ACzFA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;;;;;;;ACXA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;;AAEA;AACA;AACA;AACA;AACA,YAAW,OAAO;AAClB,YAAW,OAAO;AAClB,YAAW,OAAO;AAClB,YAAW,OAAO;AAClB,YAAW,UAAU;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6GAA4G;AAC5G;AACA;AACA;AACA;AACA;AACA;AACA,UAAS;AACT;AACA;AACA;AACA;AACA;AACA,4DAA2D;AAC3D;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;AC1FA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;;;;;;AC1DA;AACA;;AAEA;AACA;AACA,YAAW,YAAY;AACvB,cAAa,OAAO;AACpB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,IAAG;AACH;AACA;AACA;AACA,IAAG;AACH;AACA;AACA;AACA,IAAG;AACH;AACA;AACA,IAAG;AACH;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,8BAA6B;;AAE7B;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,6B;;;;;;ACpFA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;;AAEA;;;;;;;AC1BA;;AAEA;;AAEA,gCAA+B,qDAAqD;;AAEpF;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA,qD;;;;;;AClCA;;AAEA;;AAEA,oDAAmD,gBAAgB,sBAAsB,OAAO,2BAA2B,0BAA0B,yDAAyD,2BAA2B,EAAE,EAAE,EAAE,eAAe;;AAE9P,kCAAiC,2CAA2C,gBAAgB,kBAAkB,OAAO,2BAA2B,wDAAwD,gCAAgC,uDAAuD,2DAA2D,EAAE,EAAE,yDAAyD,qEAAqE,6DAA6D,oBAAoB,GAAG,EAAE;;AAEljB,uCAAsC,uCAAuC,kBAAkB;;AAE/F,kDAAiD,0CAA0C,0DAA0D,EAAE;;AAEvJ,2CAA0C,+DAA+D,qGAAqG,EAAE,yEAAyE,eAAe,yEAAyE,EAAE,EAAE,uHAAuH;;AAE5e;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA,IAAG;;AAEH;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,uCAAsC;AACtC,0CAAyC;AACzC,yCAAwC;AACxC,4CAA2C;AAC3C;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,yBAAwB,qIAAqI;AAC7J;AACA;;AAEA;AACA,gCAA+B,MAAM,cAAc,MAAM;AACzD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,iDAAgD;AAChD;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,iDAAgD;AAChD;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,YAAW;AACX;AACA;AACA,4BAA2B,qBAAqB;AAChD;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,UAAS;;AAET;;AAEA;AACA,QAAO;AACP;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA,8DAA6D;AAC7D;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA,EAAC;;AAED;AACA;;AAEA;AACA;AACA,W;;;;;;;;ACxQA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,qC;;;;;;;ACjBA,UAAS,IAAI,iCAAiC,OAAO;AACrD,MAAK,cAAc,yBAAyB,QAAQ,QAAQ;;AAE5D;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,qC;;;;;;;;AClBA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA,2B;;;;;;AC1CA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,IAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAG;AACH;AACA;AACA;AACA;AACA,IAAG;AACH;AACA;AACA;AACA;AACA;;AAEA,EAAC;;;;;;;;AC/BD;AACA;AACA;AACA;AACA;AACA;;AAEA,eAAc,4BAA4B;AAC1C;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAsB,eAAe;AACrC;AACA;AACA;AACA,cAAa;AACb,sCAAqC,UAAU;AAC/C;AACA;AACA;AACA,QAAO;AACP;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;;AAEA;AACA,mBAAkB,kBAAkB;AACpC;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AA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;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;AACA,KAAI,2CAA2C;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA,oBAAmB,8BAA8B;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAY;AACZ,IAAG;AACH;;AAEA;AACA;AACA;AACA;;AAEA,kBAAiB,8BAA8B;AAC/C;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,kBAAiB,8BAA8B;AAC/C;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA,kDAAiD,KAAK,wBAAwB;AAC9E,MAAK,6CAA6C;AAClD;;AAEA;AACA,4BAA2B;AAC3B;AACA,qEAAoE,KAAK,KAAK;AAC9E,6CAA4C,KAAK,OAAO;AACxD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAgB,+DAA+D;AAC/E;AACA;AACA;AACA,iBAAgB,+DAA+D;AAC/E;AACA;AACA,aAAY;AACZ,IAAG;;AAEH;AACA;AACA;AACA;AACA,kBAAiB,iCAAiC;AAClD;AACA;AACA,oBAAmB,iCAAiC;AACpD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAO;AACP;AACA;AACA;AACA;AACA,QAAO;AACP;AACA;AACA;AACA;AACA,MAAK;AACL;AACA,IAAG;AACH;AACA;AACA;AACA;AACA,QAAO;AACP;AACA;AACA;AACA;AACA,QAAO;AACP;AACA,MAAK;AACL;AACA,IAAG;;AAEH;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA,sBAAqB,6BAA6B;AAClD;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,6CAA4C;AAC5C,iDAAgD;AAChD,+CAA8C;AAC9C,mDAAkD;AAClD;AACA;AACA;AACA,mCAAkC;AAClC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAO;AACP;;AAEA;AACA;AACA;AACA;;AAEA,gCAA+B,MAAM,cAAc,MAAM;AACzD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA,iDAAgD;AAChD;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,iDAAgD;AAChD;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;;AAEA,wBAAuB,iCAAiC;AACxD;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,cAAa;AACb;AACA;AACA,8BAA6B,qBAAqB;AAClD;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,UAAS;;AAET;;AAEA;AACA,QAAO;AACP;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA,wBAAuB,KAAK,6BAA6B,KAAK;AAC9D,2BAA0B;AAC1B;AACA;AACA;AACA,MAAK;AACL;AACA;AACA,wBAAuB,uBAAuB;AAC9C;AACA;AACA;AACA;AACA;AACA,QAAO;AACP;AACA;AACA;AACA,MAAK;AACL;AACA,MAAK;AACL;AACA;AACA,MAAK;AACL;AACA,MAAK;;AAEL;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA,8DAA6D;AAC7D;AACA;;AAEA;AACA;AACA;AACA,MAAK;AACL;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA,EAAC;;AAED;AACA;;AAEA;AACA;AACA,wEAAuE;AACvE,oDAAmD;AACnD;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,yC;;;;;;;;ACvgBA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,6BAA4B;;AAE5B;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,kBAAiB,iBAAiB;AAClC;AACA;AACA;AACA,kBAAiB,iBAAiB;AAClC;AACA;;AAEA;AACA;AACA;AACA;AACA,kBAAiB,iBAAiB;AAClC;AACA;AACA,kBAAiB,iBAAiB;AAClC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,MAAK;AACL;AACA;AACA,MAAK;AACL;;AAEA;AACA;AACA;AACA;AACA,sBAAqB,iBAAiB;AACtC;AACA;AACA;AACA;;AAEA;AACA;AACA,UAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAmB,iBAAiB;AACpC;AACA;AACA;AACA;AACA;AACA;AACA,QAAO;AACP;AACA;AACA;AACA;AACA;AACA,IAAG;AACH;;AAEA;AACA,2E;;;;;;AC3GA;;AAEA;;AAEA,oDAAmD,gBAAgB,sBAAsB,OAAO,2BAA2B,0BAA0B,yDAAyD,2BAA2B,EAAE,EAAE,EAAE,eAAe;;AAE9P;;AAEA,uCAAsC,uCAAuC,kBAAkB;;AAE/F;;AAEA;;AAEA,gCAA+B;AAC/B;AACA,EAAC;;AAED;AACA,qBAAoB,0BAA0B,WAAW;AACzD;;AAEA,qC;;;;;;ACtBA;;AAEA;AACA;AACA,cAAa,8BAA8B;AAC3C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","file":"b22566d5aa23f30bc952.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory(require(\"react\"));\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([\"react\"], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"ScrollArea\"] = factory(require(\"react\"));\n\telse\n\t\troot[\"ScrollArea\"] = factory(root[\"React\"]);\n})(this, function(__WEBPACK_EXTERNAL_MODULE_2__) {\nreturn \n\n\n// WEBPACK FOOTER //\n// webpack/universalModuleDefinition"," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId])\n \t\t\treturn installedModules[moduleId].exports;\n\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\texports: {},\n \t\t\tid: moduleId,\n \t\t\tloaded: false\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.loaded = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(0);\n\n\n\n// WEBPACK FOOTER //\n// webpack/bootstrap b22566d5aa23f30bc952","import ScrollArea from './ScrollArea.jsx';\n\nexport default ScrollArea;\n\n\n// WEBPACK FOOTER //\n// ./src/js/ScrollAreaWithoutCss.js","import React from 'react';\nimport PropTypes from 'prop-types';\nimport lineHeight from 'line-height';\nimport { Motion, spring } from 'react-motion';\n\nimport {\n  findDOMNode, warnAboutFunctionChild, warnAboutElementChild, positiveOrZero, modifyObjValues,\n} from './utils';\nimport ScrollBar from './Scrollbar';\n\nconst eventTypes = {\n    wheel: 'wheel',\n    api: 'api',\n    touch: 'touch',\n    touchEnd: 'touchEnd',\n    mousemove: 'mousemove',\n    keyPress: 'keypress'\n};\n\nexport default class ScrollArea extends React.Component {\n    constructor(props) {\n        super(props);\n        this.state = {\n            topPosition: 0,\n            leftPosition: 0,\n            realHeight: 0,\n            containerHeight: 0,\n            realWidth: 0,\n            containerWidth: 0\n        };\n\n        this.scrollArea = {\n            refresh: () => {\n                this.setSizesToState();\n            },\n            scrollTop: () => {\n                this.scrollTop();\n            },\n            scrollBottom: () => {\n                this.scrollBottom();\n            },\n            scrollYTo: (position) => {\n                this.scrollYTo(position);\n            },\n            scrollLeft: () => {\n                this.scrollLeft();\n            },\n            scrollRight: () => {\n                this.scrollRight();\n            },\n            scrollXTo: (position) => {\n                this.scrollXTo(position);\n            }\n        };\n\n        this.evntsPreviousValues = {\n            clientX: 0,\n            clientY: 0,\n            deltaX: 0,\n            deltaY: 0\n        };\n\n        this.bindedHandleWindowResize = this.handleWindowResize.bind(this);\n    }\n\n    getChildContext() {\n        return {\n            scrollArea: this.scrollArea\n        };\n    }\n\n    componentDidMount() {\n        if (this.props.contentWindow) {\n            this.props.contentWindow.addEventListener(\"resize\", this.bindedHandleWindowResize);\n        }\n        this.lineHeightPx = lineHeight(findDOMNode(this.content));\n        this.setSizesToState();\n    }\n\n    componentWillUnmount() {\n        if (this.props.contentWindow) {\n            this.props.contentWindow.removeEventListener(\"resize\", this.bindedHandleWindowResize);\n        }\n    }\n\n    componentDidUpdate() {\n        this.setSizesToState();\n    }\n\n    render() {\n        let {children, className, contentClassName, ownerDocument} = this.props;\n        let withMotion = this.props.smoothScrolling &&\n            (this.state.eventType === eventTypes.wheel || this.state.eventType === eventTypes.api || this.state.eventType === eventTypes.touchEnd ||\n            this.state.eventType === eventTypes.keyPress);\n\n        let scrollbarY = this.canScrollY() ? (\n            <ScrollBar\n                ownerDocument={ownerDocument}\n                realSize={this.state.realHeight}\n                containerSize={this.state.containerHeight}\n                position={this.state.topPosition}\n                onMove={this.handleScrollbarMove.bind(this)}\n                onPositionChange={this.handleScrollbarYPositionChange.bind(this)}\n                containerStyle={this.props.verticalContainerStyle}\n                scrollbarStyle={this.props.verticalScrollbarStyle}\n                smoothScrolling={withMotion}\n                minScrollSize={this.props.minScrollSize}\n                onFocus={this.focusContent.bind(this)}\n                type=\"vertical\"/>\n        ) : null;\n\n        let scrollbarX = this.canScrollX() ? (\n            <ScrollBar\n                ownerDocument={ownerDocument}\n                realSize={this.state.realWidth}\n                containerSize={this.state.containerWidth}\n                position={this.state.leftPosition}\n                onMove={this.handleScrollbarMove.bind(this)}\n                onPositionChange={this.handleScrollbarXPositionChange.bind(this)}\n                containerStyle={this.props.horizontalContainerStyle}\n                scrollbarStyle={this.props.horizontalScrollbarStyle}\n                smoothScrolling={withMotion}\n                minScrollSize={this.props.minScrollSize}\n                onFocus={this.focusContent.bind(this)}\n                type=\"horizontal\"/>\n        ) : null;\n\n        if (typeof children === 'function') {\n            warnAboutFunctionChild();\n            children = children();\n        } else {\n            warnAboutElementChild();\n        }\n\n        let classes = 'scrollarea ' + (className || '');\n        let contentClasses = 'scrollarea-content ' + (contentClassName || '');\n\n        let contentStyle = {\n            marginTop: -this.state.topPosition,\n            marginLeft: -this.state.leftPosition\n        };\n        let springifiedContentStyle = withMotion ? modifyObjValues(contentStyle, x => spring(x)) : contentStyle;\n\n        return (\n            <Motion style={springifiedContentStyle}>\n                { style =>\n                    <div\n                        ref={x => this.wrapper = x}\n                        className={classes}\n                        style={this.props.style}\n                        onWheel={this.handleWheel.bind(this)}\n                    >\n                        <div\n                            ref={x => this.content = x}\n                            style={{ ...this.props.contentStyle, ...style }}\n                            className={contentClasses}\n                            onTouchStart={this.handleTouchStart.bind(this)}\n                            onTouchMove={this.handleTouchMove.bind(this)}\n                            onTouchEnd={this.handleTouchEnd.bind(this)}\n                            onKeyDown={this.handleKeyDown.bind(this)}\n                            tabIndex={this.props.focusableTabIndex}\n                        >\n                            {children}\n                        </div>\n                        {scrollbarY}\n                        {scrollbarX}\n                    </div>\n                }\n            </Motion>\n        );\n    }\n\n    setStateFromEvent(newState, eventType) {\n        if (this.props.onScroll) {\n            this.props.onScroll(newState);\n        }\n        this.setState({...newState, eventType});\n    }\n\n    handleTouchStart(e) {\n        let {touches} = e;\n        if (touches.length === 1) {\n            let {clientX, clientY} = touches[0];\n            this.eventPreviousValues = {\n                ...this.eventPreviousValues,\n                clientY,\n                clientX,\n                timestamp: Date.now()\n            };\n        }\n    }\n\n    handleTouchMove(e) {\n        if (this.canScroll()) {\n            e.preventDefault();\n            e.stopPropagation();\n        }\n\n        let {touches} = e;\n        if (touches.length === 1) {\n            let {clientX, clientY} = touches[0];\n\n            let deltaY = this.eventPreviousValues.clientY - clientY;\n            let deltaX = this.eventPreviousValues.clientX - clientX;\n\n            this.eventPreviousValues = {\n                ...this.eventPreviousValues,\n                deltaY,\n                deltaX,\n                clientY,\n                clientX,\n                timestamp: Date.now()\n            };\n\n            this.setStateFromEvent(this.composeNewState(-deltaX, -deltaY));\n        }\n    }\n\n    handleTouchEnd(e) {\n        let {deltaX, deltaY, timestamp} = this.eventPreviousValues;\n        if (typeof deltaX === 'undefined') deltaX = 0;\n        if (typeof deltaY === 'undefined') deltaY = 0;\n        if (Date.now() - timestamp < 200) {\n            this.setStateFromEvent(this.composeNewState(-deltaX * 10, -deltaY * 10), eventTypes.touchEnd);\n        }\n\n        this.eventPreviousValues = {\n            ...this.eventPreviousValues,\n            deltaY: 0,\n            deltaX: 0\n        };\n    }\n\n    handleScrollbarMove(deltaY, deltaX) {\n        this.setStateFromEvent(this.composeNewState(deltaX, deltaY));\n    }\n\n    handleScrollbarXPositionChange(position) {\n        this.scrollXTo(position);\n    }\n\n    handleScrollbarYPositionChange(position) {\n        this.scrollYTo(position);\n    }\n\n    handleWheel(e) {\n        let deltaY = e.deltaY;\n        let deltaX = e.deltaX;\n\n        if (this.props.swapWheelAxes) {\n            [deltaY, deltaX] = [deltaX, deltaY];\n        }\n\n        /*\n         * WheelEvent.deltaMode can differ between browsers and must be normalized\n         * e.deltaMode === 0: The delta values are specified in pixels\n         * e.deltaMode === 1: The delta values are specified in lines\n         * https://developer.mozilla.org/en-US/docs/Web/API/WheelEvent/deltaMode\n         */\n        if (e.deltaMode === 1) {\n            deltaY = deltaY * this.lineHeightPx;\n            deltaX = deltaX * this.lineHeightPx;\n        }\n\n        deltaY = deltaY * this.props.speed;\n        deltaX = deltaX * this.props.speed;\n\n        let newState = this.composeNewState(-deltaX, -deltaY);\n\n        if ((newState.topPosition && this.state.topPosition !== newState.topPosition) ||\n            (newState.leftPosition && this.state.leftPosition !== newState.leftPosition) ||\n            this.props.stopScrollPropagation) {\n            e.preventDefault();\n            e.stopPropagation();\n        }\n\n        this.setStateFromEvent(newState, eventTypes.wheel);\n        this.focusContent();\n    }\n\n    handleKeyDown(e) {\n        // only handle if scroll area is in focus\n        if (e.target.tagName.toLowerCase() !== 'input' && e.target.tagName.toLowerCase() !== 'textarea' && !e.target.isContentEditable) {\n            let deltaY = 0;\n            let deltaX = 0;\n            let lineHeight = this.lineHeightPx ? this.lineHeightPx : 10;\n\n            switch (e.keyCode) {\n                case 33: // page up\n                    deltaY = this.state.containerHeight - lineHeight;\n                    break;\n                case 34: // page down\n                    deltaY = -this.state.containerHeight + lineHeight;\n                    break;\n                case 37: // left\n                    deltaX = lineHeight;\n                    break;\n                case 38: // up\n                    deltaY = lineHeight;\n                    break;\n                case 39: // right\n                    deltaX = -lineHeight;\n                    break;\n                case 40: // down\n                    deltaY = -lineHeight;\n                    break;\n            }\n\n            // only compose new state if key code matches those above\n            if (deltaY !== 0 || deltaX !== 0) {\n                let newState = this.composeNewState(deltaX, deltaY);\n\n                e.preventDefault();\n                e.stopPropagation();\n\n                this.setStateFromEvent(newState, eventTypes.keyPress);\n            }\n        }\n    }\n\n    handleWindowResize() {\n        let newState = this.computeSizes();\n        newState = this.getModifiedPositionsIfNeeded(newState);\n        this.setStateFromEvent(newState);\n    }\n\n    composeNewState(deltaX, deltaY) {\n        let newState = this.computeSizes();\n\n        if (this.canScrollY(newState)) {\n            newState.topPosition = this.computeTopPosition(deltaY, newState);\n        } else {\n          newState.topPosition = 0;\n        }\n        if (this.canScrollX(newState)) {\n            newState.leftPosition = this.computeLeftPosition(deltaX, newState);\n        }\n\n        return newState;\n    }\n\n    computeTopPosition(deltaY, sizes) {\n        let newTopPosition = this.state.topPosition - deltaY;\n        return this.normalizeTopPosition(newTopPosition, sizes);\n    }\n\n    computeLeftPosition(deltaX, sizes) {\n        let newLeftPosition = this.state.leftPosition - deltaX;\n        return this.normalizeLeftPosition(newLeftPosition, sizes);\n    }\n\n    normalizeTopPosition(newTopPosition, sizes) {\n        if (newTopPosition > sizes.realHeight - sizes.containerHeight) {\n            newTopPosition = sizes.realHeight - sizes.containerHeight;\n        }\n        if (newTopPosition < 0) {\n            newTopPosition = 0;\n        }\n        return newTopPosition;\n    }\n\n    normalizeLeftPosition(newLeftPosition, sizes) {\n        if (newLeftPosition > sizes.realWidth - sizes.containerWidth) {\n            newLeftPosition = sizes.realWidth - sizes.containerWidth;\n        } else if (newLeftPosition < 0) {\n            newLeftPosition = 0;\n        }\n\n        return newLeftPosition;\n    }\n\n    computeSizes() {\n        let realHeight = (this.content) ? this.content.offsetHeight : 0;\n        let containerHeight = (this.wrapper) ? this.wrapper.offsetHeight : 0;\n        let realWidth = (this.content) ? this.content.offsetWidth : 0;\n        let containerWidth = (this.content) ? this.wrapper.offsetWidth : 0;\n\n        return {\n            realHeight: realHeight,\n            containerHeight: containerHeight,\n            realWidth: realWidth,\n            containerWidth: containerWidth\n        };\n    }\n\n    setSizesToState() {\n        let sizes = this.computeSizes();\n        if (sizes.realHeight !== this.state.realHeight || sizes.realWidth !== this.state.realWidth) {\n            this.setStateFromEvent(this.getModifiedPositionsIfNeeded(sizes));\n        }\n    }\n\n    scrollTop() {\n        this.scrollYTo(0);\n    }\n\n    scrollBottom() {\n        this.scrollYTo((this.state.realHeight - this.state.containerHeight));\n    }\n\n    scrollLeft() {\n        this.scrollXTo(0);\n    }\n\n    scrollRight() {\n        this.scrollXTo((this.state.realWidth - this.state.containerWidth));\n    }\n\n    scrollYTo(topPosition) {\n        if (this.canScrollY()) {\n            let position = this.normalizeTopPosition(topPosition, this.computeSizes());\n            this.setStateFromEvent({topPosition: position}, eventTypes.api);\n        }\n    }\n\n    scrollXTo(leftPosition) {\n        if (this.canScrollX()) {\n            let position = this.normalizeLeftPosition(leftPosition, this.computeSizes());\n            this.setStateFromEvent({leftPosition: position}, eventTypes.api);\n        }\n    }\n\n    canScrollY(state = this.state) {\n        let scrollableY = state.realHeight > state.containerHeight;\n        return scrollableY && this.props.vertical;\n    }\n\n    canScrollX(state = this.state) {\n        let scrollableX = state.realWidth > state.containerWidth;\n        return scrollableX && this.props.horizontal;\n    }\n\n    canScroll(state = this.state) {\n        return this.canScrollY(state) || this.canScrollX(state);\n    }\n\n    getModifiedPositionsIfNeeded(newState) {\n        let bottomPosition = newState.realHeight - newState.containerHeight;\n        if (this.state.topPosition >= bottomPosition) {\n            newState.topPosition = this.canScrollY(newState) ? positiveOrZero(bottomPosition) : 0;\n        }\n\n        let rightPosition = newState.realWidth - newState.containerWidth;\n        if (this.state.leftPosition >= rightPosition) {\n            newState.leftPosition = this.canScrollX(newState) ? positiveOrZero(rightPosition) : 0;\n        }\n\n        return newState;\n    }\n\n    focusContent() {\n        if(this.content) {\n            findDOMNode(this.content).focus();\n        }\n    }\n}\n\nScrollArea.childContextTypes = {\n    scrollArea: PropTypes.object,\n};\n\nScrollArea.propTypes = {\n    className: PropTypes.string,\n    style: PropTypes.object,\n    speed: PropTypes.number,\n    contentClassName: PropTypes.string,\n    contentStyle: PropTypes.object,\n    vertical: PropTypes.bool,\n    verticalContainerStyle: PropTypes.object,\n    verticalScrollbarStyle: PropTypes.object,\n    horizontal: PropTypes.bool,\n    horizontalContainerStyle: PropTypes.object,\n    horizontalScrollbarStyle: PropTypes.object,\n    onScroll: PropTypes.func,\n    contentWindow: PropTypes.any,\n    ownerDocument: PropTypes.any,\n    smoothScrolling: PropTypes.bool,\n    minScrollSize: PropTypes.number,\n    swapWheelAxes: PropTypes.bool,\n    stopScrollPropagation: PropTypes.bool,\n    focusableTabIndex: PropTypes.number,\n};\n\nScrollArea.defaultProps = {\n    speed: 1,\n    vertical: true,\n    horizontal: true,\n    smoothScrolling: false,\n    swapWheelAxes: false,\n    contentWindow: (typeof window === \"object\") ? window : undefined,\n    ownerDocument: (typeof document === \"object\") ? document : undefined,\n    focusableTabIndex: 1,\n};\n\n\n\n// WEBPACK FOOTER //\n// ./src/js/ScrollArea.jsx","module.exports = __WEBPACK_EXTERNAL_MODULE_2__;\n\n\n//////////////////\n// WEBPACK FOOTER\n// external {\"root\":\"React\",\"commonjs2\":\"react\",\"commonjs\":\"react\",\"amd\":\"react\"}\n// module id = 2\n// module chunks = 0","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nif (process.env.NODE_ENV !== 'production') {\n  var REACT_ELEMENT_TYPE = (typeof Symbol === 'function' &&\n    Symbol.for &&\n    Symbol.for('react.element')) ||\n    0xeac7;\n\n  var isValidElement = function(object) {\n    return typeof object === 'object' &&\n      object !== null &&\n      object.$$typeof === REACT_ELEMENT_TYPE;\n  };\n\n  // By explicitly using `prop-types` you are opting into new development behavior.\n  // http://fb.me/prop-types-in-prod\n  var throwOnDirectAccess = true;\n  module.exports = require('./factoryWithTypeCheckers')(isValidElement, throwOnDirectAccess);\n} else {\n  // By explicitly using `prop-types` you are opting into new production behavior.\n  // http://fb.me/prop-types-in-prod\n  module.exports = require('./factoryWithThrowingShims')();\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/prop-types/index.js\n// module id = 3\n// module chunks = 0","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // 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\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // 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.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/process/browser.js\n// module id = 4\n// module chunks = 0","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar assign = require('object-assign');\n\nvar ReactPropTypesSecret = require('./lib/ReactPropTypesSecret');\nvar checkPropTypes = require('./checkPropTypes');\n\nvar printWarning = function() {};\n\nif (process.env.NODE_ENV !== 'production') {\n  printWarning = function(text) {\n    var message = 'Warning: ' + text;\n    if (typeof console !== 'undefined') {\n      console.error(message);\n    }\n    try {\n      // --- Welcome to debugging React ---\n      // This error was thrown as a convenience so that you can use this stack\n      // to find the callsite that caused this warning to fire.\n      throw new Error(message);\n    } catch (x) {}\n  };\n}\n\nfunction emptyFunctionThatReturnsNull() {\n  return null;\n}\n\nmodule.exports = function(isValidElement, throwOnDirectAccess) {\n  /* global Symbol */\n  var ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;\n  var FAUX_ITERATOR_SYMBOL = '@@iterator'; // Before Symbol spec.\n\n  /**\n   * Returns the iterator method function contained on the iterable object.\n   *\n   * Be sure to invoke the function with the iterable as context:\n   *\n   *     var iteratorFn = getIteratorFn(myIterable);\n   *     if (iteratorFn) {\n   *       var iterator = iteratorFn.call(myIterable);\n   *       ...\n   *     }\n   *\n   * @param {?object} maybeIterable\n   * @return {?function}\n   */\n  function getIteratorFn(maybeIterable) {\n    var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]);\n    if (typeof iteratorFn === 'function') {\n      return iteratorFn;\n    }\n  }\n\n  /**\n   * Collection of methods that allow declaration and validation of props that are\n   * supplied to React components. Example usage:\n   *\n   *   var Props = require('ReactPropTypes');\n   *   var MyArticle = React.createClass({\n   *     propTypes: {\n   *       // An optional string prop named \"description\".\n   *       description: Props.string,\n   *\n   *       // A required enum prop named \"category\".\n   *       category: Props.oneOf(['News','Photos']).isRequired,\n   *\n   *       // A prop named \"dialog\" that requires an instance of Dialog.\n   *       dialog: Props.instanceOf(Dialog).isRequired\n   *     },\n   *     render: function() { ... }\n   *   });\n   *\n   * A more formal specification of how these methods are used:\n   *\n   *   type := array|bool|func|object|number|string|oneOf([...])|instanceOf(...)\n   *   decl := ReactPropTypes.{type}(.isRequired)?\n   *\n   * Each and every declaration produces a function with the same signature. This\n   * allows the creation of custom validation functions. For example:\n   *\n   *  var MyLink = React.createClass({\n   *    propTypes: {\n   *      // An optional string or URI prop named \"href\".\n   *      href: function(props, propName, componentName) {\n   *        var propValue = props[propName];\n   *        if (propValue != null && typeof propValue !== 'string' &&\n   *            !(propValue instanceof URI)) {\n   *          return new Error(\n   *            'Expected a string or an URI for ' + propName + ' in ' +\n   *            componentName\n   *          );\n   *        }\n   *      }\n   *    },\n   *    render: function() {...}\n   *  });\n   *\n   * @internal\n   */\n\n  var ANONYMOUS = '<<anonymous>>';\n\n  // Important!\n  // Keep this list in sync with production version in `./factoryWithThrowingShims.js`.\n  var ReactPropTypes = {\n    array: createPrimitiveTypeChecker('array'),\n    bool: createPrimitiveTypeChecker('boolean'),\n    func: createPrimitiveTypeChecker('function'),\n    number: createPrimitiveTypeChecker('number'),\n    object: createPrimitiveTypeChecker('object'),\n    string: createPrimitiveTypeChecker('string'),\n    symbol: createPrimitiveTypeChecker('symbol'),\n\n    any: createAnyTypeChecker(),\n    arrayOf: createArrayOfTypeChecker,\n    element: createElementTypeChecker(),\n    instanceOf: createInstanceTypeChecker,\n    node: createNodeChecker(),\n    objectOf: createObjectOfTypeChecker,\n    oneOf: createEnumTypeChecker,\n    oneOfType: createUnionTypeChecker,\n    shape: createShapeTypeChecker,\n    exact: createStrictShapeTypeChecker,\n  };\n\n  /**\n   * inlined Object.is polyfill to avoid requiring consumers ship their own\n   * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is\n   */\n  /*eslint-disable no-self-compare*/\n  function is(x, y) {\n    // SameValue algorithm\n    if (x === y) {\n      // Steps 1-5, 7-10\n      // Steps 6.b-6.e: +0 != -0\n      return x !== 0 || 1 / x === 1 / y;\n    } else {\n      // Step 6.a: NaN == NaN\n      return x !== x && y !== y;\n    }\n  }\n  /*eslint-enable no-self-compare*/\n\n  /**\n   * We use an Error-like object for backward compatibility as people may call\n   * PropTypes directly and inspect their output. However, we don't use real\n   * Errors anymore. We don't inspect their stack anyway, and creating them\n   * is prohibitively expensive if they are created too often, such as what\n   * happens in oneOfType() for any type before the one that matched.\n   */\n  function PropTypeError(message) {\n    this.message = message;\n    this.stack = '';\n  }\n  // Make `instanceof Error` still work for returned errors.\n  PropTypeError.prototype = Error.prototype;\n\n  function createChainableTypeChecker(validate) {\n    if (process.env.NODE_ENV !== 'production') {\n      var manualPropTypeCallCache = {};\n      var manualPropTypeWarningCount = 0;\n    }\n    function checkType(isRequired, props, propName, componentName, location, propFullName, secret) {\n      componentName = componentName || ANONYMOUS;\n      propFullName = propFullName || propName;\n\n      if (secret !== ReactPropTypesSecret) {\n        if (throwOnDirectAccess) {\n          // New behavior only for users of `prop-types` package\n          var err = new Error(\n            'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +\n            'Use `PropTypes.checkPropTypes()` to call them. ' +\n            'Read more at http://fb.me/use-check-prop-types'\n          );\n          err.name = 'Invariant Violation';\n          throw err;\n        } else if (process.env.NODE_ENV !== 'production' && typeof console !== 'undefined') {\n          // Old behavior for people using React.PropTypes\n          var cacheKey = componentName + ':' + propName;\n          if (\n            !manualPropTypeCallCache[cacheKey] &&\n            // Avoid spamming the console because they are often not actionable except for lib authors\n            manualPropTypeWarningCount < 3\n          ) {\n            printWarning(\n              'You are manually calling a React.PropTypes validation ' +\n              'function for the `' + propFullName + '` prop on `' + componentName  + '`. This is deprecated ' +\n              'and will throw in the standalone `prop-types` package. ' +\n              'You may be seeing this warning due to a third-party PropTypes ' +\n              'library. See https://fb.me/react-warning-dont-call-proptypes ' + 'for details.'\n            );\n            manualPropTypeCallCache[cacheKey] = true;\n            manualPropTypeWarningCount++;\n          }\n        }\n      }\n      if (props[propName] == null) {\n        if (isRequired) {\n          if (props[propName] === null) {\n            return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required ' + ('in `' + componentName + '`, but its value is `null`.'));\n          }\n          return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required in ' + ('`' + componentName + '`, but its value is `undefined`.'));\n        }\n        return null;\n      } else {\n        return validate(props, propName, componentName, location, propFullName);\n      }\n    }\n\n    var chainedCheckType = checkType.bind(null, false);\n    chainedCheckType.isRequired = checkType.bind(null, true);\n\n    return chainedCheckType;\n  }\n\n  function createPrimitiveTypeChecker(expectedType) {\n    function validate(props, propName, componentName, location, propFullName, secret) {\n      var propValue = props[propName];\n      var propType = getPropType(propValue);\n      if (propType !== expectedType) {\n        // `propValue` being instance of, say, date/regexp, pass the 'object'\n        // check, but we can offer a more precise error message here rather than\n        // 'of type `object`'.\n        var preciseType = getPreciseType(propValue);\n\n        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + preciseType + '` supplied to `' + componentName + '`, expected ') + ('`' + expectedType + '`.'));\n      }\n      return null;\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function createAnyTypeChecker() {\n    return createChainableTypeChecker(emptyFunctionThatReturnsNull);\n  }\n\n  function createArrayOfTypeChecker(typeChecker) {\n    function validate(props, propName, componentName, location, propFullName) {\n      if (typeof typeChecker !== 'function') {\n        return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside arrayOf.');\n      }\n      var propValue = props[propName];\n      if (!Array.isArray(propValue)) {\n        var propType = getPropType(propValue);\n        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an array.'));\n      }\n      for (var i = 0; i < propValue.length; i++) {\n        var error = typeChecker(propValue, i, componentName, location, propFullName + '[' + i + ']', ReactPropTypesSecret);\n        if (error instanceof Error) {\n          return error;\n        }\n      }\n      return null;\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function createElementTypeChecker() {\n    function validate(props, propName, componentName, location, propFullName) {\n      var propValue = props[propName];\n      if (!isValidElement(propValue)) {\n        var propType = getPropType(propValue);\n        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement.'));\n      }\n      return null;\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function createInstanceTypeChecker(expectedClass) {\n    function validate(props, propName, componentName, location, propFullName) {\n      if (!(props[propName] instanceof expectedClass)) {\n        var expectedClassName = expectedClass.name || ANONYMOUS;\n        var actualClassName = getClassName(props[propName]);\n        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + actualClassName + '` supplied to `' + componentName + '`, expected ') + ('instance of `' + expectedClassName + '`.'));\n      }\n      return null;\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function createEnumTypeChecker(expectedValues) {\n    if (!Array.isArray(expectedValues)) {\n      process.env.NODE_ENV !== 'production' ? printWarning('Invalid argument supplied to oneOf, expected an instance of array.') : void 0;\n      return emptyFunctionThatReturnsNull;\n    }\n\n    function validate(props, propName, componentName, location, propFullName) {\n      var propValue = props[propName];\n      for (var i = 0; i < expectedValues.length; i++) {\n        if (is(propValue, expectedValues[i])) {\n          return null;\n        }\n      }\n\n      var valuesString = JSON.stringify(expectedValues);\n      return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of value `' + propValue + '` ' + ('supplied to `' + componentName + '`, expected one of ' + valuesString + '.'));\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function createObjectOfTypeChecker(typeChecker) {\n    function validate(props, propName, componentName, location, propFullName) {\n      if (typeof typeChecker !== 'function') {\n        return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside objectOf.');\n      }\n      var propValue = props[propName];\n      var propType = getPropType(propValue);\n      if (propType !== 'object') {\n        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an object.'));\n      }\n      for (var key in propValue) {\n        if (propValue.hasOwnProperty(key)) {\n          var error = typeChecker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);\n          if (error instanceof Error) {\n            return error;\n          }\n        }\n      }\n      return null;\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function createUnionTypeChecker(arrayOfTypeCheckers) {\n    if (!Array.isArray(arrayOfTypeCheckers)) {\n      process.env.NODE_ENV !== 'production' ? printWarning('Invalid argument supplied to oneOfType, expected an instance of array.') : void 0;\n      return emptyFunctionThatReturnsNull;\n    }\n\n    for (var i = 0; i < arrayOfTypeCheckers.length; i++) {\n      var checker = arrayOfTypeCheckers[i];\n      if (typeof checker !== 'function') {\n        printWarning(\n          'Invalid argument supplied to oneOfType. Expected an array of check functions, but ' +\n          'received ' + getPostfixForTypeWarning(checker) + ' at index ' + i + '.'\n        );\n        return emptyFunctionThatReturnsNull;\n      }\n    }\n\n    function validate(props, propName, componentName, location, propFullName) {\n      for (var i = 0; i < arrayOfTypeCheckers.length; i++) {\n        var checker = arrayOfTypeCheckers[i];\n        if (checker(props, propName, componentName, location, propFullName, ReactPropTypesSecret) == null) {\n          return null;\n        }\n      }\n\n      return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`.'));\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function createNodeChecker() {\n    function validate(props, propName, componentName, location, propFullName) {\n      if (!isNode(props[propName])) {\n        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`, expected a ReactNode.'));\n      }\n      return null;\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function createShapeTypeChecker(shapeTypes) {\n    function validate(props, propName, componentName, location, propFullName) {\n      var propValue = props[propName];\n      var propType = getPropType(propValue);\n      if (propType !== 'object') {\n        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));\n      }\n      for (var key in shapeTypes) {\n        var checker = shapeTypes[key];\n        if (!checker) {\n          continue;\n        }\n        var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);\n        if (error) {\n          return error;\n        }\n      }\n      return null;\n    }\n    return createChainableTypeChecker(validate);\n  }\n\n  function createStrictShapeTypeChecker(shapeTypes) {\n    function validate(props, propName, componentName, location, propFullName) {\n      var propValue = props[propName];\n      var propType = getPropType(propValue);\n      if (propType !== 'object') {\n        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));\n      }\n      // We need to check all keys in case some are required but missing from\n      // props.\n      var allKeys = assign({}, props[propName], shapeTypes);\n      for (var key in allKeys) {\n        var checker = shapeTypes[key];\n        if (!checker) {\n          return new PropTypeError(\n            'Invalid ' + location + ' `' + propFullName + '` key `' + key + '` supplied to `' + componentName + '`.' +\n            '\\nBad object: ' + JSON.stringify(props[propName], null, '  ') +\n            '\\nValid keys: ' +  JSON.stringify(Object.keys(shapeTypes), null, '  ')\n          );\n        }\n        var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);\n        if (error) {\n          return error;\n        }\n      }\n      return null;\n    }\n\n    return createChainableTypeChecker(validate);\n  }\n\n  function isNode(propValue) {\n    switch (typeof propValue) {\n      case 'number':\n      case 'string':\n      case 'undefined':\n        return true;\n      case 'boolean':\n        return !propValue;\n      case 'object':\n        if (Array.isArray(propValue)) {\n          return propValue.every(isNode);\n        }\n        if (propValue === null || isValidElement(propValue)) {\n          return true;\n        }\n\n        var iteratorFn = getIteratorFn(propValue);\n        if (iteratorFn) {\n          var iterator = iteratorFn.call(propValue);\n          var step;\n          if (iteratorFn !== propValue.entries) {\n            while (!(step = iterator.next()).done) {\n              if (!isNode(step.value)) {\n                return false;\n              }\n            }\n          } else {\n            // Iterator will provide entry [k,v] tuples rather than values.\n            while (!(step = iterator.next()).done) {\n              var entry = step.value;\n              if (entry) {\n                if (!isNode(entry[1])) {\n                  return false;\n                }\n              }\n            }\n          }\n        } else {\n          return false;\n        }\n\n        return true;\n      default:\n        return false;\n    }\n  }\n\n  function isSymbol(propType, propValue) {\n    // Native Symbol.\n    if (propType === 'symbol') {\n      return true;\n    }\n\n    // 19.4.3.5 Symbol.prototype[@@toStringTag] === 'Symbol'\n    if (propValue['@@toStringTag'] === 'Symbol') {\n      return true;\n    }\n\n    // Fallback for non-spec compliant Symbols which are polyfilled.\n    if (typeof Symbol === 'function' && propValue instanceof Symbol) {\n      return true;\n    }\n\n    return false;\n  }\n\n  // Equivalent of `typeof` but with special handling for array and regexp.\n  function getPropType(propValue) {\n    var propType = typeof propValue;\n    if (Array.isArray(propValue)) {\n      return 'array';\n    }\n    if (propValue instanceof RegExp) {\n      // Old webkits (at least until Android 4.0) return 'function' rather than\n      // 'object' for typeof a RegExp. We'll normalize this here so that /bla/\n      // passes PropTypes.object.\n      return 'object';\n    }\n    if (isSymbol(propType, propValue)) {\n      return 'symbol';\n    }\n    return propType;\n  }\n\n  // This handles more types than `getPropType`. Only used for error messages.\n  // See `createPrimitiveTypeChecker`.\n  function getPreciseType(propValue) {\n    if (typeof propValue === 'undefined' || propValue === null) {\n      return '' + propValue;\n    }\n    var propType = getPropType(propValue);\n    if (propType === 'object') {\n      if (propValue instanceof Date) {\n        return 'date';\n      } else if (propValue instanceof RegExp) {\n        return 'regexp';\n      }\n    }\n    return propType;\n  }\n\n  // Returns a string that is postfixed to a warning about an invalid type.\n  // For example, \"undefined\" or \"of type array\"\n  function getPostfixForTypeWarning(value) {\n    var type = getPreciseType(value);\n    switch (type) {\n      case 'array':\n      case 'object':\n        return 'an ' + type;\n      case 'boolean':\n      case 'date':\n      case 'regexp':\n        return 'a ' + type;\n      default:\n        return type;\n    }\n  }\n\n  // Returns class name of the object, if any.\n  function getClassName(propValue) {\n    if (!propValue.constructor || !propValue.constructor.name) {\n      return ANONYMOUS;\n    }\n    return propValue.constructor.name;\n  }\n\n  ReactPropTypes.checkPropTypes = checkPropTypes;\n  ReactPropTypes.PropTypes = ReactPropTypes;\n\n  return ReactPropTypes;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/prop-types/factoryWithTypeCheckers.js\n// module id = 5\n// module chunks = 0","/*\nobject-assign\n(c) Sindre Sorhus\n@license MIT\n*/\n\n'use strict';\n/* eslint-disable no-unused-vars */\nvar getOwnPropertySymbols = Object.getOwnPropertySymbols;\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nvar propIsEnumerable = Object.prototype.propertyIsEnumerable;\n\nfunction toObject(val) {\n\tif (val === null || val === undefined) {\n\t\tthrow new TypeError('Object.assign cannot be called with null or undefined');\n\t}\n\n\treturn Object(val);\n}\n\nfunction shouldUseNative() {\n\ttry {\n\t\tif (!Object.assign) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// Detect buggy property enumeration order in older V8 versions.\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=4118\n\t\tvar test1 = new String('abc');  // eslint-disable-line no-new-wrappers\n\t\ttest1[5] = 'de';\n\t\tif (Object.getOwnPropertyNames(test1)[0] === '5') {\n\t\t\treturn false;\n\t\t}\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=3056\n\t\tvar test2 = {};\n\t\tfor (var i = 0; i < 10; i++) {\n\t\t\ttest2['_' + String.fromCharCode(i)] = i;\n\t\t}\n\t\tvar order2 = Object.getOwnPropertyNames(test2).map(function (n) {\n\t\t\treturn test2[n];\n\t\t});\n\t\tif (order2.join('') !== '0123456789') {\n\t\t\treturn false;\n\t\t}\n\n\t\t// https://bugs.chromium.org/p/v8/issues/detail?id=3056\n\t\tvar test3 = {};\n\t\t'abcdefghijklmnopqrst'.split('').forEach(function (letter) {\n\t\t\ttest3[letter] = letter;\n\t\t});\n\t\tif (Object.keys(Object.assign({}, test3)).join('') !==\n\t\t\t\t'abcdefghijklmnopqrst') {\n\t\t\treturn false;\n\t\t}\n\n\t\treturn true;\n\t} catch (err) {\n\t\t// We don't expect any of the above to throw, but better to be safe.\n\t\treturn false;\n\t}\n}\n\nmodule.exports = shouldUseNative() ? Object.assign : function (target, source) {\n\tvar from;\n\tvar to = toObject(target);\n\tvar symbols;\n\n\tfor (var s = 1; s < arguments.length; s++) {\n\t\tfrom = Object(arguments[s]);\n\n\t\tfor (var key in from) {\n\t\t\tif (hasOwnProperty.call(from, key)) {\n\t\t\t\tto[key] = from[key];\n\t\t\t}\n\t\t}\n\n\t\tif (getOwnPropertySymbols) {\n\t\t\tsymbols = getOwnPropertySymbols(from);\n\t\t\tfor (var i = 0; i < symbols.length; i++) {\n\t\t\t\tif (propIsEnumerable.call(from, symbols[i])) {\n\t\t\t\t\tto[symbols[i]] = from[symbols[i]];\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn to;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/object-assign/index.js\n// module id = 6\n// module chunks = 0","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';\n\nmodule.exports = ReactPropTypesSecret;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/prop-types/lib/ReactPropTypesSecret.js\n// module id = 7\n// module chunks = 0","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar printWarning = function() {};\n\nif (process.env.NODE_ENV !== 'production') {\n  var ReactPropTypesSecret = require('./lib/ReactPropTypesSecret');\n  var loggedTypeFailures = {};\n\n  printWarning = function(text) {\n    var message = 'Warning: ' + text;\n    if (typeof console !== 'undefined') {\n      console.error(message);\n    }\n    try {\n      // --- Welcome to debugging React ---\n      // This error was thrown as a convenience so that you can use this stack\n      // to find the callsite that caused this warning to fire.\n      throw new Error(message);\n    } catch (x) {}\n  };\n}\n\n/**\n * Assert that the values match with the type specs.\n * Error messages are memorized and will only be shown once.\n *\n * @param {object} typeSpecs Map of name to a ReactPropType\n * @param {object} values Runtime values that need to be type-checked\n * @param {string} location e.g. \"prop\", \"context\", \"child context\"\n * @param {string} componentName Name of the component for error messages.\n * @param {?Function} getStack Returns the component stack.\n * @private\n */\nfunction checkPropTypes(typeSpecs, values, location, componentName, getStack) {\n  if (process.env.NODE_ENV !== 'production') {\n    for (var typeSpecName in typeSpecs) {\n      if (typeSpecs.hasOwnProperty(typeSpecName)) {\n        var error;\n        // Prop type validation may throw. In case they do, we don't want to\n        // fail the render phase where it didn't fail before. So we log it.\n        // After these have been cleaned up, we'll let them throw.\n        try {\n          // This is intentionally an invariant that gets caught. It's the same\n          // behavior as without this statement except with a better message.\n          if (typeof typeSpecs[typeSpecName] !== 'function') {\n            var err = Error(\n              (componentName || 'React class') + ': ' + location + ' type `' + typeSpecName + '` is invalid; ' +\n              'it must be a function, usually from the `prop-types` package, but received `' + typeof typeSpecs[typeSpecName] + '`.'\n            );\n            err.name = 'Invariant Violation';\n            throw err;\n          }\n          error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);\n        } catch (ex) {\n          error = ex;\n        }\n        if (error && !(error instanceof Error)) {\n          printWarning(\n            (componentName || 'React class') + ': type specification of ' +\n            location + ' `' + typeSpecName + '` is invalid; the type checker ' +\n            'function must return `null` or an `Error` but returned a ' + typeof error + '. ' +\n            'You may have forgotten to pass an argument to the type checker ' +\n            'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' +\n            'shape all require an argument).'\n          )\n\n        }\n        if (error instanceof Error && !(error.message in loggedTypeFailures)) {\n          // Only monitor this failure once because there tends to be a lot of the\n          // same error.\n          loggedTypeFailures[error.message] = true;\n\n          var stack = getStack ? getStack() : '';\n\n          printWarning(\n            'Failed ' + location + ' type: ' + error.message + (stack != null ? stack : '')\n          );\n        }\n      }\n    }\n  }\n}\n\nmodule.exports = checkPropTypes;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/prop-types/checkPropTypes.js\n// module id = 8\n// module chunks = 0","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar ReactPropTypesSecret = require('./lib/ReactPropTypesSecret');\n\nfunction emptyFunction() {}\n\nmodule.exports = function() {\n  function shim(props, propName, componentName, location, propFullName, secret) {\n    if (secret === ReactPropTypesSecret) {\n      // It is still safe when called from React.\n      return;\n    }\n    var err = new Error(\n      'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +\n      'Use PropTypes.checkPropTypes() to call them. ' +\n      'Read more at http://fb.me/use-check-prop-types'\n    );\n    err.name = 'Invariant Violation';\n    throw err;\n  };\n  shim.isRequired = shim;\n  function getShim() {\n    return shim;\n  };\n  // Important!\n  // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.\n  var ReactPropTypes = {\n    array: shim,\n    bool: shim,\n    func: shim,\n    number: shim,\n    object: shim,\n    string: shim,\n    symbol: shim,\n\n    any: shim,\n    arrayOf: getShim,\n    element: shim,\n    instanceOf: getShim,\n    node: shim,\n    objectOf: getShim,\n    oneOf: getShim,\n    oneOfType: getShim,\n    shape: getShim,\n    exact: getShim\n  };\n\n  ReactPropTypes.checkPropTypes = emptyFunction;\n  ReactPropTypes.PropTypes = ReactPropTypes;\n\n  return ReactPropTypes;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/prop-types/factoryWithThrowingShims.js\n// module id = 9\n// module chunks = 0","// Load in dependencies\nvar computedStyle = require('computed-style');\n\n/**\n * Calculate the `line-height` of a given node\n * @param {HTMLElement} node Element to calculate line height of. Must be in the DOM.\n * @returns {Number} `line-height` of the element in pixels\n */\nfunction lineHeight(node) {\n  // Grab the line-height via style\n  var lnHeightStr = computedStyle(node, 'line-height'),\n      lnHeight = parseFloat(lnHeightStr, 10);\n\n  // If the lineHeight did not contain a unit (i.e. it was numeric), convert it to ems (e.g. '2.3' === '2.3em')\n  if (lnHeightStr === lnHeight + '') {\n    // Save the old lineHeight style and update the em unit to the element\n    var _lnHeightStyle = node.style.lineHeight;\n    node.style.lineHeight = lnHeightStr + 'em';\n\n    // Calculate the em based height\n    lnHeightStr = computedStyle(node, 'line-height');\n    lnHeight = parseFloat(lnHeightStr, 10);\n\n    // Revert the lineHeight style\n    if (_lnHeightStyle) {\n      node.style.lineHeight = _lnHeightStyle;\n    } else {\n      delete node.style.lineHeight;\n    }\n  }\n\n  // If the lineHeight is in `pt`, convert it to pixels (4px for 3pt)\n  // DEV: `em` units are converted to `pt` in IE6\n  // Conversion ratio from https://developer.mozilla.org/en-US/docs/Web/CSS/length\n  if (lnHeightStr.indexOf('pt') !== -1) {\n    lnHeight *= 4;\n    lnHeight /= 3;\n  } else if (lnHeightStr.indexOf('mm') !== -1) {\n  // Otherwise, if the lineHeight is in `mm`, convert it to pixels (96px for 25.4mm)\n    lnHeight *= 96;\n    lnHeight /= 25.4;\n  } else if (lnHeightStr.indexOf('cm') !== -1) {\n  // Otherwise, if the lineHeight is in `cm`, convert it to pixels (96px for 2.54cm)\n    lnHeight *= 96;\n    lnHeight /= 2.54;\n  } else if (lnHeightStr.indexOf('in') !== -1) {\n  // Otherwise, if the lineHeight is in `in`, convert it to pixels (96px for 1in)\n    lnHeight *= 96;\n  } else if (lnHeightStr.indexOf('pc') !== -1) {\n  // Otherwise, if the lineHeight is in `pc`, convert it to pixels (12pt for 1pc)\n    lnHeight *= 16;\n  }\n\n  // Continue our computation\n  lnHeight = Math.round(lnHeight);\n\n  // If the line-height is \"normal\", calculate by font-size\n  if (lnHeightStr === 'normal') {\n    // Create a temporary node\n    var nodeName = node.nodeName,\n        _node = document.createElement(nodeName);\n    _node.innerHTML = '&nbsp;';\n\n    // Set the font-size of the element\n    var fontSizeStr = computedStyle(node, 'font-size');\n    _node.style.fontSize = fontSizeStr;\n\n    // Append it to the body\n    var body = document.body;\n    body.appendChild(_node);\n\n    // Assume the line height of the element is the height\n    var height = _node.offsetHeight;\n    lnHeight = height;\n\n    // Remove our child from the DOM\n    body.removeChild(_node);\n  }\n\n  // Return the calculated height\n  return lnHeight;\n}\n\n// Export lineHeight\nmodule.exports = lineHeight;\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/line-height/lib/line-height.js\n// module id = 10\n// module chunks = 0","// This code has been refactored for 140 bytes\n// You can see the original here: https://github.com/twolfson/computedStyle/blob/04cd1da2e30fa45844f95f5cb1ac898e9b9ef050/lib/computedStyle.js\nvar computedStyle = function (el, prop, getComputedStyle) {\n  getComputedStyle = window.getComputedStyle;\n\n  // In one fell swoop\n  return (\n    // If we have getComputedStyle\n    getComputedStyle ?\n      // Query it\n      // TODO: From CSS-Query notes, we might need (node, null) for FF\n      getComputedStyle(el) :\n\n    // Otherwise, we are in IE and use currentStyle\n      el.currentStyle\n  )[\n    // Switch to camelCase for CSSOM\n    // DEV: Grabbed from jQuery\n    // https://github.com/jquery/jquery/blob/1.9-stable/src/css.js#L191-L194\n    // https://github.com/jquery/jquery/blob/1.9-stable/src/core.js#L593-L597\n    prop.replace(/-(\\w)/gi, function (word, letter) {\n      return letter.toUpperCase();\n    })\n  ];\n};\n\nmodule.exports = computedStyle;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/line-height/~/computed-style/dist/computedStyle.commonjs.js\n// module id = 11\n// module chunks = 0","'use strict';\n\nexports.__esModule = true;\n\nfunction _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }\n\nvar _Motion = require('./Motion');\n\nexports.Motion = _interopRequire(_Motion);\n\nvar _StaggeredMotion = require('./StaggeredMotion');\n\nexports.StaggeredMotion = _interopRequire(_StaggeredMotion);\n\nvar _TransitionMotion = require('./TransitionMotion');\n\nexports.TransitionMotion = _interopRequire(_TransitionMotion);\n\nvar _spring = require('./spring');\n\nexports.spring = _interopRequire(_spring);\n\nvar _presets = require('./presets');\n\nexports.presets = _interopRequire(_presets);\n\nvar _stripStyle = require('./stripStyle');\n\nexports.stripStyle = _interopRequire(_stripStyle);\n\n// deprecated, dummy warning function\n\nvar _reorderKeys = require('./reorderKeys');\n\nexports.reorderKeys = _interopRequire(_reorderKeys);\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/react-motion/lib/react-motion.js\n// module id = 12\n// module chunks = 0","'use strict';\n\nexports.__esModule = true;\n\nvar _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; };\n\nvar _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; }; })();\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }\n\nfunction _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; }\n\nvar _mapToZero = require('./mapToZero');\n\nvar _mapToZero2 = _interopRequireDefault(_mapToZero);\n\nvar _stripStyle = require('./stripStyle');\n\nvar _stripStyle2 = _interopRequireDefault(_stripStyle);\n\nvar _stepper3 = require('./stepper');\n\nvar _stepper4 = _interopRequireDefault(_stepper3);\n\nvar _performanceNow = require('performance-now');\n\nvar _performanceNow2 = _interopRequireDefault(_performanceNow);\n\nvar _raf = require('raf');\n\nvar _raf2 = _interopRequireDefault(_raf);\n\nvar _shouldStopAnimation = require('./shouldStopAnimation');\n\nvar _shouldStopAnimation2 = _interopRequireDefault(_shouldStopAnimation);\n\nvar _react = require('react');\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _propTypes = require('prop-types');\n\nvar _propTypes2 = _interopRequireDefault(_propTypes);\n\nvar msPerFrame = 1000 / 60;\n\nvar Motion = (function (_React$Component) {\n  _inherits(Motion, _React$Component);\n\n  _createClass(Motion, null, [{\n    key: 'propTypes',\n    value: {\n      // TOOD: warn against putting a config in here\n      defaultStyle: _propTypes2['default'].objectOf(_propTypes2['default'].number),\n      style: _propTypes2['default'].objectOf(_propTypes2['default'].oneOfType([_propTypes2['default'].number, _propTypes2['default'].object])).isRequired,\n      children: _propTypes2['default'].func.isRequired,\n      onRest: _propTypes2['default'].func\n    },\n    enumerable: true\n  }]);\n\n  function Motion(props) {\n    var _this = this;\n\n    _classCallCheck(this, Motion);\n\n    _React$Component.call(this, props);\n    this.wasAnimating = false;\n    this.animationID = null;\n    this.prevTime = 0;\n    this.accumulatedTime = 0;\n    this.unreadPropStyle = null;\n\n    this.clearUnreadPropStyle = function (destStyle) {\n      var dirty = false;\n      var _state = _this.state;\n      var currentStyle = _state.currentStyle;\n      var currentVelocity = _state.currentVelocity;\n      var lastIdealStyle = _state.lastIdealStyle;\n      var lastIdealVelocity = _state.lastIdealVelocity;\n\n      for (var key in destStyle) {\n        if (!Object.prototype.hasOwnProperty.call(destStyle, key)) {\n          continue;\n        }\n\n        var styleValue = destStyle[key];\n        if (typeof styleValue === 'number') {\n          if (!dirty) {\n            dirty = true;\n            currentStyle = _extends({}, currentStyle);\n            currentVelocity = _extends({}, currentVelocity);\n            lastIdealStyle = _extends({}, lastIdealStyle);\n            lastIdealVelocity = _extends({}, lastIdealVelocity);\n          }\n\n          currentStyle[key] = styleValue;\n          currentVelocity[key] = 0;\n          lastIdealStyle[key] = styleValue;\n          lastIdealVelocity[key] = 0;\n        }\n      }\n\n      if (dirty) {\n        _this.setState({ currentStyle: currentStyle, currentVelocity: currentVelocity, lastIdealStyle: lastIdealStyle, lastIdealVelocity: lastIdealVelocity });\n      }\n    };\n\n    this.startAnimationIfNecessary = function () {\n      // TODO: when config is {a: 10} and dest is {a: 10} do we raf once and\n      // call cb? No, otherwise accidental parent rerender causes cb trigger\n      _this.animationID = _raf2['default'](function (timestamp) {\n        // check if we need to animate in the first place\n        var propsStyle = _this.props.style;\n        if (_shouldStopAnimation2['default'](_this.state.currentStyle, propsStyle, _this.state.currentVelocity)) {\n          if (_this.wasAnimating && _this.props.onRest) {\n            _this.props.onRest();\n          }\n\n          // no need to cancel animationID here; shouldn't have any in flight\n          _this.animationID = null;\n          _this.wasAnimating = false;\n          _this.accumulatedTime = 0;\n          return;\n        }\n\n        _this.wasAnimating = true;\n\n        var currentTime = timestamp || _performanceNow2['default']();\n        var timeDelta = currentTime - _this.prevTime;\n        _this.prevTime = currentTime;\n        _this.accumulatedTime = _this.accumulatedTime + timeDelta;\n        // more than 10 frames? prolly switched browser tab. Restart\n        if (_this.accumulatedTime > msPerFrame * 10) {\n          _this.accumulatedTime = 0;\n        }\n\n        if (_this.accumulatedTime === 0) {\n          // no need to cancel animationID here; shouldn't have any in flight\n          _this.animationID = null;\n          _this.startAnimationIfNecessary();\n          return;\n        }\n\n        var currentFrameCompletion = (_this.accumulatedTime - Math.floor(_this.accumulatedTime / msPerFrame) * msPerFrame) / msPerFrame;\n        var framesToCatchUp = Math.floor(_this.accumulatedTime / msPerFrame);\n\n        var newLastIdealStyle = {};\n        var newLastIdealVelocity = {};\n        var newCurrentStyle = {};\n        var newCurrentVelocity = {};\n\n        for (var key in propsStyle) {\n          if (!Object.prototype.hasOwnProperty.call(propsStyle, key)) {\n            continue;\n          }\n\n          var styleValue = propsStyle[key];\n          if (typeof styleValue === 'number') {\n            newCurrentStyle[key] = styleValue;\n            newCurrentVelocity[key] = 0;\n            newLastIdealStyle[key] = styleValue;\n            newLastIdealVelocity[key] = 0;\n          } else {\n            var newLastIdealStyleValue = _this.state.lastIdealStyle[key];\n            var newLastIdealVelocityValue = _this.state.lastIdealVelocity[key];\n            for (var i = 0; i < framesToCatchUp; i++) {\n              var _stepper = _stepper4['default'](msPerFrame / 1000, newLastIdealStyleValue, newLastIdealVelocityValue, styleValue.val, styleValue.stiffness, styleValue.damping, styleValue.precision);\n\n              newLastIdealStyleValue = _stepper[0];\n              newLastIdealVelocityValue = _stepper[1];\n            }\n\n            var _stepper2 = _stepper4['default'](msPerFrame / 1000, newLastIdealStyleValue, newLastIdealVelocityValue, styleValue.val, styleValue.stiffness, styleValue.damping, styleValue.precision);\n\n            var nextIdealX = _stepper2[0];\n            var nextIdealV = _stepper2[1];\n\n            newCurrentStyle[key] = newLastIdealStyleValue + (nextIdealX - newLastIdealStyleValue) * currentFrameCompletion;\n            newCurrentVelocity[key] = newLastIdealVelocityValue + (nextIdealV - newLastIdealVelocityValue) * currentFrameCompletion;\n            newLastIdealStyle[key] = newLastIdealStyleValue;\n            newLastIdealVelocity[key] = newLastIdealVelocityValue;\n          }\n        }\n\n        _this.animationID = null;\n        // the amount we're looped over above\n        _this.accumulatedTime -= framesToCatchUp * msPerFrame;\n\n        _this.setState({\n          currentStyle: newCurrentStyle,\n          currentVelocity: newCurrentVelocity,\n          lastIdealStyle: newLastIdealStyle,\n          lastIdealVelocity: newLastIdealVelocity\n        });\n\n        _this.unreadPropStyle = null;\n\n        _this.startAnimationIfNecessary();\n      });\n    };\n\n    this.state = this.defaultState();\n  }\n\n  Motion.prototype.defaultState = function defaultState() {\n    var _props = this.props;\n    var defaultStyle = _props.defaultStyle;\n    var style = _props.style;\n\n    var currentStyle = defaultStyle || _stripStyle2['default'](style);\n    var currentVelocity = _mapToZero2['default'](currentStyle);\n    return {\n      currentStyle: currentStyle,\n      currentVelocity: currentVelocity,\n      lastIdealStyle: currentStyle,\n      lastIdealVelocity: currentVelocity\n    };\n  };\n\n  // it's possible that currentStyle's value is stale: if props is immediately\n  // changed from 0 to 400 to spring(0) again, the async currentStyle is still\n  // at 0 (didn't have time to tick and interpolate even once). If we naively\n  // compare currentStyle with destVal it'll be 0 === 0 (no animation, stop).\n  // In reality currentStyle should be 400\n\n  Motion.prototype.componentDidMount = function componentDidMount() {\n    this.prevTime = _performanceNow2['default']();\n    this.startAnimationIfNecessary();\n  };\n\n  Motion.prototype.componentWillReceiveProps = function componentWillReceiveProps(props) {\n    if (this.unreadPropStyle != null) {\n      // previous props haven't had the chance to be set yet; set them here\n      this.clearUnreadPropStyle(this.unreadPropStyle);\n    }\n\n    this.unreadPropStyle = props.style;\n    if (this.animationID == null) {\n      this.prevTime = _performanceNow2['default']();\n      this.startAnimationIfNecessary();\n    }\n  };\n\n  Motion.prototype.componentWillUnmount = function componentWillUnmount() {\n    if (this.animationID != null) {\n      _raf2['default'].cancel(this.animationID);\n      this.animationID = null;\n    }\n  };\n\n  Motion.prototype.render = function render() {\n    var renderedChildren = this.props.children(this.state.currentStyle);\n    return renderedChildren && _react2['default'].Children.only(renderedChildren);\n  };\n\n  return Motion;\n})(_react2['default'].Component);\n\nexports['default'] = Motion;\nmodule.exports = exports['default'];\n\n// after checking for unreadPropStyle != null, we manually go set the\n// non-interpolating values (those that are a number, without a spring\n// config)\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/react-motion/lib/Motion.js\n// module id = 13\n// module chunks = 0","\n\n// currently used to initiate the velocity style object to 0\n'use strict';\n\nexports.__esModule = true;\nexports['default'] = mapToZero;\n\nfunction mapToZero(obj) {\n  var ret = {};\n  for (var key in obj) {\n    if (Object.prototype.hasOwnProperty.call(obj, key)) {\n      ret[key] = 0;\n    }\n  }\n  return ret;\n}\n\nmodule.exports = exports['default'];\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/react-motion/lib/mapToZero.js\n// module id = 14\n// module chunks = 0","\n// turn {x: {val: 1, stiffness: 1, damping: 2}, y: 2} generated by\n// `{x: spring(1, {stiffness: 1, damping: 2}), y: 2}` into {x: 1, y: 2}\n\n'use strict';\n\nexports.__esModule = true;\nexports['default'] = stripStyle;\n\nfunction stripStyle(style) {\n  var ret = {};\n  for (var key in style) {\n    if (!Object.prototype.hasOwnProperty.call(style, key)) {\n      continue;\n    }\n    ret[key] = typeof style[key] === 'number' ? style[key] : style[key].val;\n  }\n  return ret;\n}\n\nmodule.exports = exports['default'];\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/react-motion/lib/stripStyle.js\n// module id = 15\n// module chunks = 0","\n\n// stepper is used a lot. Saves allocation to return the same array wrapper.\n// This is fine and danger-free against mutations because the callsite\n// immediately destructures it and gets the numbers inside without passing the\n\"use strict\";\n\nexports.__esModule = true;\nexports[\"default\"] = stepper;\n\nvar reusedTuple = [0, 0];\n\nfunction stepper(secondPerFrame, x, v, destX, k, b, precision) {\n  // Spring stiffness, in kg / s^2\n\n  // for animations, destX is really spring length (spring at rest). initial\n  // position is considered as the stretched/compressed position of a spring\n  var Fspring = -k * (x - destX);\n\n  // Damping, in kg / s\n  var Fdamper = -b * v;\n\n  // usually we put mass here, but for animation purposes, specifying mass is a\n  // bit redundant. you could simply adjust k and b accordingly\n  // let a = (Fspring + Fdamper) / mass;\n  var a = Fspring + Fdamper;\n\n  var newV = v + a * secondPerFrame;\n  var newX = x + newV * secondPerFrame;\n\n  if (Math.abs(newV) < precision && Math.abs(newX - destX) < precision) {\n    reusedTuple[0] = destX;\n    reusedTuple[1] = 0;\n    return reusedTuple;\n  }\n\n  reusedTuple[0] = newX;\n  reusedTuple[1] = newV;\n  return reusedTuple;\n}\n\nmodule.exports = exports[\"default\"];\n// array reference around.\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/react-motion/lib/stepper.js\n// module id = 16\n// module chunks = 0","// Generated by CoffeeScript 1.7.1\n(function() {\n  var getNanoSeconds, hrtime, loadTime;\n\n  if ((typeof performance !== \"undefined\" && performance !== null) && performance.now) {\n    module.exports = function() {\n      return performance.now();\n    };\n  } else if ((typeof process !== \"undefined\" && process !== null) && process.hrtime) {\n    module.exports = function() {\n      return (getNanoSeconds() - loadTime) / 1e6;\n    };\n    hrtime = process.hrtime;\n    getNanoSeconds = function() {\n      var hr;\n      hr = hrtime();\n      return hr[0] * 1e9 + hr[1];\n    };\n    loadTime = getNanoSeconds();\n  } else if (Date.now) {\n    module.exports = function() {\n      return Date.now() - loadTime;\n    };\n    loadTime = Date.now();\n  } else {\n    module.exports = function() {\n      return new Date().getTime() - loadTime;\n    };\n    loadTime = new Date().getTime();\n  }\n\n}).call(this);\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/performance-now/lib/performance-now.js\n// module id = 17\n// module chunks = 0","var now = require('performance-now')\n  , root = typeof window === 'undefined' ? global : window\n  , vendors = ['moz', 'webkit']\n  , suffix = 'AnimationFrame'\n  , raf = root['request' + suffix]\n  , caf = root['cancel' + suffix] || root['cancelRequest' + suffix]\n\nfor(var i = 0; !raf && i < vendors.length; i++) {\n  raf = root[vendors[i] + 'Request' + suffix]\n  caf = root[vendors[i] + 'Cancel' + suffix]\n      || root[vendors[i] + 'CancelRequest' + suffix]\n}\n\n// Some versions of FF have rAF but not cAF\nif(!raf || !caf) {\n  var last = 0\n    , id = 0\n    , queue = []\n    , frameDuration = 1000 / 60\n\n  raf = function(callback) {\n    if(queue.length === 0) {\n      var _now = now()\n        , next = Math.max(0, frameDuration - (_now - last))\n      last = next + _now\n      setTimeout(function() {\n        var cp = queue.slice(0)\n        // Clear queue here to prevent\n        // callbacks from appending listeners\n        // to the current frame's queue\n        queue.length = 0\n        for(var i = 0; i < cp.length; i++) {\n          if(!cp[i].cancelled) {\n            try{\n              cp[i].callback(last)\n            } catch(e) {\n              setTimeout(function() { throw e }, 0)\n            }\n          }\n        }\n      }, Math.round(next))\n    }\n    queue.push({\n      handle: ++id,\n      callback: callback,\n      cancelled: false\n    })\n    return id\n  }\n\n  caf = function(handle) {\n    for(var i = 0; i < queue.length; i++) {\n      if(queue[i].handle === handle) {\n        queue[i].cancelled = true\n      }\n    }\n  }\n}\n\nmodule.exports = function(fn) {\n  // Wrap in a new function to prevent\n  // `cancel` potentially being assigned\n  // to the native rAF function\n  return raf.call(root, fn)\n}\nmodule.exports.cancel = function() {\n  caf.apply(root, arguments)\n}\nmodule.exports.polyfill = function(object) {\n  if (!object) {\n    object = root;\n  }\n  object.requestAnimationFrame = raf\n  object.cancelAnimationFrame = caf\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/raf/index.js\n// module id = 18\n// module chunks = 0","// Generated by CoffeeScript 1.12.2\n(function() {\n  var getNanoSeconds, hrtime, loadTime, moduleLoadTime, nodeLoadTime, upTime;\n\n  if ((typeof performance !== \"undefined\" && performance !== null) && performance.now) {\n    module.exports = function() {\n      return performance.now();\n    };\n  } else if ((typeof process !== \"undefined\" && process !== null) && process.hrtime) {\n    module.exports = function() {\n      return (getNanoSeconds() - nodeLoadTime) / 1e6;\n    };\n    hrtime = process.hrtime;\n    getNanoSeconds = function() {\n      var hr;\n      hr = hrtime();\n      return hr[0] * 1e9 + hr[1];\n    };\n    moduleLoadTime = getNanoSeconds();\n    upTime = process.uptime() * 1e9;\n    nodeLoadTime = moduleLoadTime - upTime;\n  } else if (Date.now) {\n    module.exports = function() {\n      return Date.now() - loadTime;\n    };\n    loadTime = Date.now();\n  } else {\n    module.exports = function() {\n      return new Date().getTime() - loadTime;\n    };\n    loadTime = new Date().getTime();\n  }\n\n}).call(this);\n\n//# sourceMappingURL=performance-now.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/raf/~/performance-now/lib/performance-now.js\n// module id = 19\n// module chunks = 0","\n\n// usage assumption: currentStyle values have already been rendered but it says\n// nothing of whether currentStyle is stale (see unreadPropStyle)\n'use strict';\n\nexports.__esModule = true;\nexports['default'] = shouldStopAnimation;\n\nfunction shouldStopAnimation(currentStyle, style, currentVelocity) {\n  for (var key in style) {\n    if (!Object.prototype.hasOwnProperty.call(style, key)) {\n      continue;\n    }\n\n    if (currentVelocity[key] !== 0) {\n      return false;\n    }\n\n    var styleValue = typeof style[key] === 'number' ? style[key] : style[key].val;\n    // stepper will have already taken care of rounding precision errors, so\n    // won't have such thing as 0.9999 !=== 1\n    if (currentStyle[key] !== styleValue) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nmodule.exports = exports['default'];\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/react-motion/lib/shouldStopAnimation.js\n// module id = 20\n// module chunks = 0","'use strict';\n\nexports.__esModule = true;\n\nvar _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; };\n\nvar _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; }; })();\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }\n\nfunction _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; }\n\nvar _mapToZero = require('./mapToZero');\n\nvar _mapToZero2 = _interopRequireDefault(_mapToZero);\n\nvar _stripStyle = require('./stripStyle');\n\nvar _stripStyle2 = _interopRequireDefault(_stripStyle);\n\nvar _stepper3 = require('./stepper');\n\nvar _stepper4 = _interopRequireDefault(_stepper3);\n\nvar _performanceNow = require('performance-now');\n\nvar _performanceNow2 = _interopRequireDefault(_performanceNow);\n\nvar _raf = require('raf');\n\nvar _raf2 = _interopRequireDefault(_raf);\n\nvar _shouldStopAnimation = require('./shouldStopAnimation');\n\nvar _shouldStopAnimation2 = _interopRequireDefault(_shouldStopAnimation);\n\nvar _react = require('react');\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _propTypes = require('prop-types');\n\nvar _propTypes2 = _interopRequireDefault(_propTypes);\n\nvar msPerFrame = 1000 / 60;\n\nfunction shouldStopAnimationAll(currentStyles, styles, currentVelocities) {\n  for (var i = 0; i < currentStyles.length; i++) {\n    if (!_shouldStopAnimation2['default'](currentStyles[i], styles[i], currentVelocities[i])) {\n      return false;\n    }\n  }\n  return true;\n}\n\nvar StaggeredMotion = (function (_React$Component) {\n  _inherits(StaggeredMotion, _React$Component);\n\n  _createClass(StaggeredMotion, null, [{\n    key: 'propTypes',\n    value: {\n      // TOOD: warn against putting a config in here\n      defaultStyles: _propTypes2['default'].arrayOf(_propTypes2['default'].objectOf(_propTypes2['default'].number)),\n      styles: _propTypes2['default'].func.isRequired,\n      children: _propTypes2['default'].func.isRequired\n    },\n    enumerable: true\n  }]);\n\n  function StaggeredMotion(props) {\n    var _this = this;\n\n    _classCallCheck(this, StaggeredMotion);\n\n    _React$Component.call(this, props);\n    this.animationID = null;\n    this.prevTime = 0;\n    this.accumulatedTime = 0;\n    this.unreadPropStyles = null;\n\n    this.clearUnreadPropStyle = function (unreadPropStyles) {\n      var _state = _this.state;\n      var currentStyles = _state.currentStyles;\n      var currentVelocities = _state.currentVelocities;\n      var lastIdealStyles = _state.lastIdealStyles;\n      var lastIdealVelocities = _state.lastIdealVelocities;\n\n      var someDirty = false;\n      for (var i = 0; i < unreadPropStyles.length; i++) {\n        var unreadPropStyle = unreadPropStyles[i];\n        var dirty = false;\n\n        for (var key in unreadPropStyle) {\n          if (!Object.prototype.hasOwnProperty.call(unreadPropStyle, key)) {\n            continue;\n          }\n\n          var styleValue = unreadPropStyle[key];\n          if (typeof styleValue === 'number') {\n            if (!dirty) {\n              dirty = true;\n              someDirty = true;\n              currentStyles[i] = _extends({}, currentStyles[i]);\n              currentVelocities[i] = _extends({}, currentVelocities[i]);\n              lastIdealStyles[i] = _extends({}, lastIdealStyles[i]);\n              lastIdealVelocities[i] = _extends({}, lastIdealVelocities[i]);\n            }\n            currentStyles[i][key] = styleValue;\n            currentVelocities[i][key] = 0;\n            lastIdealStyles[i][key] = styleValue;\n            lastIdealVelocities[i][key] = 0;\n          }\n        }\n      }\n\n      if (someDirty) {\n        _this.setState({ currentStyles: currentStyles, currentVelocities: currentVelocities, lastIdealStyles: lastIdealStyles, lastIdealVelocities: lastIdealVelocities });\n      }\n    };\n\n    this.startAnimationIfNecessary = function () {\n      // TODO: when config is {a: 10} and dest is {a: 10} do we raf once and\n      // call cb? No, otherwise accidental parent rerender causes cb trigger\n      _this.animationID = _raf2['default'](function (timestamp) {\n        var destStyles = _this.props.styles(_this.state.lastIdealStyles);\n\n        // check if we need to animate in the first place\n        if (shouldStopAnimationAll(_this.state.currentStyles, destStyles, _this.state.currentVelocities)) {\n          // no need to cancel animationID here; shouldn't have any in flight\n          _this.animationID = null;\n          _this.accumulatedTime = 0;\n          return;\n        }\n\n        var currentTime = timestamp || _performanceNow2['default']();\n        var timeDelta = currentTime - _this.prevTime;\n        _this.prevTime = currentTime;\n        _this.accumulatedTime = _this.accumulatedTime + timeDelta;\n        // more than 10 frames? prolly switched browser tab. Restart\n        if (_this.accumulatedTime > msPerFrame * 10) {\n          _this.accumulatedTime = 0;\n        }\n\n        if (_this.accumulatedTime === 0) {\n          // no need to cancel animationID here; shouldn't have any in flight\n          _this.animationID = null;\n          _this.startAnimationIfNecessary();\n          return;\n        }\n\n        var currentFrameCompletion = (_this.accumulatedTime - Math.floor(_this.accumulatedTime / msPerFrame) * msPerFrame) / msPerFrame;\n        var framesToCatchUp = Math.floor(_this.accumulatedTime / msPerFrame);\n\n        var newLastIdealStyles = [];\n        var newLastIdealVelocities = [];\n        var newCurrentStyles = [];\n        var newCurrentVelocities = [];\n\n        for (var i = 0; i < destStyles.length; i++) {\n          var destStyle = destStyles[i];\n          var newCurrentStyle = {};\n          var newCurrentVelocity = {};\n          var newLastIdealStyle = {};\n          var newLastIdealVelocity = {};\n\n          for (var key in destStyle) {\n            if (!Object.prototype.hasOwnProperty.call(destStyle, key)) {\n              continue;\n            }\n\n            var styleValue = destStyle[key];\n            if (typeof styleValue === 'number') {\n              newCurrentStyle[key] = styleValue;\n              newCurrentVelocity[key] = 0;\n              newLastIdealStyle[key] = styleValue;\n              newLastIdealVelocity[key] = 0;\n            } else {\n              var newLastIdealStyleValue = _this.state.lastIdealStyles[i][key];\n              var newLastIdealVelocityValue = _this.state.lastIdealVelocities[i][key];\n              for (var j = 0; j < framesToCatchUp; j++) {\n                var _stepper = _stepper4['default'](msPerFrame / 1000, newLastIdealStyleValue, newLastIdealVelocityValue, styleValue.val, styleValue.stiffness, styleValue.damping, styleValue.precision);\n\n                newLastIdealStyleValue = _stepper[0];\n                newLastIdealVelocityValue = _stepper[1];\n              }\n\n              var _stepper2 = _stepper4['default'](msPerFrame / 1000, newLastIdealStyleValue, newLastIdealVelocityValue, styleValue.val, styleValue.stiffness, styleValue.damping, styleValue.precision);\n\n              var nextIdealX = _stepper2[0];\n              var nextIdealV = _stepper2[1];\n\n              newCurrentStyle[key] = newLastIdealStyleValue + (nextIdealX - newLastIdealStyleValue) * currentFrameCompletion;\n              newCurrentVelocity[key] = newLastIdealVelocityValue + (nextIdealV - newLastIdealVelocityValue) * currentFrameCompletion;\n              newLastIdealStyle[key] = newLastIdealStyleValue;\n              newLastIdealVelocity[key] = newLastIdealVelocityValue;\n            }\n          }\n\n          newCurrentStyles[i] = newCurrentStyle;\n          newCurrentVelocities[i] = newCurrentVelocity;\n          newLastIdealStyles[i] = newLastIdealStyle;\n          newLastIdealVelocities[i] = newLastIdealVelocity;\n        }\n\n        _this.animationID = null;\n        // the amount we're looped over above\n        _this.accumulatedTime -= framesToCatchUp * msPerFrame;\n\n        _this.setState({\n          currentStyles: newCurrentStyles,\n          currentVelocities: newCurrentVelocities,\n          lastIdealStyles: newLastIdealStyles,\n          lastIdealVelocities: newLastIdealVelocities\n        });\n\n        _this.unreadPropStyles = null;\n\n        _this.startAnimationIfNecessary();\n      });\n    };\n\n    this.state = this.defaultState();\n  }\n\n  StaggeredMotion.prototype.defaultState = function defaultState() {\n    var _props = this.props;\n    var defaultStyles = _props.defaultStyles;\n    var styles = _props.styles;\n\n    var currentStyles = defaultStyles || styles().map(_stripStyle2['default']);\n    var currentVelocities = currentStyles.map(function (currentStyle) {\n      return _mapToZero2['default'](currentStyle);\n    });\n    return {\n      currentStyles: currentStyles,\n      currentVelocities: currentVelocities,\n      lastIdealStyles: currentStyles,\n      lastIdealVelocities: currentVelocities\n    };\n  };\n\n  StaggeredMotion.prototype.componentDidMount = function componentDidMount() {\n    this.prevTime = _performanceNow2['default']();\n    this.startAnimationIfNecessary();\n  };\n\n  StaggeredMotion.prototype.componentWillReceiveProps = function componentWillReceiveProps(props) {\n    if (this.unreadPropStyles != null) {\n      // previous props haven't had the chance to be set yet; set them here\n      this.clearUnreadPropStyle(this.unreadPropStyles);\n    }\n\n    this.unreadPropStyles = props.styles(this.state.lastIdealStyles);\n    if (this.animationID == null) {\n      this.prevTime = _performanceNow2['default']();\n      this.startAnimationIfNecessary();\n    }\n  };\n\n  StaggeredMotion.prototype.componentWillUnmount = function componentWillUnmount() {\n    if (this.animationID != null) {\n      _raf2['default'].cancel(this.animationID);\n      this.animationID = null;\n    }\n  };\n\n  StaggeredMotion.prototype.render = function render() {\n    var renderedChildren = this.props.children(this.state.currentStyles);\n    return renderedChildren && _react2['default'].Children.only(renderedChildren);\n  };\n\n  return StaggeredMotion;\n})(_react2['default'].Component);\n\nexports['default'] = StaggeredMotion;\nmodule.exports = exports['default'];\n\n// it's possible that currentStyle's value is stale: if props is immediately\n// changed from 0 to 400 to spring(0) again, the async currentStyle is still\n// at 0 (didn't have time to tick and interpolate even once). If we naively\n// compare currentStyle with destVal it'll be 0 === 0 (no animation, stop).\n// In reality currentStyle should be 400\n\n// after checking for unreadPropStyles != null, we manually go set the\n// non-interpolating values (those that are a number, without a spring\n// config)\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/react-motion/lib/StaggeredMotion.js\n// module id = 21\n// module chunks = 0","'use strict';\n\nexports.__esModule = true;\n\nvar _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; };\n\nvar _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; }; })();\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }\n\nfunction _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; }\n\nvar _mapToZero = require('./mapToZero');\n\nvar _mapToZero2 = _interopRequireDefault(_mapToZero);\n\nvar _stripStyle = require('./stripStyle');\n\nvar _stripStyle2 = _interopRequireDefault(_stripStyle);\n\nvar _stepper3 = require('./stepper');\n\nvar _stepper4 = _interopRequireDefault(_stepper3);\n\nvar _mergeDiff = require('./mergeDiff');\n\nvar _mergeDiff2 = _interopRequireDefault(_mergeDiff);\n\nvar _performanceNow = require('performance-now');\n\nvar _performanceNow2 = _interopRequireDefault(_performanceNow);\n\nvar _raf = require('raf');\n\nvar _raf2 = _interopRequireDefault(_raf);\n\nvar _shouldStopAnimation = require('./shouldStopAnimation');\n\nvar _shouldStopAnimation2 = _interopRequireDefault(_shouldStopAnimation);\n\nvar _react = require('react');\n\nvar _react2 = _interopRequireDefault(_react);\n\nvar _propTypes = require('prop-types');\n\nvar _propTypes2 = _interopRequireDefault(_propTypes);\n\nvar msPerFrame = 1000 / 60;\n\n// the children function & (potential) styles function asks as param an\n// Array<TransitionPlainStyle>, where each TransitionPlainStyle is of the format\n// {key: string, data?: any, style: PlainStyle}. However, the way we keep\n// internal states doesn't contain such a data structure (check the state and\n// TransitionMotionState). So when children function and others ask for such\n// data we need to generate them on the fly by combining mergedPropsStyles and\n// currentStyles/lastIdealStyles\nfunction rehydrateStyles(mergedPropsStyles, unreadPropStyles, plainStyles) {\n  // Copy the value to a `const` so that Flow understands that the const won't\n  // change and will be non-nullable in the callback below.\n  var cUnreadPropStyles = unreadPropStyles;\n  if (cUnreadPropStyles == null) {\n    return mergedPropsStyles.map(function (mergedPropsStyle, i) {\n      return {\n        key: mergedPropsStyle.key,\n        data: mergedPropsStyle.data,\n        style: plainStyles[i]\n      };\n    });\n  }\n  return mergedPropsStyles.map(function (mergedPropsStyle, i) {\n    for (var j = 0; j < cUnreadPropStyles.length; j++) {\n      if (cUnreadPropStyles[j].key === mergedPropsStyle.key) {\n        return {\n          key: cUnreadPropStyles[j].key,\n          data: cUnreadPropStyles[j].data,\n          style: plainStyles[i]\n        };\n      }\n    }\n    return { key: mergedPropsStyle.key, data: mergedPropsStyle.data, style: plainStyles[i] };\n  });\n}\n\nfunction shouldStopAnimationAll(currentStyles, destStyles, currentVelocities, mergedPropsStyles) {\n  if (mergedPropsStyles.length !== destStyles.length) {\n    return false;\n  }\n\n  for (var i = 0; i < mergedPropsStyles.length; i++) {\n    if (mergedPropsStyles[i].key !== destStyles[i].key) {\n      return false;\n    }\n  }\n\n  // we have the invariant that mergedPropsStyles and\n  // currentStyles/currentVelocities/last* are synced in terms of cells, see\n  // mergeAndSync comment for more info\n  for (var i = 0; i < mergedPropsStyles.length; i++) {\n    if (!_shouldStopAnimation2['default'](currentStyles[i], destStyles[i].style, currentVelocities[i])) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\n// core key merging logic\n\n// things to do: say previously merged style is {a, b}, dest style (prop) is {b,\n// c}, previous current (interpolating) style is {a, b}\n// **invariant**: current[i] corresponds to merged[i] in terms of key\n\n// steps:\n// turn merged style into {a?, b, c}\n//    add c, value of c is destStyles.c\n//    maybe remove a, aka call willLeave(a), then merged is either {b, c} or {a, b, c}\n// turn current (interpolating) style from {a, b} into {a?, b, c}\n//    maybe remove a\n//    certainly add c, value of c is willEnter(c)\n// loop over merged and construct new current\n// dest doesn't change, that's owner's\nfunction mergeAndSync(willEnter, willLeave, didLeave, oldMergedPropsStyles, destStyles, oldCurrentStyles, oldCurrentVelocities, oldLastIdealStyles, oldLastIdealVelocities) {\n  var newMergedPropsStyles = _mergeDiff2['default'](oldMergedPropsStyles, destStyles, function (oldIndex, oldMergedPropsStyle) {\n    var leavingStyle = willLeave(oldMergedPropsStyle);\n    if (leavingStyle == null) {\n      didLeave({ key: oldMergedPropsStyle.key, data: oldMergedPropsStyle.data });\n      return null;\n    }\n    if (_shouldStopAnimation2['default'](oldCurrentStyles[oldIndex], leavingStyle, oldCurrentVelocities[oldIndex])) {\n      didLeave({ key: oldMergedPropsStyle.key, data: oldMergedPropsStyle.data });\n      return null;\n    }\n    return { key: oldMergedPropsStyle.key, data: oldMergedPropsStyle.data, style: leavingStyle };\n  });\n\n  var newCurrentStyles = [];\n  var newCurrentVelocities = [];\n  var newLastIdealStyles = [];\n  var newLastIdealVelocities = [];\n  for (var i = 0; i < newMergedPropsStyles.length; i++) {\n    var newMergedPropsStyleCell = newMergedPropsStyles[i];\n    var foundOldIndex = null;\n    for (var j = 0; j < oldMergedPropsStyles.length; j++) {\n      if (oldMergedPropsStyles[j].key === newMergedPropsStyleCell.key) {\n        foundOldIndex = j;\n        break;\n      }\n    }\n    // TODO: key search code\n    if (foundOldIndex == null) {\n      var plainStyle = willEnter(newMergedPropsStyleCell);\n      newCurrentStyles[i] = plainStyle;\n      newLastIdealStyles[i] = plainStyle;\n\n      var velocity = _mapToZero2['default'](newMergedPropsStyleCell.style);\n      newCurrentVelocities[i] = velocity;\n      newLastIdealVelocities[i] = velocity;\n    } else {\n      newCurrentStyles[i] = oldCurrentStyles[foundOldIndex];\n      newLastIdealStyles[i] = oldLastIdealStyles[foundOldIndex];\n      newCurrentVelocities[i] = oldCurrentVelocities[foundOldIndex];\n      newLastIdealVelocities[i] = oldLastIdealVelocities[foundOldIndex];\n    }\n  }\n\n  return [newMergedPropsStyles, newCurrentStyles, newCurrentVelocities, newLastIdealStyles, newLastIdealVelocities];\n}\n\nvar TransitionMotion = (function (_React$Component) {\n  _inherits(TransitionMotion, _React$Component);\n\n  _createClass(TransitionMotion, null, [{\n    key: 'propTypes',\n    value: {\n      defaultStyles: _propTypes2['default'].arrayOf(_propTypes2['default'].shape({\n        key: _propTypes2['default'].string.isRequired,\n        data: _propTypes2['default'].any,\n        style: _propTypes2['default'].objectOf(_propTypes2['default'].number).isRequired\n      })),\n      styles: _propTypes2['default'].oneOfType([_propTypes2['default'].func, _propTypes2['default'].arrayOf(_propTypes2['default'].shape({\n        key: _propTypes2['default'].string.isRequired,\n        data: _propTypes2['default'].any,\n        style: _propTypes2['default'].objectOf(_propTypes2['default'].oneOfType([_propTypes2['default'].number, _propTypes2['default'].object])).isRequired\n      }))]).isRequired,\n      children: _propTypes2['default'].func.isRequired,\n      willEnter: _propTypes2['default'].func,\n      willLeave: _propTypes2['default'].func,\n      didLeave: _propTypes2['default'].func\n    },\n    enumerable: true\n  }, {\n    key: 'defaultProps',\n    value: {\n      willEnter: function willEnter(styleThatEntered) {\n        return _stripStyle2['default'](styleThatEntered.style);\n      },\n      // recall: returning null makes the current unmounting TransitionStyle\n      // disappear immediately\n      willLeave: function willLeave() {\n        return null;\n      },\n      didLeave: function didLeave() {}\n    },\n    enumerable: true\n  }]);\n\n  function TransitionMotion(props) {\n    var _this = this;\n\n    _classCallCheck(this, TransitionMotion);\n\n    _React$Component.call(this, props);\n    this.unmounting = false;\n    this.animationID = null;\n    this.prevTime = 0;\n    this.accumulatedTime = 0;\n    this.unreadPropStyles = null;\n\n    this.clearUnreadPropStyle = function (unreadPropStyles) {\n      var _mergeAndSync = mergeAndSync(_this.props.willEnter, _this.props.willLeave, _this.props.didLeave, _this.state.mergedPropsStyles, unreadPropStyles, _this.state.currentStyles, _this.state.currentVelocities, _this.state.lastIdealStyles, _this.state.lastIdealVelocities);\n\n      var mergedPropsStyles = _mergeAndSync[0];\n      var currentStyles = _mergeAndSync[1];\n      var currentVelocities = _mergeAndSync[2];\n      var lastIdealStyles = _mergeAndSync[3];\n      var lastIdealVelocities = _mergeAndSync[4];\n\n      for (var i = 0; i < unreadPropStyles.length; i++) {\n        var unreadPropStyle = unreadPropStyles[i].style;\n        var dirty = false;\n\n        for (var key in unreadPropStyle) {\n          if (!Object.prototype.hasOwnProperty.call(unreadPropStyle, key)) {\n            continue;\n          }\n\n          var styleValue = unreadPropStyle[key];\n          if (typeof styleValue === 'number') {\n            if (!dirty) {\n              dirty = true;\n              currentStyles[i] = _extends({}, currentStyles[i]);\n              currentVelocities[i] = _extends({}, currentVelocities[i]);\n              lastIdealStyles[i] = _extends({}, lastIdealStyles[i]);\n              lastIdealVelocities[i] = _extends({}, lastIdealVelocities[i]);\n              mergedPropsStyles[i] = {\n                key: mergedPropsStyles[i].key,\n                data: mergedPropsStyles[i].data,\n                style: _extends({}, mergedPropsStyles[i].style)\n              };\n            }\n            currentStyles[i][key] = styleValue;\n            currentVelocities[i][key] = 0;\n            lastIdealStyles[i][key] = styleValue;\n            lastIdealVelocities[i][key] = 0;\n            mergedPropsStyles[i].style[key] = styleValue;\n          }\n        }\n      }\n\n      // unlike the other 2 components, we can't detect staleness and optionally\n      // opt out of setState here. each style object's data might contain new\n      // stuff we're not/cannot compare\n      _this.setState({\n        currentStyles: currentStyles,\n        currentVelocities: currentVelocities,\n        mergedPropsStyles: mergedPropsStyles,\n        lastIdealStyles: lastIdealStyles,\n        lastIdealVelocities: lastIdealVelocities\n      });\n    };\n\n    this.startAnimationIfNecessary = function () {\n      if (_this.unmounting) {\n        return;\n      }\n\n      // TODO: when config is {a: 10} and dest is {a: 10} do we raf once and\n      // call cb? No, otherwise accidental parent rerender causes cb trigger\n      _this.animationID = _raf2['default'](function (timestamp) {\n        // https://github.com/chenglou/react-motion/pull/420\n        // > if execution passes the conditional if (this.unmounting), then\n        // executes async defaultRaf and after that component unmounts and after\n        // that the callback of defaultRaf is called, then setState will be called\n        // on unmounted component.\n        if (_this.unmounting) {\n          return;\n        }\n\n        var propStyles = _this.props.styles;\n        var destStyles = typeof propStyles === 'function' ? propStyles(rehydrateStyles(_this.state.mergedPropsStyles, _this.unreadPropStyles, _this.state.lastIdealStyles)) : propStyles;\n\n        // check if we need to animate in the first place\n        if (shouldStopAnimationAll(_this.state.currentStyles, destStyles, _this.state.currentVelocities, _this.state.mergedPropsStyles)) {\n          // no need to cancel animationID here; shouldn't have any in flight\n          _this.animationID = null;\n          _this.accumulatedTime = 0;\n          return;\n        }\n\n        var currentTime = timestamp || _performanceNow2['default']();\n        var timeDelta = currentTime - _this.prevTime;\n        _this.prevTime = currentTime;\n        _this.accumulatedTime = _this.accumulatedTime + timeDelta;\n        // more than 10 frames? prolly switched browser tab. Restart\n        if (_this.accumulatedTime > msPerFrame * 10) {\n          _this.accumulatedTime = 0;\n        }\n\n        if (_this.accumulatedTime === 0) {\n          // no need to cancel animationID here; shouldn't have any in flight\n          _this.animationID = null;\n          _this.startAnimationIfNecessary();\n          return;\n        }\n\n        var currentFrameCompletion = (_this.accumulatedTime - Math.floor(_this.accumulatedTime / msPerFrame) * msPerFrame) / msPerFrame;\n        var framesToCatchUp = Math.floor(_this.accumulatedTime / msPerFrame);\n\n        var _mergeAndSync2 = mergeAndSync(_this.props.willEnter, _this.props.willLeave, _this.props.didLeave, _this.state.mergedPropsStyles, destStyles, _this.state.currentStyles, _this.state.currentVelocities, _this.state.lastIdealStyles, _this.state.lastIdealVelocities);\n\n        var newMergedPropsStyles = _mergeAndSync2[0];\n        var newCurrentStyles = _mergeAndSync2[1];\n        var newCurrentVelocities = _mergeAndSync2[2];\n        var newLastIdealStyles = _mergeAndSync2[3];\n        var newLastIdealVelocities = _mergeAndSync2[4];\n\n        for (var i = 0; i < newMergedPropsStyles.length; i++) {\n          var newMergedPropsStyle = newMergedPropsStyles[i].style;\n          var newCurrentStyle = {};\n          var newCurrentVelocity = {};\n          var newLastIdealStyle = {};\n          var newLastIdealVelocity = {};\n\n          for (var key in newMergedPropsStyle) {\n            if (!Object.prototype.hasOwnProperty.call(newMergedPropsStyle, key)) {\n              continue;\n            }\n\n            var styleValue = newMergedPropsStyle[key];\n            if (typeof styleValue === 'number') {\n              newCurrentStyle[key] = styleValue;\n              newCurrentVelocity[key] = 0;\n              newLastIdealStyle[key] = styleValue;\n              newLastIdealVelocity[key] = 0;\n            } else {\n              var newLastIdealStyleValue = newLastIdealStyles[i][key];\n              var newLastIdealVelocityValue = newLastIdealVelocities[i][key];\n              for (var j = 0; j < framesToCatchUp; j++) {\n                var _stepper = _stepper4['default'](msPerFrame / 1000, newLastIdealStyleValue, newLastIdealVelocityValue, styleValue.val, styleValue.stiffness, styleValue.damping, styleValue.precision);\n\n                newLastIdealStyleValue = _stepper[0];\n                newLastIdealVelocityValue = _stepper[1];\n              }\n\n              var _stepper2 = _stepper4['default'](msPerFrame / 1000, newLastIdealStyleValue, newLastIdealVelocityValue, styleValue.val, styleValue.stiffness, styleValue.damping, styleValue.precision);\n\n              var nextIdealX = _stepper2[0];\n              var nextIdealV = _stepper2[1];\n\n              newCurrentStyle[key] = newLastIdealStyleValue + (nextIdealX - newLastIdealStyleValue) * currentFrameCompletion;\n              newCurrentVelocity[key] = newLastIdealVelocityValue + (nextIdealV - newLastIdealVelocityValue) * currentFrameCompletion;\n              newLastIdealStyle[key] = newLastIdealStyleValue;\n              newLastIdealVelocity[key] = newLastIdealVelocityValue;\n            }\n          }\n\n          newLastIdealStyles[i] = newLastIdealStyle;\n          newLastIdealVelocities[i] = newLastIdealVelocity;\n          newCurrentStyles[i] = newCurrentStyle;\n          newCurrentVelocities[i] = newCurrentVelocity;\n        }\n\n        _this.animationID = null;\n        // the amount we're looped over above\n        _this.accumulatedTime -= framesToCatchUp * msPerFrame;\n\n        _this.setState({\n          currentStyles: newCurrentStyles,\n          currentVelocities: newCurrentVelocities,\n          lastIdealStyles: newLastIdealStyles,\n          lastIdealVelocities: newLastIdealVelocities,\n          mergedPropsStyles: newMergedPropsStyles\n        });\n\n        _this.unreadPropStyles = null;\n\n        _this.startAnimationIfNecessary();\n      });\n    };\n\n    this.state = this.defaultState();\n  }\n\n  TransitionMotion.prototype.defaultState = function defaultState() {\n    var _props = this.props;\n    var defaultStyles = _props.defaultStyles;\n    var styles = _props.styles;\n    var willEnter = _props.willEnter;\n    var willLeave = _props.willLeave;\n    var didLeave = _props.didLeave;\n\n    var destStyles = typeof styles === 'function' ? styles(defaultStyles) : styles;\n\n    // this is special. for the first time around, we don't have a comparison\n    // between last (no last) and current merged props. we'll compute last so:\n    // say default is {a, b} and styles (dest style) is {b, c}, we'll\n    // fabricate last as {a, b}\n    var oldMergedPropsStyles = undefined;\n    if (defaultStyles == null) {\n      oldMergedPropsStyles = destStyles;\n    } else {\n      oldMergedPropsStyles = defaultStyles.map(function (defaultStyleCell) {\n        // TODO: key search code\n        for (var i = 0; i < destStyles.length; i++) {\n          if (destStyles[i].key === defaultStyleCell.key) {\n            return destStyles[i];\n          }\n        }\n        return defaultStyleCell;\n      });\n    }\n    var oldCurrentStyles = defaultStyles == null ? destStyles.map(function (s) {\n      return _stripStyle2['default'](s.style);\n    }) : defaultStyles.map(function (s) {\n      return _stripStyle2['default'](s.style);\n    });\n    var oldCurrentVelocities = defaultStyles == null ? destStyles.map(function (s) {\n      return _mapToZero2['default'](s.style);\n    }) : defaultStyles.map(function (s) {\n      return _mapToZero2['default'](s.style);\n    });\n\n    var _mergeAndSync3 = mergeAndSync(\n    // Because this is an old-style createReactClass component, Flow doesn't\n    // understand that the willEnter and willLeave props have default values\n    // and will always be present.\n    willEnter, willLeave, didLeave, oldMergedPropsStyles, destStyles, oldCurrentStyles, oldCurrentVelocities, oldCurrentStyles, // oldLastIdealStyles really\n    oldCurrentVelocities);\n\n    var mergedPropsStyles = _mergeAndSync3[0];\n    var currentStyles = _mergeAndSync3[1];\n    var currentVelocities = _mergeAndSync3[2];\n    var lastIdealStyles = _mergeAndSync3[3];\n    var lastIdealVelocities = _mergeAndSync3[4];\n    // oldLastIdealVelocities really\n\n    return {\n      currentStyles: currentStyles,\n      currentVelocities: currentVelocities,\n      lastIdealStyles: lastIdealStyles,\n      lastIdealVelocities: lastIdealVelocities,\n      mergedPropsStyles: mergedPropsStyles\n    };\n  };\n\n  // after checking for unreadPropStyles != null, we manually go set the\n  // non-interpolating values (those that are a number, without a spring\n  // config)\n\n  TransitionMotion.prototype.componentDidMount = function componentDidMount() {\n    this.prevTime = _performanceNow2['default']();\n    this.startAnimationIfNecessary();\n  };\n\n  TransitionMotion.prototype.componentWillReceiveProps = function componentWillReceiveProps(props) {\n    if (this.unreadPropStyles) {\n      // previous props haven't had the chance to be set yet; set them here\n      this.clearUnreadPropStyle(this.unreadPropStyles);\n    }\n\n    var styles = props.styles;\n    if (typeof styles === 'function') {\n      this.unreadPropStyles = styles(rehydrateStyles(this.state.mergedPropsStyles, this.unreadPropStyles, this.state.lastIdealStyles));\n    } else {\n      this.unreadPropStyles = styles;\n    }\n\n    if (this.animationID == null) {\n      this.prevTime = _performanceNow2['default']();\n      this.startAnimationIfNecessary();\n    }\n  };\n\n  TransitionMotion.prototype.componentWillUnmount = function componentWillUnmount() {\n    this.unmounting = true;\n    if (this.animationID != null) {\n      _raf2['default'].cancel(this.animationID);\n      this.animationID = null;\n    }\n  };\n\n  TransitionMotion.prototype.render = function render() {\n    var hydratedStyles = rehydrateStyles(this.state.mergedPropsStyles, this.unreadPropStyles, this.state.currentStyles);\n    var renderedChildren = this.props.children(hydratedStyles);\n    return renderedChildren && _react2['default'].Children.only(renderedChildren);\n  };\n\n  return TransitionMotion;\n})(_react2['default'].Component);\n\nexports['default'] = TransitionMotion;\nmodule.exports = exports['default'];\n\n// list of styles, each containing interpolating values. Part of what's passed\n// to children function. Notice that this is\n// Array<ActualInterpolatingStyleObject>, without the wrapper that is {key: ...,\n// data: ... style: ActualInterpolatingStyleObject}. Only mergedPropsStyles\n// contains the key & data info (so that we only have a single source of truth\n// for these, and to save space). Check the comment for `rehydrateStyles` to\n// see how we regenerate the entirety of what's passed to children function\n\n// the array that keeps track of currently rendered stuff! Including stuff\n// that you've unmounted but that's still animating. This is where it lives\n\n// it's possible that currentStyle's value is stale: if props is immediately\n// changed from 0 to 400 to spring(0) again, the async currentStyle is still\n// at 0 (didn't have time to tick and interpolate even once). If we naively\n// compare currentStyle with destVal it'll be 0 === 0 (no animation, stop).\n// In reality currentStyle should be 400\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/react-motion/lib/TransitionMotion.js\n// module id = 22\n// module chunks = 0","\n\n// core keys merging algorithm. If previous render's keys are [a, b], and the\n// next render's [c, b, d], what's the final merged keys and ordering?\n\n// - c and a must both be before b\n// - b before d\n// - ordering between a and c ambiguous\n\n// this reduces to merging two partially ordered lists (e.g. lists where not\n// every item has a definite ordering, like comparing a and c above). For the\n// ambiguous ordering we deterministically choose to place the next render's\n// item after the previous'; so c after a\n\n// this is called a topological sorting. Except the existing algorithms don't\n// work well with js bc of the amount of allocation, and isn't optimized for our\n// current use-case bc the runtime is linear in terms of edges (see wiki for\n// meaning), which is huge when two lists have many common elements\n'use strict';\n\nexports.__esModule = true;\nexports['default'] = mergeDiff;\n\nfunction mergeDiff(prev, next, onRemove) {\n  // bookkeeping for easier access of a key's index below. This is 2 allocations +\n  // potentially triggering chrome hash map mode for objs (so it might be faster\n\n  var prevKeyIndex = {};\n  for (var i = 0; i < prev.length; i++) {\n    prevKeyIndex[prev[i].key] = i;\n  }\n  var nextKeyIndex = {};\n  for (var i = 0; i < next.length; i++) {\n    nextKeyIndex[next[i].key] = i;\n  }\n\n  // first, an overly elaborate way of merging prev and next, eliminating\n  // duplicates (in terms of keys). If there's dupe, keep the item in next).\n  // This way of writing it saves allocations\n  var ret = [];\n  for (var i = 0; i < next.length; i++) {\n    ret[i] = next[i];\n  }\n  for (var i = 0; i < prev.length; i++) {\n    if (!Object.prototype.hasOwnProperty.call(nextKeyIndex, prev[i].key)) {\n      // this is called my TM's `mergeAndSync`, which calls willLeave. We don't\n      // merge in keys that the user desires to kill\n      var fill = onRemove(i, prev[i]);\n      if (fill != null) {\n        ret.push(fill);\n      }\n    }\n  }\n\n  // now all the items all present. Core sorting logic to have the right order\n  return ret.sort(function (a, b) {\n    var nextOrderA = nextKeyIndex[a.key];\n    var nextOrderB = nextKeyIndex[b.key];\n    var prevOrderA = prevKeyIndex[a.key];\n    var prevOrderB = prevKeyIndex[b.key];\n\n    if (nextOrderA != null && nextOrderB != null) {\n      // both keys in next\n      return nextKeyIndex[a.key] - nextKeyIndex[b.key];\n    } else if (prevOrderA != null && prevOrderB != null) {\n      // both keys in prev\n      return prevKeyIndex[a.key] - prevKeyIndex[b.key];\n    } else if (nextOrderA != null) {\n      // key a in next, key b in prev\n\n      // how to determine the order between a and b? We find a \"pivot\" (term\n      // abuse), a key present in both prev and next, that is sandwiched between\n      // a and b. In the context of our above example, if we're comparing a and\n      // d, b's (the only) pivot\n      for (var i = 0; i < next.length; i++) {\n        var pivot = next[i].key;\n        if (!Object.prototype.hasOwnProperty.call(prevKeyIndex, pivot)) {\n          continue;\n        }\n\n        if (nextOrderA < nextKeyIndex[pivot] && prevOrderB > prevKeyIndex[pivot]) {\n          return -1;\n        } else if (nextOrderA > nextKeyIndex[pivot] && prevOrderB < prevKeyIndex[pivot]) {\n          return 1;\n        }\n      }\n      // pluggable. default to: next bigger than prev\n      return 1;\n    }\n    // prevOrderA, nextOrderB\n    for (var i = 0; i < next.length; i++) {\n      var pivot = next[i].key;\n      if (!Object.prototype.hasOwnProperty.call(prevKeyIndex, pivot)) {\n        continue;\n      }\n      if (nextOrderB < nextKeyIndex[pivot] && prevOrderA > prevKeyIndex[pivot]) {\n        return 1;\n      } else if (nextOrderB > nextKeyIndex[pivot] && prevOrderA < prevKeyIndex[pivot]) {\n        return -1;\n      }\n    }\n    // pluggable. default to: next bigger than prev\n    return -1;\n  });\n}\n\nmodule.exports = exports['default'];\n// to loop through and find a key's index each time), but I no longer care\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/react-motion/lib/mergeDiff.js\n// module id = 23\n// module chunks = 0","'use strict';\n\nexports.__esModule = true;\n\nvar _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; };\n\nexports['default'] = spring;\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }\n\nvar _presets = require('./presets');\n\nvar _presets2 = _interopRequireDefault(_presets);\n\nvar defaultConfig = _extends({}, _presets2['default'].noWobble, {\n  precision: 0.01\n});\n\nfunction spring(val, config) {\n  return _extends({}, defaultConfig, config, { val: val });\n}\n\nmodule.exports = exports['default'];\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/react-motion/lib/spring.js\n// module id = 24\n// module chunks = 0","\"use strict\";\n\nexports.__esModule = true;\nexports[\"default\"] = {\n  noWobble: { stiffness: 170, damping: 26 }, // the default, if nothing provided\n  gentle: { stiffness: 120, damping: 14 },\n  wobbly: { stiffness: 180, damping: 12 },\n  stiff: { stiffness: 210, damping: 20 }\n};\nmodule.exports = exports[\"default\"];\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/react-motion/lib/presets.js\n// module id = 25\n// module chunks = 0","'use strict';\n\nexports.__esModule = true;\nexports['default'] = reorderKeys;\n\nvar hasWarned = false;\n\nfunction reorderKeys() {\n  if (process.env.NODE_ENV === 'development') {\n    if (!hasWarned) {\n      hasWarned = true;\n      console.error('`reorderKeys` has been removed, since it is no longer needed for TransitionMotion\\'s new styles array API.');\n    }\n  }\n}\n\nmodule.exports = exports['default'];\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/react-motion/lib/reorderKeys.js\n// module id = 26\n// module chunks = 0","import React from 'react';\n\nconst react13 = isReact13(React);\nvar didWarnAboutChild = false;\n\nexport function findDOMNode(component){\n    if(!react13){\n        return component;\n    }else{\n        return React.findDOMNode(component);\n    }\n}\n\nexport function warnAboutFunctionChild() {\n    if (didWarnAboutChild || react13) {\n      return;\n    }\n\n    didWarnAboutChild = true;\n    console.error('With React 0.14 and later versions, you no longer need to wrap <ScrollArea> child into a function.');\n  }\n\nexport function warnAboutElementChild() {\n    if (didWarnAboutChild || !react13) {\n          return;\n    }\n\n    didWarnAboutChild = true;\n    console.error( 'With React 0.13, you need to wrap <ScrollArea> child into a function.' );\n  }\n\nexport function positiveOrZero(number){\n    return number < 0 ? 0 : number;\n}\n\nexport function modifyObjValues (obj, modifier = x => x){\n    let modifiedObj = {};\n    for(let key in obj){\n        if(obj.hasOwnProperty(key)) modifiedObj[key] = modifier(obj[key]);\n    }\n    \n    return modifiedObj;\n}\n\nexport function isReact13(React) {\n    const { version } = React;\n    if (typeof version !== 'string') {\n        return true;\n    }\n\n    const parts = version.split('.');\n    const major = parseInt(parts[0], 10);\n    const minor = parseInt(parts[1], 10);\n\n    return major === 0 && minor === 13;\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/js/utils.js","import React from 'react';\nimport PropTypes from 'prop-types';\nimport { Motion, spring } from 'react-motion';\nimport { modifyObjValues } from './utils';\n\nclass ScrollBar extends React.Component {\n    constructor(props){\n        super(props);\n        let newState = this.calculateState(props);\n        this.state = {\n            position: newState.position,\n            scrollSize: newState.scrollSize,\n            isDragging: false,\n            lastClientPosition: 0\n        };\n\n        if(props.type === 'vertical'){\n            this.bindedHandleMouseMove = this.handleMouseMoveForVertical.bind(this);\n        } else {\n            this.bindedHandleMouseMove = this.handleMouseMoveForHorizontal.bind(this);\n        }\n\n        this.bindedHandleMouseUp = this.handleMouseUp.bind(this);\n    }\n\n    componentDidMount(){\n        if (this.props.ownerDocument) {\n            this.props.ownerDocument.addEventListener(\"mousemove\", this.bindedHandleMouseMove);\n            this.props.ownerDocument.addEventListener(\"mouseup\", this.bindedHandleMouseUp);\n        }\n    }\n\n    componentWillReceiveProps(nextProps){\n        this.setState(this.calculateState(nextProps));\n    }\n\n    componentWillUnmount(){\n        if (this.props.ownerDocument) {\n            this.props.ownerDocument.removeEventListener(\"mousemove\", this.bindedHandleMouseMove);\n            this.props.ownerDocument.removeEventListener(\"mouseup\", this.bindedHandleMouseUp);\n        }\n    }\n\n    calculateFractionalPosition(realContentSize, containerSize, contentPosition){\n        let relativeSize = realContentSize - containerSize;\n\n        return 1 - ((relativeSize - contentPosition) / relativeSize);\n    }\n\n    calculateState(props){\n        let fractionalPosition = this.calculateFractionalPosition(props.realSize, props.containerSize, props.position);\n        let proportionalToPageScrollSize = props.containerSize * props.containerSize / props.realSize;\n        let scrollSize = proportionalToPageScrollSize < props.minScrollSize ? props.minScrollSize : proportionalToPageScrollSize;\n\n        let scrollPosition = (props.containerSize - scrollSize) * fractionalPosition;\n        return {\n            scrollSize: scrollSize,\n            position: Math.round(scrollPosition)\n        };\n    }\n\n    render(){\n        let {smoothScrolling, isDragging, type, scrollbarStyle, containerStyle} = this.props;\n        let isVoriziontal = type === 'horizontal';\n        let isVertical = type === 'vertical';\n        let scrollStyles = this.createScrollStyles();\n        let springifiedScrollStyles = smoothScrolling ? modifyObjValues(scrollStyles, x => spring(x)) : scrollStyles;\n\n        let scrollbarClasses = `scrollbar-container ${isDragging ? 'active' : ''} ${isVoriziontal ? 'horizontal' : ''} ${isVertical ? 'vertical' : ''}`;\n\n        return (\n            <Motion style={springifiedScrollStyles}>\n                { style =>\n                    <div\n                        className={scrollbarClasses}\n                        style={containerStyle}\n                        onMouseDown={this.handleScrollBarContainerClick.bind(this)}\n                        ref={ x => this.scrollbarContainer = x }\n                    >\n                        <div\n                            className=\"scrollbar\"\n                            style={{ ...scrollbarStyle, ...style }}\n                            onMouseDown={this.handleMouseDown.bind(this)}\n                        />\n                    </div>\n                }\n            </Motion>\n        );\n    }\n\n    handleScrollBarContainerClick(e) {\n        e.preventDefault();\n        let multiplier = this.computeMultiplier();\n        let clientPosition = this.isVertical() ? e.clientY : e.clientX;\n        let { top, left } = this.scrollbarContainer.getBoundingClientRect();\n        let clientScrollPosition = this.isVertical() ? top : left;\n\n        let position = clientPosition - clientScrollPosition;\n        let proportionalToPageScrollSize = this.props.containerSize * this.props.containerSize / this.props.realSize;\n\n        this.setState({isDragging: true, lastClientPosition: clientPosition });\n        this.props.onPositionChange((position - proportionalToPageScrollSize / 2) / multiplier);\n    }\n\n    handleMouseMoveForHorizontal(e){\n        let multiplier = this.computeMultiplier();\n\n        if(this.state.isDragging){\n            e.preventDefault();\n            let deltaX = this.state.lastClientPosition - e.clientX;\n            this.setState({ lastClientPosition: e.clientX });\n            this.props.onMove(0, deltaX / multiplier);\n        }\n    }\n\n    handleMouseMoveForVertical(e){\n        let multiplier = this.computeMultiplier();\n\n        if(this.state.isDragging){\n            e.preventDefault();\n            let deltaY = this.state.lastClientPosition - e.clientY;\n            this.setState({ lastClientPosition: e.clientY });\n            this.props.onMove(deltaY / multiplier, 0);\n        }\n    }\n\n    handleMouseDown(e){\n        e.preventDefault();\n        e.stopPropagation();\n        let lastClientPosition = this.isVertical() ? e.clientY: e.clientX;\n        this.setState({isDragging: true, lastClientPosition: lastClientPosition });\n\n        this.props.onFocus();\n    }\n\n    handleMouseUp(e){\n        if (this.state.isDragging) {\n            e.preventDefault();\n            this.setState({isDragging: false });\n        }\n    }\n\n    createScrollStyles(){\n        if(this.props.type === 'vertical'){\n            return {\n                height: this.state.scrollSize,\n                marginTop: this.state.position\n            };\n        } else {\n            return {\n                width: this.state.scrollSize,\n                marginLeft: this.state.position\n            };\n        }\n    }\n\n    computeMultiplier(){\n        return (this.props.containerSize) / this.props.realSize;\n    }\n\n    isVertical(){\n       return this.props.type === 'vertical';\n    }\n}\n\nScrollBar.propTypes = {\n    onMove: PropTypes.func,\n    onPositionChange: PropTypes.func,\n    onFocus: PropTypes.func,\n    realSize: PropTypes.number,\n    containerSize: PropTypes.number,\n    position: PropTypes.number,\n    containerStyle: PropTypes.object,\n    scrollbarStyle: PropTypes.object,\n    type: PropTypes.oneOf(['vertical', 'horizontal']),\n    ownerDocument: PropTypes.any,\n    smoothScrolling: PropTypes.bool,\n    minScrollSize: PropTypes.number\n};\n\nScrollBar.defaultProps = {\n    type : 'vertical',\n    smoothScrolling: false,\n};\n\nexport default ScrollBar;\n\n\n\n// WEBPACK FOOTER //\n// ./src/js/Scrollbar.jsx"],"sourceRoot":""} \ No newline at end of file diff --git a/dist/scrollArea.js b/dist/scrollArea.js new file mode 100644 index 0000000..cc98f80 --- /dev/null +++ b/dist/scrollArea.js @@ -0,0 +1,4173 @@ +(function webpackUniversalModuleDefinition(root, factory) { + if(typeof exports === 'object' && typeof module === 'object') + module.exports = factory(require("react")); + else if(typeof define === 'function' && define.amd) + define(["react"], factory); + else if(typeof exports === 'object') + exports["ScrollArea"] = factory(require("react")); + else + root["ScrollArea"] = factory(root["React"]); +})(this, function(__WEBPACK_EXTERNAL_MODULE_6__) { +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); +/******/ }) +/************************************************************************/ +/******/ ([ +/* 0 */ +/***/ (function(module, exports, __webpack_require__) { + + 'use strict'; + + Object.defineProperty(exports, "__esModule", { + value: true + }); + + __webpack_require__(1); + + var _ScrollArea = __webpack_require__(5); + + var _ScrollArea2 = _interopRequireDefault(_ScrollArea); + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + + exports.default = _ScrollArea2.default; + +/***/ }), +/* 1 */ +/***/ (function(module, exports, __webpack_require__) { + + // style-loader: Adds some css to the DOM by adding a