}\n \n )\n}\n\nconst StaticQuery = props => {\n const { data, query, render, children } = props\n\n return (\n \n {staticQueryData => (\n \n )}\n \n )\n}\n\nconst useStaticQuery = query => {\n if (\n typeof React.useContext !== `function` &&\n process.env.NODE_ENV === `development`\n ) {\n throw new Error(\n `You're likely using a version of React that doesn't support Hooks\\n` +\n `Please update React and ReactDOM to 16.8.0 or later to use the useStaticQuery hook.`\n )\n }\n const context = React.useContext(StaticQueryContext)\n\n // query is a stringified number like `3303882` when wrapped with graphql, If a user forgets\n // to wrap the query in a grqphql, then casting it to a Number results in `NaN` allowing us to\n // catch the misuse of the API and give proper direction\n if (isNaN(Number(query))) {\n throw new Error(`useStaticQuery was called with a string but expects to be called using \\`graphql\\`. Try this:\n\nimport { useStaticQuery, graphql } from 'gatsby';\n\nuseStaticQuery(graphql\\`${query}\\`);\n`)\n }\n\n if (context[query]?.data) {\n return context[query].data\n } else {\n throw new Error(\n `The result of this StaticQuery could not be fetched.\\n\\n` +\n `This is likely a bug in Gatsby and if refreshing the page does not fix it, ` +\n `please open an issue in https://github.com/gatsbyjs/gatsby/issues`\n )\n }\n}\n\nStaticQuery.propTypes = {\n data: PropTypes.object,\n query: PropTypes.string.isRequired,\n render: PropTypes.func,\n children: PropTypes.func,\n}\n\nfunction graphql() {\n throw new Error(\n `It appears like Gatsby is misconfigured. Gatsby related \\`graphql\\` calls ` +\n `are supposed to only be evaluated at compile time, and then compiled away. ` +\n `Unfortunately, something went wrong and the query was left in the compiled code.\\n\\n` +\n `Unless your site has a complex or custom babel/Gatsby configuration this is likely a bug in Gatsby.`\n )\n}\n\nexport {\n Link,\n withAssetPrefix,\n withPrefix,\n graphql,\n parsePath,\n navigate,\n push, // TODO replace for v3\n replace, // TODO remove replace for v3\n navigateTo, // TODO: remove navigateTo for v3\n useScrollRestoration,\n StaticQueryContext,\n StaticQuery,\n PageRenderer,\n useStaticQuery,\n prefetchPathname,\n}\n","var isCallable = require('../internals/is-callable');\nvar tryToString = require('../internals/try-to-string');\n\nvar $TypeError = TypeError;\n\n// `Assert: IsCallable(argument) is true`\nmodule.exports = function (argument) {\n if (isCallable(argument)) return argument;\n throw $TypeError(tryToString(argument) + ' is not a function');\n};\n","var safeIsNaN = Number.isNaN || function ponyfill(value) {\n return typeof value === 'number' && value !== value;\n};\n\nfunction isEqual(first, second) {\n if (first === second) {\n return true;\n }\n\n if (safeIsNaN(first) && safeIsNaN(second)) {\n return true;\n }\n\n return false;\n}\n\nfunction areInputsEqual(newInputs, lastInputs) {\n if (newInputs.length !== lastInputs.length) {\n return false;\n }\n\n for (var i = 0; i < newInputs.length; i++) {\n if (!isEqual(newInputs[i], lastInputs[i])) {\n return false;\n }\n }\n\n return true;\n}\n\nfunction memoizeOne(resultFn, isEqual) {\n if (isEqual === void 0) {\n isEqual = areInputsEqual;\n }\n\n var lastThis;\n var lastArgs = [];\n var lastResult;\n var calledOnce = false;\n\n function memoized() {\n var newArgs = [];\n\n for (var _i = 0; _i < arguments.length; _i++) {\n newArgs[_i] = arguments[_i];\n }\n\n if (calledOnce && lastThis === this && isEqual(newArgs, lastArgs)) {\n return lastResult;\n }\n\n lastResult = resultFn.apply(this, newArgs);\n calledOnce = true;\n lastThis = this;\n lastArgs = newArgs;\n return lastResult;\n }\n\n return memoized;\n}\n\nexport default memoizeOne;","module.exports = function (bitmap, value) {\n return {\n enumerable: !(bitmap & 1),\n configurable: !(bitmap & 2),\n writable: !(bitmap & 4),\n value: value\n };\n};\n","var DESCRIPTORS = require('../internals/descriptors');\nvar hasOwn = require('../internals/has-own-property');\n\nvar FunctionPrototype = Function.prototype;\n// eslint-disable-next-line es-x/no-object-getownpropertydescriptor -- safe\nvar getDescriptor = DESCRIPTORS && Object.getOwnPropertyDescriptor;\n\nvar EXISTS = hasOwn(FunctionPrototype, 'name');\n// additional protection from minified / mangled / dropped function names\nvar PROPER = EXISTS && (function something() { /* empty */ }).name === 'something';\nvar CONFIGURABLE = EXISTS && (!DESCRIPTORS || (DESCRIPTORS && getDescriptor(FunctionPrototype, 'name').configurable));\n\nmodule.exports = {\n EXISTS: EXISTS,\n PROPER: PROPER,\n CONFIGURABLE: CONFIGURABLE\n};\n","module.exports = __webpack_public_path__ + \"static/Moderat-Regular-3c144790c77538f48ac964029d7101a9.woff2\";","var global = require('../internals/global');\n\n// eslint-disable-next-line es-x/no-object-defineproperty -- safe\nvar defineProperty = Object.defineProperty;\n\nmodule.exports = function (key, value) {\n try {\n defineProperty(global, key, { value: value, configurable: true, writable: true });\n } catch (error) {\n global[key] = value;\n } return value;\n};\n","var classof = require('../internals/classof-raw');\nvar global = require('../internals/global');\n\nmodule.exports = classof(global.process) == 'process';\n","\"use strict\";\n\nmodule.exports = Object.assign;","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; };\n\nfunction _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _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; }\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\n/* eslint-disable jsx-a11y/anchor-has-content */\nimport React, { useContext } from \"react\";\nimport PropTypes from \"prop-types\";\nimport invariant from \"invariant\";\nimport createContext from \"create-react-context\";\nimport { polyfill } from \"react-lifecycles-compat\";\nimport { startsWith, pick, resolve, match, insertParams, validateRedirect, shallowCompare } from \"./lib/utils\";\nimport { globalHistory, navigate, createHistory, createMemorySource } from \"./lib/history\";\n\n////////////////////////////////////////////////////////////////////////////////\n\nvar createNamedContext = function createNamedContext(name, defaultValue) {\n var Ctx = createContext(defaultValue);\n Ctx.displayName = name;\n return Ctx;\n};\n\n////////////////////////////////////////////////////////////////////////////////\n// Location Context/Provider\nvar LocationContext = createNamedContext(\"Location\");\n\n// sets up a listener if there isn't one already so apps don't need to be\n// wrapped in some top level provider\nvar Location = function Location(_ref) {\n var children = _ref.children;\n return React.createElement(\n LocationContext.Consumer,\n null,\n function (context) {\n return context ? children(context) : React.createElement(\n LocationProvider,\n null,\n children\n );\n }\n );\n};\n\nvar LocationProvider = function (_React$Component) {\n _inherits(LocationProvider, _React$Component);\n\n function LocationProvider() {\n var _temp, _this, _ret;\n\n _classCallCheck(this, LocationProvider);\n\n for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {\n args[_key] = arguments[_key];\n }\n\n return _ret = (_temp = (_this = _possibleConstructorReturn(this, _React$Component.call.apply(_React$Component, [this].concat(args))), _this), _this.state = {\n context: _this.getContext(),\n refs: { unlisten: null }\n }, _temp), _possibleConstructorReturn(_this, _ret);\n }\n\n LocationProvider.prototype.getContext = function getContext() {\n var _props$history = this.props.history,\n navigate = _props$history.navigate,\n location = _props$history.location;\n\n return { navigate: navigate, location: location };\n };\n\n LocationProvider.prototype.componentDidCatch = function componentDidCatch(error, info) {\n if (isRedirect(error)) {\n var _navigate = this.props.history.navigate;\n\n _navigate(error.uri, { replace: true });\n } else {\n throw error;\n }\n };\n\n LocationProvider.prototype.componentDidUpdate = function componentDidUpdate(prevProps, prevState) {\n if (prevState.context.location !== this.state.context.location) {\n this.props.history._onTransitionComplete();\n }\n };\n\n LocationProvider.prototype.componentDidMount = function componentDidMount() {\n var _this2 = this;\n\n var refs = this.state.refs,\n history = this.props.history;\n\n history._onTransitionComplete();\n refs.unlisten = history.listen(function () {\n Promise.resolve().then(function () {\n // TODO: replace rAF with react deferred update API when it's ready https://github.com/facebook/react/issues/13306\n requestAnimationFrame(function () {\n if (!_this2.unmounted) {\n _this2.setState(function () {\n return { context: _this2.getContext() };\n });\n }\n });\n });\n });\n };\n\n LocationProvider.prototype.componentWillUnmount = function componentWillUnmount() {\n var refs = this.state.refs;\n\n this.unmounted = true;\n refs.unlisten();\n };\n\n LocationProvider.prototype.render = function render() {\n var context = this.state.context,\n children = this.props.children;\n\n return React.createElement(\n LocationContext.Provider,\n { value: context },\n typeof children === \"function\" ? children(context) : children || null\n );\n };\n\n return LocationProvider;\n}(React.Component);\n\n////////////////////////////////////////////////////////////////////////////////\n\n\nLocationProvider.defaultProps = {\n history: globalHistory\n};\nprocess.env.NODE_ENV !== \"production\" ? LocationProvider.propTypes = {\n history: PropTypes.object.isRequired\n} : void 0;\nvar ServerLocation = function ServerLocation(_ref2) {\n var url = _ref2.url,\n children = _ref2.children;\n\n var searchIndex = url.indexOf(\"?\");\n var searchExists = searchIndex > -1;\n var pathname = void 0;\n var search = \"\";\n var hash = \"\";\n\n if (searchExists) {\n pathname = url.substring(0, searchIndex);\n search = url.substring(searchIndex);\n } else {\n pathname = url;\n }\n\n return React.createElement(\n LocationContext.Provider,\n {\n value: {\n location: {\n pathname: pathname,\n search: search,\n hash: hash\n },\n navigate: function navigate() {\n throw new Error(\"You can't call navigate on the server.\");\n }\n }\n },\n children\n );\n};\n////////////////////////////////////////////////////////////////////////////////\n// Sets baseuri and basepath for nested routers and links\nvar BaseContext = createNamedContext(\"Base\", { baseuri: \"/\", basepath: \"/\" });\n\n////////////////////////////////////////////////////////////////////////////////\n// The main event, welcome to the show everybody.\nvar Router = function Router(props) {\n return React.createElement(\n BaseContext.Consumer,\n null,\n function (baseContext) {\n return React.createElement(\n Location,\n null,\n function (locationContext) {\n return React.createElement(RouterImpl, _extends({}, baseContext, locationContext, props));\n }\n );\n }\n );\n};\n\nvar RouterImpl = function (_React$PureComponent) {\n _inherits(RouterImpl, _React$PureComponent);\n\n function RouterImpl() {\n _classCallCheck(this, RouterImpl);\n\n return _possibleConstructorReturn(this, _React$PureComponent.apply(this, arguments));\n }\n\n RouterImpl.prototype.render = function render() {\n var _props = this.props,\n location = _props.location,\n _navigate2 = _props.navigate,\n basepath = _props.basepath,\n primary = _props.primary,\n children = _props.children,\n baseuri = _props.baseuri,\n _props$component = _props.component,\n component = _props$component === undefined ? \"div\" : _props$component,\n domProps = _objectWithoutProperties(_props, [\"location\", \"navigate\", \"basepath\", \"primary\", \"children\", \"baseuri\", \"component\"]);\n\n var routes = React.Children.toArray(children).reduce(function (array, child) {\n var routes = createRoute(basepath)(child);\n return array.concat(routes);\n }, []);\n var pathname = location.pathname;\n\n\n var match = pick(routes, pathname);\n\n if (match) {\n var params = match.params,\n uri = match.uri,\n route = match.route,\n element = match.route.value;\n\n // remove the /* from the end for child routes relative paths\n\n basepath = route.default ? basepath : route.path.replace(/\\*$/, \"\");\n\n var props = _extends({}, params, {\n uri: uri,\n location: location,\n navigate: function navigate(to, options) {\n return _navigate2(resolve(to, uri), options);\n }\n });\n\n var clone = React.cloneElement(element, props, element.props.children ? React.createElement(\n Router,\n { location: location, primary: primary },\n element.props.children\n ) : undefined);\n\n // using 'div' for < 16.3 support\n var FocusWrapper = primary ? FocusHandler : component;\n // don't pass any props to 'div'\n var wrapperProps = primary ? _extends({ uri: uri, location: location, component: component }, domProps) : domProps;\n\n return React.createElement(\n BaseContext.Provider,\n { value: { baseuri: uri, basepath: basepath } },\n React.createElement(\n FocusWrapper,\n wrapperProps,\n clone\n )\n );\n } else {\n // Not sure if we want this, would require index routes at every level\n // warning(\n // false,\n // `\\n\\nNothing matched:\\n\\t${\n // location.pathname\n // }\\n\\nPaths checked: \\n\\t${routes\n // .map(route => route.path)\n // .join(\n // \"\\n\\t\"\n // )}\\n\\nTo get rid of this warning, add a default NotFound component as child of Router:\n // \\n\\tlet NotFound = () =>
Not Found!
\n // \\n\\t\\n\\t \\n\\t {/* ... */}\\n\\t`\n // );\n return null;\n }\n };\n\n return RouterImpl;\n}(React.PureComponent);\n\nRouterImpl.defaultProps = {\n primary: true\n};\n\n\nvar FocusContext = createNamedContext(\"Focus\");\n\nvar FocusHandler = function FocusHandler(_ref3) {\n var uri = _ref3.uri,\n location = _ref3.location,\n component = _ref3.component,\n domProps = _objectWithoutProperties(_ref3, [\"uri\", \"location\", \"component\"]);\n\n return React.createElement(\n FocusContext.Consumer,\n null,\n function (requestFocus) {\n return React.createElement(FocusHandlerImpl, _extends({}, domProps, {\n component: component,\n requestFocus: requestFocus,\n uri: uri,\n location: location\n }));\n }\n );\n};\n\n// don't focus on initial render\nvar initialRender = true;\nvar focusHandlerCount = 0;\n\nvar FocusHandlerImpl = function (_React$Component2) {\n _inherits(FocusHandlerImpl, _React$Component2);\n\n function FocusHandlerImpl() {\n var _temp2, _this4, _ret2;\n\n _classCallCheck(this, FocusHandlerImpl);\n\n for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n args[_key2] = arguments[_key2];\n }\n\n return _ret2 = (_temp2 = (_this4 = _possibleConstructorReturn(this, _React$Component2.call.apply(_React$Component2, [this].concat(args))), _this4), _this4.state = {}, _this4.requestFocus = function (node) {\n if (!_this4.state.shouldFocus && node) {\n node.focus();\n }\n }, _temp2), _possibleConstructorReturn(_this4, _ret2);\n }\n\n FocusHandlerImpl.getDerivedStateFromProps = function getDerivedStateFromProps(nextProps, prevState) {\n var initial = prevState.uri == null;\n if (initial) {\n return _extends({\n shouldFocus: true\n }, nextProps);\n } else {\n var myURIChanged = nextProps.uri !== prevState.uri;\n var navigatedUpToMe = prevState.location.pathname !== nextProps.location.pathname && nextProps.location.pathname === nextProps.uri;\n return _extends({\n shouldFocus: myURIChanged || navigatedUpToMe\n }, nextProps);\n }\n };\n\n FocusHandlerImpl.prototype.componentDidMount = function componentDidMount() {\n focusHandlerCount++;\n this.focus();\n };\n\n FocusHandlerImpl.prototype.componentWillUnmount = function componentWillUnmount() {\n focusHandlerCount--;\n if (focusHandlerCount === 0) {\n initialRender = true;\n }\n };\n\n FocusHandlerImpl.prototype.componentDidUpdate = function componentDidUpdate(prevProps, prevState) {\n if (prevProps.location !== this.props.location && this.state.shouldFocus) {\n this.focus();\n }\n };\n\n FocusHandlerImpl.prototype.focus = function focus() {\n if (process.env.NODE_ENV === \"test\") {\n // getting cannot read property focus of null in the tests\n // and that bit of global `initialRender` state causes problems\n // should probably figure it out!\n return;\n }\n\n var requestFocus = this.props.requestFocus;\n\n\n if (requestFocus) {\n requestFocus(this.node);\n } else {\n if (initialRender) {\n initialRender = false;\n } else if (this.node) {\n // React polyfills [autofocus] and it fires earlier than cDM,\n // so we were stealing focus away, this line prevents that.\n if (!this.node.contains(document.activeElement)) {\n this.node.focus();\n }\n }\n }\n };\n\n FocusHandlerImpl.prototype.render = function render() {\n var _this5 = this;\n\n var _props2 = this.props,\n children = _props2.children,\n style = _props2.style,\n requestFocus = _props2.requestFocus,\n _props2$component = _props2.component,\n Comp = _props2$component === undefined ? \"div\" : _props2$component,\n uri = _props2.uri,\n location = _props2.location,\n domProps = _objectWithoutProperties(_props2, [\"children\", \"style\", \"requestFocus\", \"component\", \"uri\", \"location\"]);\n\n return React.createElement(\n Comp,\n _extends({\n style: _extends({ outline: \"none\" }, style),\n tabIndex: \"-1\",\n ref: function ref(n) {\n return _this5.node = n;\n }\n }, domProps),\n React.createElement(\n FocusContext.Provider,\n { value: this.requestFocus },\n this.props.children\n )\n );\n };\n\n return FocusHandlerImpl;\n}(React.Component);\n\npolyfill(FocusHandlerImpl);\n\nvar k = function k() {};\n\n////////////////////////////////////////////////////////////////////////////////\nvar forwardRef = React.forwardRef;\n\nif (typeof forwardRef === \"undefined\") {\n forwardRef = function forwardRef(C) {\n return C;\n };\n}\n\nvar Link = forwardRef(function (_ref4, ref) {\n var innerRef = _ref4.innerRef,\n props = _objectWithoutProperties(_ref4, [\"innerRef\"]);\n\n return React.createElement(\n BaseContext.Consumer,\n null,\n function (_ref5) {\n var basepath = _ref5.basepath,\n baseuri = _ref5.baseuri;\n return React.createElement(\n Location,\n null,\n function (_ref6) {\n var location = _ref6.location,\n navigate = _ref6.navigate;\n\n var to = props.to,\n state = props.state,\n replace = props.replace,\n _props$getProps = props.getProps,\n getProps = _props$getProps === undefined ? k : _props$getProps,\n anchorProps = _objectWithoutProperties(props, [\"to\", \"state\", \"replace\", \"getProps\"]);\n\n var href = resolve(to, baseuri);\n var encodedHref = encodeURI(href);\n var isCurrent = location.pathname === encodedHref;\n var isPartiallyCurrent = startsWith(location.pathname, encodedHref);\n\n return React.createElement(\"a\", _extends({\n ref: ref || innerRef,\n \"aria-current\": isCurrent ? \"page\" : undefined\n }, anchorProps, getProps({ isCurrent: isCurrent, isPartiallyCurrent: isPartiallyCurrent, href: href, location: location }), {\n href: href,\n onClick: function onClick(event) {\n if (anchorProps.onClick) anchorProps.onClick(event);\n if (shouldNavigate(event)) {\n event.preventDefault();\n var shouldReplace = replace;\n if (typeof replace !== \"boolean\" && isCurrent) {\n var _location$state = _extends({}, location.state),\n key = _location$state.key,\n restState = _objectWithoutProperties(_location$state, [\"key\"]);\n\n shouldReplace = shallowCompare(_extends({}, state), restState);\n }\n navigate(href, {\n state: state,\n replace: shouldReplace\n });\n }\n }\n }));\n }\n );\n }\n );\n});\n\nLink.displayName = \"Link\";\n\nprocess.env.NODE_ENV !== \"production\" ? Link.propTypes = {\n to: PropTypes.string.isRequired\n} : void 0;\n\n////////////////////////////////////////////////////////////////////////////////\nfunction RedirectRequest(uri) {\n this.uri = uri;\n}\n\nvar isRedirect = function isRedirect(o) {\n return o instanceof RedirectRequest;\n};\n\nvar redirectTo = function redirectTo(to) {\n throw new RedirectRequest(to);\n};\n\nvar RedirectImpl = function (_React$Component3) {\n _inherits(RedirectImpl, _React$Component3);\n\n function RedirectImpl() {\n _classCallCheck(this, RedirectImpl);\n\n return _possibleConstructorReturn(this, _React$Component3.apply(this, arguments));\n }\n\n // Support React < 16 with this hook\n RedirectImpl.prototype.componentDidMount = function componentDidMount() {\n var _props3 = this.props,\n navigate = _props3.navigate,\n to = _props3.to,\n from = _props3.from,\n _props3$replace = _props3.replace,\n replace = _props3$replace === undefined ? true : _props3$replace,\n state = _props3.state,\n noThrow = _props3.noThrow,\n baseuri = _props3.baseuri,\n props = _objectWithoutProperties(_props3, [\"navigate\", \"to\", \"from\", \"replace\", \"state\", \"noThrow\", \"baseuri\"]);\n\n Promise.resolve().then(function () {\n var resolvedTo = resolve(to, baseuri);\n navigate(insertParams(resolvedTo, props), { replace: replace, state: state });\n });\n };\n\n RedirectImpl.prototype.render = function render() {\n var _props4 = this.props,\n navigate = _props4.navigate,\n to = _props4.to,\n from = _props4.from,\n replace = _props4.replace,\n state = _props4.state,\n noThrow = _props4.noThrow,\n baseuri = _props4.baseuri,\n props = _objectWithoutProperties(_props4, [\"navigate\", \"to\", \"from\", \"replace\", \"state\", \"noThrow\", \"baseuri\"]);\n\n var resolvedTo = resolve(to, baseuri);\n if (!noThrow) redirectTo(insertParams(resolvedTo, props));\n return null;\n };\n\n return RedirectImpl;\n}(React.Component);\n\nvar Redirect = function Redirect(props) {\n return React.createElement(\n BaseContext.Consumer,\n null,\n function (_ref7) {\n var baseuri = _ref7.baseuri;\n return React.createElement(\n Location,\n null,\n function (locationContext) {\n return React.createElement(RedirectImpl, _extends({}, locationContext, { baseuri: baseuri }, props));\n }\n );\n }\n );\n};\n\nprocess.env.NODE_ENV !== \"production\" ? Redirect.propTypes = {\n from: PropTypes.string,\n to: PropTypes.string.isRequired\n} : void 0;\n\n////////////////////////////////////////////////////////////////////////////////\nvar Match = function Match(_ref8) {\n var path = _ref8.path,\n children = _ref8.children;\n return React.createElement(\n BaseContext.Consumer,\n null,\n function (_ref9) {\n var baseuri = _ref9.baseuri;\n return React.createElement(\n Location,\n null,\n function (_ref10) {\n var navigate = _ref10.navigate,\n location = _ref10.location;\n\n var resolvedPath = resolve(path, baseuri);\n var result = match(resolvedPath, location.pathname);\n return children({\n navigate: navigate,\n location: location,\n match: result ? _extends({}, result.params, {\n uri: result.uri,\n path: path\n }) : null\n });\n }\n );\n }\n );\n};\n\n////////////////////////////////////////////////////////////////////////////////\n// Hooks\n\nvar useLocation = function useLocation() {\n var context = useContext(LocationContext);\n\n if (!context) {\n throw new Error(\"useLocation hook was used but a LocationContext.Provider was not found in the parent tree. Make sure this is used in a component that is a child of Router\");\n }\n\n return context.location;\n};\n\nvar useNavigate = function useNavigate() {\n var context = useContext(LocationContext);\n\n if (!context) {\n throw new Error(\"useNavigate hook was used but a LocationContext.Provider was not found in the parent tree. Make sure this is used in a component that is a child of Router\");\n }\n\n return context.navigate;\n};\n\nvar useParams = function useParams() {\n var context = useContext(BaseContext);\n\n if (!context) {\n throw new Error(\"useParams hook was used but a LocationContext.Provider was not found in the parent tree. Make sure this is used in a component that is a child of Router\");\n }\n\n var location = useLocation();\n\n var results = match(context.basepath, location.pathname);\n\n return results ? results.params : null;\n};\n\nvar useMatch = function useMatch(path) {\n if (!path) {\n throw new Error(\"useMatch(path: string) requires an argument of a string to match against\");\n }\n var context = useContext(BaseContext);\n\n if (!context) {\n throw new Error(\"useMatch hook was used but a LocationContext.Provider was not found in the parent tree. Make sure this is used in a component that is a child of Router\");\n }\n\n var location = useLocation();\n\n var resolvedPath = resolve(path, context.baseuri);\n var result = match(resolvedPath, location.pathname);\n return result ? _extends({}, result.params, {\n uri: result.uri,\n path: path\n }) : null;\n};\n\n////////////////////////////////////////////////////////////////////////////////\n// Junk\nvar stripSlashes = function stripSlashes(str) {\n return str.replace(/(^\\/+|\\/+$)/g, \"\");\n};\n\nvar createRoute = function createRoute(basepath) {\n return function (element) {\n if (!element) {\n return null;\n }\n\n if (element.type === React.Fragment && element.props.children) {\n return React.Children.map(element.props.children, createRoute(basepath));\n }\n !(element.props.path || element.props.default || element.type === Redirect) ? process.env.NODE_ENV !== \"production\" ? invariant(false, \": Children of must have a `path` or `default` prop, or be a ``. None found on element type `\" + element.type + \"`\") : invariant(false) : void 0;\n\n !!(element.type === Redirect && (!element.props.from || !element.props.to)) ? process.env.NODE_ENV !== \"production\" ? invariant(false, \" requires both \\\"from\\\" and \\\"to\\\" props when inside a .\") : invariant(false) : void 0;\n\n !!(element.type === Redirect && !validateRedirect(element.props.from, element.props.to)) ? process.env.NODE_ENV !== \"production\" ? invariant(false, \" has mismatched dynamic segments, ensure both paths have the exact same dynamic segments.\") : invariant(false) : void 0;\n\n if (element.props.default) {\n return { value: element, default: true };\n }\n\n var elementPath = element.type === Redirect ? element.props.from : element.props.path;\n\n var path = elementPath === \"/\" ? basepath : stripSlashes(basepath) + \"/\" + stripSlashes(elementPath);\n\n return {\n value: element,\n default: element.props.default,\n path: element.props.children ? stripSlashes(path) + \"/*\" : path\n };\n };\n};\n\nvar shouldNavigate = function shouldNavigate(event) {\n return !event.defaultPrevented && event.button === 0 && !(event.metaKey || event.altKey || event.ctrlKey || event.shiftKey);\n};\n\n////////////////////////////////////////////////////////////////////////\nexport { Link, Location, LocationProvider, Match, Redirect, Router, ServerLocation, createHistory, createMemorySource, isRedirect, navigate, redirectTo, globalHistory, match as matchPath, useLocation, useNavigate, useParams, useMatch , BaseContext };","/**\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 ReactIs = require('react-is');\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')(ReactIs.isElement, 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","!function (e) {\n \"object\" == typeof exports && \"undefined\" != typeof module ? module.exports = e(null) : \"function\" == typeof define && define.amd ? define(e(null)) : window.stylis = e(null);\n}(function e(a) {\n \"use strict\";\n\n var r = /^\\0+/g,\n c = /[\\0\\r\\f]/g,\n s = /: */g,\n t = /zoo|gra/,\n i = /([,: ])(transform)/g,\n f = /,+\\s*(?![^(]*[)])/g,\n n = / +\\s*(?![^(]*[)])/g,\n l = / *[\\0] */g,\n o = /,\\r+?/g,\n h = /([\\t\\r\\n ])*\\f?&/g,\n u = /:global\\(((?:[^\\(\\)\\[\\]]*|\\[.*\\]|\\([^\\(\\)]*\\))*)\\)/g,\n d = /\\W+/g,\n b = /@(k\\w+)\\s*(\\S*)\\s*/,\n p = /::(place)/g,\n k = /:(read-only)/g,\n g = /\\s+(?=[{\\];=:>])/g,\n A = /([[}=:>])\\s+/g,\n C = /(\\{[^{]+?);(?=\\})/g,\n w = /\\s{2,}/g,\n v = /([^\\(])(:+) */g,\n m = /[svh]\\w+-[tblr]{2}/,\n x = /\\(\\s*(.*)\\s*\\)/g,\n $ = /([\\s\\S]*?);/g,\n y = /-self|flex-/g,\n O = /[^]*?(:[rp][el]a[\\w-]+)[^]*/,\n j = /stretch|:\\s*\\w+\\-(?:conte|avail)/,\n z = /([^-])(image-set\\()/,\n N = \"-webkit-\",\n S = \"-moz-\",\n F = \"-ms-\",\n W = 59,\n q = 125,\n B = 123,\n D = 40,\n E = 41,\n G = 91,\n H = 93,\n I = 10,\n J = 13,\n K = 9,\n L = 64,\n M = 32,\n P = 38,\n Q = 45,\n R = 95,\n T = 42,\n U = 44,\n V = 58,\n X = 39,\n Y = 34,\n Z = 47,\n _ = 62,\n ee = 43,\n ae = 126,\n re = 0,\n ce = 12,\n se = 11,\n te = 107,\n ie = 109,\n fe = 115,\n ne = 112,\n le = 111,\n oe = 105,\n he = 99,\n ue = 100,\n de = 112,\n be = 1,\n pe = 1,\n ke = 0,\n ge = 1,\n Ae = 1,\n Ce = 1,\n we = 0,\n ve = 0,\n me = 0,\n xe = [],\n $e = [],\n ye = 0,\n Oe = null,\n je = -2,\n ze = -1,\n Ne = 0,\n Se = 1,\n Fe = 2,\n We = 3,\n qe = 0,\n Be = 1,\n De = \"\",\n Ee = \"\",\n Ge = \"\";\n\n function He(e, a, s, t, i) {\n for (var f, n, o = 0, h = 0, u = 0, d = 0, g = 0, A = 0, C = 0, w = 0, m = 0, $ = 0, y = 0, O = 0, j = 0, z = 0, R = 0, we = 0, $e = 0, Oe = 0, je = 0, ze = s.length, Je = ze - 1, Re = \"\", Te = \"\", Ue = \"\", Ve = \"\", Xe = \"\", Ye = \"\"; R < ze;) {\n if (C = s.charCodeAt(R), R === Je) if (h + d + u + o !== 0) {\n if (0 !== h) C = h === Z ? I : Z;\n d = u = o = 0, ze++, Je++;\n }\n\n if (h + d + u + o === 0) {\n if (R === Je) {\n if (we > 0) Te = Te.replace(c, \"\");\n\n if (Te.trim().length > 0) {\n switch (C) {\n case M:\n case K:\n case W:\n case J:\n case I:\n break;\n\n default:\n Te += s.charAt(R);\n }\n\n C = W;\n }\n }\n\n if (1 === $e) switch (C) {\n case B:\n case q:\n case W:\n case Y:\n case X:\n case D:\n case E:\n case U:\n $e = 0;\n\n case K:\n case J:\n case I:\n case M:\n break;\n\n default:\n for ($e = 0, je = R, g = C, R--, C = W; je < ze;) {\n switch (s.charCodeAt(je++)) {\n case I:\n case J:\n case W:\n ++R, C = g, je = ze;\n break;\n\n case V:\n if (we > 0) ++R, C = g;\n\n case B:\n je = ze;\n }\n }\n\n }\n\n switch (C) {\n case B:\n for (g = (Te = Te.trim()).charCodeAt(0), y = 1, je = ++R; R < ze;) {\n switch (C = s.charCodeAt(R)) {\n case B:\n y++;\n break;\n\n case q:\n y--;\n break;\n\n case Z:\n switch (A = s.charCodeAt(R + 1)) {\n case T:\n case Z:\n R = Qe(A, R, Je, s);\n }\n\n break;\n\n case G:\n C++;\n\n case D:\n C++;\n\n case Y:\n case X:\n for (; R++ < Je && s.charCodeAt(R) !== C;) {\n ;\n }\n\n }\n\n if (0 === y) break;\n R++;\n }\n\n if (Ue = s.substring(je, R), g === re) g = (Te = Te.replace(r, \"\").trim()).charCodeAt(0);\n\n switch (g) {\n case L:\n if (we > 0) Te = Te.replace(c, \"\");\n\n switch (A = Te.charCodeAt(1)) {\n case ue:\n case ie:\n case fe:\n case Q:\n f = a;\n break;\n\n default:\n f = xe;\n }\n\n if (je = (Ue = He(a, f, Ue, A, i + 1)).length, me > 0 && 0 === je) je = Te.length;\n if (ye > 0) if (f = Ie(xe, Te, Oe), n = Pe(We, Ue, f, a, pe, be, je, A, i, t), Te = f.join(\"\"), void 0 !== n) if (0 === (je = (Ue = n.trim()).length)) A = 0, Ue = \"\";\n if (je > 0) switch (A) {\n case fe:\n Te = Te.replace(x, Me);\n\n case ue:\n case ie:\n case Q:\n Ue = Te + \"{\" + Ue + \"}\";\n break;\n\n case te:\n if (Ue = (Te = Te.replace(b, \"$1 $2\" + (Be > 0 ? De : \"\"))) + \"{\" + Ue + \"}\", 1 === Ae || 2 === Ae && Le(\"@\" + Ue, 3)) Ue = \"@\" + N + Ue + \"@\" + Ue;else Ue = \"@\" + Ue;\n break;\n\n default:\n if (Ue = Te + Ue, t === de) Ve += Ue, Ue = \"\";\n } else Ue = \"\";\n break;\n\n default:\n Ue = He(a, Ie(a, Te, Oe), Ue, t, i + 1);\n }\n\n Xe += Ue, O = 0, $e = 0, z = 0, we = 0, Oe = 0, j = 0, Te = \"\", Ue = \"\", C = s.charCodeAt(++R);\n break;\n\n case q:\n case W:\n if ((je = (Te = (we > 0 ? Te.replace(c, \"\") : Te).trim()).length) > 1) {\n if (0 === z) if ((g = Te.charCodeAt(0)) === Q || g > 96 && g < 123) je = (Te = Te.replace(\" \", \":\")).length;\n if (ye > 0) if (void 0 !== (n = Pe(Se, Te, a, e, pe, be, Ve.length, t, i, t))) if (0 === (je = (Te = n.trim()).length)) Te = \"\\0\\0\";\n\n switch (g = Te.charCodeAt(0), A = Te.charCodeAt(1), g) {\n case re:\n break;\n\n case L:\n if (A === oe || A === he) {\n Ye += Te + s.charAt(R);\n break;\n }\n\n default:\n if (Te.charCodeAt(je - 1) === V) break;\n Ve += Ke(Te, g, A, Te.charCodeAt(2));\n }\n }\n\n O = 0, $e = 0, z = 0, we = 0, Oe = 0, Te = \"\", C = s.charCodeAt(++R);\n }\n }\n\n switch (C) {\n case J:\n case I:\n if (h + d + u + o + ve === 0) switch ($) {\n case E:\n case X:\n case Y:\n case L:\n case ae:\n case _:\n case T:\n case ee:\n case Z:\n case Q:\n case V:\n case U:\n case W:\n case B:\n case q:\n break;\n\n default:\n if (z > 0) $e = 1;\n }\n if (h === Z) h = 0;else if (ge + O === 0 && t !== te && Te.length > 0) we = 1, Te += \"\\0\";\n if (ye * qe > 0) Pe(Ne, Te, a, e, pe, be, Ve.length, t, i, t);\n be = 1, pe++;\n break;\n\n case W:\n case q:\n if (h + d + u + o === 0) {\n be++;\n break;\n }\n\n default:\n switch (be++, Re = s.charAt(R), C) {\n case K:\n case M:\n if (d + o + h === 0) switch (w) {\n case U:\n case V:\n case K:\n case M:\n Re = \"\";\n break;\n\n default:\n if (C !== M) Re = \" \";\n }\n break;\n\n case re:\n Re = \"\\\\0\";\n break;\n\n case ce:\n Re = \"\\\\f\";\n break;\n\n case se:\n Re = \"\\\\v\";\n break;\n\n case P:\n if (d + h + o === 0 && ge > 0) Oe = 1, we = 1, Re = \"\\f\" + Re;\n break;\n\n case 108:\n if (d + h + o + ke === 0 && z > 0) switch (R - z) {\n case 2:\n if (w === ne && s.charCodeAt(R - 3) === V) ke = w;\n\n case 8:\n if (m === le) ke = m;\n }\n break;\n\n case V:\n if (d + h + o === 0) z = R;\n break;\n\n case U:\n if (h + u + d + o === 0) we = 1, Re += \"\\r\";\n break;\n\n case Y:\n case X:\n if (0 === h) d = d === C ? 0 : 0 === d ? C : d;\n break;\n\n case G:\n if (d + h + u === 0) o++;\n break;\n\n case H:\n if (d + h + u === 0) o--;\n break;\n\n case E:\n if (d + h + o === 0) u--;\n break;\n\n case D:\n if (d + h + o === 0) {\n if (0 === O) switch (2 * w + 3 * m) {\n case 533:\n break;\n\n default:\n y = 0, O = 1;\n }\n u++;\n }\n\n break;\n\n case L:\n if (h + u + d + o + z + j === 0) j = 1;\n break;\n\n case T:\n case Z:\n if (d + o + u > 0) break;\n\n switch (h) {\n case 0:\n switch (2 * C + 3 * s.charCodeAt(R + 1)) {\n case 235:\n h = Z;\n break;\n\n case 220:\n je = R, h = T;\n }\n\n break;\n\n case T:\n if (C === Z && w === T && je + 2 !== R) {\n if (33 === s.charCodeAt(je + 2)) Ve += s.substring(je, R + 1);\n Re = \"\", h = 0;\n }\n\n }\n\n }\n\n if (0 === h) {\n if (ge + d + o + j === 0 && t !== te && C !== W) switch (C) {\n case U:\n case ae:\n case _:\n case ee:\n case E:\n case D:\n if (0 === O) {\n switch (w) {\n case K:\n case M:\n case I:\n case J:\n Re += \"\\0\";\n break;\n\n default:\n Re = \"\\0\" + Re + (C === U ? \"\" : \"\\0\");\n }\n\n we = 1;\n } else switch (C) {\n case D:\n if (z + 7 === R && 108 === w) z = 0;\n O = ++y;\n break;\n\n case E:\n if (0 == (O = --y)) we = 1, Re += \"\\0\";\n }\n\n break;\n\n case K:\n case M:\n switch (w) {\n case re:\n case B:\n case q:\n case W:\n case U:\n case ce:\n case K:\n case M:\n case I:\n case J:\n break;\n\n default:\n if (0 === O) we = 1, Re += \"\\0\";\n }\n\n }\n if (Te += Re, C !== M && C !== K) $ = C;\n }\n\n }\n\n m = w, w = C, R++;\n }\n\n if (je = Ve.length, me > 0) if (0 === je && 0 === Xe.length && 0 === a[0].length == false) if (t !== ie || 1 === a.length && (ge > 0 ? Ee : Ge) === a[0]) je = a.join(\",\").length + 2;\n\n if (je > 0) {\n if (f = 0 === ge && t !== te ? function (e) {\n for (var a, r, s = 0, t = e.length, i = Array(t); s < t; ++s) {\n for (var f = e[s].split(l), n = \"\", o = 0, h = 0, u = 0, d = 0, b = f.length; o < b; ++o) {\n if (0 === (h = (r = f[o]).length) && b > 1) continue;\n if (u = n.charCodeAt(n.length - 1), d = r.charCodeAt(0), a = \"\", 0 !== o) switch (u) {\n case T:\n case ae:\n case _:\n case ee:\n case M:\n case D:\n break;\n\n default:\n a = \" \";\n }\n\n switch (d) {\n case P:\n r = a + Ee;\n\n case ae:\n case _:\n case ee:\n case M:\n case E:\n case D:\n break;\n\n case G:\n r = a + r + Ee;\n break;\n\n case V:\n switch (2 * r.charCodeAt(1) + 3 * r.charCodeAt(2)) {\n case 530:\n if (Ce > 0) {\n r = a + r.substring(8, h - 1);\n break;\n }\n\n default:\n if (o < 1 || f[o - 1].length < 1) r = a + Ee + r;\n }\n\n break;\n\n case U:\n a = \"\";\n\n default:\n if (h > 1 && r.indexOf(\":\") > 0) r = a + r.replace(v, \"$1\" + Ee + \"$2\");else r = a + r + Ee;\n }\n\n n += r;\n }\n\n i[s] = n.replace(c, \"\").trim();\n }\n\n return i;\n }(a) : a, ye > 0) if (void 0 !== (n = Pe(Fe, Ve, f, e, pe, be, je, t, i, t)) && 0 === (Ve = n).length) return Ye + Ve + Xe;\n\n if (Ve = f.join(\",\") + \"{\" + Ve + \"}\", Ae * ke != 0) {\n if (2 === Ae && !Le(Ve, 2)) ke = 0;\n\n switch (ke) {\n case le:\n Ve = Ve.replace(k, \":\" + S + \"$1\") + Ve;\n break;\n\n case ne:\n Ve = Ve.replace(p, \"::\" + N + \"input-$1\") + Ve.replace(p, \"::\" + S + \"$1\") + Ve.replace(p, \":\" + F + \"input-$1\") + Ve;\n }\n\n ke = 0;\n }\n }\n\n return Ye + Ve + Xe;\n }\n\n function Ie(e, a, r) {\n var c = a.trim().split(o),\n s = c,\n t = c.length,\n i = e.length;\n\n switch (i) {\n case 0:\n case 1:\n for (var f = 0, n = 0 === i ? \"\" : e[0] + \" \"; f < t; ++f) {\n s[f] = Je(n, s[f], r, i).trim();\n }\n\n break;\n\n default:\n f = 0;\n var l = 0;\n\n for (s = []; f < t; ++f) {\n for (var h = 0; h < i; ++h) {\n s[l++] = Je(e[h] + \" \", c[f], r, i).trim();\n }\n }\n\n }\n\n return s;\n }\n\n function Je(e, a, r, c) {\n var s = a,\n t = s.charCodeAt(0);\n if (t < 33) t = (s = s.trim()).charCodeAt(0);\n\n switch (t) {\n case P:\n switch (ge + c) {\n case 0:\n case 1:\n if (0 === e.trim().length) break;\n\n default:\n return s.replace(h, \"$1\" + e.trim());\n }\n\n break;\n\n case V:\n switch (s.charCodeAt(1)) {\n case 103:\n if (Ce > 0 && ge > 0) return s.replace(u, \"$1\").replace(h, \"$1\" + Ge);\n break;\n\n default:\n return e.trim() + s.replace(h, \"$1\" + e.trim());\n }\n\n default:\n if (r * ge > 0 && s.indexOf(\"\\f\") > 0) return s.replace(h, (e.charCodeAt(0) === V ? \"\" : \"$1\") + e.trim());\n }\n\n return e + s;\n }\n\n function Ke(e, a, r, c) {\n var l,\n o = 0,\n h = e + \";\",\n u = 2 * a + 3 * r + 4 * c;\n if (944 === u) return function (e) {\n var a = e.length,\n r = e.indexOf(\":\", 9) + 1,\n c = e.substring(0, r).trim(),\n s = e.substring(r, a - 1).trim();\n\n switch (e.charCodeAt(9) * Be) {\n case 0:\n break;\n\n case Q:\n if (110 !== e.charCodeAt(10)) break;\n\n default:\n for (var t = s.split((s = \"\", f)), i = 0, r = 0, a = t.length; i < a; r = 0, ++i) {\n for (var l = t[i], o = l.split(n); l = o[r];) {\n var h = l.charCodeAt(0);\n if (1 === Be && (h > L && h < 90 || h > 96 && h < 123 || h === R || h === Q && l.charCodeAt(1) !== Q)) switch (isNaN(parseFloat(l)) + (-1 !== l.indexOf(\"(\"))) {\n case 1:\n switch (l) {\n case \"infinite\":\n case \"alternate\":\n case \"backwards\":\n case \"running\":\n case \"normal\":\n case \"forwards\":\n case \"both\":\n case \"none\":\n case \"linear\":\n case \"ease\":\n case \"ease-in\":\n case \"ease-out\":\n case \"ease-in-out\":\n case \"paused\":\n case \"reverse\":\n case \"alternate-reverse\":\n case \"inherit\":\n case \"initial\":\n case \"unset\":\n case \"step-start\":\n case \"step-end\":\n break;\n\n default:\n l += De;\n }\n\n }\n o[r++] = l;\n }\n\n s += (0 === i ? \"\" : \",\") + o.join(\" \");\n }\n\n }\n\n if (s = c + s + \";\", 1 === Ae || 2 === Ae && Le(s, 1)) return N + s + s;\n return s;\n }(h);else if (0 === Ae || 2 === Ae && !Le(h, 1)) return h;\n\n switch (u) {\n case 1015:\n return 97 === h.charCodeAt(10) ? N + h + h : h;\n\n case 951:\n return 116 === h.charCodeAt(3) ? N + h + h : h;\n\n case 963:\n return 110 === h.charCodeAt(5) ? N + h + h : h;\n\n case 1009:\n if (100 !== h.charCodeAt(4)) break;\n\n case 969:\n case 942:\n return N + h + h;\n\n case 978:\n return N + h + S + h + h;\n\n case 1019:\n case 983:\n return N + h + S + h + F + h + h;\n\n case 883:\n if (h.charCodeAt(8) === Q) return N + h + h;\n if (h.indexOf(\"image-set(\", 11) > 0) return h.replace(z, \"$1\" + N + \"$2\") + h;\n return h;\n\n case 932:\n if (h.charCodeAt(4) === Q) switch (h.charCodeAt(5)) {\n case 103:\n return N + \"box-\" + h.replace(\"-grow\", \"\") + N + h + F + h.replace(\"grow\", \"positive\") + h;\n\n case 115:\n return N + h + F + h.replace(\"shrink\", \"negative\") + h;\n\n case 98:\n return N + h + F + h.replace(\"basis\", \"preferred-size\") + h;\n }\n return N + h + F + h + h;\n\n case 964:\n return N + h + F + \"flex-\" + h + h;\n\n case 1023:\n if (99 !== h.charCodeAt(8)) break;\n return l = h.substring(h.indexOf(\":\", 15)).replace(\"flex-\", \"\").replace(\"space-between\", \"justify\"), N + \"box-pack\" + l + N + h + F + \"flex-pack\" + l + h;\n\n case 1005:\n return t.test(h) ? h.replace(s, \":\" + N) + h.replace(s, \":\" + S) + h : h;\n\n case 1e3:\n switch (o = (l = h.substring(13).trim()).indexOf(\"-\") + 1, l.charCodeAt(0) + l.charCodeAt(o)) {\n case 226:\n l = h.replace(m, \"tb\");\n break;\n\n case 232:\n l = h.replace(m, \"tb-rl\");\n break;\n\n case 220:\n l = h.replace(m, \"lr\");\n break;\n\n default:\n return h;\n }\n\n return N + h + F + l + h;\n\n case 1017:\n if (-1 === h.indexOf(\"sticky\", 9)) return h;\n\n case 975:\n switch (o = (h = e).length - 10, u = (l = (33 === h.charCodeAt(o) ? h.substring(0, o) : h).substring(e.indexOf(\":\", 7) + 1).trim()).charCodeAt(0) + (0 | l.charCodeAt(7))) {\n case 203:\n if (l.charCodeAt(8) < 111) break;\n\n case 115:\n h = h.replace(l, N + l) + \";\" + h;\n break;\n\n case 207:\n case 102:\n h = h.replace(l, N + (u > 102 ? \"inline-\" : \"\") + \"box\") + \";\" + h.replace(l, N + l) + \";\" + h.replace(l, F + l + \"box\") + \";\" + h;\n }\n\n return h + \";\";\n\n case 938:\n if (h.charCodeAt(5) === Q) switch (h.charCodeAt(6)) {\n case 105:\n return l = h.replace(\"-items\", \"\"), N + h + N + \"box-\" + l + F + \"flex-\" + l + h;\n\n case 115:\n return N + h + F + \"flex-item-\" + h.replace(y, \"\") + h;\n\n default:\n return N + h + F + \"flex-line-pack\" + h.replace(\"align-content\", \"\").replace(y, \"\") + h;\n }\n break;\n\n case 973:\n case 989:\n if (h.charCodeAt(3) !== Q || 122 === h.charCodeAt(4)) break;\n\n case 931:\n case 953:\n if (true === j.test(e)) if (115 === (l = e.substring(e.indexOf(\":\") + 1)).charCodeAt(0)) return Ke(e.replace(\"stretch\", \"fill-available\"), a, r, c).replace(\":fill-available\", \":stretch\");else return h.replace(l, N + l) + h.replace(l, S + l.replace(\"fill-\", \"\")) + h;\n break;\n\n case 962:\n if (h = N + h + (102 === h.charCodeAt(5) ? F + h : \"\") + h, r + c === 211 && 105 === h.charCodeAt(13) && h.indexOf(\"transform\", 10) > 0) return h.substring(0, h.indexOf(\";\", 27) + 1).replace(i, \"$1\" + N + \"$2\") + h;\n }\n\n return h;\n }\n\n function Le(e, a) {\n var r = e.indexOf(1 === a ? \":\" : \"{\"),\n c = e.substring(0, 3 !== a ? r : 10),\n s = e.substring(r + 1, e.length - 1);\n return Oe(2 !== a ? c : c.replace(O, \"$1\"), s, a);\n }\n\n function Me(e, a) {\n var r = Ke(a, a.charCodeAt(0), a.charCodeAt(1), a.charCodeAt(2));\n return r !== a + \";\" ? r.replace($, \" or ($1)\").substring(4) : \"(\" + a + \")\";\n }\n\n function Pe(e, a, r, c, s, t, i, f, n, l) {\n for (var o, h = 0, u = a; h < ye; ++h) {\n switch (o = $e[h].call(Te, e, u, r, c, s, t, i, f, n, l)) {\n case void 0:\n case false:\n case true:\n case null:\n break;\n\n default:\n u = o;\n }\n }\n\n if (u !== a) return u;\n }\n\n function Qe(e, a, r, c) {\n for (var s = a + 1; s < r; ++s) {\n switch (c.charCodeAt(s)) {\n case Z:\n if (e === T) if (c.charCodeAt(s - 1) === T && a + 2 !== s) return s + 1;\n break;\n\n case I:\n if (e === Z) return s + 1;\n }\n }\n\n return s;\n }\n\n function Re(e) {\n for (var a in e) {\n var r = e[a];\n\n switch (a) {\n case \"keyframe\":\n Be = 0 | r;\n break;\n\n case \"global\":\n Ce = 0 | r;\n break;\n\n case \"cascade\":\n ge = 0 | r;\n break;\n\n case \"compress\":\n we = 0 | r;\n break;\n\n case \"semicolon\":\n ve = 0 | r;\n break;\n\n case \"preserve\":\n me = 0 | r;\n break;\n\n case \"prefix\":\n if (Oe = null, !r) Ae = 0;else if (\"function\" != typeof r) Ae = 1;else Ae = 2, Oe = r;\n }\n }\n\n return Re;\n }\n\n function Te(a, r) {\n if (void 0 !== this && this.constructor === Te) return e(a);\n var s = a,\n t = s.charCodeAt(0);\n if (t < 33) t = (s = s.trim()).charCodeAt(0);\n if (Be > 0) De = s.replace(d, t === G ? \"\" : \"-\");\n if (t = 1, 1 === ge) Ge = s;else Ee = s;\n var i,\n f = [Ge];\n if (ye > 0) if (void 0 !== (i = Pe(ze, r, f, f, pe, be, 0, 0, 0, 0)) && \"string\" == typeof i) r = i;\n var n = He(xe, f, r, 0, 0);\n if (ye > 0) if (void 0 !== (i = Pe(je, n, f, f, pe, be, n.length, 0, 0, 0)) && \"string\" != typeof (n = i)) t = 0;\n return De = \"\", Ge = \"\", Ee = \"\", ke = 0, pe = 1, be = 1, we * t == 0 ? n : n.replace(c, \"\").replace(g, \"\").replace(A, \"$1\").replace(C, \"$1\").replace(w, \" \");\n }\n\n if (Te.use = function e(a) {\n switch (a) {\n case void 0:\n case null:\n ye = $e.length = 0;\n break;\n\n default:\n if (\"function\" == typeof a) $e[ye++] = a;else if (\"object\" == typeof a) for (var r = 0, c = a.length; r < c; ++r) {\n e(a[r]);\n } else qe = 0 | !!a;\n }\n\n return e;\n }, Te.set = Re, void 0 !== a) Re(a);\n return Te;\n});","var NATIVE_WEAK_MAP = require('../internals/native-weak-map');\nvar global = require('../internals/global');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar isObject = require('../internals/is-object');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar hasOwn = require('../internals/has-own-property');\nvar shared = require('../internals/shared-store');\nvar sharedKey = require('../internals/shared-key');\nvar hiddenKeys = require('../internals/hidden-keys');\n\nvar OBJECT_ALREADY_INITIALIZED = 'Object already initialized';\nvar TypeError = global.TypeError;\nvar WeakMap = global.WeakMap;\nvar set, get, has;\n\nvar enforce = function (it) {\n return has(it) ? get(it) : set(it, {});\n};\n\nvar getterFor = function (TYPE) {\n return function (it) {\n var state;\n if (!isObject(it) || (state = get(it)).type !== TYPE) {\n throw TypeError('Incompatible receiver, ' + TYPE + ' required');\n } return state;\n };\n};\n\nif (NATIVE_WEAK_MAP || shared.state) {\n var store = shared.state || (shared.state = new WeakMap());\n var wmget = uncurryThis(store.get);\n var wmhas = uncurryThis(store.has);\n var wmset = uncurryThis(store.set);\n set = function (it, metadata) {\n if (wmhas(store, it)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);\n metadata.facade = it;\n wmset(store, it, metadata);\n return metadata;\n };\n get = function (it) {\n return wmget(store, it) || {};\n };\n has = function (it) {\n return wmhas(store, it);\n };\n} else {\n var STATE = sharedKey('state');\n hiddenKeys[STATE] = true;\n set = function (it, metadata) {\n if (hasOwn(it, STATE)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);\n metadata.facade = it;\n createNonEnumerableProperty(it, STATE, metadata);\n return metadata;\n };\n get = function (it) {\n return hasOwn(it, STATE) ? it[STATE] : {};\n };\n has = function (it) {\n return hasOwn(it, STATE);\n };\n}\n\nmodule.exports = {\n set: set,\n get: get,\n has: has,\n enforce: enforce,\n getterFor: getterFor\n};\n","'use strict';\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.onRouteUpdate = function (_ref) {\n var location = _ref.location;\n\n var trackingId = window.GATSBY_GTAG_PLUGIN_GA_TRACKING_ID;\n var anonymize = window.GATSBY_GTAG_PLUGIN_ANONYMIZE || false;\n\n if (!trackingId || typeof window.gtag !== 'function') {\n return;\n }\n\n var locationStr = '';\n\n if (location) {\n locationStr = '' + location.pathname + location.search + location.hash;\n }\n\n var anonymizeObj = {};\n if (anonymize) {\n anonymizeObj = { anonymize_ip: true };\n }\n\n window.gtag('config', trackingId, _extends({\n page_path: locationStr\n }, anonymizeObj));\n};","module.exports = __webpack_public_path__ + \"static/PPNeueMontreal-Regular-c9d07127480b3e924fecf0feb32fefe5.woff\";","module.exports = __webpack_public_path__ + \"static/TANMEMORIES-Italic-0a3761663e0c0d837378189685ca8f28.ttf\";","function _typeof(obj) {\n \"@babel/helpers - typeof\";\n\n return (module.exports = _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) {\n return typeof obj;\n } : function (obj) {\n return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports), _typeof(obj);\n}\n\nmodule.exports = _typeof, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","/**\n * Remove a prefix from a string. Return the input string if the given prefix\n * isn't found.\n */\n\nexport default function stripPrefix(str, prefix = ``) {\n if (!prefix) {\n return str\n }\n\n if (str === prefix) {\n return `/`\n }\n\n if (str.startsWith(`${prefix}/`)) {\n return str.slice(prefix.length)\n }\n\n return str\n}\n","\"use strict\";\n\nexports.__esModule = true;\nexports.parsePath = parsePath;\n\nfunction parsePath(path) {\n var pathname = path || \"/\";\n var search = \"\";\n var hash = \"\";\n var hashIndex = pathname.indexOf(\"#\");\n\n if (hashIndex !== -1) {\n hash = pathname.substr(hashIndex);\n pathname = pathname.substr(0, hashIndex);\n }\n\n var searchIndex = pathname.indexOf(\"?\");\n\n if (searchIndex !== -1) {\n search = pathname.substr(searchIndex);\n pathname = pathname.substr(0, searchIndex);\n }\n\n return {\n pathname: pathname,\n search: search === \"?\" ? \"\" : search,\n hash: hash === \"#\" ? \"\" : hash\n };\n}","// eslint-disable-next-line es-x/no-object-getownpropertysymbols -- safe\nexports.f = Object.getOwnPropertySymbols;\n","export default function _setPrototypeOf(o, p) {\n _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {\n o.__proto__ = p;\n return o;\n };\n return _setPrototypeOf(o, p);\n}","import setPrototypeOf from \"./setPrototypeOf.js\";\nexport default function _inheritsLoose(subClass, superClass) {\n subClass.prototype = Object.create(superClass.prototype);\n subClass.prototype.constructor = subClass;\n setPrototypeOf(subClass, superClass);\n}","// IE8- don't enum bug keys\nmodule.exports = [\n 'constructor',\n 'hasOwnProperty',\n 'isPrototypeOf',\n 'propertyIsEnumerable',\n 'toLocaleString',\n 'toString',\n 'valueOf'\n];\n","const support = function (feature) {\n if (typeof document === `undefined`) {\n return false\n }\n const fakeLink = document.createElement(`link`)\n try {\n if (fakeLink.relList && typeof fakeLink.relList.supports === `function`) {\n return fakeLink.relList.supports(feature)\n }\n } catch (err) {\n return false\n }\n return false\n}\n\nconst linkPrefetchStrategy = function (url, options) {\n return new Promise((resolve, reject) => {\n if (typeof document === `undefined`) {\n reject()\n return\n }\n\n const link = document.createElement(`link`)\n link.setAttribute(`rel`, `prefetch`)\n link.setAttribute(`href`, url)\n\n Object.keys(options).forEach(key => {\n link.setAttribute(key, options[key])\n })\n\n link.onload = resolve\n link.onerror = reject\n\n const parentElement =\n document.getElementsByTagName(`head`)[0] ||\n document.getElementsByName(`script`)[0].parentNode\n parentElement.appendChild(link)\n })\n}\n\nconst xhrPrefetchStrategy = function (url) {\n return new Promise((resolve, reject) => {\n const req = new XMLHttpRequest()\n req.open(`GET`, url, true)\n\n req.onload = () => {\n if (req.status === 200) {\n resolve()\n } else {\n reject()\n }\n }\n\n req.send(null)\n })\n}\n\nconst supportedPrefetchStrategy = support(`prefetch`)\n ? linkPrefetchStrategy\n : xhrPrefetchStrategy\n\nconst preFetched = {}\n\nconst prefetch = function (url, options) {\n return new Promise(resolve => {\n if (preFetched[url]) {\n resolve()\n return\n }\n\n supportedPrefetchStrategy(url, options)\n .then(() => {\n resolve()\n preFetched[url] = true\n })\n .catch(() => {}) // 404s are logged to the console anyway\n })\n}\n\nexport default prefetch\n","import prefetchHelper from \"./prefetch\"\nimport emitter from \"./emitter\"\nimport { setMatchPaths, findPath, findMatchPath } from \"./find-path\"\n\n/**\n * Available resource loading statuses\n */\nexport const PageResourceStatus = {\n /**\n * At least one of critical resources failed to load\n */\n Error: `error`,\n /**\n * Resources loaded successfully\n */\n Success: `success`,\n}\n\nconst preferDefault = m => (m && m.default) || m\n\nconst stripSurroundingSlashes = s => {\n s = s[0] === `/` ? s.slice(1) : s\n s = s.endsWith(`/`) ? s.slice(0, -1) : s\n return s\n}\n\nconst createPageDataUrl = path => {\n const fixedPath = path === `/` ? `index` : stripSurroundingSlashes(path)\n return `${__PATH_PREFIX__}/page-data/${fixedPath}/page-data.json`\n}\n\nfunction doFetch(url, method = `GET`) {\n return new Promise((resolve, reject) => {\n const req = new XMLHttpRequest()\n req.open(method, url, true)\n req.onreadystatechange = () => {\n if (req.readyState == 4) {\n resolve(req)\n }\n }\n req.send(null)\n })\n}\n\nconst doesConnectionSupportPrefetch = () => {\n if (\n `connection` in navigator &&\n typeof navigator.connection !== `undefined`\n ) {\n if ((navigator.connection.effectiveType || ``).includes(`2g`)) {\n return false\n }\n if (navigator.connection.saveData) {\n return false\n }\n }\n return true\n}\n\nconst toPageResources = (pageData, component = null) => {\n const page = {\n componentChunkName: pageData.componentChunkName,\n path: pageData.path,\n webpackCompilationHash: pageData.webpackCompilationHash,\n matchPath: pageData.matchPath,\n staticQueryHashes: pageData.staticQueryHashes,\n }\n\n return {\n component,\n json: pageData.result,\n page,\n }\n}\n\nexport class BaseLoader {\n constructor(loadComponent, matchPaths) {\n // Map of pagePath -> Page. Where Page is an object with: {\n // status: PageResourceStatus.Success || PageResourceStatus.Error,\n // payload: PageResources, // undefined if PageResourceStatus.Error\n // }\n // PageResources is {\n // component,\n // json: pageData.result,\n // page: {\n // componentChunkName,\n // path,\n // webpackCompilationHash,\n // staticQueryHashes\n // },\n // staticQueryResults\n // }\n this.pageDb = new Map()\n this.inFlightDb = new Map()\n this.staticQueryDb = {}\n this.pageDataDb = new Map()\n this.prefetchTriggered = new Set()\n this.prefetchCompleted = new Set()\n this.loadComponent = loadComponent\n setMatchPaths(matchPaths)\n }\n\n inFlightNetworkRequests = new Map()\n\n memoizedGet(url) {\n let inFlightPromise = this.inFlightNetworkRequests.get(url)\n\n if (!inFlightPromise) {\n inFlightPromise = doFetch(url, `GET`)\n this.inFlightNetworkRequests.set(url, inFlightPromise)\n }\n\n // Prefer duplication with then + catch over .finally to prevent problems in ie11 + firefox\n return inFlightPromise\n .then(response => {\n this.inFlightNetworkRequests.delete(url)\n return response\n })\n .catch(err => {\n this.inFlightNetworkRequests.delete(url)\n throw err\n })\n }\n\n setApiRunner(apiRunner) {\n this.apiRunner = apiRunner\n this.prefetchDisabled = apiRunner(`disableCorePrefetching`).some(a => a)\n }\n\n fetchPageDataJson(loadObj) {\n const { pagePath, retries = 0 } = loadObj\n const url = createPageDataUrl(pagePath)\n return this.memoizedGet(url).then(req => {\n const { status, responseText } = req\n\n // Handle 200\n if (status === 200) {\n try {\n const jsonPayload = JSON.parse(responseText)\n if (jsonPayload.path === undefined) {\n throw new Error(`not a valid pageData response`)\n }\n\n return Object.assign(loadObj, {\n status: PageResourceStatus.Success,\n payload: jsonPayload,\n })\n } catch (err) {\n // continue regardless of error\n }\n }\n\n // Handle 404\n if (status === 404 || status === 200) {\n // If the request was for a 404 page and it doesn't exist, we're done\n if (pagePath === `/404.html`) {\n return Object.assign(loadObj, {\n status: PageResourceStatus.Error,\n })\n }\n\n // Need some code here to cache the 404 request. In case\n // multiple loadPageDataJsons result in 404s\n return this.fetchPageDataJson(\n Object.assign(loadObj, { pagePath: `/404.html`, notFound: true })\n )\n }\n\n // handle 500 response (Unrecoverable)\n if (status === 500) {\n return Object.assign(loadObj, {\n status: PageResourceStatus.Error,\n })\n }\n\n // Handle everything else, including status === 0, and 503s. Should retry\n if (retries < 3) {\n return this.fetchPageDataJson(\n Object.assign(loadObj, { retries: retries + 1 })\n )\n }\n\n // Retried 3 times already, result is an error.\n return Object.assign(loadObj, {\n status: PageResourceStatus.Error,\n })\n })\n }\n\n loadPageDataJson(rawPath) {\n const pagePath = findPath(rawPath)\n if (this.pageDataDb.has(pagePath)) {\n const pageData = this.pageDataDb.get(pagePath)\n if (process.env.BUILD_STAGE !== `develop` || !pageData.stale) {\n return Promise.resolve(pageData)\n }\n }\n\n return this.fetchPageDataJson({ pagePath }).then(pageData => {\n this.pageDataDb.set(pagePath, pageData)\n\n return pageData\n })\n }\n\n findMatchPath(rawPath) {\n return findMatchPath(rawPath)\n }\n\n // TODO check all uses of this and whether they use undefined for page resources not exist\n loadPage(rawPath) {\n const pagePath = findPath(rawPath)\n if (this.pageDb.has(pagePath)) {\n const page = this.pageDb.get(pagePath)\n if (process.env.BUILD_STAGE !== `develop` || !page.payload.stale) {\n return Promise.resolve(page.payload)\n }\n }\n\n if (this.inFlightDb.has(pagePath)) {\n return this.inFlightDb.get(pagePath)\n }\n\n const inFlightPromise = Promise.all([\n this.loadAppData(),\n this.loadPageDataJson(pagePath),\n ]).then(allData => {\n const result = allData[1]\n if (result.status === PageResourceStatus.Error) {\n return {\n status: PageResourceStatus.Error,\n }\n }\n\n let pageData = result.payload\n const { componentChunkName, staticQueryHashes = [] } = pageData\n\n const finalResult = {}\n\n const componentChunkPromise = this.loadComponent(componentChunkName).then(\n component => {\n finalResult.createdAt = new Date()\n let pageResources\n if (!component) {\n finalResult.status = PageResourceStatus.Error\n } else {\n finalResult.status = PageResourceStatus.Success\n if (result.notFound === true) {\n finalResult.notFound = true\n }\n pageData = Object.assign(pageData, {\n webpackCompilationHash: allData[0]\n ? allData[0].webpackCompilationHash\n : ``,\n })\n pageResources = toPageResources(pageData, component)\n }\n // undefined if final result is an error\n return pageResources\n }\n )\n\n const staticQueryBatchPromise = Promise.all(\n staticQueryHashes.map(staticQueryHash => {\n // Check for cache in case this static query result has already been loaded\n if (this.staticQueryDb[staticQueryHash]) {\n const jsonPayload = this.staticQueryDb[staticQueryHash]\n return { staticQueryHash, jsonPayload }\n }\n\n return this.memoizedGet(\n `${__PATH_PREFIX__}/page-data/sq/d/${staticQueryHash}.json`\n ).then(req => {\n const jsonPayload = JSON.parse(req.responseText)\n return { staticQueryHash, jsonPayload }\n })\n })\n ).then(staticQueryResults => {\n const staticQueryResultsMap = {}\n\n staticQueryResults.forEach(({ staticQueryHash, jsonPayload }) => {\n staticQueryResultsMap[staticQueryHash] = jsonPayload\n this.staticQueryDb[staticQueryHash] = jsonPayload\n })\n\n return staticQueryResultsMap\n })\n\n return Promise.all([componentChunkPromise, staticQueryBatchPromise]).then(\n ([pageResources, staticQueryResults]) => {\n let payload\n if (pageResources) {\n payload = { ...pageResources, staticQueryResults }\n finalResult.payload = payload\n emitter.emit(`onPostLoadPageResources`, {\n page: payload,\n pageResources: payload,\n })\n }\n\n this.pageDb.set(pagePath, finalResult)\n\n return payload\n }\n )\n })\n\n inFlightPromise\n .then(response => {\n this.inFlightDb.delete(pagePath)\n })\n .catch(error => {\n this.inFlightDb.delete(pagePath)\n throw error\n })\n\n this.inFlightDb.set(pagePath, inFlightPromise)\n\n return inFlightPromise\n }\n\n // returns undefined if loading page ran into errors\n loadPageSync(rawPath) {\n const pagePath = findPath(rawPath)\n if (this.pageDb.has(pagePath)) {\n const pageData = this.pageDb.get(pagePath).payload\n return pageData\n }\n return undefined\n }\n\n shouldPrefetch(pagePath) {\n // Skip prefetching if we know user is on slow or constrained connection\n if (!doesConnectionSupportPrefetch()) {\n return false\n }\n\n // Check if the page exists.\n if (this.pageDb.has(pagePath)) {\n return false\n }\n\n return true\n }\n\n prefetch(pagePath) {\n if (!this.shouldPrefetch(pagePath)) {\n return false\n }\n\n // Tell plugins with custom prefetching logic that they should start\n // prefetching this path.\n if (!this.prefetchTriggered.has(pagePath)) {\n this.apiRunner(`onPrefetchPathname`, { pathname: pagePath })\n this.prefetchTriggered.add(pagePath)\n }\n\n // If a plugin has disabled core prefetching, stop now.\n if (this.prefetchDisabled) {\n return false\n }\n\n const realPath = findPath(pagePath)\n // Todo make doPrefetch logic cacheable\n // eslint-disable-next-line consistent-return\n this.doPrefetch(realPath).then(() => {\n if (!this.prefetchCompleted.has(pagePath)) {\n this.apiRunner(`onPostPrefetchPathname`, { pathname: pagePath })\n this.prefetchCompleted.add(pagePath)\n }\n })\n\n return true\n }\n\n doPrefetch(pagePath) {\n const pageDataUrl = createPageDataUrl(pagePath)\n return prefetchHelper(pageDataUrl, {\n crossOrigin: `anonymous`,\n as: `fetch`,\n }).then(() =>\n // This was just prefetched, so will return a response from\n // the cache instead of making another request to the server\n this.loadPageDataJson(pagePath)\n )\n }\n\n hovering(rawPath) {\n this.loadPage(rawPath)\n }\n\n getResourceURLsForPathname(rawPath) {\n const pagePath = findPath(rawPath)\n const page = this.pageDataDb.get(pagePath)\n if (page) {\n const pageResources = toPageResources(page.payload)\n\n return [\n ...createComponentUrls(pageResources.page.componentChunkName),\n createPageDataUrl(pagePath),\n ]\n } else {\n return null\n }\n }\n\n isPageNotFound(rawPath) {\n const pagePath = findPath(rawPath)\n const page = this.pageDb.get(pagePath)\n return !page || page.notFound\n }\n\n loadAppData(retries = 0) {\n return this.memoizedGet(`${__PATH_PREFIX__}/page-data/app-data.json`).then(\n req => {\n const { status, responseText } = req\n\n let appData\n\n if (status !== 200 && retries < 3) {\n // Retry 3 times incase of non-200 responses\n return this.loadAppData(retries + 1)\n }\n\n // Handle 200\n if (status === 200) {\n try {\n const jsonPayload = JSON.parse(responseText)\n if (jsonPayload.webpackCompilationHash === undefined) {\n throw new Error(`not a valid app-data response`)\n }\n\n appData = jsonPayload\n } catch (err) {\n // continue regardless of error\n }\n }\n\n return appData\n }\n )\n }\n}\n\nconst createComponentUrls = componentChunkName =>\n (window.___chunkMapping[componentChunkName] || []).map(\n chunk => __PATH_PREFIX__ + chunk\n )\n\nexport class ProdLoader extends BaseLoader {\n constructor(asyncRequires, matchPaths) {\n const loadComponent = chunkName =>\n asyncRequires.components[chunkName]\n ? asyncRequires.components[chunkName]()\n .then(preferDefault)\n // loader will handle the case when component is null\n .catch(() => null)\n : Promise.resolve()\n\n super(loadComponent, matchPaths)\n }\n\n doPrefetch(pagePath) {\n return super.doPrefetch(pagePath).then(result => {\n if (result.status !== PageResourceStatus.Success) {\n return Promise.resolve()\n }\n const pageData = result.payload\n const chunkName = pageData.componentChunkName\n const componentUrls = createComponentUrls(chunkName)\n return Promise.all(componentUrls.map(prefetchHelper)).then(() => pageData)\n })\n }\n\n loadPageDataJson(rawPath) {\n return super.loadPageDataJson(rawPath).then(data => {\n if (data.notFound) {\n // check if html file exist using HEAD request:\n // if it does we should navigate to it instead of showing 404\n return doFetch(rawPath, `HEAD`).then(req => {\n if (req.status === 200) {\n // page (.html file) actually exist (or we asked for 404 )\n // returning page resources status as errored to trigger\n // regular browser navigation to given page\n return {\n status: PageResourceStatus.Error,\n }\n }\n\n // if HEAD request wasn't 200, return notFound result\n // and show 404 page\n return data\n })\n }\n return data\n })\n }\n}\n\nlet instance\n\nexport const setLoader = _loader => {\n instance = _loader\n}\n\nexport const publicLoader = {\n // Deprecated methods. As far as we're aware, these are only used by\n // core gatsby and the offline plugin, however there's a very small\n // chance they're called by others.\n getResourcesForPathname: rawPath => {\n console.warn(\n `Warning: getResourcesForPathname is deprecated. Use loadPage instead`\n )\n return instance.i.loadPage(rawPath)\n },\n getResourcesForPathnameSync: rawPath => {\n console.warn(\n `Warning: getResourcesForPathnameSync is deprecated. Use loadPageSync instead`\n )\n return instance.i.loadPageSync(rawPath)\n },\n enqueue: rawPath => instance.prefetch(rawPath),\n\n // Real methods\n getResourceURLsForPathname: rawPath =>\n instance.getResourceURLsForPathname(rawPath),\n loadPage: rawPath => instance.loadPage(rawPath),\n loadPageSync: rawPath => instance.loadPageSync(rawPath),\n prefetch: rawPath => instance.prefetch(rawPath),\n isPageNotFound: rawPath => instance.isPageNotFound(rawPath),\n hovering: rawPath => instance.hovering(rawPath),\n loadAppData: () => instance.loadAppData(),\n}\n\nexport default publicLoader\n\nexport function getStaticQueryResults() {\n if (instance) {\n return instance.staticQueryDb\n } else {\n return {}\n }\n}\n","var requireObjectCoercible = require('../internals/require-object-coercible');\n\nvar $Object = Object;\n\n// `ToObject` abstract operation\n// https://tc39.es/ecma262/#sec-toobject\nmodule.exports = function (argument) {\n return $Object(requireObjectCoercible(argument));\n};\n","var global = require('../internals/global');\nvar isCallable = require('../internals/is-callable');\nvar inspectSource = require('../internals/inspect-source');\n\nvar WeakMap = global.WeakMap;\n\nmodule.exports = isCallable(WeakMap) && /native code/.test(inspectSource(WeakMap));\n","var fails = require('../internals/fails');\n\n// Detect IE8's incomplete defineProperty implementation\nmodule.exports = !fails(function () {\n // eslint-disable-next-line es-x/no-object-defineproperty -- required for testing\n return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] != 7;\n});\n","var isObject = require('../internals/is-object');\n\nvar $String = String;\nvar $TypeError = TypeError;\n\n// `Assert: Type(argument) is Object`\nmodule.exports = function (argument) {\n if (isObject(argument)) return argument;\n throw $TypeError($String(argument) + ' is not an object');\n};\n","'use strict';\nvar toPropertyKey = require('../internals/to-property-key');\nvar definePropertyModule = require('../internals/object-define-property');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\n\nmodule.exports = function (object, key, value) {\n var propertyKey = toPropertyKey(key);\n if (propertyKey in object) definePropertyModule.f(object, propertyKey, createPropertyDescriptor(0, value));\n else object[propertyKey] = value;\n};\n","\"use strict\";\n\nvar _interopRequireWildcard = require(\"@babel/runtime/helpers/interopRequireWildcard\");\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nexports.__esModule = true;\nexports.ScrollContainer = void 0;\n\nvar _extends2 = _interopRequireDefault(require(\"@babel/runtime/helpers/extends\"));\n\nvar _inheritsLoose2 = _interopRequireDefault(require(\"@babel/runtime/helpers/inheritsLoose\"));\n\nvar React = _interopRequireWildcard(require(\"react\"));\n\nvar _reactDom = _interopRequireDefault(require(\"react-dom\"));\n\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\n\nvar _scrollHandler = require(\"./scroll-handler\");\n\nvar _router = require(\"@reach/router\");\n\n// TODO: In Gatsby v3, this file should be removed.\n// We are deprecating this in V2 in favor of useScrollRestoration\nvar propTypes = {\n scrollKey: _propTypes.default.string.isRequired,\n shouldUpdateScroll: _propTypes.default.func,\n children: _propTypes.default.element.isRequired\n};\nvar hasNotWarnedDeprecation = true;\n\nvar ScrollContainerImplementation = /*#__PURE__*/function (_React$Component) {\n (0, _inheritsLoose2.default)(ScrollContainerImplementation, _React$Component);\n\n function ScrollContainerImplementation(props) {\n var _this;\n\n _this = _React$Component.call(this, props) || this;\n\n if (process.env.NODE_ENV !== \"production\" && hasNotWarnedDeprecation) {\n hasNotWarnedDeprecation = false;\n console.log(\"Deprecation Warning:\\n\\n Gatsby is deprecated in Gatsby v2 and will be removed in Gatsby v3.\\n Update to the React hook alternative useScrollRestoration, like this:.\\n \\n ```\\n import React from 'react';\\n import { useScrollRestoration } from 'gatsby-react-router-scroll';\\n\\n function Component() {\\n const scrollRestoration = useScrollRestoration('\" + _this.props.scrollKey + \"');\\n\\n return
;\\n }\\n ```\\n \");\n }\n\n return _this;\n }\n\n var _proto = ScrollContainerImplementation.prototype;\n\n _proto.componentDidMount = function componentDidMount() {\n var _this2 = this;\n\n // eslint-disable-next-line react/no-find-dom-node\n var node = _reactDom.default.findDOMNode(this);\n\n var _this$props = this.props,\n location = _this$props.location,\n scrollKey = _this$props.scrollKey;\n if (!node) return;\n node.addEventListener(\"scroll\", function () {\n _this2.props.context.save(location, scrollKey, node.scrollTop);\n });\n var position = this.props.context.read(location, scrollKey);\n node.scrollTo(0, position || 0);\n };\n\n _proto.render = function render() {\n return this.props.children;\n };\n\n return ScrollContainerImplementation;\n}(React.Component);\n\nvar ScrollContainer = function ScrollContainer(props) {\n return /*#__PURE__*/React.createElement(_router.Location, null, function (_ref) {\n var location = _ref.location;\n return /*#__PURE__*/React.createElement(_scrollHandler.ScrollContext.Consumer, null, function (context) {\n return /*#__PURE__*/React.createElement(ScrollContainerImplementation, (0, _extends2.default)({}, props, {\n context: context,\n location: location\n }));\n });\n });\n};\n\nexports.ScrollContainer = ScrollContainer;\nScrollContainer.propTypes = propTypes;","var isCallable = require('../internals/is-callable');\n\nmodule.exports = function (it) {\n return typeof it == 'object' ? it !== null : isCallable(it);\n};\n","var uncurryThis = require('../internals/function-uncurry-this');\nvar isCallable = require('../internals/is-callable');\nvar store = require('../internals/shared-store');\n\nvar functionToString = uncurryThis(Function.toString);\n\n// this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper\nif (!isCallable(store.inspectSource)) {\n store.inspectSource = function (it) {\n return functionToString(it);\n };\n}\n\nmodule.exports = store.inspectSource;\n","module.exports = __webpack_public_path__ + \"static/PPNeueMontreal-Regular-9a46b7989a8ea306f3d583d7270dff0c.woff2\";","var uncurryThis = require('../internals/function-uncurry-this');\n\nvar id = 0;\nvar postfix = Math.random();\nvar toString = uncurryThis(1.0.toString);\n\nmodule.exports = function (key) {\n return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString(++id + postfix, 36);\n};\n","var DESCRIPTORS = require('../internals/descriptors');\nvar definePropertyModule = require('../internals/object-define-property');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\n\nmodule.exports = DESCRIPTORS ? function (object, key, value) {\n return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));\n} : function (object, key, value) {\n object[key] = value;\n return object;\n};\n","module.exports = __webpack_public_path__ + \"static/Moderat-Regular-723c41b26d1ee5e83008a4c70e1af56d.ttf\";","var fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\n\nvar replacement = /#|\\.prototype\\./;\n\nvar isForced = function (feature, detection) {\n var value = data[normalize(feature)];\n return value == POLYFILL ? true\n : value == NATIVE ? false\n : isCallable(detection) ? fails(detection)\n : !!detection;\n};\n\nvar normalize = isForced.normalize = function (string) {\n return String(string).replace(replacement, '.').toLowerCase();\n};\n\nvar data = isForced.data = {};\nvar NATIVE = isForced.NATIVE = 'N';\nvar POLYFILL = isForced.POLYFILL = 'P';\n\nmodule.exports = isForced;\n","const preferDefault = m => (m && m.default) || m\n\nif (process.env.BUILD_STAGE === `develop`) {\n module.exports = preferDefault(require(`./public-page-renderer-dev`))\n} else if (process.env.BUILD_STAGE === `build-javascript`) {\n module.exports = preferDefault(require(`./public-page-renderer-prod`))\n} else {\n module.exports = () => null\n}\n","var DESCRIPTORS = require('../internals/descriptors');\nvar IE8_DOM_DEFINE = require('../internals/ie8-dom-define');\nvar V8_PROTOTYPE_DEFINE_BUG = require('../internals/v8-prototype-define-bug');\nvar anObject = require('../internals/an-object');\nvar toPropertyKey = require('../internals/to-property-key');\n\nvar $TypeError = TypeError;\n// eslint-disable-next-line es-x/no-object-defineproperty -- safe\nvar $defineProperty = Object.defineProperty;\n// eslint-disable-next-line es-x/no-object-getownpropertydescriptor -- safe\nvar $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\nvar ENUMERABLE = 'enumerable';\nvar CONFIGURABLE = 'configurable';\nvar WRITABLE = 'writable';\n\n// `Object.defineProperty` method\n// https://tc39.es/ecma262/#sec-object.defineproperty\nexports.f = DESCRIPTORS ? V8_PROTOTYPE_DEFINE_BUG ? function defineProperty(O, P, Attributes) {\n anObject(O);\n P = toPropertyKey(P);\n anObject(Attributes);\n if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {\n var current = $getOwnPropertyDescriptor(O, P);\n if (current && current[WRITABLE]) {\n O[P] = Attributes.value;\n Attributes = {\n configurable: CONFIGURABLE in Attributes ? Attributes[CONFIGURABLE] : current[CONFIGURABLE],\n enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE],\n writable: false\n };\n }\n } return $defineProperty(O, P, Attributes);\n} : $defineProperty : function defineProperty(O, P, Attributes) {\n anObject(O);\n P = toPropertyKey(P);\n anObject(Attributes);\n if (IE8_DOM_DEFINE) try {\n return $defineProperty(O, P, Attributes);\n } catch (error) { /* empty */ }\n if ('get' in Attributes || 'set' in Attributes) throw $TypeError('Accessors not supported');\n if ('value' in Attributes) O[P] = Attributes.value;\n return O;\n};\n","module.exports = __webpack_public_path__ + \"static/TANMEMORIES-Regular-1471c9fa108455f0f509bcb39872b919.woff\";","/*\n Why commonjs and not ES imports/exports?\n\n This module is used to alias `create-react-context` package, but drop the the actual implementation part\n because Gatsby requires version of react that has implementatoin baked in.\n \n Package source is using ES modules:\n - https://github.com/jamiebuilds/create-react-context/blob/v0.3.0/src/index.js\n \n But to build this package `babel-plugin-add-module-exports` is used ( https://www.npmjs.com/package/babel-plugin-add-module-exports).\n Which result in both `module.exports` and `exports.default` being set to same thing.\n\n We don't use that babel plugin so we only have `exports.default`.\n\n This cause problems in various 3rd party react components that rely on `module.exports` being set.\n See https://github.com/gatsbyjs/gatsby/issues/23645 for example of it.\n \n Instead of adding same babel plugin we mimic output here. Adding babel plugin just for this would:\n a) unnecesairly slow down compilation for all other files (if we just apply it everywhere)\n b) or complicate babel-loader configuration with overwrite specifically for this file\n*/\n\nconst { createContext } = require(`react`)\n\nmodule.exports = createContext\nmodule.exports.default = createContext\n","\"use strict\";\n\nexports.imageClass = \"gatsby-resp-image-image\";\nexports.imageWrapperClass = \"gatsby-resp-image-wrapper\";\nexports.imageBackgroundClass = \"gatsby-resp-image-background-image\";","var toPrimitive = require('../internals/to-primitive');\nvar isSymbol = require('../internals/is-symbol');\n\n// `ToPropertyKey` abstract operation\n// https://tc39.es/ecma262/#sec-topropertykey\nmodule.exports = function (argument) {\n var key = toPrimitive(argument, 'string');\n return isSymbol(key) ? key : key + '';\n};\n","function _extends() {\n module.exports = _extends = Object.assign ? Object.assign.bind() : function (target) {\n for (var i = 1; i < arguments.length; i++) {\n var source = arguments[i];\n\n for (var key in source) {\n if (Object.prototype.hasOwnProperty.call(source, key)) {\n target[key] = source[key];\n }\n }\n }\n\n return target;\n }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;\n return _extends.apply(this, arguments);\n}\n\nmodule.exports = _extends, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","'use strict';\nvar fails = require('../internals/fails');\n\nmodule.exports = function (METHOD_NAME, argument) {\n var method = [][METHOD_NAME];\n return !!method && fails(function () {\n // eslint-disable-next-line no-useless-call -- required for testing\n method.call(null, argument || function () { return 1; }, 1);\n });\n};\n","\"use strict\";\n\nvar _require = require(\"./constants\"),\n imageClass = _require.imageClass,\n imageBackgroundClass = _require.imageBackgroundClass,\n imageWrapperClass = _require.imageWrapperClass;\n\nexports.onRouteUpdate = function () {\n var imageWrappers = document.querySelectorAll(\".\" + imageWrapperClass); // https://css-tricks.com/snippets/javascript/loop-queryselectorall-matches/\n // for cross-browser looping through NodeList without polyfills\n\n var _loop = function _loop(i) {\n var imageWrapper = imageWrappers[i];\n var backgroundElement = imageWrapper.querySelector(\".\" + imageBackgroundClass);\n var imageElement = imageWrapper.querySelector(\".\" + imageClass);\n\n var onImageLoad = function onImageLoad() {\n backgroundElement.style.transition = \"opacity 0.5s 0.5s\";\n backgroundElement.style.opacity = 0;\n imageElement.style.transition = \"opacity 0.5s\";\n imageElement.style.opacity = 1;\n imageElement.removeEventListener(\"load\", onImageLoad);\n };\n\n if (imageElement.complete) {\n backgroundElement.style.opacity = 0;\n } else {\n imageElement.style.opacity = 0;\n imageElement.addEventListener(\"load\", onImageLoad);\n }\n };\n\n for (var i = 0; i < imageWrappers.length; i++) {\n _loop(i);\n }\n};","/** @license React v16.13.1\n * react-is.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\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'use strict';\n\nvar b = \"function\" === typeof Symbol && Symbol.for,\n c = b ? Symbol.for(\"react.element\") : 60103,\n d = b ? Symbol.for(\"react.portal\") : 60106,\n e = b ? Symbol.for(\"react.fragment\") : 60107,\n f = b ? Symbol.for(\"react.strict_mode\") : 60108,\n g = b ? Symbol.for(\"react.profiler\") : 60114,\n h = b ? Symbol.for(\"react.provider\") : 60109,\n k = b ? Symbol.for(\"react.context\") : 60110,\n l = b ? Symbol.for(\"react.async_mode\") : 60111,\n m = b ? Symbol.for(\"react.concurrent_mode\") : 60111,\n n = b ? Symbol.for(\"react.forward_ref\") : 60112,\n p = b ? Symbol.for(\"react.suspense\") : 60113,\n q = b ? Symbol.for(\"react.suspense_list\") : 60120,\n r = b ? Symbol.for(\"react.memo\") : 60115,\n t = b ? Symbol.for(\"react.lazy\") : 60116,\n v = b ? Symbol.for(\"react.block\") : 60121,\n w = b ? Symbol.for(\"react.fundamental\") : 60117,\n x = b ? Symbol.for(\"react.responder\") : 60118,\n y = b ? Symbol.for(\"react.scope\") : 60119;\n\nfunction z(a) {\n if (\"object\" === typeof a && null !== a) {\n var u = a.$$typeof;\n\n switch (u) {\n case c:\n switch (a = a.type, a) {\n case l:\n case m:\n case e:\n case g:\n case f:\n case p:\n return a;\n\n default:\n switch (a = a && a.$$typeof, a) {\n case k:\n case n:\n case t:\n case r:\n case h:\n return a;\n\n default:\n return u;\n }\n\n }\n\n case d:\n return u;\n }\n }\n}\n\nfunction A(a) {\n return z(a) === m;\n}\n\nexports.AsyncMode = l;\nexports.ConcurrentMode = m;\nexports.ContextConsumer = k;\nexports.ContextProvider = h;\nexports.Element = c;\nexports.ForwardRef = n;\nexports.Fragment = e;\nexports.Lazy = t;\nexports.Memo = r;\nexports.Portal = d;\nexports.Profiler = g;\nexports.StrictMode = f;\nexports.Suspense = p;\n\nexports.isAsyncMode = function (a) {\n return A(a) || z(a) === l;\n};\n\nexports.isConcurrentMode = A;\n\nexports.isContextConsumer = function (a) {\n return z(a) === k;\n};\n\nexports.isContextProvider = function (a) {\n return z(a) === h;\n};\n\nexports.isElement = function (a) {\n return \"object\" === typeof a && null !== a && a.$$typeof === c;\n};\n\nexports.isForwardRef = function (a) {\n return z(a) === n;\n};\n\nexports.isFragment = function (a) {\n return z(a) === e;\n};\n\nexports.isLazy = function (a) {\n return z(a) === t;\n};\n\nexports.isMemo = function (a) {\n return z(a) === r;\n};\n\nexports.isPortal = function (a) {\n return z(a) === d;\n};\n\nexports.isProfiler = function (a) {\n return z(a) === g;\n};\n\nexports.isStrictMode = function (a) {\n return z(a) === f;\n};\n\nexports.isSuspense = function (a) {\n return z(a) === p;\n};\n\nexports.isValidElementType = function (a) {\n return \"string\" === typeof a || \"function\" === typeof a || a === e || a === m || a === g || a === f || a === p || a === q || \"object\" === typeof a && null !== a && (a.$$typeof === t || a.$$typeof === r || a.$$typeof === h || a.$$typeof === k || a.$$typeof === n || a.$$typeof === w || a.$$typeof === x || a.$$typeof === y || a.$$typeof === v);\n};\n\nexports.typeOf = z;","var arraySlice = require('../internals/array-slice-simple');\n\nvar floor = Math.floor;\n\nvar mergeSort = function (array, comparefn) {\n var length = array.length;\n var middle = floor(length / 2);\n return length < 8 ? insertionSort(array, comparefn) : merge(\n array,\n mergeSort(arraySlice(array, 0, middle), comparefn),\n mergeSort(arraySlice(array, middle), comparefn),\n comparefn\n );\n};\n\nvar insertionSort = function (array, comparefn) {\n var length = array.length;\n var i = 1;\n var element, j;\n\n while (i < length) {\n j = i;\n element = array[i];\n while (j && comparefn(array[j - 1], element) > 0) {\n array[j] = array[--j];\n }\n if (j !== i++) array[j] = element;\n } return array;\n};\n\nvar merge = function (array, left, right, comparefn) {\n var llength = left.length;\n var rlength = right.length;\n var lindex = 0;\n var rindex = 0;\n\n while (lindex < llength || rindex < rlength) {\n array[lindex + rindex] = (lindex < llength && rindex < rlength)\n ? comparefn(left[lindex], right[rindex]) <= 0 ? left[lindex++] : right[rindex++]\n : lindex < llength ? left[lindex++] : right[rindex++];\n } return array;\n};\n\nmodule.exports = mergeSort;\n","var DESCRIPTORS = require('../internals/descriptors');\nvar fails = require('../internals/fails');\n\n// V8 ~ Chrome 36-\n// https://bugs.chromium.org/p/v8/issues/detail?id=3334\nmodule.exports = DESCRIPTORS && fails(function () {\n // eslint-disable-next-line es-x/no-object-defineproperty -- required for testing\n return Object.defineProperty(function () { /* empty */ }, 'prototype', {\n value: 42,\n writable: false\n }).prototype != 42;\n});\n","import React from \"react\"\nimport PropTypes from \"prop-types\"\n\nimport loader from \"./loader\"\nimport InternalPageRenderer from \"./page-renderer\"\n\nconst ProdPageRenderer = ({ location }) => {\n const pageResources = loader.loadPageSync(location.pathname)\n if (!pageResources) {\n return null\n }\n return React.createElement(InternalPageRenderer, {\n location,\n pageResources,\n ...pageResources.json,\n })\n}\n\nProdPageRenderer.propTypes = {\n location: PropTypes.shape({\n pathname: PropTypes.string.isRequired,\n }).isRequired,\n}\n\nexport default ProdPageRenderer\n","module.exports = __webpack_public_path__ + \"static/TANMEMORIES-Regular-9619493c96a9be68c74c1ddd2f0493cd.ttf\";","/**\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() {}\nfunction emptyFunctionWithReset() {}\nemptyFunctionWithReset.resetWarningCache = 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 bigint: 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 elementType: shim,\n instanceOf: getShim,\n node: shim,\n objectOf: getShim,\n oneOf: getShim,\n oneOfType: getShim,\n shape: getShim,\n exact: getShim,\n\n checkPropTypes: emptyFunctionWithReset,\n resetWarningCache: emptyFunction\n };\n\n ReactPropTypes.PropTypes = ReactPropTypes;\n\n return ReactPropTypes;\n};\n","var ceil = Math.ceil;\nvar floor = Math.floor;\n\n// `Math.trunc` method\n// https://tc39.es/ecma262/#sec-math.trunc\n// eslint-disable-next-line es-x/no-math-trunc -- safe\nmodule.exports = Math.trunc || function trunc(x) {\n var n = +x;\n return (n > 0 ? floor : ceil)(n);\n};\n","var global = require('../internals/global');\nvar shared = require('../internals/shared');\nvar hasOwn = require('../internals/has-own-property');\nvar uid = require('../internals/uid');\nvar NATIVE_SYMBOL = require('../internals/native-symbol');\nvar USE_SYMBOL_AS_UID = require('../internals/use-symbol-as-uid');\n\nvar WellKnownSymbolsStore = shared('wks');\nvar Symbol = global.Symbol;\nvar symbolFor = Symbol && Symbol['for'];\nvar createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol : Symbol && Symbol.withoutSetter || uid;\n\nmodule.exports = function (name) {\n if (!hasOwn(WellKnownSymbolsStore, name) || !(NATIVE_SYMBOL || typeof WellKnownSymbolsStore[name] == 'string')) {\n var description = 'Symbol.' + name;\n if (NATIVE_SYMBOL && hasOwn(Symbol, name)) {\n WellKnownSymbolsStore[name] = Symbol[name];\n } else if (USE_SYMBOL_AS_UID && symbolFor) {\n WellKnownSymbolsStore[name] = symbolFor(description);\n } else {\n WellKnownSymbolsStore[name] = createWellKnownSymbol(description);\n }\n } return WellKnownSymbolsStore[name];\n};\n","import Stylis from 'stylis/stylis.min';\nimport _insertRulePlugin from 'stylis-rule-sheet';\nimport React, { cloneElement, createContext, Component, createElement } from 'react';\nimport unitless from '@emotion/unitless';\nimport { isElement, isValidElementType, ForwardRef } from 'react-is';\nimport memoize from 'memoize-one';\nimport validAttr from '@emotion/is-prop-valid';\nimport merge from 'merge-anything'; // \n\nvar interleave = function interleave(strings, interpolations) {\n var result = [strings[0]];\n\n for (var i = 0, len = interpolations.length; i < len; i += 1) {\n result.push(interpolations[i], strings[i + 1]);\n }\n\n return result;\n};\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) {\n return typeof obj;\n} : function (obj) {\n return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n};\n\nvar classCallCheck = function classCallCheck(instance, Constructor) {\n if (!(instance instanceof Constructor)) {\n throw new TypeError(\"Cannot call a class as a function\");\n }\n};\n\nvar createClass = function () {\n function defineProperties(target, props) {\n for (var i = 0; i < props.length; i++) {\n var descriptor = props[i];\n descriptor.enumerable = descriptor.enumerable || false;\n descriptor.configurable = true;\n if (\"value\" in descriptor) descriptor.writable = true;\n Object.defineProperty(target, descriptor.key, descriptor);\n }\n }\n\n return function (Constructor, protoProps, staticProps) {\n if (protoProps) defineProperties(Constructor.prototype, protoProps);\n if (staticProps) defineProperties(Constructor, staticProps);\n return Constructor;\n };\n}();\n\nvar _extends = Object.assign || function (target) {\n for (var i = 1; i < arguments.length; i++) {\n var source = arguments[i];\n\n for (var key in source) {\n if (Object.prototype.hasOwnProperty.call(source, key)) {\n target[key] = source[key];\n }\n }\n }\n\n return target;\n};\n\nvar inherits = function inherits(subClass, superClass) {\n if (typeof superClass !== \"function\" && superClass !== null) {\n throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass);\n }\n\n subClass.prototype = Object.create(superClass && superClass.prototype, {\n constructor: {\n value: subClass,\n enumerable: false,\n writable: true,\n configurable: true\n }\n });\n if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;\n};\n\nvar objectWithoutProperties = function objectWithoutProperties(obj, keys) {\n var target = {};\n\n for (var i in obj) {\n if (keys.indexOf(i) >= 0) continue;\n if (!Object.prototype.hasOwnProperty.call(obj, i)) continue;\n target[i] = obj[i];\n }\n\n return target;\n};\n\nvar possibleConstructorReturn = function possibleConstructorReturn(self, call) {\n if (!self) {\n throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n }\n\n return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self;\n}; // \n\n\nvar isPlainObject = function isPlainObject(x) {\n return (typeof x === 'undefined' ? 'undefined' : _typeof(x)) === 'object' && x.constructor === Object;\n}; // \n\n\nvar EMPTY_ARRAY = Object.freeze([]);\nvar EMPTY_OBJECT = Object.freeze({}); // \n\nfunction isFunction(test) {\n return typeof test === 'function';\n} // \n\n\nfunction getComponentName(target) {\n return (process.env.NODE_ENV !== 'production' ? typeof target === 'string' && target : false) || target.displayName || target.name || 'Component';\n} // \n\n\nfunction isStatelessFunction(test) {\n return typeof test === 'function' && !(test.prototype && test.prototype.isReactComponent);\n} // \n\n\nfunction isStyledComponent(target) {\n return target && typeof target.styledComponentId === 'string';\n} // \n\n\nvar SC_ATTR = typeof process !== 'undefined' && (process.env.REACT_APP_SC_ATTR || process.env.SC_ATTR) || 'data-styled';\nvar SC_VERSION_ATTR = 'data-styled-version';\nvar SC_STREAM_ATTR = 'data-styled-streamed';\nvar IS_BROWSER = typeof window !== 'undefined' && 'HTMLElement' in window;\nvar DISABLE_SPEEDY = typeof SC_DISABLE_SPEEDY === 'boolean' && SC_DISABLE_SPEEDY || typeof process !== 'undefined' && (process.env.REACT_APP_SC_DISABLE_SPEEDY || process.env.SC_DISABLE_SPEEDY) || process.env.NODE_ENV !== 'production'; // Shared empty execution context when generating static styles\n\nvar STATIC_EXECUTION_CONTEXT = {}; // \n\n/**\n * Parse errors.md and turn it into a simple hash of code: message\n */\n\nvar ERRORS = process.env.NODE_ENV !== 'production' ? {\n \"1\": \"Cannot create styled-component for component: %s.\\n\\n\",\n \"2\": \"Can't collect styles once you've consumed a `ServerStyleSheet`'s styles! `ServerStyleSheet` is a one off instance for each server-side render cycle.\\n\\n- Are you trying to reuse it across renders?\\n- Are you accidentally calling collectStyles twice?\\n\\n\",\n \"3\": \"Streaming SSR is only supported in a Node.js environment; Please do not try to call this method in the browser.\\n\\n\",\n \"4\": \"The `StyleSheetManager` expects a valid target or sheet prop!\\n\\n- Does this error occur on the client and is your target falsy?\\n- Does this error occur on the server and is the sheet falsy?\\n\\n\",\n \"5\": \"The clone method cannot be used on the client!\\n\\n- Are you running in a client-like environment on the server?\\n- Are you trying to run SSR on the client?\\n\\n\",\n \"6\": \"Trying to insert a new style tag, but the given Node is unmounted!\\n\\n- Are you using a custom target that isn't mounted?\\n- Does your document not have a valid head element?\\n- Have you accidentally removed a style tag manually?\\n\\n\",\n \"7\": \"ThemeProvider: Please return an object from your \\\"theme\\\" prop function, e.g.\\n\\n```js\\ntheme={() => ({})}\\n```\\n\\n\",\n \"8\": \"ThemeProvider: Please make your \\\"theme\\\" prop an object.\\n\\n\",\n \"9\": \"Missing document ``\\n\\n\",\n \"10\": \"Cannot find a StyleSheet instance. Usually this happens if there are multiple copies of styled-components loaded at once. Check out this issue for how to troubleshoot and fix the common cases where this situation can happen: https://github.com/styled-components/styled-components/issues/1941#issuecomment-417862021\\n\\n\",\n \"11\": \"_This error was replaced with a dev-time warning, it will be deleted for v4 final._ [createGlobalStyle] received children which will not be rendered. Please use the component without passing children elements.\\n\\n\",\n \"12\": \"It seems you are interpolating a keyframe declaration (%s) into an untagged string. This was supported in styled-components v3, but is not longer supported in v4 as keyframes are now injected on-demand. Please wrap your string in the css\\\\`\\\\` helper which ensures the styles are injected correctly. See https://www.styled-components.com/docs/api#css\\n\\n\",\n \"13\": \"%s is not a styled component and cannot be referred to via component selector. See https://www.styled-components.com/docs/advanced#referring-to-other-components for more details.\\n\"\n} : {};\n/**\n * super basic version of sprintf\n */\n\nfunction format() {\n var a = arguments.length <= 0 ? undefined : arguments[0];\n var b = [];\n\n for (var c = 1, len = arguments.length; c < len; c += 1) {\n b.push(arguments.length <= c ? undefined : arguments[c]);\n }\n\n b.forEach(function (d) {\n a = a.replace(/%[a-z]/, d);\n });\n return a;\n}\n/**\n * Create an error file out of errors.md for development and a simple web link to the full errors\n * in production mode.\n */\n\n\nvar StyledComponentsError = function (_Error) {\n inherits(StyledComponentsError, _Error);\n\n function StyledComponentsError(code) {\n classCallCheck(this, StyledComponentsError);\n\n for (var _len = arguments.length, interpolations = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n interpolations[_key - 1] = arguments[_key];\n }\n\n if (process.env.NODE_ENV === 'production') {\n var _this = possibleConstructorReturn(this, _Error.call(this, 'An error occurred. See https://github.com/styled-components/styled-components/blob/master/packages/styled-components/src/utils/errors.md#' + code + ' for more information.' + (interpolations.length > 0 ? ' Additional arguments: ' + interpolations.join(', ') : '')));\n } else {\n var _this = possibleConstructorReturn(this, _Error.call(this, format.apply(undefined, [ERRORS[code]].concat(interpolations)).trim()));\n }\n\n return possibleConstructorReturn(_this);\n }\n\n return StyledComponentsError;\n}(Error); // \n\n\nvar SC_COMPONENT_ID = /^[^\\S\\n]*?\\/\\* sc-component-id:\\s*(\\S+)\\s+\\*\\//gm;\n\nvar extractComps = function extractComps(maybeCSS) {\n var css = '' + (maybeCSS || ''); // Definitely a string, and a clone\n\n var existingComponents = [];\n css.replace(SC_COMPONENT_ID, function (match, componentId, matchIndex) {\n existingComponents.push({\n componentId: componentId,\n matchIndex: matchIndex\n });\n return match;\n });\n return existingComponents.map(function (_ref, i) {\n var componentId = _ref.componentId,\n matchIndex = _ref.matchIndex;\n var nextComp = existingComponents[i + 1];\n var cssFromDOM = nextComp ? css.slice(matchIndex, nextComp.matchIndex) : css.slice(matchIndex);\n return {\n componentId: componentId,\n cssFromDOM: cssFromDOM\n };\n });\n}; // \n\n\nvar COMMENT_REGEX = /^\\s*\\/\\/.*$/gm; // NOTE: This stylis instance is only used to split rules from SSR'd style tags\n\nvar stylisSplitter = new Stylis({\n global: false,\n cascade: true,\n keyframe: false,\n prefix: false,\n compress: false,\n semicolon: true\n});\nvar stylis = new Stylis({\n global: false,\n cascade: true,\n keyframe: false,\n prefix: true,\n compress: false,\n semicolon: false // NOTE: This means \"autocomplete missing semicolons\"\n\n}); // Wrap `insertRulePlugin to build a list of rules,\n// and then make our own plugin to return the rules. This\n// makes it easier to hook into the existing SSR architecture\n\nvar parsingRules = []; // eslint-disable-next-line consistent-return\n\nvar returnRulesPlugin = function returnRulesPlugin(context) {\n if (context === -2) {\n var parsedRules = parsingRules;\n parsingRules = [];\n return parsedRules;\n }\n};\n\nvar parseRulesPlugin = _insertRulePlugin(function (rule) {\n parsingRules.push(rule);\n});\n\nvar _componentId = void 0;\n\nvar _selector = void 0;\n\nvar _selectorRegexp = void 0;\n\nvar selfReferenceReplacer = function selfReferenceReplacer(match, offset, string) {\n if ( // the first self-ref is always untouched\n offset > 0 && // there should be at least two self-refs to do a replacement (.b > .b)\n string.slice(0, offset).indexOf(_selector) !== -1 && // no consecutive self refs (.b.b); that is a precedence boost and treated differently\n string.slice(offset - _selector.length, offset) !== _selector) {\n return '.' + _componentId;\n }\n\n return match;\n};\n/**\n * When writing a style like\n *\n * & + & {\n * color: red;\n * }\n *\n * The second ampersand should be a reference to the static component class. stylis\n * has no knowledge of static class so we have to intelligently replace the base selector.\n */\n\n\nvar selfReferenceReplacementPlugin = function selfReferenceReplacementPlugin(context, _, selectors) {\n if (context === 2 && selectors.length && selectors[0].lastIndexOf(_selector) > 0) {\n // eslint-disable-next-line no-param-reassign\n selectors[0] = selectors[0].replace(_selectorRegexp, selfReferenceReplacer);\n }\n};\n\nstylis.use([selfReferenceReplacementPlugin, parseRulesPlugin, returnRulesPlugin]);\nstylisSplitter.use([parseRulesPlugin, returnRulesPlugin]);\n\nvar splitByRules = function splitByRules(css) {\n return stylisSplitter('', css);\n};\n\nfunction stringifyRules(rules, selector, prefix) {\n var componentId = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : '&';\n var flatCSS = rules.join('').replace(COMMENT_REGEX, ''); // replace JS comments\n\n var cssStr = selector && prefix ? prefix + ' ' + selector + ' { ' + flatCSS + ' }' : flatCSS; // stylis has no concept of state to be passed to plugins\n // but since JS is single=threaded, we can rely on that to ensure\n // these properties stay in sync with the current stylis run\n\n _componentId = componentId;\n _selector = selector;\n _selectorRegexp = new RegExp('\\\\' + _selector + '\\\\b', 'g');\n return stylis(prefix || !selector ? '' : selector, cssStr);\n} // \n\n/* eslint-disable camelcase, no-undef */\n\n\nvar getNonce = function getNonce() {\n return typeof __webpack_nonce__ !== 'undefined' ? __webpack_nonce__ : null;\n}; // \n\n/* These are helpers for the StyleTags to keep track of the injected\n * rule names for each (component) ID that they're keeping track of.\n * They're crucial for detecting whether a name has already been\n * injected.\n * (This excludes rehydrated names) */\n\n/* adds a new ID:name pairing to a names dictionary */\n\n\nvar addNameForId = function addNameForId(names, id, name) {\n if (name) {\n // eslint-disable-next-line no-param-reassign\n var namesForId = names[id] || (names[id] = Object.create(null));\n namesForId[name] = true;\n }\n};\n/* resets an ID entirely by overwriting it in the dictionary */\n\n\nvar resetIdNames = function resetIdNames(names, id) {\n // eslint-disable-next-line no-param-reassign\n names[id] = Object.create(null);\n};\n/* factory for a names dictionary checking the existance of an ID:name pairing */\n\n\nvar hasNameForId = function hasNameForId(names) {\n return function (id, name) {\n return names[id] !== undefined && names[id][name];\n };\n};\n/* stringifies names for the html/element output */\n\n\nvar stringifyNames = function stringifyNames(names) {\n var str = ''; // eslint-disable-next-line guard-for-in\n\n for (var id in names) {\n str += Object.keys(names[id]).join(' ') + ' ';\n }\n\n return str.trim();\n};\n/* clones the nested names dictionary */\n\n\nvar cloneNames = function cloneNames(names) {\n var clone = Object.create(null); // eslint-disable-next-line guard-for-in\n\n for (var id in names) {\n clone[id] = _extends({}, names[id]);\n }\n\n return clone;\n}; // \n\n/* These are helpers that deal with the insertRule (aka speedy) API\n * They are used in the StyleTags and specifically the speedy tag\n */\n\n/* retrieve a sheet for a given style tag */\n\n\nvar sheetForTag = function sheetForTag(tag) {\n // $FlowFixMe\n if (tag.sheet) return tag.sheet;\n /* Firefox quirk requires us to step through all stylesheets to find one owned by the given tag */\n\n var size = tag.ownerDocument.styleSheets.length;\n\n for (var i = 0; i < size; i += 1) {\n var sheet = tag.ownerDocument.styleSheets[i]; // $FlowFixMe\n\n if (sheet.ownerNode === tag) return sheet;\n }\n /* we should always be able to find a tag */\n\n\n throw new StyledComponentsError(10);\n};\n/* insert a rule safely and return whether it was actually injected */\n\n\nvar safeInsertRule = function safeInsertRule(sheet, cssRule, index) {\n /* abort early if cssRule string is falsy */\n if (!cssRule) return false;\n var maxIndex = sheet.cssRules.length;\n\n try {\n /* use insertRule and cap passed index with maxIndex (no of cssRules) */\n sheet.insertRule(cssRule, index <= maxIndex ? index : maxIndex);\n } catch (err) {\n /* any error indicates an invalid rule */\n return false;\n }\n\n return true;\n};\n/* deletes `size` rules starting from `removalIndex` */\n\n\nvar deleteRules = function deleteRules(sheet, removalIndex, size) {\n var lowerBound = removalIndex - size;\n\n for (var i = removalIndex; i > lowerBound; i -= 1) {\n sheet.deleteRule(i);\n }\n}; // \n\n/* this marker separates component styles and is important for rehydration */\n\n\nvar makeTextMarker = function makeTextMarker(id) {\n return '\\n/* sc-component-id: ' + id + ' */\\n';\n};\n/* add up all numbers in array up until and including the index */\n\n\nvar addUpUntilIndex = function addUpUntilIndex(sizes, index) {\n var totalUpToIndex = 0;\n\n for (var i = 0; i <= index; i += 1) {\n totalUpToIndex += sizes[i];\n }\n\n return totalUpToIndex;\n};\n/* create a new style tag after lastEl */\n\n\nvar makeStyleTag = function makeStyleTag(target, tagEl, insertBefore) {\n var targetDocument = document;\n if (target) targetDocument = target.ownerDocument;else if (tagEl) targetDocument = tagEl.ownerDocument;\n var el = targetDocument.createElement('style');\n el.setAttribute(SC_ATTR, '');\n el.setAttribute(SC_VERSION_ATTR, \"4.4.1\");\n var nonce = getNonce();\n\n if (nonce) {\n el.setAttribute('nonce', nonce);\n }\n /* Work around insertRule quirk in EdgeHTML */\n\n\n el.appendChild(targetDocument.createTextNode(''));\n\n if (target && !tagEl) {\n /* Append to target when no previous element was passed */\n target.appendChild(el);\n } else {\n if (!tagEl || !target || !tagEl.parentNode) {\n throw new StyledComponentsError(6);\n }\n /* Insert new style tag after the previous one */\n\n\n tagEl.parentNode.insertBefore(el, insertBefore ? tagEl : tagEl.nextSibling);\n }\n\n return el;\n};\n/* takes a css factory function and outputs an html styled tag factory */\n\n\nvar wrapAsHtmlTag = function wrapAsHtmlTag(css, names) {\n return function (additionalAttrs) {\n var nonce = getNonce();\n var attrs = [nonce && 'nonce=\"' + nonce + '\"', SC_ATTR + '=\"' + stringifyNames(names) + '\"', SC_VERSION_ATTR + '=\"' + \"4.4.1\" + '\"', additionalAttrs];\n var htmlAttr = attrs.filter(Boolean).join(' ');\n return '';\n };\n};\n/* takes a css factory function and outputs an element factory */\n\n\nvar wrapAsElement = function wrapAsElement(css, names) {\n return function () {\n var _props;\n\n var props = (_props = {}, _props[SC_ATTR] = stringifyNames(names), _props[SC_VERSION_ATTR] = \"4.4.1\", _props);\n var nonce = getNonce();\n\n if (nonce) {\n // $FlowFixMe\n props.nonce = nonce;\n } // eslint-disable-next-line react/no-danger\n\n\n return React.createElement('style', _extends({}, props, {\n dangerouslySetInnerHTML: {\n __html: css()\n }\n }));\n };\n};\n\nvar getIdsFromMarkersFactory = function getIdsFromMarkersFactory(markers) {\n return function () {\n return Object.keys(markers);\n };\n};\n/* speedy tags utilise insertRule */\n\n\nvar makeSpeedyTag = function makeSpeedyTag(el, getImportRuleTag) {\n var names = Object.create(null);\n var markers = Object.create(null);\n var sizes = [];\n var extractImport = getImportRuleTag !== undefined;\n /* indicates whether getImportRuleTag was called */\n\n var usedImportRuleTag = false;\n\n var insertMarker = function insertMarker(id) {\n var prev = markers[id];\n\n if (prev !== undefined) {\n return prev;\n }\n\n markers[id] = sizes.length;\n sizes.push(0);\n resetIdNames(names, id);\n return markers[id];\n };\n\n var insertRules = function insertRules(id, cssRules, name) {\n var marker = insertMarker(id);\n var sheet = sheetForTag(el);\n var insertIndex = addUpUntilIndex(sizes, marker);\n var injectedRules = 0;\n var importRules = [];\n var cssRulesSize = cssRules.length;\n\n for (var i = 0; i < cssRulesSize; i += 1) {\n var cssRule = cssRules[i];\n var mayHaveImport = extractImport;\n /* @import rules are reordered to appear first */\n\n if (mayHaveImport && cssRule.indexOf('@import') !== -1) {\n importRules.push(cssRule);\n } else if (safeInsertRule(sheet, cssRule, insertIndex + injectedRules)) {\n mayHaveImport = false;\n injectedRules += 1;\n }\n }\n\n if (extractImport && importRules.length > 0) {\n usedImportRuleTag = true; // $FlowFixMe\n\n getImportRuleTag().insertRules(id + '-import', importRules);\n }\n\n sizes[marker] += injectedRules;\n /* add up no of injected rules */\n\n addNameForId(names, id, name);\n };\n\n var removeRules = function removeRules(id) {\n var marker = markers[id];\n if (marker === undefined) return; // $FlowFixMe\n\n if (el.isConnected === false) return;\n var size = sizes[marker];\n var sheet = sheetForTag(el);\n var removalIndex = addUpUntilIndex(sizes, marker) - 1;\n deleteRules(sheet, removalIndex, size);\n sizes[marker] = 0;\n resetIdNames(names, id);\n\n if (extractImport && usedImportRuleTag) {\n // $FlowFixMe\n getImportRuleTag().removeRules(id + '-import');\n }\n };\n\n var css = function css() {\n var _sheetForTag = sheetForTag(el),\n cssRules = _sheetForTag.cssRules;\n\n var str = ''; // eslint-disable-next-line guard-for-in\n\n for (var id in markers) {\n str += makeTextMarker(id);\n var marker = markers[id];\n var end = addUpUntilIndex(sizes, marker);\n var size = sizes[marker];\n\n for (var i = end - size; i < end; i += 1) {\n var rule = cssRules[i];\n\n if (rule !== undefined) {\n str += rule.cssText;\n }\n }\n }\n\n return str;\n };\n\n return {\n clone: function clone() {\n throw new StyledComponentsError(5);\n },\n css: css,\n getIds: getIdsFromMarkersFactory(markers),\n hasNameForId: hasNameForId(names),\n insertMarker: insertMarker,\n insertRules: insertRules,\n removeRules: removeRules,\n sealed: false,\n styleTag: el,\n toElement: wrapAsElement(css, names),\n toHTML: wrapAsHtmlTag(css, names)\n };\n};\n\nvar makeTextNode = function makeTextNode(targetDocument, id) {\n return targetDocument.createTextNode(makeTextMarker(id));\n};\n\nvar makeBrowserTag = function makeBrowserTag(el, getImportRuleTag) {\n var names = Object.create(null);\n var markers = Object.create(null);\n var extractImport = getImportRuleTag !== undefined;\n /* indicates whether getImportRuleTag was called */\n\n var usedImportRuleTag = false;\n\n var insertMarker = function insertMarker(id) {\n var prev = markers[id];\n\n if (prev !== undefined) {\n return prev;\n }\n\n markers[id] = makeTextNode(el.ownerDocument, id);\n el.appendChild(markers[id]);\n names[id] = Object.create(null);\n return markers[id];\n };\n\n var insertRules = function insertRules(id, cssRules, name) {\n var marker = insertMarker(id);\n var importRules = [];\n var cssRulesSize = cssRules.length;\n\n for (var i = 0; i < cssRulesSize; i += 1) {\n var rule = cssRules[i];\n var mayHaveImport = extractImport;\n\n if (mayHaveImport && rule.indexOf('@import') !== -1) {\n importRules.push(rule);\n } else {\n mayHaveImport = false;\n var separator = i === cssRulesSize - 1 ? '' : ' ';\n marker.appendData('' + rule + separator);\n }\n }\n\n addNameForId(names, id, name);\n\n if (extractImport && importRules.length > 0) {\n usedImportRuleTag = true; // $FlowFixMe\n\n getImportRuleTag().insertRules(id + '-import', importRules);\n }\n };\n\n var removeRules = function removeRules(id) {\n var marker = markers[id];\n if (marker === undefined) return;\n /* create new empty text node and replace the current one */\n\n var newMarker = makeTextNode(el.ownerDocument, id);\n el.replaceChild(newMarker, marker);\n markers[id] = newMarker;\n resetIdNames(names, id);\n\n if (extractImport && usedImportRuleTag) {\n // $FlowFixMe\n getImportRuleTag().removeRules(id + '-import');\n }\n };\n\n var css = function css() {\n var str = ''; // eslint-disable-next-line guard-for-in\n\n for (var id in markers) {\n str += markers[id].data;\n }\n\n return str;\n };\n\n return {\n clone: function clone() {\n throw new StyledComponentsError(5);\n },\n css: css,\n getIds: getIdsFromMarkersFactory(markers),\n hasNameForId: hasNameForId(names),\n insertMarker: insertMarker,\n insertRules: insertRules,\n removeRules: removeRules,\n sealed: false,\n styleTag: el,\n toElement: wrapAsElement(css, names),\n toHTML: wrapAsHtmlTag(css, names)\n };\n};\n\nvar makeServerTag = function makeServerTag(namesArg, markersArg) {\n var names = namesArg === undefined ? Object.create(null) : namesArg;\n var markers = markersArg === undefined ? Object.create(null) : markersArg;\n\n var insertMarker = function insertMarker(id) {\n var prev = markers[id];\n\n if (prev !== undefined) {\n return prev;\n }\n\n return markers[id] = [''];\n };\n\n var insertRules = function insertRules(id, cssRules, name) {\n var marker = insertMarker(id);\n marker[0] += cssRules.join(' ');\n addNameForId(names, id, name);\n };\n\n var removeRules = function removeRules(id) {\n var marker = markers[id];\n if (marker === undefined) return;\n marker[0] = '';\n resetIdNames(names, id);\n };\n\n var css = function css() {\n var str = ''; // eslint-disable-next-line guard-for-in\n\n for (var id in markers) {\n var cssForId = markers[id][0];\n\n if (cssForId) {\n str += makeTextMarker(id) + cssForId;\n }\n }\n\n return str;\n };\n\n var clone = function clone() {\n var namesClone = cloneNames(names);\n var markersClone = Object.create(null); // eslint-disable-next-line guard-for-in\n\n for (var id in markers) {\n markersClone[id] = [markers[id][0]];\n }\n\n return makeServerTag(namesClone, markersClone);\n };\n\n var tag = {\n clone: clone,\n css: css,\n getIds: getIdsFromMarkersFactory(markers),\n hasNameForId: hasNameForId(names),\n insertMarker: insertMarker,\n insertRules: insertRules,\n removeRules: removeRules,\n sealed: false,\n styleTag: null,\n toElement: wrapAsElement(css, names),\n toHTML: wrapAsHtmlTag(css, names)\n };\n return tag;\n};\n\nvar makeTag = function makeTag(target, tagEl, forceServer, insertBefore, getImportRuleTag) {\n if (IS_BROWSER && !forceServer) {\n var el = makeStyleTag(target, tagEl, insertBefore);\n\n if (DISABLE_SPEEDY) {\n return makeBrowserTag(el, getImportRuleTag);\n } else {\n return makeSpeedyTag(el, getImportRuleTag);\n }\n }\n\n return makeServerTag();\n};\n\nvar rehydrate = function rehydrate(tag, els, extracted) {\n /* add all extracted components to the new tag */\n for (var i = 0, len = extracted.length; i < len; i += 1) {\n var _extracted$i = extracted[i],\n componentId = _extracted$i.componentId,\n cssFromDOM = _extracted$i.cssFromDOM;\n var cssRules = splitByRules(cssFromDOM);\n tag.insertRules(componentId, cssRules);\n }\n /* remove old HTMLStyleElements, since they have been rehydrated */\n\n\n for (var _i = 0, _len = els.length; _i < _len; _i += 1) {\n var el = els[_i];\n\n if (el.parentNode) {\n el.parentNode.removeChild(el);\n }\n }\n}; // \n\n\nvar SPLIT_REGEX = /\\s+/;\n/* determine the maximum number of components before tags are sharded */\n\nvar MAX_SIZE = void 0;\n\nif (IS_BROWSER) {\n /* in speedy mode we can keep a lot more rules in a sheet before a slowdown can be expected */\n MAX_SIZE = DISABLE_SPEEDY ? 40 : 1000;\n} else {\n /* for servers we do not need to shard at all */\n MAX_SIZE = -1;\n}\n\nvar sheetRunningId = 0;\nvar master = void 0;\n\nvar StyleSheet = function () {\n /* a map from ids to tags */\n\n /* deferred rules for a given id */\n\n /* this is used for not reinjecting rules via hasNameForId() */\n\n /* when rules for an id are removed using remove() we have to ignore rehydratedNames for it */\n\n /* a list of tags belonging to this StyleSheet */\n\n /* a tag for import rules */\n\n /* current capacity until a new tag must be created */\n\n /* children (aka clones) of this StyleSheet inheriting all and future injections */\n function StyleSheet() {\n var _this = this;\n\n var target = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : IS_BROWSER ? document.head : null;\n var forceServer = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n classCallCheck(this, StyleSheet);\n\n this.getImportRuleTag = function () {\n var importRuleTag = _this.importRuleTag;\n\n if (importRuleTag !== undefined) {\n return importRuleTag;\n }\n\n var firstTag = _this.tags[0];\n var insertBefore = true;\n return _this.importRuleTag = makeTag(_this.target, firstTag ? firstTag.styleTag : null, _this.forceServer, insertBefore);\n };\n\n sheetRunningId += 1;\n this.id = sheetRunningId;\n this.forceServer = forceServer;\n this.target = forceServer ? null : target;\n this.tagMap = {};\n this.deferred = {};\n this.rehydratedNames = {};\n this.ignoreRehydratedNames = {};\n this.tags = [];\n this.capacity = 1;\n this.clones = [];\n }\n /* rehydrate all SSR'd style tags */\n\n\n StyleSheet.prototype.rehydrate = function rehydrate$$1() {\n if (!IS_BROWSER || this.forceServer) return this;\n var els = [];\n var extracted = [];\n var isStreamed = false;\n /* retrieve all of our SSR style elements from the DOM */\n\n var nodes = document.querySelectorAll('style[' + SC_ATTR + '][' + SC_VERSION_ATTR + '=\"' + \"4.4.1\" + '\"]');\n var nodesSize = nodes.length;\n /* abort rehydration if no previous style tags were found */\n\n if (!nodesSize) return this;\n\n for (var i = 0; i < nodesSize; i += 1) {\n var el = nodes[i];\n /* check if style tag is a streamed tag */\n\n if (!isStreamed) isStreamed = !!el.getAttribute(SC_STREAM_ATTR);\n /* retrieve all component names */\n\n var elNames = (el.getAttribute(SC_ATTR) || '').trim().split(SPLIT_REGEX);\n var elNamesSize = elNames.length;\n\n for (var j = 0, name; j < elNamesSize; j += 1) {\n name = elNames[j];\n /* add rehydrated name to sheet to avoid re-adding styles */\n\n this.rehydratedNames[name] = true;\n }\n /* extract all components and their CSS */\n\n\n extracted.push.apply(extracted, extractComps(el.textContent));\n /* store original HTMLStyleElement */\n\n els.push(el);\n }\n /* abort rehydration if nothing was extracted */\n\n\n var extractedSize = extracted.length;\n if (!extractedSize) return this;\n /* create a tag to be used for rehydration */\n\n var tag = this.makeTag(null);\n rehydrate(tag, els, extracted);\n /* reset capacity and adjust MAX_SIZE by the initial size of the rehydration */\n\n this.capacity = Math.max(1, MAX_SIZE - extractedSize);\n this.tags.push(tag);\n /* retrieve all component ids */\n\n for (var _j = 0; _j < extractedSize; _j += 1) {\n this.tagMap[extracted[_j].componentId] = tag;\n }\n\n return this;\n };\n /* retrieve a \"master\" instance of StyleSheet which is typically used when no other is available\n * The master StyleSheet is targeted by createGlobalStyle, keyframes, and components outside of any\n * StyleSheetManager's context */\n\n /* reset the internal \"master\" instance */\n\n\n StyleSheet.reset = function reset() {\n var forceServer = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;\n master = new StyleSheet(undefined, forceServer).rehydrate();\n };\n /* adds \"children\" to the StyleSheet that inherit all of the parents' rules\n * while their own rules do not affect the parent */\n\n\n StyleSheet.prototype.clone = function clone() {\n var sheet = new StyleSheet(this.target, this.forceServer);\n /* add to clone array */\n\n this.clones.push(sheet);\n /* clone all tags */\n\n sheet.tags = this.tags.map(function (tag) {\n var ids = tag.getIds();\n var newTag = tag.clone();\n /* reconstruct tagMap */\n\n for (var i = 0; i < ids.length; i += 1) {\n sheet.tagMap[ids[i]] = newTag;\n }\n\n return newTag;\n });\n /* clone other maps */\n\n sheet.rehydratedNames = _extends({}, this.rehydratedNames);\n sheet.deferred = _extends({}, this.deferred);\n return sheet;\n };\n /* force StyleSheet to create a new tag on the next injection */\n\n\n StyleSheet.prototype.sealAllTags = function sealAllTags() {\n this.capacity = 1;\n this.tags.forEach(function (tag) {\n // eslint-disable-next-line no-param-reassign\n tag.sealed = true;\n });\n };\n\n StyleSheet.prototype.makeTag = function makeTag$$1(tag) {\n var lastEl = tag ? tag.styleTag : null;\n var insertBefore = false;\n return makeTag(this.target, lastEl, this.forceServer, insertBefore, this.getImportRuleTag);\n };\n /* get a tag for a given componentId, assign the componentId to one, or shard */\n\n\n StyleSheet.prototype.getTagForId = function getTagForId(id) {\n /* simply return a tag, when the componentId was already assigned one */\n var prev = this.tagMap[id];\n\n if (prev !== undefined && !prev.sealed) {\n return prev;\n }\n\n var tag = this.tags[this.tags.length - 1];\n /* shard (create a new tag) if the tag is exhausted (See MAX_SIZE) */\n\n this.capacity -= 1;\n\n if (this.capacity === 0) {\n this.capacity = MAX_SIZE;\n tag = this.makeTag(tag);\n this.tags.push(tag);\n }\n\n return this.tagMap[id] = tag;\n };\n /* mainly for createGlobalStyle to check for its id */\n\n\n StyleSheet.prototype.hasId = function hasId(id) {\n return this.tagMap[id] !== undefined;\n };\n /* caching layer checking id+name to already have a corresponding tag and injected rules */\n\n\n StyleSheet.prototype.hasNameForId = function hasNameForId(id, name) {\n /* exception for rehydrated names which are checked separately */\n if (this.ignoreRehydratedNames[id] === undefined && this.rehydratedNames[name]) {\n return true;\n }\n\n var tag = this.tagMap[id];\n return tag !== undefined && tag.hasNameForId(id, name);\n };\n /* registers a componentId and registers it on its tag */\n\n\n StyleSheet.prototype.deferredInject = function deferredInject(id, cssRules) {\n /* don't inject when the id is already registered */\n if (this.tagMap[id] !== undefined) return;\n var clones = this.clones;\n\n for (var i = 0; i < clones.length; i += 1) {\n clones[i].deferredInject(id, cssRules);\n }\n\n this.getTagForId(id).insertMarker(id);\n this.deferred[id] = cssRules;\n };\n /* injects rules for a given id with a name that will need to be cached */\n\n\n StyleSheet.prototype.inject = function inject(id, cssRules, name) {\n var clones = this.clones;\n\n for (var i = 0; i < clones.length; i += 1) {\n clones[i].inject(id, cssRules, name);\n }\n\n var tag = this.getTagForId(id);\n /* add deferred rules for component */\n\n if (this.deferred[id] !== undefined) {\n // Combine passed cssRules with previously deferred CSS rules\n // NOTE: We cannot mutate the deferred array itself as all clones\n // do the same (see clones[i].inject)\n var rules = this.deferred[id].concat(cssRules);\n tag.insertRules(id, rules, name);\n this.deferred[id] = undefined;\n } else {\n tag.insertRules(id, cssRules, name);\n }\n };\n /* removes all rules for a given id, which doesn't remove its marker but resets it */\n\n\n StyleSheet.prototype.remove = function remove(id) {\n var tag = this.tagMap[id];\n if (tag === undefined) return;\n var clones = this.clones;\n\n for (var i = 0; i < clones.length; i += 1) {\n clones[i].remove(id);\n }\n /* remove all rules from the tag */\n\n\n tag.removeRules(id);\n /* ignore possible rehydrated names */\n\n this.ignoreRehydratedNames[id] = true;\n /* delete possible deferred rules */\n\n this.deferred[id] = undefined;\n };\n\n StyleSheet.prototype.toHTML = function toHTML() {\n return this.tags.map(function (tag) {\n return tag.toHTML();\n }).join('');\n };\n\n StyleSheet.prototype.toReactElements = function toReactElements() {\n var id = this.id;\n return this.tags.map(function (tag, i) {\n var key = 'sc-' + id + '-' + i;\n return cloneElement(tag.toElement(), {\n key: key\n });\n });\n };\n\n createClass(StyleSheet, null, [{\n key: 'master',\n get: function get$$1() {\n return master || (master = new StyleSheet().rehydrate());\n }\n /* NOTE: This is just for backwards-compatibility with jest-styled-components */\n\n }, {\n key: 'instance',\n get: function get$$1() {\n return StyleSheet.master;\n }\n }]);\n return StyleSheet;\n}(); // \n\n\nvar Keyframes = function () {\n function Keyframes(name, rules) {\n var _this = this;\n\n classCallCheck(this, Keyframes);\n\n this.inject = function (styleSheet) {\n if (!styleSheet.hasNameForId(_this.id, _this.name)) {\n styleSheet.inject(_this.id, _this.rules, _this.name);\n }\n };\n\n this.toString = function () {\n throw new StyledComponentsError(12, String(_this.name));\n };\n\n this.name = name;\n this.rules = rules;\n this.id = 'sc-keyframes-' + name;\n }\n\n Keyframes.prototype.getName = function getName() {\n return this.name;\n };\n\n return Keyframes;\n}(); // \n\n/**\n * inlined version of\n * https://github.com/facebook/fbjs/blob/master/packages/fbjs/src/core/hyphenateStyleName.js\n */\n\n\nvar uppercasePattern = /([A-Z])/g;\nvar msPattern = /^ms-/;\n/**\n * Hyphenates a camelcased CSS property name, for example:\n *\n * > hyphenateStyleName('backgroundColor')\n * < \"background-color\"\n * > hyphenateStyleName('MozTransition')\n * < \"-moz-transition\"\n * > hyphenateStyleName('msTransition')\n * < \"-ms-transition\"\n *\n * As Modernizr suggests (http://modernizr.com/docs/#prefixed), an `ms` prefix\n * is converted to `-ms-`.\n *\n * @param {string} string\n * @return {string}\n */\n\nfunction hyphenateStyleName(string) {\n return string.replace(uppercasePattern, '-$1').toLowerCase().replace(msPattern, '-ms-');\n} // \n// Taken from https://github.com/facebook/react/blob/b87aabdfe1b7461e7331abb3601d9e6bb27544bc/packages/react-dom/src/shared/dangerousStyleValue.js\n\n\nfunction addUnitIfNeeded(name, value) {\n // https://github.com/amilajack/eslint-plugin-flowtype-errors/issues/133\n // $FlowFixMe\n if (value == null || typeof value === 'boolean' || value === '') {\n return '';\n }\n\n if (typeof value === 'number' && value !== 0 && !(name in unitless)) {\n return value + 'px'; // Presumes implicit 'px' suffix for unitless numbers\n }\n\n return String(value).trim();\n} // \n\n/**\n * It's falsish not falsy because 0 is allowed.\n */\n\n\nvar isFalsish = function isFalsish(chunk) {\n return chunk === undefined || chunk === null || chunk === false || chunk === '';\n};\n\nvar objToCssArray = function objToCssArray(obj, prevKey) {\n var rules = [];\n var keys = Object.keys(obj);\n keys.forEach(function (key) {\n if (!isFalsish(obj[key])) {\n if (isPlainObject(obj[key])) {\n rules.push.apply(rules, objToCssArray(obj[key], key));\n return rules;\n } else if (isFunction(obj[key])) {\n rules.push(hyphenateStyleName(key) + ':', obj[key], ';');\n return rules;\n }\n\n rules.push(hyphenateStyleName(key) + ': ' + addUnitIfNeeded(key, obj[key]) + ';');\n }\n\n return rules;\n });\n return prevKey ? [prevKey + ' {'].concat(rules, ['}']) : rules;\n};\n\nfunction flatten(chunk, executionContext, styleSheet) {\n if (Array.isArray(chunk)) {\n var ruleSet = [];\n\n for (var i = 0, len = chunk.length, result; i < len; i += 1) {\n result = flatten(chunk[i], executionContext, styleSheet);\n if (result === null) continue;else if (Array.isArray(result)) ruleSet.push.apply(ruleSet, result);else ruleSet.push(result);\n }\n\n return ruleSet;\n }\n\n if (isFalsish(chunk)) {\n return null;\n }\n /* Handle other components */\n\n\n if (isStyledComponent(chunk)) {\n return '.' + chunk.styledComponentId;\n }\n /* Either execute or defer the function */\n\n\n if (isFunction(chunk)) {\n if (isStatelessFunction(chunk) && executionContext) {\n var _result = chunk(executionContext);\n\n if (process.env.NODE_ENV !== 'production' && isElement(_result)) {\n // eslint-disable-next-line no-console\n console.warn(getComponentName(chunk) + ' is not a styled component and cannot be referred to via component selector. See https://www.styled-components.com/docs/advanced#referring-to-other-components for more details.');\n }\n\n return flatten(_result, executionContext, styleSheet);\n } else return chunk;\n }\n\n if (chunk instanceof Keyframes) {\n if (styleSheet) {\n chunk.inject(styleSheet);\n return chunk.getName();\n } else return chunk;\n }\n /* Handle objects */\n\n\n return isPlainObject(chunk) ? objToCssArray(chunk) : chunk.toString();\n} // \n\n\nfunction css(styles) {\n for (var _len = arguments.length, interpolations = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n interpolations[_key - 1] = arguments[_key];\n }\n\n if (isFunction(styles) || isPlainObject(styles)) {\n // $FlowFixMe\n return flatten(interleave(EMPTY_ARRAY, [styles].concat(interpolations)));\n } // $FlowFixMe\n\n\n return flatten(interleave(styles, interpolations));\n} // \n\n\nfunction constructWithOptions(componentConstructor, tag) {\n var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : EMPTY_OBJECT;\n\n if (!isValidElementType(tag)) {\n throw new StyledComponentsError(1, String(tag));\n }\n /* This is callable directly as a template function */\n // $FlowFixMe: Not typed to avoid destructuring arguments\n\n\n var templateFunction = function templateFunction() {\n return componentConstructor(tag, options, css.apply(undefined, arguments));\n };\n /* If config methods are called, wrap up a new template function and merge options */\n\n\n templateFunction.withConfig = function (config) {\n return constructWithOptions(componentConstructor, tag, _extends({}, options, config));\n };\n /* Modify/inject new props at runtime */\n\n\n templateFunction.attrs = function (attrs) {\n return constructWithOptions(componentConstructor, tag, _extends({}, options, {\n attrs: Array.prototype.concat(options.attrs, attrs).filter(Boolean)\n }));\n };\n\n return templateFunction;\n} // \n// Source: https://github.com/garycourt/murmurhash-js/blob/master/murmurhash2_gc.js\n\n\nfunction murmurhash(c) {\n for (var e = c.length | 0, a = e | 0, d = 0, b; e >= 4;) {\n b = c.charCodeAt(d) & 255 | (c.charCodeAt(++d) & 255) << 8 | (c.charCodeAt(++d) & 255) << 16 | (c.charCodeAt(++d) & 255) << 24, b = 1540483477 * (b & 65535) + ((1540483477 * (b >>> 16) & 65535) << 16), b ^= b >>> 24, b = 1540483477 * (b & 65535) + ((1540483477 * (b >>> 16) & 65535) << 16), a = 1540483477 * (a & 65535) + ((1540483477 * (a >>> 16) & 65535) << 16) ^ b, e -= 4, ++d;\n }\n\n switch (e) {\n case 3:\n a ^= (c.charCodeAt(d + 2) & 255) << 16;\n\n case 2:\n a ^= (c.charCodeAt(d + 1) & 255) << 8;\n\n case 1:\n a ^= c.charCodeAt(d) & 255, a = 1540483477 * (a & 65535) + ((1540483477 * (a >>> 16) & 65535) << 16);\n }\n\n a ^= a >>> 13;\n a = 1540483477 * (a & 65535) + ((1540483477 * (a >>> 16) & 65535) << 16);\n return (a ^ a >>> 15) >>> 0;\n} // \n\n/* eslint-disable no-bitwise */\n\n/* This is the \"capacity\" of our alphabet i.e. 2x26 for all letters plus their capitalised\n * counterparts */\n\n\nvar charsLength = 52;\n/* start at 75 for 'a' until 'z' (25) and then start at 65 for capitalised letters */\n\nvar getAlphabeticChar = function getAlphabeticChar(code) {\n return String.fromCharCode(code + (code > 25 ? 39 : 97));\n};\n/* input a number, usually a hash and convert it to base-52 */\n\n\nfunction generateAlphabeticName(code) {\n var name = '';\n var x = void 0;\n /* get a char and divide by alphabet-length */\n\n for (x = code; x > charsLength; x = Math.floor(x / charsLength)) {\n name = getAlphabeticChar(x % charsLength) + name;\n }\n\n return getAlphabeticChar(x % charsLength) + name;\n} // \n\n\nfunction hasFunctionObjectKey(obj) {\n // eslint-disable-next-line guard-for-in, no-restricted-syntax\n for (var key in obj) {\n if (isFunction(obj[key])) {\n return true;\n }\n }\n\n return false;\n}\n\nfunction isStaticRules(rules, attrs) {\n for (var i = 0; i < rules.length; i += 1) {\n var rule = rules[i]; // recursive case\n\n if (Array.isArray(rule) && !isStaticRules(rule, attrs)) {\n return false;\n } else if (isFunction(rule) && !isStyledComponent(rule)) {\n // functions are allowed to be static if they're just being\n // used to get the classname of a nested styled component\n return false;\n }\n }\n\n if (attrs.some(function (x) {\n return isFunction(x) || hasFunctionObjectKey(x);\n })) return false;\n return true;\n} // \n\n/* combines hashStr (murmurhash) and nameGenerator for convenience */\n\n\nvar hasher = function hasher(str) {\n return generateAlphabeticName(murmurhash(str));\n};\n/*\n ComponentStyle is all the CSS-specific stuff, not\n the React-specific stuff.\n */\n\n\nvar ComponentStyle = function () {\n function ComponentStyle(rules, attrs, componentId) {\n classCallCheck(this, ComponentStyle);\n this.rules = rules;\n this.isStatic = process.env.NODE_ENV === 'production' && isStaticRules(rules, attrs);\n this.componentId = componentId;\n\n if (!StyleSheet.master.hasId(componentId)) {\n StyleSheet.master.deferredInject(componentId, []);\n }\n }\n /*\n * Flattens a rule set into valid CSS\n * Hashes it, wraps the whole chunk in a .hash1234 {}\n * Returns the hash to be injected on render()\n * */\n\n\n ComponentStyle.prototype.generateAndInjectStyles = function generateAndInjectStyles(executionContext, styleSheet) {\n var isStatic = this.isStatic,\n componentId = this.componentId,\n lastClassName = this.lastClassName;\n\n if (IS_BROWSER && isStatic && typeof lastClassName === 'string' && styleSheet.hasNameForId(componentId, lastClassName)) {\n return lastClassName;\n }\n\n var flatCSS = flatten(this.rules, executionContext, styleSheet);\n var name = hasher(this.componentId + flatCSS.join(''));\n\n if (!styleSheet.hasNameForId(componentId, name)) {\n styleSheet.inject(this.componentId, stringifyRules(flatCSS, '.' + name, undefined, componentId), name);\n }\n\n this.lastClassName = name;\n return name;\n };\n\n ComponentStyle.generateName = function generateName(str) {\n return hasher(str);\n };\n\n return ComponentStyle;\n}(); // \n\n\nvar LIMIT = 200;\n\nvar createWarnTooManyClasses = function createWarnTooManyClasses(displayName) {\n var generatedClasses = {};\n var warningSeen = false;\n return function (className) {\n if (!warningSeen) {\n generatedClasses[className] = true;\n\n if (Object.keys(generatedClasses).length >= LIMIT) {\n // Unable to find latestRule in test environment.\n\n /* eslint-disable no-console, prefer-template */\n console.warn('Over ' + LIMIT + ' classes were generated for component ' + displayName + '. \\n' + 'Consider using the attrs method, together with a style object for frequently changed styles.\\n' + 'Example:\\n' + ' const Component = styled.div.attrs(props => ({\\n' + ' style: {\\n' + ' background: props.background,\\n' + ' },\\n' + ' }))`width: 100%;`\\n\\n' + ' ');\n warningSeen = true;\n generatedClasses = {};\n }\n }\n };\n}; // \n\n\nvar determineTheme = function determineTheme(props, fallbackTheme) {\n var defaultProps = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : EMPTY_OBJECT; // Props should take precedence over ThemeProvider, which should take precedence over\n // defaultProps, but React automatically puts defaultProps on props.\n\n /* eslint-disable react/prop-types, flowtype-errors/show-errors */\n\n var isDefaultTheme = defaultProps ? props.theme === defaultProps.theme : false;\n var theme = props.theme && !isDefaultTheme ? props.theme : fallbackTheme || defaultProps.theme;\n /* eslint-enable */\n\n return theme;\n}; // \n\n\nvar escapeRegex = /[[\\].#*$><+~=|^:(),\"'`-]+/g;\nvar dashesAtEnds = /(^-|-$)/g;\n/**\n * TODO: Explore using CSS.escape when it becomes more available\n * in evergreen browsers.\n */\n\nfunction escape(str) {\n return str // Replace all possible CSS selectors\n .replace(escapeRegex, '-') // Remove extraneous hyphens at the start and end\n .replace(dashesAtEnds, '');\n} // \n\n\nfunction isTag(target) {\n return typeof target === 'string' && (process.env.NODE_ENV !== 'production' ? target.charAt(0) === target.charAt(0).toLowerCase() : true);\n} // \n\n\nfunction generateDisplayName(target) {\n // $FlowFixMe\n return isTag(target) ? 'styled.' + target : 'Styled(' + getComponentName(target) + ')';\n}\n\nvar _TYPE_STATICS;\n\nvar REACT_STATICS = {\n childContextTypes: true,\n contextTypes: true,\n defaultProps: true,\n displayName: true,\n getDerivedStateFromProps: true,\n propTypes: true,\n type: true\n};\nvar KNOWN_STATICS = {\n name: true,\n length: true,\n prototype: true,\n caller: true,\n callee: true,\n arguments: true,\n arity: true\n};\nvar TYPE_STATICS = (_TYPE_STATICS = {}, _TYPE_STATICS[ForwardRef] = {\n $$typeof: true,\n render: true\n}, _TYPE_STATICS);\nvar defineProperty$1 = Object.defineProperty,\n getOwnPropertyNames = Object.getOwnPropertyNames,\n _Object$getOwnPropert = Object.getOwnPropertySymbols,\n getOwnPropertySymbols = _Object$getOwnPropert === undefined ? function () {\n return [];\n} : _Object$getOwnPropert,\n getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor,\n getPrototypeOf = Object.getPrototypeOf,\n objectPrototype = Object.prototype;\nvar arrayPrototype = Array.prototype;\n\nfunction hoistNonReactStatics(targetComponent, sourceComponent, blacklist) {\n if (typeof sourceComponent !== 'string') {\n // don't hoist over string (html) components\n var inheritedComponent = getPrototypeOf(sourceComponent);\n\n if (inheritedComponent && inheritedComponent !== objectPrototype) {\n hoistNonReactStatics(targetComponent, inheritedComponent, blacklist);\n }\n\n var keys = arrayPrototype.concat(getOwnPropertyNames(sourceComponent), // $FlowFixMe\n getOwnPropertySymbols(sourceComponent));\n var targetStatics = TYPE_STATICS[targetComponent.$$typeof] || REACT_STATICS;\n var sourceStatics = TYPE_STATICS[sourceComponent.$$typeof] || REACT_STATICS;\n var i = keys.length;\n var descriptor = void 0;\n var key = void 0; // eslint-disable-next-line no-plusplus\n\n while (i--) {\n key = keys[i];\n\n if ( // $FlowFixMe\n !KNOWN_STATICS[key] && !(blacklist && blacklist[key]) && !(sourceStatics && sourceStatics[key]) && // $FlowFixMe\n !(targetStatics && targetStatics[key])) {\n descriptor = getOwnPropertyDescriptor(sourceComponent, key);\n\n if (descriptor) {\n try {\n // Avoid failures from read-only properties\n defineProperty$1(targetComponent, key, descriptor);\n } catch (e) {\n /* fail silently */\n }\n }\n }\n }\n\n return targetComponent;\n }\n\n return targetComponent;\n} // \n\n\nfunction isDerivedReactComponent(fn) {\n return !!(fn && fn.prototype && fn.prototype.isReactComponent);\n} // \n// Helper to call a given function, only once\n\n\nvar once = function once(cb) {\n var called = false;\n return function () {\n if (!called) {\n called = true;\n cb.apply(undefined, arguments);\n }\n };\n}; // \n\n\nvar ThemeContext = createContext();\nvar ThemeConsumer = ThemeContext.Consumer;\n/**\n * Provide a theme to an entire react component tree via context\n */\n\nvar ThemeProvider = function (_Component) {\n inherits(ThemeProvider, _Component);\n\n function ThemeProvider(props) {\n classCallCheck(this, ThemeProvider);\n\n var _this = possibleConstructorReturn(this, _Component.call(this, props));\n\n _this.getContext = memoize(_this.getContext.bind(_this));\n _this.renderInner = _this.renderInner.bind(_this);\n return _this;\n }\n\n ThemeProvider.prototype.render = function render() {\n if (!this.props.children) return null;\n return React.createElement(ThemeContext.Consumer, null, this.renderInner);\n };\n\n ThemeProvider.prototype.renderInner = function renderInner(outerTheme) {\n var context = this.getContext(this.props.theme, outerTheme);\n return React.createElement(ThemeContext.Provider, {\n value: context\n }, this.props.children);\n };\n /**\n * Get the theme from the props, supporting both (outerTheme) => {}\n * as well as object notation\n */\n\n\n ThemeProvider.prototype.getTheme = function getTheme(theme, outerTheme) {\n if (isFunction(theme)) {\n var mergedTheme = theme(outerTheme);\n\n if (process.env.NODE_ENV !== 'production' && (mergedTheme === null || Array.isArray(mergedTheme) || (typeof mergedTheme === 'undefined' ? 'undefined' : _typeof(mergedTheme)) !== 'object')) {\n throw new StyledComponentsError(7);\n }\n\n return mergedTheme;\n }\n\n if (theme === null || Array.isArray(theme) || (typeof theme === 'undefined' ? 'undefined' : _typeof(theme)) !== 'object') {\n throw new StyledComponentsError(8);\n }\n\n return _extends({}, outerTheme, theme);\n };\n\n ThemeProvider.prototype.getContext = function getContext(theme, outerTheme) {\n return this.getTheme(theme, outerTheme);\n };\n\n return ThemeProvider;\n}(Component); // \n\n\nvar CLOSING_TAG_R = /^\\s*<\\/[a-z]/i;\n\nvar ServerStyleSheet = function () {\n function ServerStyleSheet() {\n classCallCheck(this, ServerStyleSheet);\n /* The master sheet might be reset, so keep a reference here */\n\n this.masterSheet = StyleSheet.master;\n this.instance = this.masterSheet.clone();\n this.sealed = false;\n }\n /**\n * Mark the ServerStyleSheet as being fully emitted and manually GC it from the\n * StyleSheet singleton.\n */\n\n\n ServerStyleSheet.prototype.seal = function seal() {\n if (!this.sealed) {\n /* Remove sealed StyleSheets from the master sheet */\n var index = this.masterSheet.clones.indexOf(this.instance);\n this.masterSheet.clones.splice(index, 1);\n this.sealed = true;\n }\n };\n\n ServerStyleSheet.prototype.collectStyles = function collectStyles(children) {\n if (this.sealed) {\n throw new StyledComponentsError(2);\n }\n\n return React.createElement(StyleSheetManager, {\n sheet: this.instance\n }, children);\n };\n\n ServerStyleSheet.prototype.getStyleTags = function getStyleTags() {\n this.seal();\n return this.instance.toHTML();\n };\n\n ServerStyleSheet.prototype.getStyleElement = function getStyleElement() {\n this.seal();\n return this.instance.toReactElements();\n };\n\n ServerStyleSheet.prototype.interleaveWithNodeStream = function interleaveWithNodeStream(readableStream) {\n var _this = this;\n\n {\n throw new StyledComponentsError(3);\n }\n /* the tag index keeps track of which tags have already been emitted */\n\n var instance = this.instance;\n var instanceTagIndex = 0;\n var streamAttr = SC_STREAM_ATTR + '=\"true\"';\n var transformer = new stream.Transform({\n transform: function appendStyleChunks(chunk,\n /* encoding */\n _, callback) {\n var tags = instance.tags;\n var html = '';\n /* retrieve html for each new style tag */\n\n for (; instanceTagIndex < tags.length; instanceTagIndex += 1) {\n var tag = tags[instanceTagIndex];\n html += tag.toHTML(streamAttr);\n }\n /* force our StyleSheets to emit entirely new tags */\n\n\n instance.sealAllTags();\n var renderedHtml = chunk.toString();\n /* prepend style html to chunk, unless the start of the chunk is a closing tag in which case append right after that */\n\n if (CLOSING_TAG_R.test(renderedHtml)) {\n var endOfClosingTag = renderedHtml.indexOf('>');\n this.push(renderedHtml.slice(0, endOfClosingTag + 1) + html + renderedHtml.slice(endOfClosingTag + 1));\n } else this.push(html + renderedHtml);\n\n callback();\n }\n });\n readableStream.on('end', function () {\n return _this.seal();\n });\n readableStream.on('error', function (err) {\n _this.seal(); // forward the error to the transform stream\n\n\n transformer.emit('error', err);\n });\n return readableStream.pipe(transformer);\n };\n\n return ServerStyleSheet;\n}(); // \n\n\nvar StyleSheetContext = createContext();\nvar StyleSheetConsumer = StyleSheetContext.Consumer;\n\nvar StyleSheetManager = function (_Component) {\n inherits(StyleSheetManager, _Component);\n\n function StyleSheetManager(props) {\n classCallCheck(this, StyleSheetManager);\n\n var _this = possibleConstructorReturn(this, _Component.call(this, props));\n\n _this.getContext = memoize(_this.getContext);\n return _this;\n }\n\n StyleSheetManager.prototype.getContext = function getContext(sheet, target) {\n if (sheet) {\n return sheet;\n } else if (target) {\n return new StyleSheet(target);\n } else {\n throw new StyledComponentsError(4);\n }\n };\n\n StyleSheetManager.prototype.render = function render() {\n var _props = this.props,\n children = _props.children,\n sheet = _props.sheet,\n target = _props.target;\n return React.createElement(StyleSheetContext.Provider, {\n value: this.getContext(sheet, target)\n }, process.env.NODE_ENV !== 'production' ? React.Children.only(children) : children);\n };\n\n return StyleSheetManager;\n}(Component);\n\nprocess.env.NODE_ENV !== \"production\" ? void 0 : void 0; // \n\nvar identifiers = {};\n/* We depend on components having unique IDs */\n\nfunction generateId(_ComponentStyle, _displayName, parentComponentId) {\n var displayName = typeof _displayName !== 'string' ? 'sc' : escape(_displayName);\n /**\n * This ensures uniqueness if two components happen to share\n * the same displayName.\n */\n\n var nr = (identifiers[displayName] || 0) + 1;\n identifiers[displayName] = nr;\n\n var componentId = displayName + '-' + _ComponentStyle.generateName(displayName + nr);\n\n return parentComponentId ? parentComponentId + '-' + componentId : componentId;\n} // $FlowFixMe\n\n\nvar StyledComponent = function (_Component) {\n inherits(StyledComponent, _Component);\n\n function StyledComponent() {\n classCallCheck(this, StyledComponent);\n\n var _this = possibleConstructorReturn(this, _Component.call(this));\n\n _this.attrs = {};\n _this.renderOuter = _this.renderOuter.bind(_this);\n _this.renderInner = _this.renderInner.bind(_this);\n\n if (process.env.NODE_ENV !== 'production') {\n _this.warnInnerRef = once(function (displayName) {\n return (// eslint-disable-next-line no-console\n console.warn('The \"innerRef\" API has been removed in styled-components v4 in favor of React 16 ref forwarding, use \"ref\" instead like a typical component. \"innerRef\" was detected on component \"' + displayName + '\".')\n );\n });\n _this.warnAttrsFnObjectKeyDeprecated = once(function (key, displayName) {\n return (// eslint-disable-next-line no-console\n console.warn('Functions as object-form attrs({}) keys are now deprecated and will be removed in a future version of styled-components. Switch to the new attrs(props => ({})) syntax instead for easier and more powerful composition. The attrs key in question is \"' + key + '\" on component \"' + displayName + '\".', '\\n ' + new Error().stack)\n );\n });\n _this.warnNonStyledComponentAttrsObjectKey = once(function (key, displayName) {\n return (// eslint-disable-next-line no-console\n console.warn('It looks like you\\'ve used a non styled-component as the value for the \"' + key + '\" prop in an object-form attrs constructor of \"' + displayName + '\".\\n' + 'You should use the new function-form attrs constructor which avoids this issue: attrs(props => ({ yourStuff }))\\n' + \"To continue using the deprecated object syntax, you'll need to wrap your component prop in a function to make it available inside the styled component (you'll still get the deprecation warning though.)\\n\" + ('For example, { ' + key + ': () => InnerComponent } instead of { ' + key + ': InnerComponent }'))\n );\n });\n }\n\n return _this;\n }\n\n StyledComponent.prototype.render = function render() {\n return React.createElement(StyleSheetConsumer, null, this.renderOuter);\n };\n\n StyledComponent.prototype.renderOuter = function renderOuter() {\n var styleSheet = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : StyleSheet.master;\n this.styleSheet = styleSheet; // No need to subscribe a static component to theme changes, it won't change anything\n\n if (this.props.forwardedComponent.componentStyle.isStatic) return this.renderInner();\n return React.createElement(ThemeConsumer, null, this.renderInner);\n };\n\n StyledComponent.prototype.renderInner = function renderInner(theme) {\n var _props$forwardedCompo = this.props.forwardedComponent,\n componentStyle = _props$forwardedCompo.componentStyle,\n defaultProps = _props$forwardedCompo.defaultProps,\n displayName = _props$forwardedCompo.displayName,\n foldedComponentIds = _props$forwardedCompo.foldedComponentIds,\n styledComponentId = _props$forwardedCompo.styledComponentId,\n target = _props$forwardedCompo.target;\n var generatedClassName = void 0;\n\n if (componentStyle.isStatic) {\n generatedClassName = this.generateAndInjectStyles(EMPTY_OBJECT, this.props);\n } else {\n generatedClassName = this.generateAndInjectStyles(determineTheme(this.props, theme, defaultProps) || EMPTY_OBJECT, this.props);\n }\n\n var elementToBeCreated = this.props.as || this.attrs.as || target;\n var isTargetTag = isTag(elementToBeCreated);\n var propsForElement = {};\n\n var computedProps = _extends({}, this.props, this.attrs);\n\n var key = void 0; // eslint-disable-next-line guard-for-in\n\n for (key in computedProps) {\n if (process.env.NODE_ENV !== 'production' && key === 'innerRef' && isTargetTag) {\n this.warnInnerRef(displayName);\n }\n\n if (key === 'forwardedComponent' || key === 'as') {\n continue;\n } else if (key === 'forwardedRef') propsForElement.ref = computedProps[key];else if (key === 'forwardedAs') propsForElement.as = computedProps[key];else if (!isTargetTag || validAttr(key)) {\n // Don't pass through non HTML tags through to HTML elements\n propsForElement[key] = computedProps[key];\n }\n }\n\n if (this.props.style && this.attrs.style) {\n propsForElement.style = _extends({}, this.attrs.style, this.props.style);\n }\n\n propsForElement.className = Array.prototype.concat(foldedComponentIds, styledComponentId, generatedClassName !== styledComponentId ? generatedClassName : null, this.props.className, this.attrs.className).filter(Boolean).join(' ');\n return createElement(elementToBeCreated, propsForElement);\n };\n\n StyledComponent.prototype.buildExecutionContext = function buildExecutionContext(theme, props, attrs) {\n var _this2 = this;\n\n var context = _extends({}, props, {\n theme: theme\n });\n\n if (!attrs.length) return context;\n this.attrs = {};\n attrs.forEach(function (attrDef) {\n var resolvedAttrDef = attrDef;\n var attrDefWasFn = false;\n var attr = void 0;\n var key = void 0;\n\n if (isFunction(resolvedAttrDef)) {\n // $FlowFixMe\n resolvedAttrDef = resolvedAttrDef(context);\n attrDefWasFn = true;\n }\n /* eslint-disable guard-for-in */\n // $FlowFixMe\n\n\n for (key in resolvedAttrDef) {\n attr = resolvedAttrDef[key];\n\n if (!attrDefWasFn) {\n if (isFunction(attr) && !isDerivedReactComponent(attr) && !isStyledComponent(attr)) {\n if (process.env.NODE_ENV !== 'production') {\n _this2.warnAttrsFnObjectKeyDeprecated(key, props.forwardedComponent.displayName);\n }\n\n attr = attr(context);\n\n if (process.env.NODE_ENV !== 'production' && React.isValidElement(attr)) {\n _this2.warnNonStyledComponentAttrsObjectKey(key, props.forwardedComponent.displayName);\n }\n }\n }\n\n _this2.attrs[key] = attr;\n context[key] = attr;\n }\n /* eslint-enable */\n\n });\n return context;\n };\n\n StyledComponent.prototype.generateAndInjectStyles = function generateAndInjectStyles(theme, props) {\n var _props$forwardedCompo2 = props.forwardedComponent,\n attrs = _props$forwardedCompo2.attrs,\n componentStyle = _props$forwardedCompo2.componentStyle,\n warnTooManyClasses = _props$forwardedCompo2.warnTooManyClasses; // statically styled-components don't need to build an execution context object,\n // and shouldn't be increasing the number of class names\n\n if (componentStyle.isStatic && !attrs.length) {\n return componentStyle.generateAndInjectStyles(EMPTY_OBJECT, this.styleSheet);\n }\n\n var className = componentStyle.generateAndInjectStyles(this.buildExecutionContext(theme, props, attrs), this.styleSheet);\n if (process.env.NODE_ENV !== 'production' && warnTooManyClasses) warnTooManyClasses(className);\n return className;\n };\n\n return StyledComponent;\n}(Component);\n\nfunction createStyledComponent(target, options, rules) {\n var isTargetStyledComp = isStyledComponent(target);\n var isClass = !isTag(target);\n var _options$displayName = options.displayName,\n displayName = _options$displayName === undefined ? generateDisplayName(target) : _options$displayName,\n _options$componentId = options.componentId,\n componentId = _options$componentId === undefined ? generateId(ComponentStyle, options.displayName, options.parentComponentId) : _options$componentId,\n _options$ParentCompon = options.ParentComponent,\n ParentComponent = _options$ParentCompon === undefined ? StyledComponent : _options$ParentCompon,\n _options$attrs = options.attrs,\n attrs = _options$attrs === undefined ? EMPTY_ARRAY : _options$attrs;\n var styledComponentId = options.displayName && options.componentId ? escape(options.displayName) + '-' + options.componentId : options.componentId || componentId; // fold the underlying StyledComponent attrs up (implicit extend)\n\n var finalAttrs = // $FlowFixMe\n isTargetStyledComp && target.attrs ? Array.prototype.concat(target.attrs, attrs).filter(Boolean) : attrs;\n var componentStyle = new ComponentStyle(isTargetStyledComp ? // fold the underlying StyledComponent rules up (implicit extend)\n // $FlowFixMe\n target.componentStyle.rules.concat(rules) : rules, finalAttrs, styledComponentId);\n /**\n * forwardRef creates a new interim component, which we'll take advantage of\n * instead of extending ParentComponent to create _another_ interim class\n */\n\n var WrappedStyledComponent = void 0;\n\n var forwardRef = function forwardRef(props, ref) {\n return React.createElement(ParentComponent, _extends({}, props, {\n forwardedComponent: WrappedStyledComponent,\n forwardedRef: ref\n }));\n };\n\n forwardRef.displayName = displayName;\n WrappedStyledComponent = React.forwardRef(forwardRef);\n WrappedStyledComponent.displayName = displayName; // $FlowFixMe\n\n WrappedStyledComponent.attrs = finalAttrs; // $FlowFixMe\n\n WrappedStyledComponent.componentStyle = componentStyle; // $FlowFixMe\n\n WrappedStyledComponent.foldedComponentIds = isTargetStyledComp ? // $FlowFixMe\n Array.prototype.concat(target.foldedComponentIds, target.styledComponentId) : EMPTY_ARRAY; // $FlowFixMe\n\n WrappedStyledComponent.styledComponentId = styledComponentId; // fold the underlying StyledComponent target up since we folded the styles\n // $FlowFixMe\n\n WrappedStyledComponent.target = isTargetStyledComp ? target.target : target; // $FlowFixMe\n\n WrappedStyledComponent.withComponent = function withComponent(tag) {\n var previousComponentId = options.componentId,\n optionsToCopy = objectWithoutProperties(options, ['componentId']);\n var newComponentId = previousComponentId && previousComponentId + '-' + (isTag(tag) ? tag : escape(getComponentName(tag)));\n\n var newOptions = _extends({}, optionsToCopy, {\n attrs: finalAttrs,\n componentId: newComponentId,\n ParentComponent: ParentComponent\n });\n\n return createStyledComponent(tag, newOptions, rules);\n }; // $FlowFixMe\n\n\n Object.defineProperty(WrappedStyledComponent, 'defaultProps', {\n get: function get$$1() {\n return this._foldedDefaultProps;\n },\n set: function set$$1(obj) {\n // $FlowFixMe\n this._foldedDefaultProps = isTargetStyledComp ? merge(target.defaultProps, obj) : obj;\n }\n });\n\n if (process.env.NODE_ENV !== 'production') {\n // $FlowFixMe\n WrappedStyledComponent.warnTooManyClasses = createWarnTooManyClasses(displayName);\n } // $FlowFixMe\n\n\n WrappedStyledComponent.toString = function () {\n return '.' + WrappedStyledComponent.styledComponentId;\n };\n\n if (isClass) {\n hoistNonReactStatics(WrappedStyledComponent, target, {\n // all SC-specific things should not be hoisted\n attrs: true,\n componentStyle: true,\n displayName: true,\n foldedComponentIds: true,\n styledComponentId: true,\n target: true,\n withComponent: true\n });\n }\n\n return WrappedStyledComponent;\n} // \n// Thanks to ReactDOMFactories for this handy list!\n\n\nvar domElements = ['a', 'abbr', 'address', 'area', 'article', 'aside', 'audio', 'b', 'base', 'bdi', 'bdo', 'big', 'blockquote', 'body', 'br', 'button', 'canvas', 'caption', 'cite', 'code', 'col', 'colgroup', 'data', 'datalist', 'dd', 'del', 'details', 'dfn', 'dialog', 'div', 'dl', 'dt', 'em', 'embed', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'hr', 'html', 'i', 'iframe', 'img', 'input', 'ins', 'kbd', 'keygen', 'label', 'legend', 'li', 'link', 'main', 'map', 'mark', 'marquee', 'menu', 'menuitem', 'meta', 'meter', 'nav', 'noscript', 'object', 'ol', 'optgroup', 'option', 'output', 'p', 'param', 'picture', 'pre', 'progress', 'q', 'rp', 'rt', 'ruby', 's', 'samp', 'script', 'section', 'select', 'small', 'source', 'span', 'strong', 'style', 'sub', 'summary', 'sup', 'table', 'tbody', 'td', 'textarea', 'tfoot', 'th', 'thead', 'time', 'title', 'tr', 'track', 'u', 'ul', 'var', 'video', 'wbr', // SVG\n'circle', 'clipPath', 'defs', 'ellipse', 'foreignObject', 'g', 'image', 'line', 'linearGradient', 'marker', 'mask', 'path', 'pattern', 'polygon', 'polyline', 'radialGradient', 'rect', 'stop', 'svg', 'text', 'tspan']; // \n\nvar styled = function styled(tag) {\n return constructWithOptions(createStyledComponent, tag);\n}; // Shorthands for all valid HTML Elements\n\n\ndomElements.forEach(function (domElement) {\n styled[domElement] = styled(domElement);\n}); // \n\nvar GlobalStyle = function () {\n function GlobalStyle(rules, componentId) {\n classCallCheck(this, GlobalStyle);\n this.rules = rules;\n this.componentId = componentId;\n this.isStatic = isStaticRules(rules, EMPTY_ARRAY);\n\n if (!StyleSheet.master.hasId(componentId)) {\n StyleSheet.master.deferredInject(componentId, []);\n }\n }\n\n GlobalStyle.prototype.createStyles = function createStyles(executionContext, styleSheet) {\n var flatCSS = flatten(this.rules, executionContext, styleSheet);\n var css = stringifyRules(flatCSS, '');\n styleSheet.inject(this.componentId, css);\n };\n\n GlobalStyle.prototype.removeStyles = function removeStyles(styleSheet) {\n var componentId = this.componentId;\n\n if (styleSheet.hasId(componentId)) {\n styleSheet.remove(componentId);\n }\n }; // TODO: overwrite in-place instead of remove+create?\n\n\n GlobalStyle.prototype.renderStyles = function renderStyles(executionContext, styleSheet) {\n this.removeStyles(styleSheet);\n this.createStyles(executionContext, styleSheet);\n };\n\n return GlobalStyle;\n}(); // \n// place our cache into shared context so it'll persist between HMRs\n\n\nif (IS_BROWSER) {\n window.scCGSHMRCache = {};\n}\n\nfunction createGlobalStyle(strings) {\n for (var _len = arguments.length, interpolations = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n interpolations[_key - 1] = arguments[_key];\n }\n\n var rules = css.apply(undefined, [strings].concat(interpolations));\n var id = 'sc-global-' + murmurhash(JSON.stringify(rules));\n var style = new GlobalStyle(rules, id);\n\n var GlobalStyleComponent = function (_React$Component) {\n inherits(GlobalStyleComponent, _React$Component);\n\n function GlobalStyleComponent(props) {\n classCallCheck(this, GlobalStyleComponent);\n\n var _this = possibleConstructorReturn(this, _React$Component.call(this, props));\n\n var _this$constructor = _this.constructor,\n globalStyle = _this$constructor.globalStyle,\n styledComponentId = _this$constructor.styledComponentId;\n\n if (IS_BROWSER) {\n window.scCGSHMRCache[styledComponentId] = (window.scCGSHMRCache[styledComponentId] || 0) + 1;\n }\n /**\n * This fixes HMR compatibility. Don't ask me why, but this combination of\n * caching the closure variables via statics and then persisting the statics in\n * state works across HMR where no other combination did. ¯\\_(ツ)_/¯\n */\n\n\n _this.state = {\n globalStyle: globalStyle,\n styledComponentId: styledComponentId\n };\n return _this;\n }\n\n GlobalStyleComponent.prototype.componentWillUnmount = function componentWillUnmount() {\n if (window.scCGSHMRCache[this.state.styledComponentId]) {\n window.scCGSHMRCache[this.state.styledComponentId] -= 1;\n }\n /**\n * Depending on the order \"render\" is called this can cause the styles to be lost\n * until the next render pass of the remaining instance, which may\n * not be immediate.\n */\n\n\n if (window.scCGSHMRCache[this.state.styledComponentId] === 0) {\n this.state.globalStyle.removeStyles(this.styleSheet);\n }\n };\n\n GlobalStyleComponent.prototype.render = function render() {\n var _this2 = this;\n\n if (process.env.NODE_ENV !== 'production' && React.Children.count(this.props.children)) {\n // eslint-disable-next-line no-console\n console.warn('The global style component ' + this.state.styledComponentId + ' was given child JSX. createGlobalStyle does not render children.');\n }\n\n return React.createElement(StyleSheetConsumer, null, function (styleSheet) {\n _this2.styleSheet = styleSheet || StyleSheet.master;\n var globalStyle = _this2.state.globalStyle;\n\n if (globalStyle.isStatic) {\n globalStyle.renderStyles(STATIC_EXECUTION_CONTEXT, _this2.styleSheet);\n return null;\n } else {\n return React.createElement(ThemeConsumer, null, function (theme) {\n // $FlowFixMe\n var defaultProps = _this2.constructor.defaultProps;\n\n var context = _extends({}, _this2.props);\n\n if (typeof theme !== 'undefined') {\n context.theme = determineTheme(_this2.props, theme, defaultProps);\n }\n\n globalStyle.renderStyles(context, _this2.styleSheet);\n return null;\n });\n }\n });\n };\n\n return GlobalStyleComponent;\n }(React.Component);\n\n GlobalStyleComponent.globalStyle = style;\n GlobalStyleComponent.styledComponentId = id;\n return GlobalStyleComponent;\n} // \n\n\nvar replaceWhitespace = function replaceWhitespace(str) {\n return str.replace(/\\s|\\\\n/g, '');\n};\n\nfunction keyframes(strings) {\n /* Warning if you've used keyframes on React Native */\n if (process.env.NODE_ENV !== 'production' && typeof navigator !== 'undefined' && navigator.product === 'ReactNative') {\n // eslint-disable-next-line no-console\n console.warn('`keyframes` cannot be used on ReactNative, only on the web. To do animation in ReactNative please use Animated.');\n }\n\n for (var _len = arguments.length, interpolations = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n interpolations[_key - 1] = arguments[_key];\n }\n\n var rules = css.apply(undefined, [strings].concat(interpolations));\n var name = generateAlphabeticName(murmurhash(replaceWhitespace(JSON.stringify(rules))));\n return new Keyframes(name, stringifyRules(rules, name, '@keyframes'));\n} // \n\n\nvar withTheme = function withTheme(Component$$1) {\n var WithTheme = React.forwardRef(function (props, ref) {\n return React.createElement(ThemeConsumer, null, function (theme) {\n // $FlowFixMe\n var defaultProps = Component$$1.defaultProps;\n var themeProp = determineTheme(props, theme, defaultProps);\n\n if (process.env.NODE_ENV !== 'production' && themeProp === undefined) {\n // eslint-disable-next-line no-console\n console.warn('[withTheme] You are not using a ThemeProvider nor passing a theme prop or a theme in defaultProps in component class \"' + getComponentName(Component$$1) + '\"');\n }\n\n return React.createElement(Component$$1, _extends({}, props, {\n theme: themeProp,\n ref: ref\n }));\n });\n });\n hoistNonReactStatics(WithTheme, Component$$1);\n WithTheme.displayName = 'WithTheme(' + getComponentName(Component$$1) + ')';\n return WithTheme;\n}; // \n\n/* eslint-disable */\n\n\nvar __DO_NOT_USE_OR_YOU_WILL_BE_HAUNTED_BY_SPOOKY_GHOSTS = {\n StyleSheet: StyleSheet\n}; // \n\n/* Warning if you've imported this file on React Native */\n\nif (process.env.NODE_ENV !== 'production' && typeof navigator !== 'undefined' && navigator.product === 'ReactNative') {\n // eslint-disable-next-line no-console\n console.warn(\"It looks like you've imported 'styled-components' on React Native.\\n\" + \"Perhaps you're looking to import 'styled-components/native'?\\n\" + 'Read more about this at https://www.styled-components.com/docs/basics#react-native');\n}\n/* Warning if there are several instances of styled-components */\n\n\nif (process.env.NODE_ENV !== 'production' && process.env.NODE_ENV !== 'test' && typeof window !== 'undefined' && typeof navigator !== 'undefined' && typeof navigator.userAgent === 'string' && navigator.userAgent.indexOf('Node.js') === -1 && navigator.userAgent.indexOf('jsdom') === -1) {\n window['__styled-components-init__'] = window['__styled-components-init__'] || 0;\n\n if (window['__styled-components-init__'] === 1) {\n // eslint-disable-next-line no-console\n console.warn(\"It looks like there are several instances of 'styled-components' initialized in this application. \" + 'This may cause dynamic styles not rendering properly, errors happening during rehydration process ' + 'and makes your application bigger without a good reason.\\n\\n' + 'See https://s-c.sh/2BAXzed for more info.');\n }\n\n window['__styled-components-init__'] += 1;\n} //\n\n\nexport default styled;\nexport { createGlobalStyle, css, isStyledComponent, keyframes, ServerStyleSheet, StyleSheetConsumer, StyleSheetContext, StyleSheetManager, ThemeConsumer, ThemeContext, ThemeProvider, withTheme, __DO_NOT_USE_OR_YOU_WILL_BE_HAUNTED_BY_SPOOKY_GHOSTS };","var call = require('../internals/function-call');\nvar isObject = require('../internals/is-object');\nvar isSymbol = require('../internals/is-symbol');\nvar getMethod = require('../internals/get-method');\nvar ordinaryToPrimitive = require('../internals/ordinary-to-primitive');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar $TypeError = TypeError;\nvar TO_PRIMITIVE = wellKnownSymbol('toPrimitive');\n\n// `ToPrimitive` abstract operation\n// https://tc39.es/ecma262/#sec-toprimitive\nmodule.exports = function (input, pref) {\n if (!isObject(input) || isSymbol(input)) return input;\n var exoticToPrim = getMethod(input, TO_PRIMITIVE);\n var result;\n if (exoticToPrim) {\n if (pref === undefined) pref = 'default';\n result = call(exoticToPrim, input, pref);\n if (!isObject(result) || isSymbol(result)) return result;\n throw $TypeError(\"Can't convert object to primitive value\");\n }\n if (pref === undefined) pref = 'number';\n return ordinaryToPrimitive(input, pref);\n};\n","module.exports = false;\n","var NATIVE_BIND = require('../internals/function-bind-native');\n\nvar call = Function.prototype.call;\n\nmodule.exports = NATIVE_BIND ? call.bind(call) : function () {\n return call.apply(call, arguments);\n};\n","var uncurryThis = require('../internals/function-uncurry-this');\n\nvar toString = uncurryThis({}.toString);\nvar stringSlice = uncurryThis(''.slice);\n\nmodule.exports = function (it) {\n return stringSlice(toString(it), 8, -1);\n};\n","var global = require('../internals/global');\nvar defineGlobalProperty = require('../internals/define-global-property');\n\nvar SHARED = '__core-js_shared__';\nvar store = global[SHARED] || defineGlobalProperty(SHARED, {});\n\nmodule.exports = store;\n","const plugins = require(`./api-runner-browser-plugins`)\nconst {\n getResourcesForPathname,\n getResourcesForPathnameSync,\n getResourceURLsForPathname,\n loadPage,\n loadPageSync,\n} = require(`./loader`).publicLoader\n\nexports.apiRunner = (api, args = {}, defaultReturn, argTransform) => {\n // Hooks for gatsby-cypress's API handler\n if (process.env.CYPRESS_SUPPORT) {\n if (window.___apiHandler) {\n window.___apiHandler(api)\n } else if (window.___resolvedAPIs) {\n window.___resolvedAPIs.push(api)\n } else {\n window.___resolvedAPIs = [api]\n }\n }\n\n let results = plugins.map(plugin => {\n if (!plugin.plugin[api]) {\n return undefined\n }\n\n // Deprecated April 2019. Use `loadPageSync` instead\n args.getResourcesForPathnameSync = getResourcesForPathnameSync\n // Deprecated April 2019. Use `loadPage` instead\n args.getResourcesForPathname = getResourcesForPathname\n args.getResourceURLsForPathname = getResourceURLsForPathname\n args.loadPage = loadPage\n args.loadPageSync = loadPageSync\n\n const result = plugin.plugin[api](args, plugin.options)\n if (result && argTransform) {\n args = argTransform({ args, result, plugin })\n }\n return result\n })\n\n // Filter out undefined results.\n results = results.filter(result => typeof result !== `undefined`)\n\n if (results.length > 0) {\n return results\n } else if (defaultReturn) {\n return [defaultReturn]\n } else {\n return []\n }\n}\n\nexports.apiRunnerAsync = (api, args, defaultReturn) =>\n plugins.reduce(\n (previous, next) =>\n next.plugin[api]\n ? previous.then(() => next.plugin[api](args, next.options))\n : previous,\n Promise.resolve()\n )\n","var g;\n\n// This works in non-strict mode\ng = (function() {\n\treturn this;\n})();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || new Function(\"return this\")();\n} catch (e) {\n\t// This works if the window reference is available\n\tif (typeof window === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n","var uncurryThis = require('../internals/function-uncurry-this');\nvar hasOwn = require('../internals/has-own-property');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar indexOf = require('../internals/array-includes').indexOf;\nvar hiddenKeys = require('../internals/hidden-keys');\n\nvar push = uncurryThis([].push);\n\nmodule.exports = function (object, names) {\n var O = toIndexedObject(object);\n var i = 0;\n var result = [];\n var key;\n for (key in O) !hasOwn(hiddenKeys, key) && hasOwn(O, key) && push(result, key);\n // Don't enum bug & hidden keys\n while (names.length > i) if (hasOwn(O, key = names[i++])) {\n ~indexOf(result, key) || push(result, key);\n }\n return result;\n};\n","var isCallable = require('../internals/is-callable');\nvar definePropertyModule = require('../internals/object-define-property');\nvar makeBuiltIn = require('../internals/make-built-in');\nvar defineGlobalProperty = require('../internals/define-global-property');\n\nmodule.exports = function (O, key, value, options) {\n if (!options) options = {};\n var simple = options.enumerable;\n var name = options.name !== undefined ? options.name : key;\n if (isCallable(value)) makeBuiltIn(value, name, options);\n if (options.global) {\n if (simple) O[key] = value;\n else defineGlobalProperty(key, value);\n } else {\n try {\n if (!options.unsafe) delete O[key];\n else if (O[key]) simple = true;\n } catch (error) { /* empty */ }\n if (simple) O[key] = value;\n else definePropertyModule.f(O, key, {\n value: value,\n enumerable: false,\n configurable: !options.nonConfigurable,\n writable: !options.nonWritable\n });\n } return O;\n};\n","/*!\n * VERSION: 2.0.2\n * DATE: 2018-08-27\n * UPDATES AND DOCS AT: http://greensock.com\n *\n * @license Copyright (c) 2008-2018, GreenSock. All rights reserved.\n * This work is subject to the terms at http://greensock.com/standard-license or for\n * Club GreenSock members, the software agreement that was issued with your membership.\n * \n * @author: Jack Doyle, jack@greensock.com\n **/\nimport TweenLite, { _gsScope, globals, Animation, SimpleTimeline, Ease, Power0, Power1, Power2, Power3, Power4, Linear } from \"./TweenLite.js\";\n\n_gsScope._gsDefine(\"TweenMax\", [\"core.Animation\", \"core.SimpleTimeline\", \"TweenLite\"], function () {\n var _slice = function _slice(a) {\n //don't use [].slice because that doesn't work in IE8 with a NodeList that's returned by querySelectorAll()\n var b = [],\n l = a.length,\n i;\n\n for (i = 0; i !== l; b.push(a[i++])) {\n ;\n }\n\n return b;\n },\n _applyCycle = function _applyCycle(vars, targets, i) {\n var alt = vars.cycle,\n p,\n val;\n\n for (p in alt) {\n val = alt[p];\n vars[p] = typeof val === \"function\" ? val(i, targets[i]) : val[i % val.length];\n }\n\n delete vars.cycle;\n },\n TweenMax = function TweenMax(target, duration, vars) {\n TweenLite.call(this, target, duration, vars);\n this._cycle = 0;\n this._yoyo = this.vars.yoyo === true || !!this.vars.yoyoEase;\n this._repeat = this.vars.repeat || 0;\n this._repeatDelay = this.vars.repeatDelay || 0;\n\n if (this._repeat) {\n this._uncache(true); //ensures that if there is any repeat, the totalDuration will get recalculated to accurately report it.\n\n }\n\n this.render = TweenMax.prototype.render; //speed optimization (avoid prototype lookup on this \"hot\" method)\n },\n _tinyNum = 0.0000000001,\n TweenLiteInternals = TweenLite._internals,\n _isSelector = TweenLiteInternals.isSelector,\n _isArray = TweenLiteInternals.isArray,\n p = TweenMax.prototype = TweenLite.to({}, 0.1, {}),\n _blankArray = [];\n\n TweenMax.version = \"2.0.2\";\n p.constructor = TweenMax;\n p.kill()._gc = false;\n TweenMax.killTweensOf = TweenMax.killDelayedCallsTo = TweenLite.killTweensOf;\n TweenMax.getTweensOf = TweenLite.getTweensOf;\n TweenMax.lagSmoothing = TweenLite.lagSmoothing;\n TweenMax.ticker = TweenLite.ticker;\n TweenMax.render = TweenLite.render;\n\n p.invalidate = function () {\n this._yoyo = this.vars.yoyo === true || !!this.vars.yoyoEase;\n this._repeat = this.vars.repeat || 0;\n this._repeatDelay = this.vars.repeatDelay || 0;\n this._yoyoEase = null;\n\n this._uncache(true);\n\n return TweenLite.prototype.invalidate.call(this);\n };\n\n p.updateTo = function (vars, resetDuration) {\n var curRatio = this.ratio,\n immediate = this.vars.immediateRender || vars.immediateRender,\n p;\n\n if (resetDuration && this._startTime < this._timeline._time) {\n this._startTime = this._timeline._time;\n\n this._uncache(false);\n\n if (this._gc) {\n this._enabled(true, false);\n } else {\n this._timeline.insert(this, this._startTime - this._delay); //ensures that any necessary re-sequencing of Animations in the timeline occurs to make sure the rendering order is correct.\n\n }\n }\n\n for (p in vars) {\n this.vars[p] = vars[p];\n }\n\n if (this._initted || immediate) {\n if (resetDuration) {\n this._initted = false;\n\n if (immediate) {\n this.render(0, true, true);\n }\n } else {\n if (this._gc) {\n this._enabled(true, false);\n }\n\n if (this._notifyPluginsOfEnabled && this._firstPT) {\n TweenLite._onPluginEvent(\"_onDisable\", this); //in case a plugin like MotionBlur must perform some cleanup tasks\n\n }\n\n if (this._time / this._duration > 0.998) {\n //if the tween has finished (or come extremely close to finishing), we just need to rewind it to 0 and then render it again at the end which forces it to re-initialize (parsing the new vars). We allow tweens that are close to finishing (but haven't quite finished) to work this way too because otherwise, the values are so small when determining where to project the starting values that binary math issues creep in and can make the tween appear to render incorrectly when run backwards.\n var prevTime = this._totalTime;\n this.render(0, true, false);\n this._initted = false;\n this.render(prevTime, true, false);\n } else {\n this._initted = false;\n\n this._init();\n\n if (this._time > 0 || immediate) {\n var inv = 1 / (1 - curRatio),\n pt = this._firstPT,\n endValue;\n\n while (pt) {\n endValue = pt.s + pt.c;\n pt.c *= inv;\n pt.s = endValue - pt.c;\n pt = pt._next;\n }\n }\n }\n }\n }\n\n return this;\n };\n\n p.render = function (time, suppressEvents, force) {\n if (!this._initted) if (this._duration === 0 && this.vars.repeat) {\n //zero duration tweens that render immediately have render() called from TweenLite's constructor, before TweenMax's constructor has finished setting _repeat, _repeatDelay, and _yoyo which are critical in determining totalDuration() so we need to call invalidate() which is a low-kb way to get those set properly.\n this.invalidate();\n }\n var totalDur = !this._dirty ? this._totalDuration : this.totalDuration(),\n prevTime = this._time,\n prevTotalTime = this._totalTime,\n prevCycle = this._cycle,\n duration = this._duration,\n prevRawPrevTime = this._rawPrevTime,\n isComplete,\n callback,\n pt,\n cycleDuration,\n r,\n type,\n pow,\n rawPrevTime,\n yoyoEase;\n\n if (time >= totalDur - 0.0000001 && time >= 0) {\n //to work around occasional floating point math artifacts.\n this._totalTime = totalDur;\n this._cycle = this._repeat;\n\n if (this._yoyo && (this._cycle & 1) !== 0) {\n this._time = 0;\n this.ratio = this._ease._calcEnd ? this._ease.getRatio(0) : 0;\n } else {\n this._time = duration;\n this.ratio = this._ease._calcEnd ? this._ease.getRatio(1) : 1;\n }\n\n if (!this._reversed) {\n isComplete = true;\n callback = \"onComplete\";\n force = force || this._timeline.autoRemoveChildren; //otherwise, if the animation is unpaused/activated after it's already finished, it doesn't get removed from the parent timeline.\n }\n\n if (duration === 0) if (this._initted || !this.vars.lazy || force) {\n //zero-duration tweens are tricky because we must discern the momentum/direction of time in order to determine whether the starting values should be rendered or the ending values. If the \"playhead\" of its timeline goes past the zero-duration tween in the forward direction or lands directly on it, the end values should be rendered, but if the timeline's \"playhead\" moves past it in the backward direction (from a postitive time to a negative time), the starting values must be rendered.\n if (this._startTime === this._timeline._duration) {\n //if a zero-duration tween is at the VERY end of a timeline and that timeline renders at its end, it will typically add a tiny bit of cushion to the render time to prevent rounding errors from getting in the way of tweens rendering their VERY end. If we then reverse() that timeline, the zero-duration tween will trigger its onReverseComplete even though technically the playhead didn't pass over it again. It's a very specific edge case we must accommodate.\n time = 0;\n }\n\n if (prevRawPrevTime < 0 || time <= 0 && time >= -0.0000001 || prevRawPrevTime === _tinyNum && this.data !== \"isPause\") if (prevRawPrevTime !== time) {\n //note: when this.data is \"isPause\", it's a callback added by addPause() on a timeline that we should not be triggered when LEAVING its exact start time. In other words, tl.addPause(1).play(1) shouldn't pause.\n force = true;\n\n if (prevRawPrevTime > _tinyNum) {\n callback = \"onReverseComplete\";\n }\n }\n this._rawPrevTime = rawPrevTime = !suppressEvents || time || prevRawPrevTime === time ? time : _tinyNum; //when the playhead arrives at EXACTLY time 0 (right on top) of a zero-duration tween, we need to discern if events are suppressed so that when the playhead moves again (next time), it'll trigger the callback. If events are NOT suppressed, obviously the callback would be triggered in this render. Basically, the callback should fire either when the playhead ARRIVES or LEAVES this exact spot, not both. Imagine doing a timeline.seek(0) and there's a callback that sits at 0. Since events are suppressed on that seek() by default, nothing will fire, but when the playhead moves off of that position, the callback should fire. This behavior is what people intuitively expect. We set the _rawPrevTime to be a precise tiny number to indicate this scenario rather than using another property/variable which would increase memory usage. This technique is less readable, but more efficient.\n }\n } else if (time < 0.0000001) {\n //to work around occasional floating point math artifacts, round super small values to 0.\n this._totalTime = this._time = this._cycle = 0;\n this.ratio = this._ease._calcEnd ? this._ease.getRatio(0) : 0;\n\n if (prevTotalTime !== 0 || duration === 0 && prevRawPrevTime > 0) {\n callback = \"onReverseComplete\";\n isComplete = this._reversed;\n }\n\n if (time < 0) {\n this._active = false;\n if (duration === 0) if (this._initted || !this.vars.lazy || force) {\n //zero-duration tweens are tricky because we must discern the momentum/direction of time in order to determine whether the starting values should be rendered or the ending values. If the \"playhead\" of its timeline goes past the zero-duration tween in the forward direction or lands directly on it, the end values should be rendered, but if the timeline's \"playhead\" moves past it in the backward direction (from a postitive time to a negative time), the starting values must be rendered.\n if (prevRawPrevTime >= 0) {\n force = true;\n }\n\n this._rawPrevTime = rawPrevTime = !suppressEvents || time || prevRawPrevTime === time ? time : _tinyNum; //when the playhead arrives at EXACTLY time 0 (right on top) of a zero-duration tween, we need to discern if events are suppressed so that when the playhead moves again (next time), it'll trigger the callback. If events are NOT suppressed, obviously the callback would be triggered in this render. Basically, the callback should fire either when the playhead ARRIVES or LEAVES this exact spot, not both. Imagine doing a timeline.seek(0) and there's a callback that sits at 0. Since events are suppressed on that seek() by default, nothing will fire, but when the playhead moves off of that position, the callback should fire. This behavior is what people intuitively expect. We set the _rawPrevTime to be a precise tiny number to indicate this scenario rather than using another property/variable which would increase memory usage. This technique is less readable, but more efficient.\n }\n }\n\n if (!this._initted) {\n //if we render the very beginning (time == 0) of a fromTo(), we must force the render (normal tweens wouldn't need to render at a time of 0 when the prevTime was also 0). This is also mandatory to make sure overwriting kicks in immediately.\n force = true;\n }\n } else {\n this._totalTime = this._time = time;\n\n if (this._repeat !== 0) {\n cycleDuration = duration + this._repeatDelay;\n this._cycle = this._totalTime / cycleDuration >> 0; //originally _totalTime % cycleDuration but floating point errors caused problems, so I normalized it. (4 % 0.8 should be 0 but some browsers report it as 0.79999999!)\n\n if (this._cycle !== 0) if (this._cycle === this._totalTime / cycleDuration && prevTotalTime <= time) {\n this._cycle--; //otherwise when rendered exactly at the end time, it will act as though it is repeating (at the beginning)\n }\n this._time = this._totalTime - this._cycle * cycleDuration;\n if (this._yoyo) if ((this._cycle & 1) !== 0) {\n this._time = duration - this._time;\n yoyoEase = this._yoyoEase || this.vars.yoyoEase; //note: we don't set this._yoyoEase in _init() like we do other properties because it's TweenMax-specific and doing it here allows us to optimize performance (most tweens don't have a yoyoEase). Note that we also must skip the this.ratio calculation further down right after we _init() in this function, because we're doing it here.\n\n if (yoyoEase) {\n if (!this._yoyoEase) {\n if (yoyoEase === true && !this._initted) {\n //if it's not initted and yoyoEase is true, this._ease won't have been populated yet so we must discern it here.\n yoyoEase = this.vars.ease;\n this._yoyoEase = yoyoEase = !yoyoEase ? TweenLite.defaultEase : yoyoEase instanceof Ease ? yoyoEase : typeof yoyoEase === \"function\" ? new Ease(yoyoEase, this.vars.easeParams) : Ease.map[yoyoEase] || TweenLite.defaultEase;\n } else {\n this._yoyoEase = yoyoEase = yoyoEase === true ? this._ease : yoyoEase instanceof Ease ? yoyoEase : Ease.map[yoyoEase];\n }\n }\n\n this.ratio = yoyoEase ? 1 - yoyoEase.getRatio((duration - this._time) / duration) : 0;\n }\n }\n\n if (this._time > duration) {\n this._time = duration;\n } else if (this._time < 0) {\n this._time = 0;\n }\n }\n\n if (this._easeType && !yoyoEase) {\n r = this._time / duration;\n type = this._easeType;\n pow = this._easePower;\n\n if (type === 1 || type === 3 && r >= 0.5) {\n r = 1 - r;\n }\n\n if (type === 3) {\n r *= 2;\n }\n\n if (pow === 1) {\n r *= r;\n } else if (pow === 2) {\n r *= r * r;\n } else if (pow === 3) {\n r *= r * r * r;\n } else if (pow === 4) {\n r *= r * r * r * r;\n }\n\n if (type === 1) {\n this.ratio = 1 - r;\n } else if (type === 2) {\n this.ratio = r;\n } else if (this._time / duration < 0.5) {\n this.ratio = r / 2;\n } else {\n this.ratio = 1 - r / 2;\n }\n } else if (!yoyoEase) {\n this.ratio = this._ease.getRatio(this._time / duration);\n }\n }\n\n if (prevTime === this._time && !force && prevCycle === this._cycle) {\n if (prevTotalTime !== this._totalTime) if (this._onUpdate) if (!suppressEvents) {\n //so that onUpdate fires even during the repeatDelay - as long as the totalTime changed, we should trigger onUpdate.\n this._callback(\"onUpdate\");\n }\n return;\n } else if (!this._initted) {\n this._init();\n\n if (!this._initted || this._gc) {\n //immediateRender tweens typically won't initialize until the playhead advances (_time is greater than 0) in order to ensure that overwriting occurs properly. Also, if all of the tweening properties have been overwritten (which would cause _gc to be true, as set in _init()), we shouldn't continue otherwise an onStart callback could be called for example.\n return;\n } else if (!force && this._firstPT && (this.vars.lazy !== false && this._duration || this.vars.lazy && !this._duration)) {\n //we stick it in the queue for rendering at the very end of the tick - this is a performance optimization because browsers invalidate styles and force a recalculation if you read, write, and then read style data (so it's better to read/read/read/write/write/write than read/write/read/write/read/write). The down side, of course, is that usually you WANT things to render immediately because you may have code running right after that which depends on the change. Like imagine running TweenLite.set(...) and then immediately after that, creating a nother tween that animates the same property to another value; the starting values of that 2nd tween wouldn't be accurate if lazy is true.\n this._time = prevTime;\n this._totalTime = prevTotalTime;\n this._rawPrevTime = prevRawPrevTime;\n this._cycle = prevCycle;\n TweenLiteInternals.lazyTweens.push(this);\n this._lazy = [time, suppressEvents];\n return;\n } //_ease is initially set to defaultEase, so now that init() has run, _ease is set properly and we need to recalculate the ratio. Overall this is faster than using conditional logic earlier in the method to avoid having to set ratio twice because we only init() once but renderTime() gets called VERY frequently.\n\n\n if (this._time && !isComplete && !yoyoEase) {\n this.ratio = this._ease.getRatio(this._time / duration);\n } else if (isComplete && this._ease._calcEnd && !yoyoEase) {\n this.ratio = this._ease.getRatio(this._time === 0 ? 0 : 1);\n }\n }\n\n if (this._lazy !== false) {\n this._lazy = false;\n }\n\n if (!this._active) if (!this._paused && this._time !== prevTime && time >= 0) {\n this._active = true; //so that if the user renders a tween (as opposed to the timeline rendering it), the timeline is forced to re-render and align it with the proper time/frame on the next rendering cycle. Maybe the tween already finished but the user manually re-renders it as halfway done.\n }\n\n if (prevTotalTime === 0) {\n if (this._initted === 2 && time > 0) {\n //this.invalidate();\n this._init(); //will just apply overwriting since _initted of (2) means it was a from() tween that had immediateRender:true\n\n }\n\n if (this._startAt) {\n if (time >= 0) {\n this._startAt.render(time, true, force);\n } else if (!callback) {\n callback = \"_dummyGS\"; //if no callback is defined, use a dummy value just so that the condition at the end evaluates as true because _startAt should render AFTER the normal render loop when the time is negative. We could handle this in a more intuitive way, of course, but the render loop is the MOST important thing to optimize, so this technique allows us to avoid adding extra conditional logic in a high-frequency area.\n }\n }\n\n if (this.vars.onStart) if (this._totalTime !== 0 || duration === 0) if (!suppressEvents) {\n this._callback(\"onStart\");\n }\n }\n\n pt = this._firstPT;\n\n while (pt) {\n if (pt.f) {\n pt.t[pt.p](pt.c * this.ratio + pt.s);\n } else {\n pt.t[pt.p] = pt.c * this.ratio + pt.s;\n }\n\n pt = pt._next;\n }\n\n if (this._onUpdate) {\n if (time < 0) if (this._startAt && this._startTime) {\n //if the tween is positioned at the VERY beginning (_startTime 0) of its parent timeline, it's illegal for the playhead to go back further, so we should not render the recorded startAt values.\n this._startAt.render(time, true, force); //note: for performance reasons, we tuck this conditional logic inside less traveled areas (most tweens don't have an onUpdate). We'd just have it at the end before the onComplete, but the values should be updated before any onUpdate is called, so we ALSO put it here and then if it's not called, we do so later near the onComplete.\n\n }\n if (!suppressEvents) if (this._totalTime !== prevTotalTime || callback) {\n this._callback(\"onUpdate\");\n }\n }\n\n if (this._cycle !== prevCycle) if (!suppressEvents) if (!this._gc) if (this.vars.onRepeat) {\n this._callback(\"onRepeat\");\n }\n if (callback) if (!this._gc || force) {\n //check gc because there's a chance that kill() could be called in an onUpdate\n if (time < 0 && this._startAt && !this._onUpdate && this._startTime) {\n //if the tween is positioned at the VERY beginning (_startTime 0) of its parent timeline, it's illegal for the playhead to go back further, so we should not render the recorded startAt values.\n this._startAt.render(time, true, force);\n }\n\n if (isComplete) {\n if (this._timeline.autoRemoveChildren) {\n this._enabled(false, false);\n }\n\n this._active = false;\n }\n\n if (!suppressEvents && this.vars[callback]) {\n this._callback(callback);\n }\n\n if (duration === 0 && this._rawPrevTime === _tinyNum && rawPrevTime !== _tinyNum) {\n //the onComplete or onReverseComplete could trigger movement of the playhead and for zero-duration tweens (which must discern direction) that land directly back on their start time, we don't want to fire again on the next render. Think of several addPause()'s in a timeline that forces the playhead to a certain spot, but what if it's already paused and another tween is tweening the \"time\" of the timeline? Each time it moves [forward] past that spot, it would move back, and since suppressEvents is true, it'd reset _rawPrevTime to _tinyNum so that when it begins again, the callback would fire (so ultimately it could bounce back and forth during that tween). Again, this is a very uncommon scenario, but possible nonetheless.\n this._rawPrevTime = 0;\n }\n }\n }; //---- STATIC FUNCTIONS -----------------------------------------------------------------------------------------------------------\n\n\n TweenMax.to = function (target, duration, vars) {\n return new TweenMax(target, duration, vars);\n };\n\n TweenMax.from = function (target, duration, vars) {\n vars.runBackwards = true;\n vars.immediateRender = vars.immediateRender != false;\n return new TweenMax(target, duration, vars);\n };\n\n TweenMax.fromTo = function (target, duration, fromVars, toVars) {\n toVars.startAt = fromVars;\n toVars.immediateRender = toVars.immediateRender != false && fromVars.immediateRender != false;\n return new TweenMax(target, duration, toVars);\n };\n\n TweenMax.staggerTo = TweenMax.allTo = function (targets, duration, vars, stagger, onCompleteAll, onCompleteAllParams, onCompleteAllScope) {\n stagger = stagger || 0;\n\n var delay = 0,\n a = [],\n finalComplete = function finalComplete() {\n if (vars.onComplete) {\n vars.onComplete.apply(vars.onCompleteScope || this, arguments);\n }\n\n onCompleteAll.apply(onCompleteAllScope || vars.callbackScope || this, onCompleteAllParams || _blankArray);\n },\n cycle = vars.cycle,\n fromCycle = vars.startAt && vars.startAt.cycle,\n l,\n copy,\n i,\n p;\n\n if (!_isArray(targets)) {\n if (typeof targets === \"string\") {\n targets = TweenLite.selector(targets) || targets;\n }\n\n if (_isSelector(targets)) {\n targets = _slice(targets);\n }\n }\n\n targets = targets || [];\n\n if (stagger < 0) {\n targets = _slice(targets);\n targets.reverse();\n stagger *= -1;\n }\n\n l = targets.length - 1;\n\n for (i = 0; i <= l; i++) {\n copy = {};\n\n for (p in vars) {\n copy[p] = vars[p];\n }\n\n if (cycle) {\n _applyCycle(copy, targets, i);\n\n if (copy.duration != null) {\n duration = copy.duration;\n delete copy.duration;\n }\n }\n\n if (fromCycle) {\n fromCycle = copy.startAt = {};\n\n for (p in vars.startAt) {\n fromCycle[p] = vars.startAt[p];\n }\n\n _applyCycle(copy.startAt, targets, i);\n }\n\n copy.delay = delay + (copy.delay || 0);\n\n if (i === l && onCompleteAll) {\n copy.onComplete = finalComplete;\n }\n\n a[i] = new TweenMax(targets[i], duration, copy);\n delay += stagger;\n }\n\n return a;\n };\n\n TweenMax.staggerFrom = TweenMax.allFrom = function (targets, duration, vars, stagger, onCompleteAll, onCompleteAllParams, onCompleteAllScope) {\n vars.runBackwards = true;\n vars.immediateRender = vars.immediateRender != false;\n return TweenMax.staggerTo(targets, duration, vars, stagger, onCompleteAll, onCompleteAllParams, onCompleteAllScope);\n };\n\n TweenMax.staggerFromTo = TweenMax.allFromTo = function (targets, duration, fromVars, toVars, stagger, onCompleteAll, onCompleteAllParams, onCompleteAllScope) {\n toVars.startAt = fromVars;\n toVars.immediateRender = toVars.immediateRender != false && fromVars.immediateRender != false;\n return TweenMax.staggerTo(targets, duration, toVars, stagger, onCompleteAll, onCompleteAllParams, onCompleteAllScope);\n };\n\n TweenMax.delayedCall = function (delay, callback, params, scope, useFrames) {\n return new TweenMax(callback, 0, {\n delay: delay,\n onComplete: callback,\n onCompleteParams: params,\n callbackScope: scope,\n onReverseComplete: callback,\n onReverseCompleteParams: params,\n immediateRender: false,\n useFrames: useFrames,\n overwrite: 0\n });\n };\n\n TweenMax.set = function (target, vars) {\n return new TweenMax(target, 0, vars);\n };\n\n TweenMax.isTweening = function (target) {\n return TweenLite.getTweensOf(target, true).length > 0;\n };\n\n var _getChildrenOf = function _getChildrenOf(timeline, includeTimelines) {\n var a = [],\n cnt = 0,\n tween = timeline._first;\n\n while (tween) {\n if (tween instanceof TweenLite) {\n a[cnt++] = tween;\n } else {\n if (includeTimelines) {\n a[cnt++] = tween;\n }\n\n a = a.concat(_getChildrenOf(tween, includeTimelines));\n cnt = a.length;\n }\n\n tween = tween._next;\n }\n\n return a;\n },\n getAllTweens = TweenMax.getAllTweens = function (includeTimelines) {\n return _getChildrenOf(Animation._rootTimeline, includeTimelines).concat(_getChildrenOf(Animation._rootFramesTimeline, includeTimelines));\n };\n\n TweenMax.killAll = function (complete, tweens, delayedCalls, timelines) {\n if (tweens == null) {\n tweens = true;\n }\n\n if (delayedCalls == null) {\n delayedCalls = true;\n }\n\n var a = getAllTweens(timelines != false),\n l = a.length,\n allTrue = tweens && delayedCalls && timelines,\n isDC,\n tween,\n i;\n\n for (i = 0; i < l; i++) {\n tween = a[i];\n\n if (allTrue || tween instanceof SimpleTimeline || (isDC = tween.target === tween.vars.onComplete) && delayedCalls || tweens && !isDC) {\n if (complete) {\n tween.totalTime(tween._reversed ? 0 : tween.totalDuration());\n } else {\n tween._enabled(false, false);\n }\n }\n }\n };\n\n TweenMax.killChildTweensOf = function (parent, complete) {\n if (parent == null) {\n return;\n }\n\n var tl = TweenLiteInternals.tweenLookup,\n a,\n curParent,\n p,\n i,\n l;\n\n if (typeof parent === \"string\") {\n parent = TweenLite.selector(parent) || parent;\n }\n\n if (_isSelector(parent)) {\n parent = _slice(parent);\n }\n\n if (_isArray(parent)) {\n i = parent.length;\n\n while (--i > -1) {\n TweenMax.killChildTweensOf(parent[i], complete);\n }\n\n return;\n }\n\n a = [];\n\n for (p in tl) {\n curParent = tl[p].target.parentNode;\n\n while (curParent) {\n if (curParent === parent) {\n a = a.concat(tl[p].tweens);\n }\n\n curParent = curParent.parentNode;\n }\n }\n\n l = a.length;\n\n for (i = 0; i < l; i++) {\n if (complete) {\n a[i].totalTime(a[i].totalDuration());\n }\n\n a[i]._enabled(false, false);\n }\n };\n\n var _changePause = function _changePause(pause, tweens, delayedCalls, timelines) {\n tweens = tweens !== false;\n delayedCalls = delayedCalls !== false;\n timelines = timelines !== false;\n var a = getAllTweens(timelines),\n allTrue = tweens && delayedCalls && timelines,\n i = a.length,\n isDC,\n tween;\n\n while (--i > -1) {\n tween = a[i];\n\n if (allTrue || tween instanceof SimpleTimeline || (isDC = tween.target === tween.vars.onComplete) && delayedCalls || tweens && !isDC) {\n tween.paused(pause);\n }\n }\n };\n\n TweenMax.pauseAll = function (tweens, delayedCalls, timelines) {\n _changePause(true, tweens, delayedCalls, timelines);\n };\n\n TweenMax.resumeAll = function (tweens, delayedCalls, timelines) {\n _changePause(false, tweens, delayedCalls, timelines);\n };\n\n TweenMax.globalTimeScale = function (value) {\n var tl = Animation._rootTimeline,\n t = TweenLite.ticker.time;\n\n if (!arguments.length) {\n return tl._timeScale;\n }\n\n value = value || _tinyNum; //can't allow zero because it'll throw the math off\n\n tl._startTime = t - (t - tl._startTime) * tl._timeScale / value;\n tl = Animation._rootFramesTimeline;\n t = TweenLite.ticker.frame;\n tl._startTime = t - (t - tl._startTime) * tl._timeScale / value;\n tl._timeScale = Animation._rootTimeline._timeScale = value;\n return value;\n }; //---- GETTERS / SETTERS ----------------------------------------------------------------------------------------------------------\n\n\n p.progress = function (value, suppressEvents) {\n return !arguments.length ? this._time / this.duration() : this.totalTime(this.duration() * (this._yoyo && (this._cycle & 1) !== 0 ? 1 - value : value) + this._cycle * (this._duration + this._repeatDelay), suppressEvents);\n };\n\n p.totalProgress = function (value, suppressEvents) {\n return !arguments.length ? this._totalTime / this.totalDuration() : this.totalTime(this.totalDuration() * value, suppressEvents);\n };\n\n p.time = function (value, suppressEvents) {\n if (!arguments.length) {\n return this._time;\n }\n\n if (this._dirty) {\n this.totalDuration();\n }\n\n if (value > this._duration) {\n value = this._duration;\n }\n\n if (this._yoyo && (this._cycle & 1) !== 0) {\n value = this._duration - value + this._cycle * (this._duration + this._repeatDelay);\n } else if (this._repeat !== 0) {\n value += this._cycle * (this._duration + this._repeatDelay);\n }\n\n return this.totalTime(value, suppressEvents);\n };\n\n p.duration = function (value) {\n if (!arguments.length) {\n return this._duration; //don't set _dirty = false because there could be repeats that haven't been factored into the _totalDuration yet. Otherwise, if you create a repeated TweenMax and then immediately check its duration(), it would cache the value and the totalDuration would not be correct, thus repeats wouldn't take effect.\n }\n\n return Animation.prototype.duration.call(this, value);\n };\n\n p.totalDuration = function (value) {\n if (!arguments.length) {\n if (this._dirty) {\n //instead of Infinity, we use 999999999999 so that we can accommodate reverses\n this._totalDuration = this._repeat === -1 ? 999999999999 : this._duration * (this._repeat + 1) + this._repeatDelay * this._repeat;\n this._dirty = false;\n }\n\n return this._totalDuration;\n }\n\n return this._repeat === -1 ? this : this.duration((value - this._repeat * this._repeatDelay) / (this._repeat + 1));\n };\n\n p.repeat = function (value) {\n if (!arguments.length) {\n return this._repeat;\n }\n\n this._repeat = value;\n return this._uncache(true);\n };\n\n p.repeatDelay = function (value) {\n if (!arguments.length) {\n return this._repeatDelay;\n }\n\n this._repeatDelay = value;\n return this._uncache(true);\n };\n\n p.yoyo = function (value) {\n if (!arguments.length) {\n return this._yoyo;\n }\n\n this._yoyo = value;\n return this;\n };\n\n return TweenMax;\n}, true);\n\nexport var TweenMax = globals.TweenMax;\nexport var TweenMaxBase = TweenMax;\nexport { TweenMax as default };\nexport { TweenLite, Ease, Power0, Power1, Power2, Power3, Power4, Linear };","/*!\n * VERSION: 0.6.1\n * DATE: 2018-08-27\n * UPDATES AND DOCS AT: http://greensock.com\n *\n * @license Copyright (c) 2008-2018, GreenSock. All rights reserved.\n * This work is subject to the terms at http://greensock.com/standard-license or for\n * Club GreenSock members, the software agreement that was issued with your membership.\n * \n * @author: Jack Doyle, jack@greensock.com\n */\nimport { _gsScope } from \"./TweenLite.js\";\nexport var AttrPlugin = _gsScope._gsDefine.plugin({\n propName: \"attr\",\n API: 2,\n version: \"0.6.1\",\n //called when the tween renders for the first time. This is where initial values should be recorded and any setup routines should run.\n init: function init(target, value, tween, index) {\n var p, end;\n\n if (typeof target.setAttribute !== \"function\") {\n return false;\n }\n\n for (p in value) {\n end = value[p];\n\n if (typeof end === \"function\") {\n end = end(index, target);\n }\n\n this._addTween(target, \"setAttribute\", target.getAttribute(p) + \"\", end + \"\", p, false, p);\n\n this._overwriteProps.push(p);\n }\n\n return true;\n }\n});\nexport { AttrPlugin as default };","/*!\n * VERSION: 1.6.0\n * DATE: 2018-08-27\n * UPDATES AND DOCS AT: http://greensock.com\n *\n * @license Copyright (c) 2008-2018, GreenSock. All rights reserved.\n * This work is subject to the terms at http://greensock.com/standard-license or for\n * Club GreenSock members, the software agreement that was issued with your membership.\n * \n * @author: Jack Doyle, jack@greensock.com\n **/\nimport { _gsScope } from \"./TweenLite.js\";\nexport var RoundPropsPlugin = _gsScope._gsDefine.plugin({\n propName: \"roundProps\",\n version: \"1.7.0\",\n priority: -1,\n API: 2,\n //called when the tween renders for the first time. This is where initial values should be recorded and any setup routines should run.\n init: function init(target, value, tween) {\n this._tween = tween;\n return true;\n }\n}),\n _getRoundFunc = function _getRoundFunc(v) {\n //pass in 0.1 get a function that'll round to the nearest tenth, or 5 to round to the closest 5, or 0.001 to the closest 1000th, etc.\n var p = v < 1 ? Math.pow(10, (v + \"\").length - 2) : 1; //to avoid floating point math errors (like 24 * 0.1 == 2.4000000000000004), we chop off at a specific number of decimal places (much faster than toFixed()\n\n return function (n) {\n return (Math.round(n / v) * v * p | 0) / p;\n };\n},\n _roundLinkedList = function _roundLinkedList(node, mod) {\n while (node) {\n if (!node.f && !node.blob) {\n node.m = mod || Math.round;\n }\n\n node = node._next;\n }\n},\n p = RoundPropsPlugin.prototype;\n\np._onInitAllProps = function () {\n var tween = this._tween,\n rp = tween.vars.roundProps,\n lookup = {},\n rpt = tween._propLookup.roundProps,\n pt,\n next,\n i,\n p;\n\n if (typeof rp === \"object\" && !rp.push) {\n for (p in rp) {\n lookup[p] = _getRoundFunc(rp[p]);\n }\n } else {\n if (typeof rp === \"string\") {\n rp = rp.split(\",\");\n }\n\n i = rp.length;\n\n while (--i > -1) {\n lookup[rp[i]] = Math.round;\n }\n }\n\n for (p in lookup) {\n pt = tween._firstPT;\n\n while (pt) {\n next = pt._next; //record here, because it may get removed\n\n if (pt.pg) {\n pt.t._mod(lookup);\n } else if (pt.n === p) {\n if (pt.f === 2 && pt.t) {\n //a blob (text containing multiple numeric values)\n _roundLinkedList(pt.t._firstPT, lookup[p]);\n } else {\n this._add(pt.t, p, pt.s, pt.c, lookup[p]); //remove from linked list\n\n\n if (next) {\n next._prev = pt._prev;\n }\n\n if (pt._prev) {\n pt._prev._next = next;\n } else if (tween._firstPT === pt) {\n tween._firstPT = next;\n }\n\n pt._next = pt._prev = null;\n tween._propLookup[p] = rpt;\n }\n }\n\n pt = next;\n }\n }\n\n return false;\n};\n\np._add = function (target, p, s, c, mod) {\n this._addTween(target, p, s, s + c, p, mod || Math.round);\n\n this._overwriteProps.push(p);\n};\n\nexport { RoundPropsPlugin as default };","/*!\n * VERSION: 0.3.1\n * DATE: 2018-08-27\n * UPDATES AND DOCS AT: http://greensock.com\n *\n * @license Copyright (c) 2008-2018, GreenSock. All rights reserved.\n * This work is subject to the terms at http://greensock.com/standard-license or for\n * Club GreenSock members, the software agreement that was issued with your membership.\n * \n * @author: Jack Doyle, jack@greensock.com\n **/\nimport { _gsScope } from \"./TweenLite.js\";\nexport var DirectionalRotationPlugin = _gsScope._gsDefine.plugin({\n propName: \"directionalRotation\",\n version: \"0.3.1\",\n API: 2,\n //called when the tween renders for the first time. This is where initial values should be recorded and any setup routines should run.\n init: function init(target, value, tween, index) {\n if (typeof value !== \"object\") {\n value = {\n rotation: value\n };\n }\n\n this.finals = {};\n var cap = value.useRadians === true ? Math.PI * 2 : 360,\n min = 0.000001,\n p,\n v,\n start,\n end,\n dif,\n split;\n\n for (p in value) {\n if (p !== \"useRadians\") {\n end = value[p];\n\n if (typeof end === \"function\") {\n end = end(index, target);\n }\n\n split = (end + \"\").split(\"_\");\n v = split[0];\n start = parseFloat(typeof target[p] !== \"function\" ? target[p] : target[p.indexOf(\"set\") || typeof target[\"get\" + p.substr(3)] !== \"function\" ? p : \"get\" + p.substr(3)]());\n end = this.finals[p] = typeof v === \"string\" && v.charAt(1) === \"=\" ? start + parseInt(v.charAt(0) + \"1\", 10) * Number(v.substr(2)) : Number(v) || 0;\n dif = end - start;\n\n if (split.length) {\n v = split.join(\"_\");\n\n if (v.indexOf(\"short\") !== -1) {\n dif = dif % cap;\n\n if (dif !== dif % (cap / 2)) {\n dif = dif < 0 ? dif + cap : dif - cap;\n }\n }\n\n if (v.indexOf(\"_cw\") !== -1 && dif < 0) {\n dif = (dif + cap * 9999999999) % cap - (dif / cap | 0) * cap;\n } else if (v.indexOf(\"ccw\") !== -1 && dif > 0) {\n dif = (dif - cap * 9999999999) % cap - (dif / cap | 0) * cap;\n }\n }\n\n if (dif > min || dif < -min) {\n this._addTween(target, p, start, start + dif, p);\n\n this._overwriteProps.push(p);\n }\n }\n }\n\n return true;\n },\n //called each time the values should be updated, and the ratio gets passed as the only parameter (typically it's a value between 0 and 1, but it can exceed those when using an ease like Elastic.easeOut or Back.easeOut, etc.)\n set: function set(ratio) {\n var pt;\n\n if (ratio !== 1) {\n this._super.setRatio.call(this, ratio);\n } else {\n pt = this._firstPT;\n\n while (pt) {\n if (pt.f) {\n pt.t[pt.p](this.finals[pt.p]);\n } else {\n pt.t[pt.p] = this.finals[pt.p];\n }\n\n pt = pt._next;\n }\n }\n }\n});\nDirectionalRotationPlugin._autoCSS = true;\nexport { DirectionalRotationPlugin as default };","/*!\n * VERSION: 2.0.2\n * DATE: 2018-08-27\n * UPDATES AND DOCS AT: http://greensock.com\n *\n * @license Copyright (c) 2008-2018, GreenSock. All rights reserved.\n * This work is subject to the terms at http://greensock.com/standard-license or for\n * Club GreenSock members, the software agreement that was issued with your membership.\n * \n * @author: Jack Doyle, jack@greensock.com\n */\nimport TweenLite, { _gsScope, globals, Animation, SimpleTimeline } from \"./TweenLite.js\";\n\n_gsScope._gsDefine(\"TimelineLite\", [\"core.Animation\", \"core.SimpleTimeline\", \"TweenLite\"], function () {\n var TimelineLite = function TimelineLite(vars) {\n SimpleTimeline.call(this, vars);\n this._labels = {};\n this.autoRemoveChildren = this.vars.autoRemoveChildren === true;\n this.smoothChildTiming = this.vars.smoothChildTiming === true;\n this._sortChildren = true;\n this._onUpdate = this.vars.onUpdate;\n var v = this.vars,\n val,\n p;\n\n for (p in v) {\n val = v[p];\n if (_isArray(val)) if (val.join(\"\").indexOf(\"{self}\") !== -1) {\n v[p] = this._swapSelfInParams(val);\n }\n }\n\n if (_isArray(v.tweens)) {\n this.add(v.tweens, 0, v.align, v.stagger);\n }\n },\n _tinyNum = 0.0000000001,\n TweenLiteInternals = TweenLite._internals,\n _internals = TimelineLite._internals = {},\n _isSelector = TweenLiteInternals.isSelector,\n _isArray = TweenLiteInternals.isArray,\n _lazyTweens = TweenLiteInternals.lazyTweens,\n _lazyRender = TweenLiteInternals.lazyRender,\n _globals = _gsScope._gsDefine.globals,\n _copy = function _copy(vars) {\n var copy = {},\n p;\n\n for (p in vars) {\n copy[p] = vars[p];\n }\n\n return copy;\n },\n _applyCycle = function _applyCycle(vars, targets, i) {\n var alt = vars.cycle,\n p,\n val;\n\n for (p in alt) {\n val = alt[p];\n vars[p] = typeof val === \"function\" ? val(i, targets[i]) : val[i % val.length];\n }\n\n delete vars.cycle;\n },\n _pauseCallback = _internals.pauseCallback = function () {},\n _slice = function _slice(a) {\n //don't use [].slice because that doesn't work in IE8 with a NodeList that's returned by querySelectorAll()\n var b = [],\n l = a.length,\n i;\n\n for (i = 0; i !== l; b.push(a[i++])) {\n ;\n }\n\n return b;\n },\n p = TimelineLite.prototype = new SimpleTimeline();\n\n TimelineLite.version = \"2.0.2\";\n p.constructor = TimelineLite;\n p.kill()._gc = p._forcingPlayhead = p._hasPause = false;\n /* might use later...\n //translates a local time inside an animation to the corresponding time on the root/global timeline, factoring in all nesting and timeScales.\n function localToGlobal(time, animation) {\n \twhile (animation) {\n \t\ttime = (time / animation._timeScale) + animation._startTime;\n \t\tanimation = animation.timeline;\n \t}\n \treturn time;\n }\n \t//translates the supplied time on the root/global timeline into the corresponding local time inside a particular animation, factoring in all nesting and timeScales\n function globalToLocal(time, animation) {\n \tvar scale = 1;\n \ttime -= localToGlobal(0, animation);\n \twhile (animation) {\n \t\tscale *= animation._timeScale;\n \t\tanimation = animation.timeline;\n \t}\n \treturn time * scale;\n }\n */\n\n p.to = function (target, duration, vars, position) {\n var Engine = vars.repeat && _globals.TweenMax || TweenLite;\n return duration ? this.add(new Engine(target, duration, vars), position) : this.set(target, vars, position);\n };\n\n p.from = function (target, duration, vars, position) {\n return this.add((vars.repeat && _globals.TweenMax || TweenLite).from(target, duration, vars), position);\n };\n\n p.fromTo = function (target, duration, fromVars, toVars, position) {\n var Engine = toVars.repeat && _globals.TweenMax || TweenLite;\n return duration ? this.add(Engine.fromTo(target, duration, fromVars, toVars), position) : this.set(target, toVars, position);\n };\n\n p.staggerTo = function (targets, duration, vars, stagger, position, onCompleteAll, onCompleteAllParams, onCompleteAllScope) {\n var tl = new TimelineLite({\n onComplete: onCompleteAll,\n onCompleteParams: onCompleteAllParams,\n callbackScope: onCompleteAllScope,\n smoothChildTiming: this.smoothChildTiming\n }),\n cycle = vars.cycle,\n copy,\n i;\n\n if (typeof targets === \"string\") {\n targets = TweenLite.selector(targets) || targets;\n }\n\n targets = targets || [];\n\n if (_isSelector(targets)) {\n //senses if the targets object is a selector. If it is, we should translate it into an array.\n targets = _slice(targets);\n }\n\n stagger = stagger || 0;\n\n if (stagger < 0) {\n targets = _slice(targets);\n targets.reverse();\n stagger *= -1;\n }\n\n for (i = 0; i < targets.length; i++) {\n copy = _copy(vars);\n\n if (copy.startAt) {\n copy.startAt = _copy(copy.startAt);\n\n if (copy.startAt.cycle) {\n _applyCycle(copy.startAt, targets, i);\n }\n }\n\n if (cycle) {\n _applyCycle(copy, targets, i);\n\n if (copy.duration != null) {\n duration = copy.duration;\n delete copy.duration;\n }\n }\n\n tl.to(targets[i], duration, copy, i * stagger);\n }\n\n return this.add(tl, position);\n };\n\n p.staggerFrom = function (targets, duration, vars, stagger, position, onCompleteAll, onCompleteAllParams, onCompleteAllScope) {\n vars.immediateRender = vars.immediateRender != false;\n vars.runBackwards = true;\n return this.staggerTo(targets, duration, vars, stagger, position, onCompleteAll, onCompleteAllParams, onCompleteAllScope);\n };\n\n p.staggerFromTo = function (targets, duration, fromVars, toVars, stagger, position, onCompleteAll, onCompleteAllParams, onCompleteAllScope) {\n toVars.startAt = fromVars;\n toVars.immediateRender = toVars.immediateRender != false && fromVars.immediateRender != false;\n return this.staggerTo(targets, duration, toVars, stagger, position, onCompleteAll, onCompleteAllParams, onCompleteAllScope);\n };\n\n p.call = function (callback, params, scope, position) {\n return this.add(TweenLite.delayedCall(0, callback, params, scope), position);\n };\n\n p.set = function (target, vars, position) {\n position = this._parseTimeOrLabel(position, 0, true);\n\n if (vars.immediateRender == null) {\n vars.immediateRender = position === this._time && !this._paused;\n }\n\n return this.add(new TweenLite(target, 0, vars), position);\n };\n\n TimelineLite.exportRoot = function (vars, ignoreDelayedCalls) {\n vars = vars || {};\n\n if (vars.smoothChildTiming == null) {\n vars.smoothChildTiming = true;\n }\n\n var tl = new TimelineLite(vars),\n root = tl._timeline,\n hasNegativeStart,\n time,\n tween,\n next;\n\n if (ignoreDelayedCalls == null) {\n ignoreDelayedCalls = true;\n }\n\n root._remove(tl, true);\n\n tl._startTime = 0;\n tl._rawPrevTime = tl._time = tl._totalTime = root._time;\n tween = root._first;\n\n while (tween) {\n next = tween._next;\n\n if (!ignoreDelayedCalls || !(tween instanceof TweenLite && tween.target === tween.vars.onComplete)) {\n time = tween._startTime - tween._delay;\n\n if (time < 0) {\n hasNegativeStart = 1;\n }\n\n tl.add(tween, time);\n }\n\n tween = next;\n }\n\n root.add(tl, 0);\n\n if (hasNegativeStart) {\n //calling totalDuration() will force the adjustment necessary to shift the children forward so none of them start before zero, and moves the timeline backwards the same amount, so the playhead is still aligned where it should be globally, but the timeline doesn't have illegal children that start before zero.\n tl.totalDuration();\n }\n\n return tl;\n };\n\n p.add = function (value, position, align, stagger) {\n var curTime, l, i, child, tl, beforeRawTime;\n\n if (typeof position !== \"number\") {\n position = this._parseTimeOrLabel(position, 0, true, value);\n }\n\n if (!(value instanceof Animation)) {\n if (value instanceof Array || value && value.push && _isArray(value)) {\n align = align || \"normal\";\n stagger = stagger || 0;\n curTime = position;\n l = value.length;\n\n for (i = 0; i < l; i++) {\n if (_isArray(child = value[i])) {\n child = new TimelineLite({\n tweens: child\n });\n }\n\n this.add(child, curTime);\n\n if (typeof child !== \"string\" && typeof child !== \"function\") {\n if (align === \"sequence\") {\n curTime = child._startTime + child.totalDuration() / child._timeScale;\n } else if (align === \"start\") {\n child._startTime -= child.delay();\n }\n }\n\n curTime += stagger;\n }\n\n return this._uncache(true);\n } else if (typeof value === \"string\") {\n return this.addLabel(value, position);\n } else if (typeof value === \"function\") {\n value = TweenLite.delayedCall(0, value);\n } else {\n throw \"Cannot add \" + value + \" into the timeline; it is not a tween, timeline, function, or string.\";\n }\n }\n\n SimpleTimeline.prototype.add.call(this, value, position);\n\n if (value._time) {\n //in case, for example, the _startTime is moved on a tween that has already rendered. Imagine it's at its end state, then the startTime is moved WAY later (after the end of this timeline), it should render at its beginning.\n curTime = Math.max(0, Math.min(value.totalDuration(), (this.rawTime() - value._startTime) * value._timeScale));\n\n if (Math.abs(curTime - value._totalTime) > 0.00001) {\n //if an onComplete restarts the tween in a nested timeline, for example, there could be an endless loop without this logic (v2.0.2), like var masterTL = new TimelineMax({autoRemoveChildren: true}), tl = new TimelineMax(); tl.eventCallback(\"onComplete\", function() { tl.restart() } );tl.fromTo('div', 1.1, { rotation: 0 }, { rotation: 360 }, 0);masterTL.add(tl);\n value.render(curTime, false, false);\n }\n } //if the timeline has already ended but the inserted tween/timeline extends the duration, we should enable this timeline again so that it renders properly. We should also align the playhead with the parent timeline's when appropriate.\n\n\n if (this._gc || this._time === this._duration) if (!this._paused) if (this._duration < this.duration()) {\n //in case any of the ancestors had completed but should now be enabled...\n tl = this;\n beforeRawTime = tl.rawTime() > value._startTime; //if the tween is placed on the timeline so that it starts BEFORE the current rawTime, we should align the playhead (move the timeline). This is because sometimes users will create a timeline, let it finish, and much later append a tween and expect it to run instead of jumping to its end state. While technically one could argue that it should jump to its end state, that's not what users intuitively expect.\n\n while (tl._timeline) {\n if (beforeRawTime && tl._timeline.smoothChildTiming) {\n tl.totalTime(tl._totalTime, true); //moves the timeline (shifts its startTime) if necessary, and also enables it.\n } else if (tl._gc) {\n tl._enabled(true, false);\n }\n\n tl = tl._timeline;\n }\n }\n return this;\n };\n\n p.remove = function (value) {\n if (value instanceof Animation) {\n this._remove(value, false);\n\n var tl = value._timeline = value.vars.useFrames ? Animation._rootFramesTimeline : Animation._rootTimeline; //now that it's removed, default it to the root timeline so that if it gets played again, it doesn't jump back into this timeline.\n\n value._startTime = (value._paused ? value._pauseTime : tl._time) - (!value._reversed ? value._totalTime : value.totalDuration() - value._totalTime) / value._timeScale; //ensure that if it gets played again, the timing is correct.\n\n return this;\n } else if (value instanceof Array || value && value.push && _isArray(value)) {\n var i = value.length;\n\n while (--i > -1) {\n this.remove(value[i]);\n }\n\n return this;\n } else if (typeof value === \"string\") {\n return this.removeLabel(value);\n }\n\n return this.kill(null, value);\n };\n\n p._remove = function (tween, skipDisable) {\n SimpleTimeline.prototype._remove.call(this, tween, skipDisable);\n\n var last = this._last;\n\n if (!last) {\n this._time = this._totalTime = this._duration = this._totalDuration = 0;\n } else if (this._time > this.duration()) {\n this._time = this._duration;\n this._totalTime = this._totalDuration;\n }\n\n return this;\n };\n\n p.append = function (value, offsetOrLabel) {\n return this.add(value, this._parseTimeOrLabel(null, offsetOrLabel, true, value));\n };\n\n p.insert = p.insertMultiple = function (value, position, align, stagger) {\n return this.add(value, position || 0, align, stagger);\n };\n\n p.appendMultiple = function (tweens, offsetOrLabel, align, stagger) {\n return this.add(tweens, this._parseTimeOrLabel(null, offsetOrLabel, true, tweens), align, stagger);\n };\n\n p.addLabel = function (label, position) {\n this._labels[label] = this._parseTimeOrLabel(position);\n return this;\n };\n\n p.addPause = function (position, callback, params, scope) {\n var t = TweenLite.delayedCall(0, _pauseCallback, params, scope || this);\n t.vars.onComplete = t.vars.onReverseComplete = callback;\n t.data = \"isPause\";\n this._hasPause = true;\n return this.add(t, position);\n };\n\n p.removeLabel = function (label) {\n delete this._labels[label];\n return this;\n };\n\n p.getLabelTime = function (label) {\n return this._labels[label] != null ? this._labels[label] : -1;\n };\n\n p._parseTimeOrLabel = function (timeOrLabel, offsetOrLabel, appendIfAbsent, ignore) {\n var clippedDuration, i; //if we're about to add a tween/timeline (or an array of them) that's already a child of this timeline, we should remove it first so that it doesn't contaminate the duration().\n\n if (ignore instanceof Animation && ignore.timeline === this) {\n this.remove(ignore);\n } else if (ignore && (ignore instanceof Array || ignore.push && _isArray(ignore))) {\n i = ignore.length;\n\n while (--i > -1) {\n if (ignore[i] instanceof Animation && ignore[i].timeline === this) {\n this.remove(ignore[i]);\n }\n }\n }\n\n clippedDuration = typeof timeOrLabel === \"number\" && !offsetOrLabel ? 0 : this.duration() > 99999999999 ? this.recent().endTime(false) : this._duration; //in case there's a child that infinitely repeats, users almost never intend for the insertion point of a new child to be based on a SUPER long value like that so we clip it and assume the most recently-added child's endTime should be used instead.\n\n if (typeof offsetOrLabel === \"string\") {\n return this._parseTimeOrLabel(offsetOrLabel, appendIfAbsent && typeof timeOrLabel === \"number\" && this._labels[offsetOrLabel] == null ? timeOrLabel - clippedDuration : 0, appendIfAbsent);\n }\n\n offsetOrLabel = offsetOrLabel || 0;\n\n if (typeof timeOrLabel === \"string\" && (isNaN(timeOrLabel) || this._labels[timeOrLabel] != null)) {\n //if the string is a number like \"1\", check to see if there's a label with that name, otherwise interpret it as a number (absolute value).\n i = timeOrLabel.indexOf(\"=\");\n\n if (i === -1) {\n if (this._labels[timeOrLabel] == null) {\n return appendIfAbsent ? this._labels[timeOrLabel] = clippedDuration + offsetOrLabel : offsetOrLabel;\n }\n\n return this._labels[timeOrLabel] + offsetOrLabel;\n }\n\n offsetOrLabel = parseInt(timeOrLabel.charAt(i - 1) + \"1\", 10) * Number(timeOrLabel.substr(i + 1));\n timeOrLabel = i > 1 ? this._parseTimeOrLabel(timeOrLabel.substr(0, i - 1), 0, appendIfAbsent) : clippedDuration;\n } else if (timeOrLabel == null) {\n timeOrLabel = clippedDuration;\n }\n\n return Number(timeOrLabel) + offsetOrLabel;\n };\n\n p.seek = function (position, suppressEvents) {\n return this.totalTime(typeof position === \"number\" ? position : this._parseTimeOrLabel(position), suppressEvents !== false);\n };\n\n p.stop = function () {\n return this.paused(true);\n };\n\n p.gotoAndPlay = function (position, suppressEvents) {\n return this.play(position, suppressEvents);\n };\n\n p.gotoAndStop = function (position, suppressEvents) {\n return this.pause(position, suppressEvents);\n };\n\n p.render = function (time, suppressEvents, force) {\n if (this._gc) {\n this._enabled(true, false);\n }\n\n var prevTime = this._time,\n totalDur = !this._dirty ? this._totalDuration : this.totalDuration(),\n prevStart = this._startTime,\n prevTimeScale = this._timeScale,\n prevPaused = this._paused,\n tween,\n isComplete,\n next,\n callback,\n internalForce,\n pauseTween,\n curTime;\n\n if (prevTime !== this._time) {\n //if totalDuration() finds a child with a negative startTime and smoothChildTiming is true, things get shifted around internally so we need to adjust the time accordingly. For example, if a tween starts at -30 we must shift EVERYTHING forward 30 seconds and move this timeline's startTime backward by 30 seconds so that things align with the playhead (no jump).\n time += this._time - prevTime;\n }\n\n if (time >= totalDur - 0.0000001 && time >= 0) {\n //to work around occasional floating point math artifacts.\n this._totalTime = this._time = totalDur;\n if (!this._reversed) if (!this._hasPausedChild()) {\n isComplete = true;\n callback = \"onComplete\";\n internalForce = !!this._timeline.autoRemoveChildren; //otherwise, if the animation is unpaused/activated after it's already finished, it doesn't get removed from the parent timeline.\n\n if (this._duration === 0) if (time <= 0 && time >= -0.0000001 || this._rawPrevTime < 0 || this._rawPrevTime === _tinyNum) if (this._rawPrevTime !== time && this._first) {\n internalForce = true;\n\n if (this._rawPrevTime > _tinyNum) {\n callback = \"onReverseComplete\";\n }\n }\n }\n this._rawPrevTime = this._duration || !suppressEvents || time || this._rawPrevTime === time ? time : _tinyNum; //when the playhead arrives at EXACTLY time 0 (right on top) of a zero-duration timeline or tween, we need to discern if events are suppressed so that when the playhead moves again (next time), it'll trigger the callback. If events are NOT suppressed, obviously the callback would be triggered in this render. Basically, the callback should fire either when the playhead ARRIVES or LEAVES this exact spot, not both. Imagine doing a timeline.seek(0) and there's a callback that sits at 0. Since events are suppressed on that seek() by default, nothing will fire, but when the playhead moves off of that position, the callback should fire. This behavior is what people intuitively expect. We set the _rawPrevTime to be a precise tiny number to indicate this scenario rather than using another property/variable which would increase memory usage. This technique is less readable, but more efficient.\n\n time = totalDur + 0.0001; //to avoid occasional floating point rounding errors - sometimes child tweens/timelines were not being fully completed (their progress might be 0.999999999999998 instead of 1 because when _time - tween._startTime is performed, floating point errors would return a value that was SLIGHTLY off). Try (999999999999.7 - 999999999999) * 1 = 0.699951171875 instead of 0.7.\n } else if (time < 0.0000001) {\n //to work around occasional floating point math artifacts, round super small values to 0.\n this._totalTime = this._time = 0;\n\n if (prevTime !== 0 || this._duration === 0 && this._rawPrevTime !== _tinyNum && (this._rawPrevTime > 0 || time < 0 && this._rawPrevTime >= 0)) {\n callback = \"onReverseComplete\";\n isComplete = this._reversed;\n }\n\n if (time < 0) {\n this._active = false;\n\n if (this._timeline.autoRemoveChildren && this._reversed) {\n //ensures proper GC if a timeline is resumed after it's finished reversing.\n internalForce = isComplete = true;\n callback = \"onReverseComplete\";\n } else if (this._rawPrevTime >= 0 && this._first) {\n //when going back beyond the start, force a render so that zero-duration tweens that sit at the very beginning render their start values properly. Otherwise, if the parent timeline's playhead lands exactly at this timeline's startTime, and then moves backwards, the zero-duration tweens at the beginning would still be at their end state.\n internalForce = true;\n }\n\n this._rawPrevTime = time;\n } else {\n this._rawPrevTime = this._duration || !suppressEvents || time || this._rawPrevTime === time ? time : _tinyNum; //when the playhead arrives at EXACTLY time 0 (right on top) of a zero-duration timeline or tween, we need to discern if events are suppressed so that when the playhead moves again (next time), it'll trigger the callback. If events are NOT suppressed, obviously the callback would be triggered in this render. Basically, the callback should fire either when the playhead ARRIVES or LEAVES this exact spot, not both. Imagine doing a timeline.seek(0) and there's a callback that sits at 0. Since events are suppressed on that seek() by default, nothing will fire, but when the playhead moves off of that position, the callback should fire. This behavior is what people intuitively expect. We set the _rawPrevTime to be a precise tiny number to indicate this scenario rather than using another property/variable which would increase memory usage. This technique is less readable, but more efficient.\n\n if (time === 0 && isComplete) {\n //if there's a zero-duration tween at the very beginning of a timeline and the playhead lands EXACTLY at time 0, that tween will correctly render its end values, but we need to keep the timeline alive for one more render so that the beginning values render properly as the parent's playhead keeps moving beyond the begining. Imagine obj.x starts at 0 and then we do tl.set(obj, {x:100}).to(obj, 1, {x:200}) and then later we tl.reverse()...the goal is to have obj.x revert to 0. If the playhead happens to land on exactly 0, without this chunk of code, it'd complete the timeline and remove it from the rendering queue (not good).\n tween = this._first;\n\n while (tween && tween._startTime === 0) {\n if (!tween._duration) {\n isComplete = false;\n }\n\n tween = tween._next;\n }\n }\n\n time = 0; //to avoid occasional floating point rounding errors (could cause problems especially with zero-duration tweens at the very beginning of the timeline)\n\n if (!this._initted) {\n internalForce = true;\n }\n }\n } else {\n if (this._hasPause && !this._forcingPlayhead && !suppressEvents) {\n if (time >= prevTime) {\n tween = this._first;\n\n while (tween && tween._startTime <= time && !pauseTween) {\n if (!tween._duration) if (tween.data === \"isPause\" && !tween.ratio && !(tween._startTime === 0 && this._rawPrevTime === 0)) {\n pauseTween = tween;\n }\n tween = tween._next;\n }\n } else {\n tween = this._last;\n\n while (tween && tween._startTime >= time && !pauseTween) {\n if (!tween._duration) if (tween.data === \"isPause\" && tween._rawPrevTime > 0) {\n pauseTween = tween;\n }\n tween = tween._prev;\n }\n }\n\n if (pauseTween) {\n this._time = time = pauseTween._startTime;\n this._totalTime = time + this._cycle * (this._totalDuration + this._repeatDelay);\n }\n }\n\n this._totalTime = this._time = this._rawPrevTime = time;\n }\n\n if ((this._time === prevTime || !this._first) && !force && !internalForce && !pauseTween) {\n return;\n } else if (!this._initted) {\n this._initted = true;\n }\n\n if (!this._active) if (!this._paused && this._time !== prevTime && time > 0) {\n this._active = true; //so that if the user renders the timeline (as opposed to the parent timeline rendering it), it is forced to re-render and align it with the proper time/frame on the next rendering cycle. Maybe the timeline already finished but the user manually re-renders it as halfway done, for example.\n }\n if (prevTime === 0) if (this.vars.onStart) if (this._time !== 0 || !this._duration) if (!suppressEvents) {\n this._callback(\"onStart\");\n }\n curTime = this._time;\n\n if (curTime >= prevTime) {\n tween = this._first;\n\n while (tween) {\n next = tween._next; //record it here because the value could change after rendering...\n\n if (curTime !== this._time || this._paused && !prevPaused) {\n //in case a tween pauses or seeks the timeline when rendering, like inside of an onUpdate/onComplete\n break;\n } else if (tween._active || tween._startTime <= curTime && !tween._paused && !tween._gc) {\n if (pauseTween === tween) {\n this.pause();\n }\n\n if (!tween._reversed) {\n tween.render((time - tween._startTime) * tween._timeScale, suppressEvents, force);\n } else {\n tween.render((!tween._dirty ? tween._totalDuration : tween.totalDuration()) - (time - tween._startTime) * tween._timeScale, suppressEvents, force);\n }\n }\n\n tween = next;\n }\n } else {\n tween = this._last;\n\n while (tween) {\n next = tween._prev; //record it here because the value could change after rendering...\n\n if (curTime !== this._time || this._paused && !prevPaused) {\n //in case a tween pauses or seeks the timeline when rendering, like inside of an onUpdate/onComplete\n break;\n } else if (tween._active || tween._startTime <= prevTime && !tween._paused && !tween._gc) {\n if (pauseTween === tween) {\n pauseTween = tween._prev; //the linked list is organized by _startTime, thus it's possible that a tween could start BEFORE the pause and end after it, in which case it would be positioned before the pause tween in the linked list, but we should render it before we pause() the timeline and cease rendering. This is only a concern when going in reverse.\n\n while (pauseTween && pauseTween.endTime() > this._time) {\n pauseTween.render(pauseTween._reversed ? pauseTween.totalDuration() - (time - pauseTween._startTime) * pauseTween._timeScale : (time - pauseTween._startTime) * pauseTween._timeScale, suppressEvents, force);\n pauseTween = pauseTween._prev;\n }\n\n pauseTween = null;\n this.pause();\n }\n\n if (!tween._reversed) {\n tween.render((time - tween._startTime) * tween._timeScale, suppressEvents, force);\n } else {\n tween.render((!tween._dirty ? tween._totalDuration : tween.totalDuration()) - (time - tween._startTime) * tween._timeScale, suppressEvents, force);\n }\n }\n\n tween = next;\n }\n }\n\n if (this._onUpdate) if (!suppressEvents) {\n if (_lazyTweens.length) {\n //in case rendering caused any tweens to lazy-init, we should render them because typically when a timeline finishes, users expect things to have rendered fully. Imagine an onUpdate on a timeline that reports/checks tweened values.\n _lazyRender();\n }\n\n this._callback(\"onUpdate\");\n }\n if (callback) if (!this._gc) if (prevStart === this._startTime || prevTimeScale !== this._timeScale) if (this._time === 0 || totalDur >= this.totalDuration()) {\n //if one of the tweens that was rendered altered this timeline's startTime (like if an onComplete reversed the timeline), it probably isn't complete. If it is, don't worry, because whatever call altered the startTime would complete if it was necessary at the new time. The only exception is the timeScale property. Also check _gc because there's a chance that kill() could be called in an onUpdate\n if (isComplete) {\n if (_lazyTweens.length) {\n //in case rendering caused any tweens to lazy-init, we should render them because typically when a timeline finishes, users expect things to have rendered fully. Imagine an onComplete on a timeline that reports/checks tweened values.\n _lazyRender();\n }\n\n if (this._timeline.autoRemoveChildren) {\n this._enabled(false, false);\n }\n\n this._active = false;\n }\n\n if (!suppressEvents && this.vars[callback]) {\n this._callback(callback);\n }\n }\n };\n\n p._hasPausedChild = function () {\n var tween = this._first;\n\n while (tween) {\n if (tween._paused || tween instanceof TimelineLite && tween._hasPausedChild()) {\n return true;\n }\n\n tween = tween._next;\n }\n\n return false;\n };\n\n p.getChildren = function (nested, tweens, timelines, ignoreBeforeTime) {\n ignoreBeforeTime = ignoreBeforeTime || -9999999999;\n var a = [],\n tween = this._first,\n cnt = 0;\n\n while (tween) {\n if (tween._startTime < ignoreBeforeTime) {//do nothing\n } else if (tween instanceof TweenLite) {\n if (tweens !== false) {\n a[cnt++] = tween;\n }\n } else {\n if (timelines !== false) {\n a[cnt++] = tween;\n }\n\n if (nested !== false) {\n a = a.concat(tween.getChildren(true, tweens, timelines));\n cnt = a.length;\n }\n }\n\n tween = tween._next;\n }\n\n return a;\n };\n\n p.getTweensOf = function (target, nested) {\n var disabled = this._gc,\n a = [],\n cnt = 0,\n tweens,\n i;\n\n if (disabled) {\n this._enabled(true, true); //getTweensOf() filters out disabled tweens, and we have to mark them as _gc = true when the timeline completes in order to allow clean garbage collection, so temporarily re-enable the timeline here.\n\n }\n\n tweens = TweenLite.getTweensOf(target);\n i = tweens.length;\n\n while (--i > -1) {\n if (tweens[i].timeline === this || nested && this._contains(tweens[i])) {\n a[cnt++] = tweens[i];\n }\n }\n\n if (disabled) {\n this._enabled(false, true);\n }\n\n return a;\n };\n\n p.recent = function () {\n return this._recent;\n };\n\n p._contains = function (tween) {\n var tl = tween.timeline;\n\n while (tl) {\n if (tl === this) {\n return true;\n }\n\n tl = tl.timeline;\n }\n\n return false;\n };\n\n p.shiftChildren = function (amount, adjustLabels, ignoreBeforeTime) {\n ignoreBeforeTime = ignoreBeforeTime || 0;\n var tween = this._first,\n labels = this._labels,\n p;\n\n while (tween) {\n if (tween._startTime >= ignoreBeforeTime) {\n tween._startTime += amount;\n }\n\n tween = tween._next;\n }\n\n if (adjustLabels) {\n for (p in labels) {\n if (labels[p] >= ignoreBeforeTime) {\n labels[p] += amount;\n }\n }\n }\n\n return this._uncache(true);\n };\n\n p._kill = function (vars, target) {\n if (!vars && !target) {\n return this._enabled(false, false);\n }\n\n var tweens = !target ? this.getChildren(true, true, false) : this.getTweensOf(target),\n i = tweens.length,\n changed = false;\n\n while (--i > -1) {\n if (tweens[i]._kill(vars, target)) {\n changed = true;\n }\n }\n\n return changed;\n };\n\n p.clear = function (labels) {\n var tweens = this.getChildren(false, true, true),\n i = tweens.length;\n this._time = this._totalTime = 0;\n\n while (--i > -1) {\n tweens[i]._enabled(false, false);\n }\n\n if (labels !== false) {\n this._labels = {};\n }\n\n return this._uncache(true);\n };\n\n p.invalidate = function () {\n var tween = this._first;\n\n while (tween) {\n tween.invalidate();\n tween = tween._next;\n }\n\n return Animation.prototype.invalidate.call(this);\n ;\n };\n\n p._enabled = function (enabled, ignoreTimeline) {\n if (enabled === this._gc) {\n var tween = this._first;\n\n while (tween) {\n tween._enabled(enabled, true);\n\n tween = tween._next;\n }\n }\n\n return SimpleTimeline.prototype._enabled.call(this, enabled, ignoreTimeline);\n };\n\n p.totalTime = function (time, suppressEvents, uncapped) {\n this._forcingPlayhead = true;\n var val = Animation.prototype.totalTime.apply(this, arguments);\n this._forcingPlayhead = false;\n return val;\n };\n\n p.duration = function (value) {\n if (!arguments.length) {\n if (this._dirty) {\n this.totalDuration(); //just triggers recalculation\n }\n\n return this._duration;\n }\n\n if (this.duration() !== 0 && value !== 0) {\n this.timeScale(this._duration / value);\n }\n\n return this;\n };\n\n p.totalDuration = function (value) {\n if (!arguments.length) {\n if (this._dirty) {\n var max = 0,\n tween = this._last,\n prevStart = 999999999999,\n prev,\n end;\n\n while (tween) {\n prev = tween._prev; //record it here in case the tween changes position in the sequence...\n\n if (tween._dirty) {\n tween.totalDuration(); //could change the tween._startTime, so make sure the tween's cache is clean before analyzing it.\n }\n\n if (tween._startTime > prevStart && this._sortChildren && !tween._paused && !this._calculatingDuration) {\n //in case one of the tweens shifted out of order, it needs to be re-inserted into the correct position in the sequence\n this._calculatingDuration = 1; //prevent endless recursive calls - there are methods that get triggered that check duration/totalDuration when we add(), like _parseTimeOrLabel().\n\n this.add(tween, tween._startTime - tween._delay);\n this._calculatingDuration = 0;\n } else {\n prevStart = tween._startTime;\n }\n\n if (tween._startTime < 0 && !tween._paused) {\n //children aren't allowed to have negative startTimes unless smoothChildTiming is true, so adjust here if one is found.\n max -= tween._startTime;\n\n if (this._timeline.smoothChildTiming) {\n this._startTime += tween._startTime / this._timeScale;\n this._time -= tween._startTime;\n this._totalTime -= tween._startTime;\n this._rawPrevTime -= tween._startTime;\n }\n\n this.shiftChildren(-tween._startTime, false, -9999999999);\n prevStart = 0;\n }\n\n end = tween._startTime + tween._totalDuration / tween._timeScale;\n\n if (end > max) {\n max = end;\n }\n\n tween = prev;\n }\n\n this._duration = this._totalDuration = max;\n this._dirty = false;\n }\n\n return this._totalDuration;\n }\n\n return value && this.totalDuration() ? this.timeScale(this._totalDuration / value) : this;\n };\n\n p.paused = function (value) {\n if (!value) {\n //if there's a pause directly at the spot from where we're unpausing, skip it.\n var tween = this._first,\n time = this._time;\n\n while (tween) {\n if (tween._startTime === time && tween.data === \"isPause\") {\n tween._rawPrevTime = 0; //remember, _rawPrevTime is how zero-duration tweens/callbacks sense directionality and determine whether or not to fire. If _rawPrevTime is the same as _startTime on the next render, it won't fire.\n }\n\n tween = tween._next;\n }\n }\n\n return Animation.prototype.paused.apply(this, arguments);\n };\n\n p.usesFrames = function () {\n var tl = this._timeline;\n\n while (tl._timeline) {\n tl = tl._timeline;\n }\n\n return tl === Animation._rootFramesTimeline;\n };\n\n p.rawTime = function (wrapRepeats) {\n return wrapRepeats && (this._paused || this._repeat && this.time() > 0 && this.totalProgress() < 1) ? this._totalTime % (this._duration + this._repeatDelay) : this._paused ? this._totalTime : (this._timeline.rawTime(wrapRepeats) - this._startTime) * this._timeScale;\n };\n\n return TimelineLite;\n}, true);\n\nexport var TimelineLite = globals.TimelineLite;\nexport { TimelineLite as default };","import \"core-js/modules/es.array.sort.js\";\n\n/*!\n * VERSION: 2.0.2\n * DATE: 2018-08-27\n * UPDATES AND DOCS AT: http://greensock.com\n *\n * @license Copyright (c) 2008-2018, GreenSock. All rights reserved.\n * This work is subject to the terms at http://greensock.com/standard-license or for\n * Club GreenSock members, the software agreement that was issued with your membership.\n * \n * @author: Jack Doyle, jack@greensock.com\n */\nimport TweenLite, { _gsScope, globals, Ease, Animation } from \"./TweenLite.js\";\nimport TimelineLite from \"./TimelineLite.js\";\n\n_gsScope._gsDefine(\"TimelineMax\", [\"TimelineLite\", \"TweenLite\", \"easing.Ease\"], function () {\n var TimelineMax = function TimelineMax(vars) {\n TimelineLite.call(this, vars);\n this._repeat = this.vars.repeat || 0;\n this._repeatDelay = this.vars.repeatDelay || 0;\n this._cycle = 0;\n this._yoyo = this.vars.yoyo === true;\n this._dirty = true;\n },\n _tinyNum = 0.0000000001,\n TweenLiteInternals = TweenLite._internals,\n _lazyTweens = TweenLiteInternals.lazyTweens,\n _lazyRender = TweenLiteInternals.lazyRender,\n _globals = _gsScope._gsDefine.globals,\n _easeNone = new Ease(null, null, 1, 0),\n p = TimelineMax.prototype = new TimelineLite();\n\n p.constructor = TimelineMax;\n p.kill()._gc = false;\n TimelineMax.version = \"2.0.2\";\n\n p.invalidate = function () {\n this._yoyo = this.vars.yoyo === true;\n this._repeat = this.vars.repeat || 0;\n this._repeatDelay = this.vars.repeatDelay || 0;\n\n this._uncache(true);\n\n return TimelineLite.prototype.invalidate.call(this);\n };\n\n p.addCallback = function (callback, position, params, scope) {\n return this.add(TweenLite.delayedCall(0, callback, params, scope), position);\n };\n\n p.removeCallback = function (callback, position) {\n if (callback) {\n if (position == null) {\n this._kill(null, callback);\n } else {\n var a = this.getTweensOf(callback, false),\n i = a.length,\n time = this._parseTimeOrLabel(position);\n\n while (--i > -1) {\n if (a[i]._startTime === time) {\n a[i]._enabled(false, false);\n }\n }\n }\n }\n\n return this;\n };\n\n p.removePause = function (position) {\n return this.removeCallback(TimelineLite._internals.pauseCallback, position);\n };\n\n p.tweenTo = function (position, vars) {\n vars = vars || {};\n var copy = {\n ease: _easeNone,\n useFrames: this.usesFrames(),\n immediateRender: false,\n lazy: false\n },\n Engine = vars.repeat && _globals.TweenMax || TweenLite,\n duration,\n p,\n t;\n\n for (p in vars) {\n copy[p] = vars[p];\n }\n\n copy.time = this._parseTimeOrLabel(position);\n duration = Math.abs(Number(copy.time) - this._time) / this._timeScale || 0.001;\n t = new Engine(this, duration, copy);\n\n copy.onStart = function () {\n t.target.paused(true);\n\n if (t.vars.time !== t.target.time() && duration === t.duration() && !t.isFromTo) {\n //don't make the duration zero - if it's supposed to be zero, don't worry because it's already initting the tween and will complete immediately, effectively making the duration zero anyway. If we make duration zero, the tween won't run at all.\n t.duration(Math.abs(t.vars.time - t.target.time()) / t.target._timeScale).render(t.time(), true, true); //render() right away to ensure that things look right, especially in the case of .tweenTo(0).\n }\n\n if (vars.onStart) {\n //in case the user had an onStart in the vars - we don't want to overwrite it.\n vars.onStart.apply(vars.onStartScope || vars.callbackScope || t, vars.onStartParams || []); //don't use t._callback(\"onStart\") or it'll point to the copy.onStart and we'll get a recursion error.\n }\n };\n\n return t;\n };\n\n p.tweenFromTo = function (fromPosition, toPosition, vars) {\n vars = vars || {};\n fromPosition = this._parseTimeOrLabel(fromPosition);\n vars.startAt = {\n onComplete: this.seek,\n onCompleteParams: [fromPosition],\n callbackScope: this\n };\n vars.immediateRender = vars.immediateRender !== false;\n var t = this.tweenTo(toPosition, vars);\n t.isFromTo = 1; //to ensure we don't mess with the duration in the onStart (we've got the start and end values here, so lock it in)\n\n return t.duration(Math.abs(t.vars.time - fromPosition) / this._timeScale || 0.001);\n };\n\n p.render = function (time, suppressEvents, force) {\n if (this._gc) {\n this._enabled(true, false);\n }\n\n var prevTime = this._time,\n totalDur = !this._dirty ? this._totalDuration : this.totalDuration(),\n dur = this._duration,\n prevTotalTime = this._totalTime,\n prevStart = this._startTime,\n prevTimeScale = this._timeScale,\n prevRawPrevTime = this._rawPrevTime,\n prevPaused = this._paused,\n prevCycle = this._cycle,\n tween,\n isComplete,\n next,\n callback,\n internalForce,\n cycleDuration,\n pauseTween,\n curTime;\n\n if (prevTime !== this._time) {\n //if totalDuration() finds a child with a negative startTime and smoothChildTiming is true, things get shifted around internally so we need to adjust the time accordingly. For example, if a tween starts at -30 we must shift EVERYTHING forward 30 seconds and move this timeline's startTime backward by 30 seconds so that things align with the playhead (no jump).\n time += this._time - prevTime;\n }\n\n if (time >= totalDur - 0.0000001 && time >= 0) {\n //to work around occasional floating point math artifacts.\n if (!this._locked) {\n this._totalTime = totalDur;\n this._cycle = this._repeat;\n }\n\n if (!this._reversed) if (!this._hasPausedChild()) {\n isComplete = true;\n callback = \"onComplete\";\n internalForce = !!this._timeline.autoRemoveChildren; //otherwise, if the animation is unpaused/activated after it's already finished, it doesn't get removed from the parent timeline.\n\n if (this._duration === 0) if (time <= 0 && time >= -0.0000001 || prevRawPrevTime < 0 || prevRawPrevTime === _tinyNum) if (prevRawPrevTime !== time && this._first) {\n internalForce = true;\n\n if (prevRawPrevTime > _tinyNum) {\n callback = \"onReverseComplete\";\n }\n }\n }\n this._rawPrevTime = this._duration || !suppressEvents || time || this._rawPrevTime === time ? time : _tinyNum; //when the playhead arrives at EXACTLY time 0 (right on top) of a zero-duration timeline or tween, we need to discern if events are suppressed so that when the playhead moves again (next time), it'll trigger the callback. If events are NOT suppressed, obviously the callback would be triggered in this render. Basically, the callback should fire either when the playhead ARRIVES or LEAVES this exact spot, not both. Imagine doing a timeline.seek(0) and there's a callback that sits at 0. Since events are suppressed on that seek() by default, nothing will fire, but when the playhead moves off of that position, the callback should fire. This behavior is what people intuitively expect. We set the _rawPrevTime to be a precise tiny number to indicate this scenario rather than using another property/variable which would increase memory usage. This technique is less readable, but more efficient.\n\n if (this._yoyo && (this._cycle & 1) !== 0) {\n this._time = time = 0;\n } else {\n this._time = dur;\n time = dur + 0.0001; //to avoid occasional floating point rounding errors - sometimes child tweens/timelines were not being fully completed (their progress might be 0.999999999999998 instead of 1 because when _time - tween._startTime is performed, floating point errors would return a value that was SLIGHTLY off). Try (999999999999.7 - 999999999999) * 1 = 0.699951171875 instead of 0.7. We cannot do less then 0.0001 because the same issue can occur when the duration is extremely large like 999999999999 in which case adding 0.00000001, for example, causes it to act like nothing was added.\n }\n } else if (time < 0.0000001) {\n //to work around occasional floating point math artifacts, round super small values to 0.\n if (!this._locked) {\n this._totalTime = this._cycle = 0;\n }\n\n this._time = 0;\n\n if (prevTime !== 0 || dur === 0 && prevRawPrevTime !== _tinyNum && (prevRawPrevTime > 0 || time < 0 && prevRawPrevTime >= 0) && !this._locked) {\n //edge case for checking time < 0 && prevRawPrevTime >= 0: a zero-duration fromTo() tween inside a zero-duration timeline (yeah, very rare)\n callback = \"onReverseComplete\";\n isComplete = this._reversed;\n }\n\n if (time < 0) {\n this._active = false;\n\n if (this._timeline.autoRemoveChildren && this._reversed) {\n internalForce = isComplete = true;\n callback = \"onReverseComplete\";\n } else if (prevRawPrevTime >= 0 && this._first) {\n //when going back beyond the start, force a render so that zero-duration tweens that sit at the very beginning render their start values properly. Otherwise, if the parent timeline's playhead lands exactly at this timeline's startTime, and then moves backwards, the zero-duration tweens at the beginning would still be at their end state.\n internalForce = true;\n }\n\n this._rawPrevTime = time;\n } else {\n this._rawPrevTime = dur || !suppressEvents || time || this._rawPrevTime === time ? time : _tinyNum; //when the playhead arrives at EXACTLY time 0 (right on top) of a zero-duration timeline or tween, we need to discern if events are suppressed so that when the playhead moves again (next time), it'll trigger the callback. If events are NOT suppressed, obviously the callback would be triggered in this render. Basically, the callback should fire either when the playhead ARRIVES or LEAVES this exact spot, not both. Imagine doing a timeline.seek(0) and there's a callback that sits at 0. Since events are suppressed on that seek() by default, nothing will fire, but when the playhead moves off of that position, the callback should fire. This behavior is what people intuitively expect. We set the _rawPrevTime to be a precise tiny number to indicate this scenario rather than using another property/variable which would increase memory usage. This technique is less readable, but more efficient.\n\n if (time === 0 && isComplete) {\n //if there's a zero-duration tween at the very beginning of a timeline and the playhead lands EXACTLY at time 0, that tween will correctly render its end values, but we need to keep the timeline alive for one more render so that the beginning values render properly as the parent's playhead keeps moving beyond the begining. Imagine obj.x starts at 0 and then we do tl.set(obj, {x:100}).to(obj, 1, {x:200}) and then later we tl.reverse()...the goal is to have obj.x revert to 0. If the playhead happens to land on exactly 0, without this chunk of code, it'd complete the timeline and remove it from the rendering queue (not good).\n tween = this._first;\n\n while (tween && tween._startTime === 0) {\n if (!tween._duration) {\n isComplete = false;\n }\n\n tween = tween._next;\n }\n }\n\n time = 0; //to avoid occasional floating point rounding errors (could cause problems especially with zero-duration tweens at the very beginning of the timeline)\n\n if (!this._initted) {\n internalForce = true;\n }\n }\n } else {\n if (dur === 0 && prevRawPrevTime < 0) {\n //without this, zero-duration repeating timelines (like with a simple callback nested at the very beginning and a repeatDelay) wouldn't render the first time through.\n internalForce = true;\n }\n\n this._time = this._rawPrevTime = time;\n\n if (!this._locked) {\n this._totalTime = time;\n\n if (this._repeat !== 0) {\n cycleDuration = dur + this._repeatDelay;\n this._cycle = this._totalTime / cycleDuration >> 0; //originally _totalTime % cycleDuration but floating point errors caused problems, so I normalized it. (4 % 0.8 should be 0 but it gets reported as 0.79999999!)\n\n if (this._cycle !== 0) if (this._cycle === this._totalTime / cycleDuration && prevTotalTime <= time) {\n this._cycle--; //otherwise when rendered exactly at the end time, it will act as though it is repeating (at the beginning)\n }\n this._time = this._totalTime - this._cycle * cycleDuration;\n if (this._yoyo) if ((this._cycle & 1) !== 0) {\n this._time = dur - this._time;\n }\n\n if (this._time > dur) {\n this._time = dur;\n time = dur + 0.0001; //to avoid occasional floating point rounding error\n } else if (this._time < 0) {\n this._time = time = 0;\n } else {\n time = this._time;\n }\n }\n }\n\n if (this._hasPause && !this._forcingPlayhead && !suppressEvents) {\n time = this._time;\n\n if (time >= prevTime || this._repeat && prevCycle !== this._cycle) {\n tween = this._first;\n\n while (tween && tween._startTime <= time && !pauseTween) {\n if (!tween._duration) if (tween.data === \"isPause\" && !tween.ratio && !(tween._startTime === 0 && this._rawPrevTime === 0)) {\n pauseTween = tween;\n }\n tween = tween._next;\n }\n } else {\n tween = this._last;\n\n while (tween && tween._startTime >= time && !pauseTween) {\n if (!tween._duration) if (tween.data === \"isPause\" && tween._rawPrevTime > 0) {\n pauseTween = tween;\n }\n tween = tween._prev;\n }\n }\n\n if (pauseTween && pauseTween._startTime < dur) {\n this._time = time = pauseTween._startTime;\n this._totalTime = time + this._cycle * (this._totalDuration + this._repeatDelay);\n }\n }\n }\n\n if (this._cycle !== prevCycle) if (!this._locked) {\n /*\n make sure children at the end/beginning of the timeline are rendered properly. If, for example, \n a 3-second long timeline rendered at 2.9 seconds previously, and now renders at 3.2 seconds (which\n would get transated to 2.8 seconds if the timeline yoyos or 0.2 seconds if it just repeats), there\n could be a callback or a short tween that's at 2.95 or 3 seconds in which wouldn't render. So \n we need to push the timeline to the end (and/or beginning depending on its yoyo value). Also we must\n ensure that zero-duration tweens at the very beginning or end of the TimelineMax work. \n */\n var backwards = this._yoyo && (prevCycle & 1) !== 0,\n wrap = backwards === (this._yoyo && (this._cycle & 1) !== 0),\n recTotalTime = this._totalTime,\n recCycle = this._cycle,\n recRawPrevTime = this._rawPrevTime,\n recTime = this._time;\n this._totalTime = prevCycle * dur;\n\n if (this._cycle < prevCycle) {\n backwards = !backwards;\n } else {\n this._totalTime += dur;\n }\n\n this._time = prevTime; //temporarily revert _time so that render() renders the children in the correct order. Without this, tweens won't rewind correctly. We could arhictect things in a \"cleaner\" way by splitting out the rendering queue into a separate method but for performance reasons, we kept it all inside this method.\n\n this._rawPrevTime = dur === 0 ? prevRawPrevTime - 0.0001 : prevRawPrevTime;\n this._cycle = prevCycle;\n this._locked = true; //prevents changes to totalTime and skips repeat/yoyo behavior when we recursively call render()\n\n prevTime = backwards ? 0 : dur;\n this.render(prevTime, suppressEvents, dur === 0);\n if (!suppressEvents) if (!this._gc) {\n if (this.vars.onRepeat) {\n this._cycle = recCycle; //in case the onRepeat alters the playhead or invalidates(), we shouldn't stay locked or use the previous cycle.\n\n this._locked = false;\n\n this._callback(\"onRepeat\");\n }\n }\n\n if (prevTime !== this._time) {\n //in case there's a callback like onComplete in a nested tween/timeline that changes the playhead position, like via seek(), we should just abort.\n return;\n }\n\n if (wrap) {\n this._cycle = prevCycle; //if there's an onRepeat, we reverted this above, so make sure it's set properly again. We also unlocked in that scenario, so reset that too.\n\n this._locked = true;\n prevTime = backwards ? dur + 0.0001 : -0.0001;\n this.render(prevTime, true, false);\n }\n\n this._locked = false;\n\n if (this._paused && !prevPaused) {\n //if the render() triggered callback that paused this timeline, we should abort (very rare, but possible)\n return;\n }\n\n this._time = recTime;\n this._totalTime = recTotalTime;\n this._cycle = recCycle;\n this._rawPrevTime = recRawPrevTime;\n }\n\n if ((this._time === prevTime || !this._first) && !force && !internalForce && !pauseTween) {\n if (prevTotalTime !== this._totalTime) if (this._onUpdate) if (!suppressEvents) {\n //so that onUpdate fires even during the repeatDelay - as long as the totalTime changed, we should trigger onUpdate.\n this._callback(\"onUpdate\");\n }\n return;\n } else if (!this._initted) {\n this._initted = true;\n }\n\n if (!this._active) if (!this._paused && this._totalTime !== prevTotalTime && time > 0) {\n this._active = true; //so that if the user renders the timeline (as opposed to the parent timeline rendering it), it is forced to re-render and align it with the proper time/frame on the next rendering cycle. Maybe the timeline already finished but the user manually re-renders it as halfway done, for example.\n }\n if (prevTotalTime === 0) if (this.vars.onStart) if (this._totalTime !== 0 || !this._totalDuration) if (!suppressEvents) {\n this._callback(\"onStart\");\n }\n curTime = this._time;\n\n if (curTime >= prevTime) {\n tween = this._first;\n\n while (tween) {\n next = tween._next; //record it here because the value could change after rendering...\n\n if (curTime !== this._time || this._paused && !prevPaused) {\n //in case a tween pauses or seeks the timeline when rendering, like inside of an onUpdate/onComplete\n break;\n } else if (tween._active || tween._startTime <= this._time && !tween._paused && !tween._gc) {\n if (pauseTween === tween) {\n this.pause();\n }\n\n if (!tween._reversed) {\n tween.render((time - tween._startTime) * tween._timeScale, suppressEvents, force);\n } else {\n tween.render((!tween._dirty ? tween._totalDuration : tween.totalDuration()) - (time - tween._startTime) * tween._timeScale, suppressEvents, force);\n }\n }\n\n tween = next;\n }\n } else {\n tween = this._last;\n\n while (tween) {\n next = tween._prev; //record it here because the value could change after rendering...\n\n if (curTime !== this._time || this._paused && !prevPaused) {\n //in case a tween pauses or seeks the timeline when rendering, like inside of an onUpdate/onComplete\n break;\n } else if (tween._active || tween._startTime <= prevTime && !tween._paused && !tween._gc) {\n if (pauseTween === tween) {\n pauseTween = tween._prev; //the linked list is organized by _startTime, thus it's possible that a tween could start BEFORE the pause and end after it, in which case it would be positioned before the pause tween in the linked list, but we should render it before we pause() the timeline and cease rendering. This is only a concern when going in reverse.\n\n while (pauseTween && pauseTween.endTime() > this._time) {\n pauseTween.render(pauseTween._reversed ? pauseTween.totalDuration() - (time - pauseTween._startTime) * pauseTween._timeScale : (time - pauseTween._startTime) * pauseTween._timeScale, suppressEvents, force);\n pauseTween = pauseTween._prev;\n }\n\n pauseTween = null;\n this.pause();\n }\n\n if (!tween._reversed) {\n tween.render((time - tween._startTime) * tween._timeScale, suppressEvents, force);\n } else {\n tween.render((!tween._dirty ? tween._totalDuration : tween.totalDuration()) - (time - tween._startTime) * tween._timeScale, suppressEvents, force);\n }\n }\n\n tween = next;\n }\n }\n\n if (this._onUpdate) if (!suppressEvents) {\n if (_lazyTweens.length) {\n //in case rendering caused any tweens to lazy-init, we should render them because typically when a timeline finishes, users expect things to have rendered fully. Imagine an onUpdate on a timeline that reports/checks tweened values.\n _lazyRender();\n }\n\n this._callback(\"onUpdate\");\n }\n if (callback) if (!this._locked) if (!this._gc) if (prevStart === this._startTime || prevTimeScale !== this._timeScale) if (this._time === 0 || totalDur >= this.totalDuration()) {\n //if one of the tweens that was rendered altered this timeline's startTime (like if an onComplete reversed the timeline), it probably isn't complete. If it is, don't worry, because whatever call altered the startTime would complete if it was necessary at the new time. The only exception is the timeScale property. Also check _gc because there's a chance that kill() could be called in an onUpdate\n if (isComplete) {\n if (_lazyTweens.length) {\n //in case rendering caused any tweens to lazy-init, we should render them because typically when a timeline finishes, users expect things to have rendered fully. Imagine an onComplete on a timeline that reports/checks tweened values.\n _lazyRender();\n }\n\n if (this._timeline.autoRemoveChildren) {\n this._enabled(false, false);\n }\n\n this._active = false;\n }\n\n if (!suppressEvents && this.vars[callback]) {\n this._callback(callback);\n }\n }\n };\n\n p.getActive = function (nested, tweens, timelines) {\n if (nested == null) {\n nested = true;\n }\n\n if (tweens == null) {\n tweens = true;\n }\n\n if (timelines == null) {\n timelines = false;\n }\n\n var a = [],\n all = this.getChildren(nested, tweens, timelines),\n cnt = 0,\n l = all.length,\n i,\n tween;\n\n for (i = 0; i < l; i++) {\n tween = all[i];\n\n if (tween.isActive()) {\n a[cnt++] = tween;\n }\n }\n\n return a;\n };\n\n p.getLabelAfter = function (time) {\n if (!time) if (time !== 0) {\n //faster than isNan()\n time = this._time;\n }\n var labels = this.getLabelsArray(),\n l = labels.length,\n i;\n\n for (i = 0; i < l; i++) {\n if (labels[i].time > time) {\n return labels[i].name;\n }\n }\n\n return null;\n };\n\n p.getLabelBefore = function (time) {\n if (time == null) {\n time = this._time;\n }\n\n var labels = this.getLabelsArray(),\n i = labels.length;\n\n while (--i > -1) {\n if (labels[i].time < time) {\n return labels[i].name;\n }\n }\n\n return null;\n };\n\n p.getLabelsArray = function () {\n var a = [],\n cnt = 0,\n p;\n\n for (p in this._labels) {\n a[cnt++] = {\n time: this._labels[p],\n name: p\n };\n }\n\n a.sort(function (a, b) {\n return a.time - b.time;\n });\n return a;\n };\n\n p.invalidate = function () {\n this._locked = false; //unlock and set cycle in case invalidate() is called from inside an onRepeat\n\n return TimelineLite.prototype.invalidate.call(this);\n }; //---- GETTERS / SETTERS -------------------------------------------------------------------------------------------------------\n\n\n p.progress = function (value, suppressEvents) {\n return !arguments.length ? this._time / this.duration() || 0 : this.totalTime(this.duration() * (this._yoyo && (this._cycle & 1) !== 0 ? 1 - value : value) + this._cycle * (this._duration + this._repeatDelay), suppressEvents);\n };\n\n p.totalProgress = function (value, suppressEvents) {\n return !arguments.length ? this._totalTime / this.totalDuration() || 0 : this.totalTime(this.totalDuration() * value, suppressEvents);\n };\n\n p.totalDuration = function (value) {\n if (!arguments.length) {\n if (this._dirty) {\n TimelineLite.prototype.totalDuration.call(this); //just forces refresh\n //Instead of Infinity, we use 999999999999 so that we can accommodate reverses.\n\n this._totalDuration = this._repeat === -1 ? 999999999999 : this._duration * (this._repeat + 1) + this._repeatDelay * this._repeat;\n }\n\n return this._totalDuration;\n }\n\n return this._repeat === -1 || !value ? this : this.timeScale(this.totalDuration() / value);\n };\n\n p.time = function (value, suppressEvents) {\n if (!arguments.length) {\n return this._time;\n }\n\n if (this._dirty) {\n this.totalDuration();\n }\n\n if (value > this._duration) {\n value = this._duration;\n }\n\n if (this._yoyo && (this._cycle & 1) !== 0) {\n value = this._duration - value + this._cycle * (this._duration + this._repeatDelay);\n } else if (this._repeat !== 0) {\n value += this._cycle * (this._duration + this._repeatDelay);\n }\n\n return this.totalTime(value, suppressEvents);\n };\n\n p.repeat = function (value) {\n if (!arguments.length) {\n return this._repeat;\n }\n\n this._repeat = value;\n return this._uncache(true);\n };\n\n p.repeatDelay = function (value) {\n if (!arguments.length) {\n return this._repeatDelay;\n }\n\n this._repeatDelay = value;\n return this._uncache(true);\n };\n\n p.yoyo = function (value) {\n if (!arguments.length) {\n return this._yoyo;\n }\n\n this._yoyo = value;\n return this;\n };\n\n p.currentLabel = function (value) {\n if (!arguments.length) {\n return this.getLabelBefore(this._time + 0.00000001);\n }\n\n return this.seek(value, true);\n };\n\n return TimelineMax;\n}, true);\n\nexport var TimelineMax = globals.TimelineMax;\nexport { TimelineLite, TimelineMax as default };","/*!\n * VERSION: 1.3.8\n * DATE: 2018-05-30\n * UPDATES AND DOCS AT: http://greensock.com\n *\n * @license Copyright (c) 2008-2018, GreenSock. All rights reserved.\n * This work is subject to the terms at http://greensock.com/standard-license or for\n * Club GreenSock members, the software agreement that was issued with your membership.\n * \n * @author: Jack Doyle, jack@greensock.com\n **/\nimport { _gsScope } from \"./TweenLite.js\";\n\nvar _RAD2DEG = 180 / Math.PI,\n _r1 = [],\n _r2 = [],\n _r3 = [],\n _corProps = {},\n _globals = _gsScope._gsDefine.globals,\n Segment = function Segment(a, b, c, d) {\n if (c === d) {\n //if c and d match, the final autoRotate value could lock at -90 degrees, so differentiate them slightly.\n c = d - (d - b) / 1000000;\n }\n\n if (a === b) {\n //if a and b match, the starting autoRotate value could lock at -90 degrees, so differentiate them slightly.\n b = a + (c - a) / 1000000;\n }\n\n this.a = a;\n this.b = b;\n this.c = c;\n this.d = d;\n this.da = d - a;\n this.ca = c - a;\n this.ba = b - a;\n},\n _correlate = \",x,y,z,left,top,right,bottom,marginTop,marginLeft,marginRight,marginBottom,paddingLeft,paddingTop,paddingRight,paddingBottom,backgroundPosition,backgroundPosition_y,\",\n cubicToQuadratic = function cubicToQuadratic(a, b, c, d) {\n var q1 = {\n a: a\n },\n q2 = {},\n q3 = {},\n q4 = {\n c: d\n },\n mab = (a + b) / 2,\n mbc = (b + c) / 2,\n mcd = (c + d) / 2,\n mabc = (mab + mbc) / 2,\n mbcd = (mbc + mcd) / 2,\n m8 = (mbcd - mabc) / 8;\n q1.b = mab + (a - mab) / 4;\n q2.b = mabc + m8;\n q1.c = q2.a = (q1.b + q2.b) / 2;\n q2.c = q3.a = (mabc + mbcd) / 2;\n q3.b = mbcd - m8;\n q4.b = mcd + (d - mcd) / 4;\n q3.c = q4.a = (q3.b + q4.b) / 2;\n return [q1, q2, q3, q4];\n},\n _calculateControlPoints = function _calculateControlPoints(a, curviness, quad, basic, correlate) {\n var l = a.length - 1,\n ii = 0,\n cp1 = a[0].a,\n i,\n p1,\n p2,\n p3,\n seg,\n m1,\n m2,\n mm,\n cp2,\n qb,\n r1,\n r2,\n tl;\n\n for (i = 0; i < l; i++) {\n seg = a[ii];\n p1 = seg.a;\n p2 = seg.d;\n p3 = a[ii + 1].d;\n\n if (correlate) {\n r1 = _r1[i];\n r2 = _r2[i];\n tl = (r2 + r1) * curviness * 0.25 / (basic ? 0.5 : _r3[i] || 0.5);\n m1 = p2 - (p2 - p1) * (basic ? curviness * 0.5 : r1 !== 0 ? tl / r1 : 0);\n m2 = p2 + (p3 - p2) * (basic ? curviness * 0.5 : r2 !== 0 ? tl / r2 : 0);\n mm = p2 - (m1 + ((m2 - m1) * (r1 * 3 / (r1 + r2) + 0.5) / 4 || 0));\n } else {\n m1 = p2 - (p2 - p1) * curviness * 0.5;\n m2 = p2 + (p3 - p2) * curviness * 0.5;\n mm = p2 - (m1 + m2) / 2;\n }\n\n m1 += mm;\n m2 += mm;\n seg.c = cp2 = m1;\n\n if (i !== 0) {\n seg.b = cp1;\n } else {\n seg.b = cp1 = seg.a + (seg.c - seg.a) * 0.6; //instead of placing b on a exactly, we move it inline with c so that if the user specifies an ease like Back.easeIn or Elastic.easeIn which goes BEYOND the beginning, it will do so smoothly.\n }\n\n seg.da = p2 - p1;\n seg.ca = cp2 - p1;\n seg.ba = cp1 - p1;\n\n if (quad) {\n qb = cubicToQuadratic(p1, cp1, cp2, p2);\n a.splice(ii, 1, qb[0], qb[1], qb[2], qb[3]);\n ii += 4;\n } else {\n ii++;\n }\n\n cp1 = m2;\n }\n\n seg = a[ii];\n seg.b = cp1;\n seg.c = cp1 + (seg.d - cp1) * 0.4; //instead of placing c on d exactly, we move it inline with b so that if the user specifies an ease like Back.easeOut or Elastic.easeOut which goes BEYOND the end, it will do so smoothly.\n\n seg.da = seg.d - seg.a;\n seg.ca = seg.c - seg.a;\n seg.ba = cp1 - seg.a;\n\n if (quad) {\n qb = cubicToQuadratic(seg.a, cp1, seg.c, seg.d);\n a.splice(ii, 1, qb[0], qb[1], qb[2], qb[3]);\n }\n},\n _parseAnchors = function _parseAnchors(values, p, correlate, prepend) {\n var a = [],\n l,\n i,\n p1,\n p2,\n p3,\n tmp;\n\n if (prepend) {\n values = [prepend].concat(values);\n i = values.length;\n\n while (--i > -1) {\n if (typeof (tmp = values[i][p]) === \"string\") if (tmp.charAt(1) === \"=\") {\n values[i][p] = prepend[p] + Number(tmp.charAt(0) + tmp.substr(2)); //accommodate relative values. Do it inline instead of breaking it out into a function for speed reasons\n }\n }\n }\n\n l = values.length - 2;\n\n if (l < 0) {\n a[0] = new Segment(values[0][p], 0, 0, values[0][p]);\n return a;\n }\n\n for (i = 0; i < l; i++) {\n p1 = values[i][p];\n p2 = values[i + 1][p];\n a[i] = new Segment(p1, 0, 0, p2);\n\n if (correlate) {\n p3 = values[i + 2][p];\n _r1[i] = (_r1[i] || 0) + (p2 - p1) * (p2 - p1);\n _r2[i] = (_r2[i] || 0) + (p3 - p2) * (p3 - p2);\n }\n }\n\n a[i] = new Segment(values[i][p], 0, 0, values[i + 1][p]);\n return a;\n},\n bezierThrough = function bezierThrough(values, curviness, quadratic, basic, correlate, prepend) {\n var obj = {},\n props = [],\n first = prepend || values[0],\n i,\n p,\n a,\n j,\n r,\n l,\n seamless,\n last;\n correlate = typeof correlate === \"string\" ? \",\" + correlate + \",\" : _correlate;\n\n if (curviness == null) {\n curviness = 1;\n }\n\n for (p in values[0]) {\n props.push(p);\n } //check to see if the last and first values are identical (well, within 0.05). If so, make seamless by appending the second element to the very end of the values array and the 2nd-to-last element to the very beginning (we'll remove those segments later)\n\n\n if (values.length > 1) {\n last = values[values.length - 1];\n seamless = true;\n i = props.length;\n\n while (--i > -1) {\n p = props[i];\n\n if (Math.abs(first[p] - last[p]) > 0.05) {\n //build in a tolerance of +/-0.05 to accommodate rounding errors.\n seamless = false;\n break;\n }\n }\n\n if (seamless) {\n values = values.concat(); //duplicate the array to avoid contaminating the original which the user may be reusing for other tweens\n\n if (prepend) {\n values.unshift(prepend);\n }\n\n values.push(values[1]);\n prepend = values[values.length - 3];\n }\n }\n\n _r1.length = _r2.length = _r3.length = 0;\n i = props.length;\n\n while (--i > -1) {\n p = props[i];\n _corProps[p] = correlate.indexOf(\",\" + p + \",\") !== -1;\n obj[p] = _parseAnchors(values, p, _corProps[p], prepend);\n }\n\n i = _r1.length;\n\n while (--i > -1) {\n _r1[i] = Math.sqrt(_r1[i]);\n _r2[i] = Math.sqrt(_r2[i]);\n }\n\n if (!basic) {\n i = props.length;\n\n while (--i > -1) {\n if (_corProps[p]) {\n a = obj[props[i]];\n l = a.length - 1;\n\n for (j = 0; j < l; j++) {\n r = a[j + 1].da / _r2[j] + a[j].da / _r1[j] || 0;\n _r3[j] = (_r3[j] || 0) + r * r;\n }\n }\n }\n\n i = _r3.length;\n\n while (--i > -1) {\n _r3[i] = Math.sqrt(_r3[i]);\n }\n }\n\n i = props.length;\n j = quadratic ? 4 : 1;\n\n while (--i > -1) {\n p = props[i];\n a = obj[p];\n\n _calculateControlPoints(a, curviness, quadratic, basic, _corProps[p]); //this method requires that _parseAnchors() and _setSegmentRatios() ran first so that _r1, _r2, and _r3 values are populated for all properties\n\n\n if (seamless) {\n a.splice(0, j);\n a.splice(a.length - j, j);\n }\n }\n\n return obj;\n},\n _parseBezierData = function _parseBezierData(values, type, prepend) {\n type = type || \"soft\";\n var obj = {},\n inc = type === \"cubic\" ? 3 : 2,\n soft = type === \"soft\",\n props = [],\n a,\n b,\n c,\n d,\n cur,\n i,\n j,\n l,\n p,\n cnt,\n tmp;\n\n if (soft && prepend) {\n values = [prepend].concat(values);\n }\n\n if (values == null || values.length < inc + 1) {\n throw \"invalid Bezier data\";\n }\n\n for (p in values[0]) {\n props.push(p);\n }\n\n i = props.length;\n\n while (--i > -1) {\n p = props[i];\n obj[p] = cur = [];\n cnt = 0;\n l = values.length;\n\n for (j = 0; j < l; j++) {\n a = prepend == null ? values[j][p] : typeof (tmp = values[j][p]) === \"string\" && tmp.charAt(1) === \"=\" ? prepend[p] + Number(tmp.charAt(0) + tmp.substr(2)) : Number(tmp);\n if (soft) if (j > 1) if (j < l - 1) {\n cur[cnt++] = (a + cur[cnt - 2]) / 2;\n }\n cur[cnt++] = a;\n }\n\n l = cnt - inc + 1;\n cnt = 0;\n\n for (j = 0; j < l; j += inc) {\n a = cur[j];\n b = cur[j + 1];\n c = cur[j + 2];\n d = inc === 2 ? 0 : cur[j + 3];\n cur[cnt++] = tmp = inc === 3 ? new Segment(a, b, c, d) : new Segment(a, (2 * b + a) / 3, (2 * b + c) / 3, c);\n }\n\n cur.length = cnt;\n }\n\n return obj;\n},\n _addCubicLengths = function _addCubicLengths(a, steps, resolution) {\n var inc = 1 / resolution,\n j = a.length,\n d,\n d1,\n s,\n da,\n ca,\n ba,\n p,\n i,\n inv,\n bez,\n index;\n\n while (--j > -1) {\n bez = a[j];\n s = bez.a;\n da = bez.d - s;\n ca = bez.c - s;\n ba = bez.b - s;\n d = d1 = 0;\n\n for (i = 1; i <= resolution; i++) {\n p = inc * i;\n inv = 1 - p;\n d = d1 - (d1 = (p * p * da + 3 * inv * (p * ca + inv * ba)) * p);\n index = j * resolution + i - 1;\n steps[index] = (steps[index] || 0) + d * d;\n }\n }\n},\n _parseLengthData = function _parseLengthData(obj, resolution) {\n resolution = resolution >> 0 || 6;\n var a = [],\n lengths = [],\n d = 0,\n total = 0,\n threshold = resolution - 1,\n segments = [],\n curLS = [],\n //current length segments array\n p,\n i,\n l,\n index;\n\n for (p in obj) {\n _addCubicLengths(obj[p], a, resolution);\n }\n\n l = a.length;\n\n for (i = 0; i < l; i++) {\n d += Math.sqrt(a[i]);\n index = i % resolution;\n curLS[index] = d;\n\n if (index === threshold) {\n total += d;\n index = i / resolution >> 0;\n segments[index] = curLS;\n lengths[index] = total;\n d = 0;\n curLS = [];\n }\n }\n\n return {\n length: total,\n lengths: lengths,\n segments: segments\n };\n},\n BezierPlugin = _gsScope._gsDefine.plugin({\n propName: \"bezier\",\n priority: -1,\n version: \"1.3.8\",\n API: 2,\n global: true,\n //gets called when the tween renders for the first time. This is where initial values should be recorded and any setup routines should run.\n init: function init(target, vars, tween) {\n this._target = target;\n\n if (vars instanceof Array) {\n vars = {\n values: vars\n };\n }\n\n this._func = {};\n this._mod = {};\n this._props = [];\n this._timeRes = vars.timeResolution == null ? 6 : parseInt(vars.timeResolution, 10);\n var values = vars.values || [],\n first = {},\n second = values[0],\n autoRotate = vars.autoRotate || tween.vars.orientToBezier,\n p,\n isFunc,\n i,\n j,\n prepend;\n this._autoRotate = autoRotate ? autoRotate instanceof Array ? autoRotate : [[\"x\", \"y\", \"rotation\", autoRotate === true ? 0 : Number(autoRotate) || 0]] : null;\n\n for (p in second) {\n this._props.push(p);\n }\n\n i = this._props.length;\n\n while (--i > -1) {\n p = this._props[i];\n\n this._overwriteProps.push(p);\n\n isFunc = this._func[p] = typeof target[p] === \"function\";\n first[p] = !isFunc ? parseFloat(target[p]) : target[p.indexOf(\"set\") || typeof target[\"get\" + p.substr(3)] !== \"function\" ? p : \"get\" + p.substr(3)]();\n if (!prepend) if (first[p] !== values[0][p]) {\n prepend = first;\n }\n }\n\n this._beziers = vars.type !== \"cubic\" && vars.type !== \"quadratic\" && vars.type !== \"soft\" ? bezierThrough(values, isNaN(vars.curviness) ? 1 : vars.curviness, false, vars.type === \"thruBasic\", vars.correlate, prepend) : _parseBezierData(values, vars.type, first);\n this._segCount = this._beziers[p].length;\n\n if (this._timeRes) {\n var ld = _parseLengthData(this._beziers, this._timeRes);\n\n this._length = ld.length;\n this._lengths = ld.lengths;\n this._segments = ld.segments;\n this._l1 = this._li = this._s1 = this._si = 0;\n this._l2 = this._lengths[0];\n this._curSeg = this._segments[0];\n this._s2 = this._curSeg[0];\n this._prec = 1 / this._curSeg.length;\n }\n\n if (autoRotate = this._autoRotate) {\n this._initialRotations = [];\n\n if (!(autoRotate[0] instanceof Array)) {\n this._autoRotate = autoRotate = [autoRotate];\n }\n\n i = autoRotate.length;\n\n while (--i > -1) {\n for (j = 0; j < 3; j++) {\n p = autoRotate[i][j];\n this._func[p] = typeof target[p] === \"function\" ? target[p.indexOf(\"set\") || typeof target[\"get\" + p.substr(3)] !== \"function\" ? p : \"get\" + p.substr(3)] : false;\n }\n\n p = autoRotate[i][2];\n this._initialRotations[i] = (this._func[p] ? this._func[p].call(this._target) : this._target[p]) || 0;\n\n this._overwriteProps.push(p);\n }\n }\n\n this._startRatio = tween.vars.runBackwards ? 1 : 0; //we determine the starting ratio when the tween inits which is always 0 unless the tween has runBackwards:true (indicating it's a from() tween) in which case it's 1.\n\n return true;\n },\n //called each time the values should be updated, and the ratio gets passed as the only parameter (typically it's a value between 0 and 1, but it can exceed those when using an ease like Elastic.easeOut or Back.easeOut, etc.)\n set: function set(v) {\n var segments = this._segCount,\n func = this._func,\n target = this._target,\n notStart = v !== this._startRatio,\n curIndex,\n inv,\n i,\n p,\n b,\n t,\n val,\n l,\n lengths,\n curSeg;\n\n if (!this._timeRes) {\n curIndex = v < 0 ? 0 : v >= 1 ? segments - 1 : segments * v >> 0;\n t = (v - curIndex * (1 / segments)) * segments;\n } else {\n lengths = this._lengths;\n curSeg = this._curSeg;\n v *= this._length;\n i = this._li; //find the appropriate segment (if the currently cached one isn't correct)\n\n if (v > this._l2 && i < segments - 1) {\n l = segments - 1;\n\n while (i < l && (this._l2 = lengths[++i]) <= v) {}\n\n this._l1 = lengths[i - 1];\n this._li = i;\n this._curSeg = curSeg = this._segments[i];\n this._s2 = curSeg[this._s1 = this._si = 0];\n } else if (v < this._l1 && i > 0) {\n while (i > 0 && (this._l1 = lengths[--i]) >= v) {}\n\n if (i === 0 && v < this._l1) {\n this._l1 = 0;\n } else {\n i++;\n }\n\n this._l2 = lengths[i];\n this._li = i;\n this._curSeg = curSeg = this._segments[i];\n this._s1 = curSeg[(this._si = curSeg.length - 1) - 1] || 0;\n this._s2 = curSeg[this._si];\n }\n\n curIndex = i; //now find the appropriate sub-segment (we split it into the number of pieces that was defined by \"precision\" and measured each one)\n\n v -= this._l1;\n i = this._si;\n\n if (v > this._s2 && i < curSeg.length - 1) {\n l = curSeg.length - 1;\n\n while (i < l && (this._s2 = curSeg[++i]) <= v) {}\n\n this._s1 = curSeg[i - 1];\n this._si = i;\n } else if (v < this._s1 && i > 0) {\n while (i > 0 && (this._s1 = curSeg[--i]) >= v) {}\n\n if (i === 0 && v < this._s1) {\n this._s1 = 0;\n } else {\n i++;\n }\n\n this._s2 = curSeg[i];\n this._si = i;\n }\n\n t = (i + (v - this._s1) / (this._s2 - this._s1)) * this._prec || 0;\n }\n\n inv = 1 - t;\n i = this._props.length;\n\n while (--i > -1) {\n p = this._props[i];\n b = this._beziers[p][curIndex];\n val = (t * t * b.da + 3 * inv * (t * b.ca + inv * b.ba)) * t + b.a;\n\n if (this._mod[p]) {\n val = this._mod[p](val, target);\n }\n\n if (func[p]) {\n target[p](val);\n } else {\n target[p] = val;\n }\n }\n\n if (this._autoRotate) {\n var ar = this._autoRotate,\n b2,\n x1,\n y1,\n x2,\n y2,\n add,\n conv;\n i = ar.length;\n\n while (--i > -1) {\n p = ar[i][2];\n add = ar[i][3] || 0;\n conv = ar[i][4] === true ? 1 : _RAD2DEG;\n b = this._beziers[ar[i][0]];\n b2 = this._beziers[ar[i][1]];\n\n if (b && b2) {\n //in case one of the properties got overwritten.\n b = b[curIndex];\n b2 = b2[curIndex];\n x1 = b.a + (b.b - b.a) * t;\n x2 = b.b + (b.c - b.b) * t;\n x1 += (x2 - x1) * t;\n x2 += (b.c + (b.d - b.c) * t - x2) * t;\n y1 = b2.a + (b2.b - b2.a) * t;\n y2 = b2.b + (b2.c - b2.b) * t;\n y1 += (y2 - y1) * t;\n y2 += (b2.c + (b2.d - b2.c) * t - y2) * t;\n val = notStart ? Math.atan2(y2 - y1, x2 - x1) * conv + add : this._initialRotations[i];\n\n if (this._mod[p]) {\n val = this._mod[p](val, target); //for modProps\n }\n\n if (func[p]) {\n target[p](val);\n } else {\n target[p] = val;\n }\n }\n }\n }\n }\n}),\n p = BezierPlugin.prototype;\n\nBezierPlugin.bezierThrough = bezierThrough;\nBezierPlugin.cubicToQuadratic = cubicToQuadratic;\nBezierPlugin._autoCSS = true; //indicates that this plugin can be inserted into the \"css\" object using the autoCSS feature of TweenLite\n\nBezierPlugin.quadraticToCubic = function (a, b, c) {\n return new Segment(a, (2 * b + a) / 3, (2 * b + c) / 3, c);\n};\n\nBezierPlugin._cssRegister = function () {\n var CSSPlugin = _globals.CSSPlugin;\n\n if (!CSSPlugin) {\n return;\n }\n\n var _internals = CSSPlugin._internals,\n _parseToProxy = _internals._parseToProxy,\n _setPluginRatio = _internals._setPluginRatio,\n CSSPropTween = _internals.CSSPropTween;\n\n _internals._registerComplexSpecialProp(\"bezier\", {\n parser: function parser(t, e, prop, cssp, pt, plugin) {\n if (e instanceof Array) {\n e = {\n values: e\n };\n }\n\n plugin = new BezierPlugin();\n var values = e.values,\n l = values.length - 1,\n pluginValues = [],\n v = {},\n i,\n p,\n data;\n\n if (l < 0) {\n return pt;\n }\n\n for (i = 0; i <= l; i++) {\n data = _parseToProxy(t, values[i], cssp, pt, plugin, l !== i);\n pluginValues[i] = data.end;\n }\n\n for (p in e) {\n v[p] = e[p]; //duplicate the vars object because we need to alter some things which would cause problems if the user plans to reuse the same vars object for another tween.\n }\n\n v.values = pluginValues;\n pt = new CSSPropTween(t, \"bezier\", 0, 0, data.pt, 2);\n pt.data = data;\n pt.plugin = plugin;\n pt.setRatio = _setPluginRatio;\n\n if (v.autoRotate === 0) {\n v.autoRotate = true;\n }\n\n if (v.autoRotate && !(v.autoRotate instanceof Array)) {\n i = v.autoRotate === true ? 0 : Number(v.autoRotate);\n v.autoRotate = data.end.left != null ? [[\"left\", \"top\", \"rotation\", i, false]] : data.end.x != null ? [[\"x\", \"y\", \"rotation\", i, false]] : false;\n }\n\n if (v.autoRotate) {\n if (!cssp._transform) {\n cssp._enableTransforms(false);\n }\n\n data.autoRotate = cssp._target._gsTransform;\n data.proxy.rotation = data.autoRotate.rotation || 0;\n\n cssp._overwriteProps.push(\"rotation\");\n }\n\n plugin._onInitTween(data.proxy, v, cssp._tween);\n\n return pt;\n }\n });\n};\n\np._mod = function (lookup) {\n var op = this._overwriteProps,\n i = op.length,\n val;\n\n while (--i > -1) {\n val = lookup[op[i]];\n\n if (val && typeof val === \"function\") {\n this._mod[op[i]] = val;\n }\n }\n};\n\np._kill = function (lookup) {\n var a = this._props,\n p,\n i;\n\n for (p in this._beziers) {\n if (p in lookup) {\n delete this._beziers[p];\n delete this._func[p];\n i = a.length;\n\n while (--i > -1) {\n if (a[i] === p) {\n a.splice(i, 1);\n }\n }\n }\n }\n\n a = this._autoRotate;\n\n if (a) {\n i = a.length;\n\n while (--i > -1) {\n if (lookup[a[i][2]]) {\n a.splice(i, 1);\n }\n }\n }\n\n return this._super._kill.call(this, lookup);\n};\n\nexport { BezierPlugin, BezierPlugin as default };","import \"core-js/modules/es.array.sort.js\";\n\n/*!\n * VERSION: 1.16.1\n * DATE: 2018-08-27\n * UPDATES AND DOCS AT: http://greensock.com\n *\n * @license Copyright (c) 2008-2018, GreenSock. All rights reserved.\n * This work is subject to the terms at http://greensock.com/standard-license or for\n * Club GreenSock members, the software agreement that was issued with your membership.\n * \n * @author: Jack Doyle, jack@greensock.com\n **/\nimport { _gsScope, globals, Ease, Linear, Power0, Power1, Power2, Power3, Power4 } from \"./TweenLite.js\";\n\n_gsScope._gsDefine(\"easing.Back\", [\"easing.Ease\"], function () {\n var w = _gsScope.GreenSockGlobals || _gsScope,\n gs = w.com.greensock,\n _2PI = Math.PI * 2,\n _HALF_PI = Math.PI / 2,\n _class = gs._class,\n _create = function _create(n, f) {\n var C = _class(\"easing.\" + n, function () {}, true),\n p = C.prototype = new Ease();\n\n p.constructor = C;\n p.getRatio = f;\n return C;\n },\n _easeReg = Ease.register || function () {},\n //put an empty function in place just as a safety measure in case someone loads an OLD version of TweenLite.js where Ease.register doesn't exist.\n _wrap = function _wrap(name, EaseOut, EaseIn, EaseInOut, aliases) {\n var C = _class(\"easing.\" + name, {\n easeOut: new EaseOut(),\n easeIn: new EaseIn(),\n easeInOut: new EaseInOut()\n }, true);\n\n _easeReg(C, name);\n\n return C;\n },\n EasePoint = function EasePoint(time, value, next) {\n this.t = time;\n this.v = value;\n\n if (next) {\n this.next = next;\n next.prev = this;\n this.c = next.v - value;\n this.gap = next.t - time;\n }\n },\n //Back\n _createBack = function _createBack(n, f) {\n var C = _class(\"easing.\" + n, function (overshoot) {\n this._p1 = overshoot || overshoot === 0 ? overshoot : 1.70158;\n this._p2 = this._p1 * 1.525;\n }, true),\n p = C.prototype = new Ease();\n\n p.constructor = C;\n p.getRatio = f;\n\n p.config = function (overshoot) {\n return new C(overshoot);\n };\n\n return C;\n },\n Back = _wrap(\"Back\", _createBack(\"BackOut\", function (p) {\n return (p = p - 1) * p * ((this._p1 + 1) * p + this._p1) + 1;\n }), _createBack(\"BackIn\", function (p) {\n return p * p * ((this._p1 + 1) * p - this._p1);\n }), _createBack(\"BackInOut\", function (p) {\n return (p *= 2) < 1 ? 0.5 * p * p * ((this._p2 + 1) * p - this._p2) : 0.5 * ((p -= 2) * p * ((this._p2 + 1) * p + this._p2) + 2);\n })),\n //SlowMo\n SlowMo = _class(\"easing.SlowMo\", function (linearRatio, power, yoyoMode) {\n power = power || power === 0 ? power : 0.7;\n\n if (linearRatio == null) {\n linearRatio = 0.7;\n } else if (linearRatio > 1) {\n linearRatio = 1;\n }\n\n this._p = linearRatio !== 1 ? power : 0;\n this._p1 = (1 - linearRatio) / 2;\n this._p2 = linearRatio;\n this._p3 = this._p1 + this._p2;\n this._calcEnd = yoyoMode === true;\n }, true),\n p = SlowMo.prototype = new Ease(),\n SteppedEase,\n ExpoScaleEase,\n RoughEase,\n _createElastic;\n\n p.constructor = SlowMo;\n\n p.getRatio = function (p) {\n var r = p + (0.5 - p) * this._p;\n\n if (p < this._p1) {\n return this._calcEnd ? 1 - (p = 1 - p / this._p1) * p : r - (p = 1 - p / this._p1) * p * p * p * r;\n } else if (p > this._p3) {\n return this._calcEnd ? p === 1 ? 0 : 1 - (p = (p - this._p3) / this._p1) * p : r + (p - r) * (p = (p - this._p3) / this._p1) * p * p * p; //added p === 1 ? 0 to avoid floating point rounding errors from affecting the final value, like 1 - 0.7 = 0.30000000000000004 instead of 0.3\n }\n\n return this._calcEnd ? 1 : r;\n };\n\n SlowMo.ease = new SlowMo(0.7, 0.7);\n\n p.config = SlowMo.config = function (linearRatio, power, yoyoMode) {\n return new SlowMo(linearRatio, power, yoyoMode);\n }; //SteppedEase\n\n\n SteppedEase = _class(\"easing.SteppedEase\", function (steps, immediateStart) {\n steps = steps || 1;\n this._p1 = 1 / steps;\n this._p2 = steps + (immediateStart ? 0 : 1);\n this._p3 = immediateStart ? 1 : 0;\n }, true);\n p = SteppedEase.prototype = new Ease();\n p.constructor = SteppedEase;\n\n p.getRatio = function (p) {\n if (p < 0) {\n p = 0;\n } else if (p >= 1) {\n p = 0.999999999;\n }\n\n return ((this._p2 * p | 0) + this._p3) * this._p1;\n };\n\n p.config = SteppedEase.config = function (steps, immediateStart) {\n return new SteppedEase(steps, immediateStart);\n }; //ExpoScaleEase\n\n\n ExpoScaleEase = _class(\"easing.ExpoScaleEase\", function (start, end, ease) {\n this._p1 = Math.log(end / start);\n this._p2 = end - start;\n this._p3 = start;\n this._ease = ease;\n }, true);\n p = ExpoScaleEase.prototype = new Ease();\n p.constructor = ExpoScaleEase;\n\n p.getRatio = function (p) {\n if (this._ease) {\n p = this._ease.getRatio(p);\n }\n\n return (this._p3 * Math.exp(this._p1 * p) - this._p3) / this._p2;\n };\n\n p.config = ExpoScaleEase.config = function (start, end, ease) {\n return new ExpoScaleEase(start, end, ease);\n }; //RoughEase\n\n\n RoughEase = _class(\"easing.RoughEase\", function (vars) {\n vars = vars || {};\n var taper = vars.taper || \"none\",\n a = [],\n cnt = 0,\n points = (vars.points || 20) | 0,\n i = points,\n randomize = vars.randomize !== false,\n clamp = vars.clamp === true,\n template = vars.template instanceof Ease ? vars.template : null,\n strength = typeof vars.strength === \"number\" ? vars.strength * 0.4 : 0.4,\n x,\n y,\n bump,\n invX,\n obj,\n pnt;\n\n while (--i > -1) {\n x = randomize ? Math.random() : 1 / points * i;\n y = template ? template.getRatio(x) : x;\n\n if (taper === \"none\") {\n bump = strength;\n } else if (taper === \"out\") {\n invX = 1 - x;\n bump = invX * invX * strength;\n } else if (taper === \"in\") {\n bump = x * x * strength;\n } else if (x < 0.5) {\n //\"both\" (start)\n invX = x * 2;\n bump = invX * invX * 0.5 * strength;\n } else {\n //\"both\" (end)\n invX = (1 - x) * 2;\n bump = invX * invX * 0.5 * strength;\n }\n\n if (randomize) {\n y += Math.random() * bump - bump * 0.5;\n } else if (i % 2) {\n y += bump * 0.5;\n } else {\n y -= bump * 0.5;\n }\n\n if (clamp) {\n if (y > 1) {\n y = 1;\n } else if (y < 0) {\n y = 0;\n }\n }\n\n a[cnt++] = {\n x: x,\n y: y\n };\n }\n\n a.sort(function (a, b) {\n return a.x - b.x;\n });\n pnt = new EasePoint(1, 1, null);\n i = points;\n\n while (--i > -1) {\n obj = a[i];\n pnt = new EasePoint(obj.x, obj.y, pnt);\n }\n\n this._prev = new EasePoint(0, 0, pnt.t !== 0 ? pnt : pnt.next);\n }, true);\n p = RoughEase.prototype = new Ease();\n p.constructor = RoughEase;\n\n p.getRatio = function (p) {\n var pnt = this._prev;\n\n if (p > pnt.t) {\n while (pnt.next && p >= pnt.t) {\n pnt = pnt.next;\n }\n\n pnt = pnt.prev;\n } else {\n while (pnt.prev && p <= pnt.t) {\n pnt = pnt.prev;\n }\n }\n\n this._prev = pnt;\n return pnt.v + (p - pnt.t) / pnt.gap * pnt.c;\n };\n\n p.config = function (vars) {\n return new RoughEase(vars);\n };\n\n RoughEase.ease = new RoughEase(); //Bounce\n\n _wrap(\"Bounce\", _create(\"BounceOut\", function (p) {\n if (p < 1 / 2.75) {\n return 7.5625 * p * p;\n } else if (p < 2 / 2.75) {\n return 7.5625 * (p -= 1.5 / 2.75) * p + 0.75;\n } else if (p < 2.5 / 2.75) {\n return 7.5625 * (p -= 2.25 / 2.75) * p + 0.9375;\n }\n\n return 7.5625 * (p -= 2.625 / 2.75) * p + 0.984375;\n }), _create(\"BounceIn\", function (p) {\n if ((p = 1 - p) < 1 / 2.75) {\n return 1 - 7.5625 * p * p;\n } else if (p < 2 / 2.75) {\n return 1 - (7.5625 * (p -= 1.5 / 2.75) * p + 0.75);\n } else if (p < 2.5 / 2.75) {\n return 1 - (7.5625 * (p -= 2.25 / 2.75) * p + 0.9375);\n }\n\n return 1 - (7.5625 * (p -= 2.625 / 2.75) * p + 0.984375);\n }), _create(\"BounceInOut\", function (p) {\n var invert = p < 0.5;\n\n if (invert) {\n p = 1 - p * 2;\n } else {\n p = p * 2 - 1;\n }\n\n if (p < 1 / 2.75) {\n p = 7.5625 * p * p;\n } else if (p < 2 / 2.75) {\n p = 7.5625 * (p -= 1.5 / 2.75) * p + 0.75;\n } else if (p < 2.5 / 2.75) {\n p = 7.5625 * (p -= 2.25 / 2.75) * p + 0.9375;\n } else {\n p = 7.5625 * (p -= 2.625 / 2.75) * p + 0.984375;\n }\n\n return invert ? (1 - p) * 0.5 : p * 0.5 + 0.5;\n })); //CIRC\n\n\n _wrap(\"Circ\", _create(\"CircOut\", function (p) {\n return Math.sqrt(1 - (p = p - 1) * p);\n }), _create(\"CircIn\", function (p) {\n return -(Math.sqrt(1 - p * p) - 1);\n }), _create(\"CircInOut\", function (p) {\n return (p *= 2) < 1 ? -0.5 * (Math.sqrt(1 - p * p) - 1) : 0.5 * (Math.sqrt(1 - (p -= 2) * p) + 1);\n })); //Elastic\n\n\n _createElastic = function _createElastic(n, f, def) {\n var C = _class(\"easing.\" + n, function (amplitude, period) {\n this._p1 = amplitude >= 1 ? amplitude : 1; //note: if amplitude is < 1, we simply adjust the period for a more natural feel. Otherwise the math doesn't work right and the curve starts at 1.\n\n this._p2 = (period || def) / (amplitude < 1 ? amplitude : 1);\n this._p3 = this._p2 / _2PI * (Math.asin(1 / this._p1) || 0);\n this._p2 = _2PI / this._p2; //precalculate to optimize\n }, true),\n p = C.prototype = new Ease();\n\n p.constructor = C;\n p.getRatio = f;\n\n p.config = function (amplitude, period) {\n return new C(amplitude, period);\n };\n\n return C;\n };\n\n _wrap(\"Elastic\", _createElastic(\"ElasticOut\", function (p) {\n return this._p1 * Math.pow(2, -10 * p) * Math.sin((p - this._p3) * this._p2) + 1;\n }, 0.3), _createElastic(\"ElasticIn\", function (p) {\n return -(this._p1 * Math.pow(2, 10 * (p -= 1)) * Math.sin((p - this._p3) * this._p2));\n }, 0.3), _createElastic(\"ElasticInOut\", function (p) {\n return (p *= 2) < 1 ? -0.5 * (this._p1 * Math.pow(2, 10 * (p -= 1)) * Math.sin((p - this._p3) * this._p2)) : this._p1 * Math.pow(2, -10 * (p -= 1)) * Math.sin((p - this._p3) * this._p2) * 0.5 + 1;\n }, 0.45)); //Expo\n\n\n _wrap(\"Expo\", _create(\"ExpoOut\", function (p) {\n return 1 - Math.pow(2, -10 * p);\n }), _create(\"ExpoIn\", function (p) {\n return Math.pow(2, 10 * (p - 1)) - 0.001;\n }), _create(\"ExpoInOut\", function (p) {\n return (p *= 2) < 1 ? 0.5 * Math.pow(2, 10 * (p - 1)) : 0.5 * (2 - Math.pow(2, -10 * (p - 1)));\n })); //Sine\n\n\n _wrap(\"Sine\", _create(\"SineOut\", function (p) {\n return Math.sin(p * _HALF_PI);\n }), _create(\"SineIn\", function (p) {\n return -Math.cos(p * _HALF_PI) + 1;\n }), _create(\"SineInOut\", function (p) {\n return -0.5 * (Math.cos(Math.PI * p) - 1);\n }));\n\n _class(\"easing.EaseLookup\", {\n find: function find(s) {\n return Ease.map[s];\n }\n }, true); //register the non-standard eases\n\n\n _easeReg(w.SlowMo, \"SlowMo\", \"ease,\");\n\n _easeReg(RoughEase, \"RoughEase\", \"ease,\");\n\n _easeReg(SteppedEase, \"SteppedEase\", \"ease,\");\n\n return Back;\n}, true);\n\nexport var Back = globals.Back;\nexport var Elastic = globals.Elastic;\nexport var Bounce = globals.Bounce;\nexport var RoughEase = globals.RoughEase;\nexport var SlowMo = globals.SlowMo;\nexport var SteppedEase = globals.SteppedEase;\nexport var Circ = globals.Circ;\nexport var Expo = globals.Expo;\nexport var Sine = globals.Sine;\nexport var ExpoScaleEase = globals.ExpoScaleEase;\nexport { Linear, Power0, Power1, Power2, Power3, Power4 };","/*!\n * VERSION: 2.0.2\n * DATE: 2018-08-27\n * UPDATES AND DOCS AT: http://greensock.com\n *\n * @license Copyright (c) 2008-2018, GreenSock. All rights reserved.\n * This work is subject to the terms at http://greensock.com/standard-license or for\n * Club GreenSock members, the software agreement that was issued with your membership.\n * \n * @author: Jack Doyle, jack@greensock.com\n **/\nimport TweenLite, { TweenPlugin, Ease, Power0, Power1, Power2, Power3, Power4, Linear } from \"./TweenLite.js\";\nimport TweenMaxBase from \"./TweenMaxBase.js\";\nimport CSSPlugin from \"./CSSPlugin.js\";\nimport AttrPlugin from \"./AttrPlugin.js\";\nimport RoundPropsPlugin from \"./RoundPropsPlugin.js\";\nimport DirectionalRotationPlugin from \"./DirectionalRotationPlugin.js\";\nimport TimelineLite from \"./TimelineLite.js\";\nimport TimelineMax from \"./TimelineMax.js\";\nimport BezierPlugin from \"./BezierPlugin.js\";\nimport { Back, Elastic, Bounce, RoughEase, SlowMo, SteppedEase, Circ, Expo, Sine, ExpoScaleEase } from \"./EasePack.js\"; //the following two lines are designed to prevent tree shaking of the classes that were historically included with TweenMax (otherwise, folks would have to reference CSSPlugin, for example, to ensure their CSS-related animations worked)\n\nexport var TweenMax = TweenMaxBase;\nTweenMax._autoActivated = [TimelineLite, TimelineMax, CSSPlugin, AttrPlugin, BezierPlugin, RoundPropsPlugin, DirectionalRotationPlugin, Back, Elastic, Bounce, RoughEase, SlowMo, SteppedEase, Circ, Expo, Sine, ExpoScaleEase];\nexport { TweenMax as default };\nexport { TweenLite, TimelineLite, TimelineMax, CSSPlugin, AttrPlugin, BezierPlugin, DirectionalRotationPlugin, RoundPropsPlugin, TweenPlugin, Ease, Power0, Power1, Power2, Power3, Power4, Linear, Back, Elastic, Bounce, RoughEase, SlowMo, SteppedEase, Circ, Expo, Sine, ExpoScaleEase };","var global = require('../internals/global');\nvar isObject = require('../internals/is-object');\n\nvar document = global.document;\n// typeof document.createElement is 'object' in old IE\nvar EXISTS = isObject(document) && isObject(document.createElement);\n\nmodule.exports = function (it) {\n return EXISTS ? document.createElement(it) : {};\n};\n"],"sourceRoot":""}