{"version":3,"sources":["webpack:///./node_modules/@babel/runtime/helpers/esm/assertThisInitialized.js","webpack:///./node_modules/@babel/runtime/helpers/esm/inherits.js","webpack:///./node_modules/@babel/runtime/helpers/esm/possibleConstructorReturn.js","webpack:///./node_modules/@babel/runtime/helpers/esm/getPrototypeOf.js","webpack:///./node_modules/@babel/runtime/helpers/esm/classCallCheck.js","webpack:///./node_modules/@babel/runtime/helpers/esm/createClass.js","webpack:///./node_modules/@babel/runtime/helpers/esm/defineProperty.js","webpack:///./node_modules/@babel/runtime/helpers/esm/extends.js","webpack:///./node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js","webpack:///./node_modules/react-spring/web.js","webpack:///./src/components/CollapseItem.tsx","webpack:///./src/templates/howdowework.tsx"],"names":["_assertThisInitialized","self","ReferenceError","_inherits","subClass","superClass","TypeError","prototype","Object","create","constructor","value","writable","configurable","setPrototypeOf","_possibleConstructorReturn","call","_getPrototypeOf","o","getPrototypeOf","__proto__","_classCallCheck","instance","Constructor","_defineProperties","target","props","i","length","descriptor","enumerable","defineProperty","key","_createClass","protoProps","staticProps","_defineProperty","obj","_extends","assign","arguments","source","hasOwnProperty","apply","this","_objectWithoutPropertiesLoose","excluded","sourceKeys","keys","indexOf","_createForOfIteratorHelper","allowArrayLike","it","Symbol","iterator","Array","isArray","minLen","_arrayLikeToArray","n","toString","slice","name","from","test","_unsupportedIterableToArray","F","s","done","e","_e","f","err","normalCompletion","didErr","step","next","_e2","return","arr","len","arr2","_createSuper","Derived","hasNativeReflectConstruct","Reflect","construct","sham","Proxy","Boolean","valueOf","_isNativeReflectConstruct","result","Super","NewTarget","is","a","fun","str","num","und","nul","set","Set","map","Map","equ","b","useForceUpdate","v","withDefault","defaultValue","toArray","callProp","_len","args","_key","forward","to","config","onStart","onRest","onFrame","children","reset","reverse","force","immediate","delay","attach","destroyed","interpolateTo","ref","lazy","getForwardProps","rest","reduce","k","applyAnimatedValues","colorNames","Animated","payload","getValue","child","push","index","splice","detach","_Animated","AnimatedArray","_super","_this2","forEach","p","addChild","removeChild","_Animated2","AnimatedObject","_super2","_this3","values","animated","injectApplyAnimatedValues","fn","transform","injectColorNames","names","interpolation","requestFrame","cb","window","requestAnimationFrame","injectStringInterpolator","now","Date","injectDefaultElement","el","createAnimatedStyle","manualFrameloop","animatedApi","node","current","injectCreateAnimatedStyle","factory","_AnimatedObject","AnimatedProps","_super3","callback","_this4","update","style","active","_step","time","_iterator","controller","isActive","configIdx","configs","_config","endOfAnimation","lastTime","valIdx","animatedValues","animation","fromValues","toValues","position","lastPosition","isAnimated","velocity","initialVelocity","setValue","duration","easing","startTime","decay","Math","exp","abs","lastVelocity","numSteps","floor","tension","friction","mass","isOvershooting","clamp","isVelocity","precision","isDisplacement","delete","stop","size","createInterpolator","range","output","extrapolate","outputRange","inputRange","extrapolateLeft","extrapolateRight","t","input","findRange","inputMin","inputMax","outputMin","outputMax","Infinity","interpolate","_AnimatedArray","AnimatedInterpolation","_super4","parents","_this5","calc","getPayload","_Animated3","AnimatedValue","_super5","_value","_this6","_this","animatedStyles","startPosition","flush","addAnimatedStyles","styles","add","getChildren","animatedStyle","clear","_AnimatedArray2","AnimatedValueArray","_super6","_this7","_this8","G","Controller","_this9","id","idle","hasChanged","guid","local","merged","animations","interpolations","listeners","queue","localQueue","getValues","_ref","_ref$delay","ops","entries","_ref2","entry","previous","sort","diff","onEnd","_this10","_ref3","_ref3$from","_ref3$to","_ref4","finished","async","setTimeout","runAsync","start","has","_ref5","_this11","Promise","resolve","undefined","_loop","fresh","then","r","last","_this12","_this$props","_this$props$from","_this$props$to","_this$props$config","_ref6","acc","_ref7","isNumber","isString","startsWith","isInterpolation","fromValue","toValue","toConfig","parent","interpolation$$1","newValue","currentValue","some","currentValueDiffersFromGoal","hasNewGoal","hasNewConfig","prev","updateConfig","mounted","ctrl","isFn","_useMemo","c","destroy","fill","_","newProps","controllers","all","updateCtrl","updateProps","propValues","pause","useSpring","_useSprings","_AnimatedObject2","AnimatedStyle","_super7","_this13","colors","transparent","aliceblue","antiquewhite","aqua","aquamarine","azure","beige","bisque","black","blanchedalmond","blue","blueviolet","brown","burlywood","burntsienna","cadetblue","chartreuse","chocolate","coral","cornflowerblue","cornsilk","crimson","cyan","darkblue","darkcyan","darkgoldenrod","darkgray","darkgreen","darkgrey","darkkhaki","darkmagenta","darkolivegreen","darkorange","darkorchid","darkred","darksalmon","darkseagreen","darkslateblue","darkslategray","darkslategrey","darkturquoise","darkviolet","deeppink","deepskyblue","dimgray","dimgrey","dodgerblue","firebrick","floralwhite","forestgreen","fuchsia","gainsboro","ghostwhite","gold","goldenrod","gray","green","greenyellow","grey","honeydew","hotpink","indianred","indigo","ivory","khaki","lavender","lavenderblush","lawngreen","lemonchiffon","lightblue","lightcoral","lightcyan","lightgoldenrodyellow","lightgray","lightgreen","lightgrey","lightpink","lightsalmon","lightseagreen","lightskyblue","lightslategray","lightslategrey","lightsteelblue","lightyellow","lime","limegreen","linen","magenta","maroon","mediumaquamarine","mediumblue","mediumorchid","mediumpurple","mediumseagreen","mediumslateblue","mediumspringgreen","mediumturquoise","mediumvioletred","midnightblue","mintcream","mistyrose","moccasin","navajowhite","navy","oldlace","olive","olivedrab","orange","orangered","orchid","palegoldenrod","palegreen","paleturquoise","palevioletred","papayawhip","peachpuff","peru","pink","plum","powderblue","purple","rebeccapurple","red","rosybrown","royalblue","saddlebrown","salmon","sandybrown","seagreen","seashell","sienna","silver","skyblue","slateblue","slategray","slategrey","snow","springgreen","steelblue","tan","teal","thistle","tomato","turquoise","violet","wheat","white","whitesmoke","yellow","yellowgreen","NUMBER","parts","join","rgb","RegExp","rgba","hsl","hsla","hex3","hex4","hex6","hex8","hue2rgb","q","hslToRgb","h","l","g","round","parse255","int","parseInt","parse360","parseFloat","parse1","parsePercentage","colorToRgba","color","match","int32Color","exec","concat","stringShapeRegex","colorRegex","colorNamesRegex","isUnitlessNumber","animationIterationCount","borderImageOutset","borderImageSlice","borderImageWidth","boxFlex","boxFlexGroup","boxOrdinalGroup","columnCount","columns","flex","flexGrow","flexPositive","flexShrink","flexNegative","flexOrder","gridRow","gridRowEnd","gridRowSpan","gridRowStart","gridColumn","gridColumnEnd","gridColumnSpan","gridColumnStart","fontWeight","lineClamp","lineHeight","opacity","order","orphans","tabSize","widows","zIndex","zoom","fillOpacity","floodOpacity","stopOpacity","strokeDasharray","strokeDashoffset","strokeMiterlimit","strokeOpacity","strokeWidth","prefixes","dangerousStyleValue","isCustomProperty","trim","prop","prefix","charAt","toUpperCase","substring","prefixKey","attributeCache","rangeValue","replace","outputRanges","number","p1","p2","p3","p4","nodeType","setAttribute","scrollTop","scrollLeft","attributes","filter","nodeName","parentNode","styleName","textContent","styleValue","setProperty","dashCase","toLowerCase","getAttribute","lowercase","extendedAnimated","Component","forceUpdate","propsAnimated","attachProps","oldPropsAnimated","didUpdate","getAnimatedValue","val","_getValue","animatedProps","refFn","childRef","handleRef","createElement","object","element","CollapseItem","React","useState","puxDesignCollapseItemtOpened","isOpen","setOpen","springAnim","maxHeight","useInView","threshold","triggerOnce","inView","motion","div","className","puxDesignCollapseItemColor","contentItemId","animate","variants","visible","scale","x","hidden","transition","ease","onClick","puxDesignCollapseItemDisplayTitle","puxDesignCollapseItemIsOptional","dangerouslySetInnerHTML","__html","puxDesignCollapseItemDescription","html","puxDesignCollapseItemDuration","puxDesignCollapseItemOutput","puxDesignCollapseItemNestedCollapses","contentItems","collapse","HowDoWeWork","data","pageContext","page","orchard","puxDesignHowDoWeWork","collapses","puxDesignHowDoWeWorkCollapses","pmRef","useRef","navPos","setNavPos","useEffect","clientHeight","document","getElementsByTagName","offsetHeight","offsetTop","localizedPath","localization","localizations","PuxMetaTags","metaTagsData","BreadCrumbs","default","center","items","path","displayText","puxDesignHowDoWeWorkDisplayTitle","topOffset","disableCompensation","isSticky","puxDesignHowDoWeWorkPMDescription","puxDesignHowDoWeWorkPMDuration","puxDesignHowDoWeWorkPMOutput","widgetBuilderData","widgets"],"mappings":"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","file":"ed677cf06753a218816e1f99a4b017ff1d926913-ca897cc49f59eb2c18e6.js","sourcesContent":["export default function _assertThisInitialized(self) {\n  if (self === void 0) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n\n  return self;\n}","import setPrototypeOf from \"./setPrototypeOf.js\";\nexport default function _inherits(subClass, superClass) {\n  if (typeof superClass !== \"function\" && superClass !== null) {\n    throw new TypeError(\"Super expression must either be null or a function\");\n  }\n\n  subClass.prototype = Object.create(superClass && superClass.prototype, {\n    constructor: {\n      value: subClass,\n      writable: true,\n      configurable: true\n    }\n  });\n  if (superClass) setPrototypeOf(subClass, superClass);\n}","import _typeof from \"@babel/runtime/helpers/typeof\";\nimport assertThisInitialized from \"./assertThisInitialized.js\";\nexport default function _possibleConstructorReturn(self, call) {\n  if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) {\n    return call;\n  }\n\n  return assertThisInitialized(self);\n}","export default function _getPrototypeOf(o) {\n  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {\n    return o.__proto__ || Object.getPrototypeOf(o);\n  };\n  return _getPrototypeOf(o);\n}","export default function _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\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\nexport default function _createClass(Constructor, protoProps, staticProps) {\n  if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n  if (staticProps) _defineProperties(Constructor, staticProps);\n  return Constructor;\n}","export default function _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n}","export default function _extends() {\n  _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\n  return _extends.apply(this, arguments);\n}","export default function _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\n\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n\n  return target;\n}","import _toConsumableArray from \"E:/Gatsby/Puxdesign/Prod/gatsby/node_modules/@babel/runtime/helpers/esm/toConsumableArray\";\nimport _assertThisInitialized from \"E:/Gatsby/Puxdesign/Prod/gatsby/node_modules/@babel/runtime/helpers/esm/assertThisInitialized\";\nimport _inherits from \"E:/Gatsby/Puxdesign/Prod/gatsby/node_modules/@babel/runtime/helpers/esm/inherits\";\nimport _possibleConstructorReturn from \"E:/Gatsby/Puxdesign/Prod/gatsby/node_modules/@babel/runtime/helpers/esm/possibleConstructorReturn\";\nimport _getPrototypeOf from \"E:/Gatsby/Puxdesign/Prod/gatsby/node_modules/@babel/runtime/helpers/esm/getPrototypeOf\";\nimport _classCallCheck from \"E:/Gatsby/Puxdesign/Prod/gatsby/node_modules/@babel/runtime/helpers/esm/classCallCheck\";\nimport _createClass from \"E:/Gatsby/Puxdesign/Prod/gatsby/node_modules/@babel/runtime/helpers/esm/createClass\";\nimport _defineProperty from \"E:/Gatsby/Puxdesign/Prod/gatsby/node_modules/@babel/runtime/helpers/esm/defineProperty\";\n\nfunction _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }\n\nfunction _isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }\n\nimport \"core-js/modules/es.array.reduce.js\";\nimport \"core-js/modules/es.array.sort.js\";\nimport _extends from '@babel/runtime/helpers/esm/extends';\nimport _objectWithoutPropertiesLoose from '@babel/runtime/helpers/esm/objectWithoutPropertiesLoose';\nimport React, { useState, useCallback, forwardRef, useRef, useEffect, useImperativeHandle, useMemo } from 'react';\nvar is = {\n  arr: Array.isArray,\n  obj: function obj(a) {\n    return Object.prototype.toString.call(a) === '[object Object]';\n  },\n  fun: function fun(a) {\n    return typeof a === 'function';\n  },\n  str: function str(a) {\n    return typeof a === 'string';\n  },\n  num: function num(a) {\n    return typeof a === 'number';\n  },\n  und: function und(a) {\n    return a === void 0;\n  },\n  nul: function nul(a) {\n    return a === null;\n  },\n  set: function set(a) {\n    return a instanceof Set;\n  },\n  map: function map(a) {\n    return a instanceof Map;\n  },\n  equ: function equ(a, b) {\n    if (typeof a !== typeof b) return false;\n    if (is.str(a) || is.num(a)) return a === b;\n    if (is.obj(a) && is.obj(b) && Object.keys(a).length + Object.keys(b).length === 0) return true;\n    var i;\n\n    for (i in a) {\n      if (!(i in b)) return false;\n    }\n\n    for (i in b) {\n      if (a[i] !== b[i]) return false;\n    }\n\n    return is.und(i) ? a === b : true;\n  }\n};\n\nfunction merge(target, lowercase) {\n  if (lowercase === void 0) {\n    lowercase = true;\n  }\n\n  return function (object) {\n    return (is.arr(object) ? object : Object.keys(object)).reduce(function (acc, element) {\n      var key = lowercase ? element[0].toLowerCase() + element.substring(1) : element;\n      acc[key] = target(key);\n      return acc;\n    }, target);\n  };\n}\n\nfunction useForceUpdate() {\n  var _useState = useState(false),\n      f = _useState[1];\n\n  var forceUpdate = useCallback(function () {\n    return f(function (v) {\n      return !v;\n    });\n  }, []);\n  return forceUpdate;\n}\n\nfunction withDefault(value, defaultValue) {\n  return is.und(value) || is.nul(value) ? defaultValue : value;\n}\n\nfunction toArray(a) {\n  return !is.und(a) ? is.arr(a) ? a : [a] : [];\n}\n\nfunction callProp(obj) {\n  for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n    args[_key - 1] = arguments[_key];\n  }\n\n  return is.fun(obj) ? obj.apply(void 0, args) : obj;\n}\n\nfunction getForwardProps(props) {\n  var to = props.to,\n      from = props.from,\n      config = props.config,\n      onStart = props.onStart,\n      onRest = props.onRest,\n      onFrame = props.onFrame,\n      children = props.children,\n      reset = props.reset,\n      reverse = props.reverse,\n      force = props.force,\n      immediate = props.immediate,\n      delay = props.delay,\n      attach = props.attach,\n      destroyed = props.destroyed,\n      interpolateTo = props.interpolateTo,\n      ref = props.ref,\n      lazy = props.lazy,\n      forward = _objectWithoutPropertiesLoose(props, [\"to\", \"from\", \"config\", \"onStart\", \"onRest\", \"onFrame\", \"children\", \"reset\", \"reverse\", \"force\", \"immediate\", \"delay\", \"attach\", \"destroyed\", \"interpolateTo\", \"ref\", \"lazy\"]);\n\n  return forward;\n}\n\nfunction interpolateTo(props) {\n  var forward = getForwardProps(props);\n  if (is.und(forward)) return _extends({\n    to: forward\n  }, props);\n  var rest = Object.keys(props).reduce(function (a, k) {\n    return !is.und(forward[k]) ? a : _extends({}, a, _defineProperty({}, k, props[k]));\n  }, {});\n  return _extends({\n    to: forward\n  }, rest);\n}\n\nfunction handleRef(ref, forward) {\n  if (forward) {\n    // If it's a function, assume it's a ref callback\n    if (is.fun(forward)) forward(ref);else if (is.obj(forward)) {\n      forward.current = ref;\n    }\n  }\n\n  return ref;\n}\n\nvar Animated = /*#__PURE__*/function () {\n  function Animated() {\n    _classCallCheck(this, Animated);\n\n    this.payload = void 0;\n    this.children = [];\n  }\n\n  _createClass(Animated, [{\n    key: \"getAnimatedValue\",\n    value: function getAnimatedValue() {\n      return this.getValue();\n    }\n  }, {\n    key: \"getPayload\",\n    value: function getPayload() {\n      return this.payload || this;\n    }\n  }, {\n    key: \"attach\",\n    value: function attach() {}\n  }, {\n    key: \"detach\",\n    value: function detach() {}\n  }, {\n    key: \"getChildren\",\n    value: function getChildren() {\n      return this.children;\n    }\n  }, {\n    key: \"addChild\",\n    value: function addChild(child) {\n      if (this.children.length === 0) this.attach();\n      this.children.push(child);\n    }\n  }, {\n    key: \"removeChild\",\n    value: function removeChild(child) {\n      var index = this.children.indexOf(child);\n      this.children.splice(index, 1);\n      if (this.children.length === 0) this.detach();\n    }\n  }]);\n\n  return Animated;\n}();\n\nvar AnimatedArray = /*#__PURE__*/function (_Animated) {\n  _inherits(AnimatedArray, _Animated);\n\n  var _super = _createSuper(AnimatedArray);\n\n  function AnimatedArray() {\n    var _this2;\n\n    _classCallCheck(this, AnimatedArray);\n\n    _this2 = _super.apply(this, arguments);\n    _this2.payload = [];\n\n    _this2.attach = function () {\n      return _this2.payload.forEach(function (p) {\n        return p instanceof Animated && p.addChild(_assertThisInitialized(_this2));\n      });\n    };\n\n    _this2.detach = function () {\n      return _this2.payload.forEach(function (p) {\n        return p instanceof Animated && p.removeChild(_assertThisInitialized(_this2));\n      });\n    };\n\n    return _this2;\n  }\n\n  return AnimatedArray;\n}(Animated);\n\nvar AnimatedObject = /*#__PURE__*/function (_Animated2) {\n  _inherits(AnimatedObject, _Animated2);\n\n  var _super2 = _createSuper(AnimatedObject);\n\n  function AnimatedObject() {\n    var _this3;\n\n    _classCallCheck(this, AnimatedObject);\n\n    _this3 = _super2.apply(this, arguments);\n    _this3.payload = {};\n\n    _this3.attach = function () {\n      return Object.values(_this3.payload).forEach(function (s) {\n        return s instanceof Animated && s.addChild(_assertThisInitialized(_this3));\n      });\n    };\n\n    _this3.detach = function () {\n      return Object.values(_this3.payload).forEach(function (s) {\n        return s instanceof Animated && s.removeChild(_assertThisInitialized(_this3));\n      });\n    };\n\n    return _this3;\n  }\n\n  _createClass(AnimatedObject, [{\n    key: \"getValue\",\n    value: function getValue(animated) {\n      if (animated === void 0) {\n        animated = false;\n      }\n\n      var payload = {};\n\n      for (var key in this.payload) {\n        var value = this.payload[key];\n        if (animated && !(value instanceof Animated)) continue;\n        payload[key] = value instanceof Animated ? value[animated ? 'getAnimatedValue' : 'getValue']() : value;\n      }\n\n      return payload;\n    }\n  }, {\n    key: \"getAnimatedValue\",\n    value: function getAnimatedValue() {\n      return this.getValue(true);\n    }\n  }]);\n\n  return AnimatedObject;\n}(Animated);\n\nvar applyAnimatedValues;\n\nfunction injectApplyAnimatedValues(fn, transform) {\n  applyAnimatedValues = {\n    fn: fn,\n    transform: transform\n  };\n}\n\nvar colorNames;\n\nfunction injectColorNames(names) {\n  colorNames = names;\n}\n\nvar requestFrame = function requestFrame(cb) {\n  return typeof window !== 'undefined' ? window.requestAnimationFrame(cb) : -1;\n};\n\nvar cancelFrame = function cancelFrame(id) {\n  typeof window !== 'undefined' && window.cancelAnimationFrame(id);\n};\n\nfunction injectFrame(raf, caf) {\n  requestFrame = raf;\n  cancelFrame = caf;\n}\n\nvar interpolation;\n\nfunction injectStringInterpolator(fn) {\n  interpolation = fn;\n}\n\nvar now = function now() {\n  return Date.now();\n};\n\nfunction injectNow(nowFn) {\n  now = nowFn;\n}\n\nvar defaultElement;\n\nfunction injectDefaultElement(el) {\n  defaultElement = el;\n}\n\nvar animatedApi = function animatedApi(node) {\n  return node.current;\n};\n\nfunction injectAnimatedApi(fn) {\n  animatedApi = fn;\n}\n\nvar createAnimatedStyle;\n\nfunction injectCreateAnimatedStyle(factory) {\n  createAnimatedStyle = factory;\n}\n\nvar manualFrameloop;\n\nfunction injectManualFrameloop(callback) {\n  manualFrameloop = callback;\n}\n\nvar Globals = /*#__PURE__*/Object.freeze({\n  get applyAnimatedValues() {\n    return applyAnimatedValues;\n  },\n\n  injectApplyAnimatedValues: injectApplyAnimatedValues,\n\n  get colorNames() {\n    return colorNames;\n  },\n\n  injectColorNames: injectColorNames,\n\n  get requestFrame() {\n    return requestFrame;\n  },\n\n  get cancelFrame() {\n    return cancelFrame;\n  },\n\n  injectFrame: injectFrame,\n\n  get interpolation() {\n    return interpolation;\n  },\n\n  injectStringInterpolator: injectStringInterpolator,\n\n  get now() {\n    return now;\n  },\n\n  injectNow: injectNow,\n\n  get defaultElement() {\n    return defaultElement;\n  },\n\n  injectDefaultElement: injectDefaultElement,\n\n  get animatedApi() {\n    return animatedApi;\n  },\n\n  injectAnimatedApi: injectAnimatedApi,\n\n  get createAnimatedStyle() {\n    return createAnimatedStyle;\n  },\n\n  injectCreateAnimatedStyle: injectCreateAnimatedStyle,\n\n  get manualFrameloop() {\n    return manualFrameloop;\n  },\n\n  injectManualFrameloop: injectManualFrameloop\n});\n/**\n * Wraps the `style` property with `AnimatedStyle`.\n */\n\nvar AnimatedProps = /*#__PURE__*/function (_AnimatedObject) {\n  _inherits(AnimatedProps, _AnimatedObject);\n\n  var _super3 = _createSuper(AnimatedProps);\n\n  function AnimatedProps(props, callback) {\n    var _this4;\n\n    _classCallCheck(this, AnimatedProps);\n\n    _this4 = _super3.call(this);\n    _this4.update = void 0;\n    _this4.payload = !props.style ? props : _extends({}, props, {\n      style: createAnimatedStyle(props.style)\n    });\n    _this4.update = callback;\n\n    _this4.attach();\n\n    return _this4;\n  }\n\n  return AnimatedProps;\n}(AnimatedObject);\n\nvar isFunctionComponent = function isFunctionComponent(val) {\n  return is.fun(val) && !(val.prototype instanceof React.Component);\n};\n\nvar createAnimatedComponent = function createAnimatedComponent(Component) {\n  var AnimatedComponent = forwardRef(function (props, ref) {\n    var forceUpdate = useForceUpdate();\n    var mounted = useRef(true);\n    var propsAnimated = useRef(null);\n    var node = useRef(null);\n    var attachProps = useCallback(function (props) {\n      var oldPropsAnimated = propsAnimated.current;\n\n      var callback = function callback() {\n        var didUpdate = false;\n\n        if (node.current) {\n          didUpdate = applyAnimatedValues.fn(node.current, propsAnimated.current.getAnimatedValue());\n        }\n\n        if (!node.current || didUpdate === false) {\n          // If no referenced node has been found, or the update target didn't have a\n          // native-responder, then forceUpdate the animation ...\n          forceUpdate();\n        }\n      };\n\n      propsAnimated.current = new AnimatedProps(props, callback);\n      oldPropsAnimated && oldPropsAnimated.detach();\n    }, []);\n    useEffect(function () {\n      return function () {\n        mounted.current = false;\n        propsAnimated.current && propsAnimated.current.detach();\n      };\n    }, []);\n    useImperativeHandle(ref, function () {\n      return animatedApi(node, mounted, forceUpdate);\n    });\n    attachProps(props);\n\n    var _getValue = propsAnimated.current.getValue(),\n        scrollTop = _getValue.scrollTop,\n        scrollLeft = _getValue.scrollLeft,\n        animatedProps = _objectWithoutPropertiesLoose(_getValue, [\"scrollTop\", \"scrollLeft\"]); // Functions cannot have refs, see:\n    // See: https://github.com/react-spring/react-spring/issues/569\n\n\n    var refFn = isFunctionComponent(Component) ? undefined : function (childRef) {\n      return node.current = handleRef(childRef, ref);\n    };\n    return React.createElement(Component, _extends({}, animatedProps, {\n      ref: refFn\n    }));\n  });\n  return AnimatedComponent;\n};\n\nvar active = false;\nvar controllers = new Set();\n\nvar update = function update() {\n  if (!active) return false;\n  var time = now();\n\n  var _iterator = _createForOfIteratorHelper(controllers),\n      _step;\n\n  try {\n    for (_iterator.s(); !(_step = _iterator.n()).done;) {\n      var controller = _step.value;\n      var isActive = false;\n\n      for (var configIdx = 0; configIdx < controller.configs.length; configIdx++) {\n        var _config = controller.configs[configIdx];\n        var endOfAnimation = void 0,\n            lastTime = void 0;\n\n        for (var valIdx = 0; valIdx < _config.animatedValues.length; valIdx++) {\n          var animation = _config.animatedValues[valIdx]; // If an animation is done, skip, until all of them conclude\n\n          if (animation.done) continue;\n          var from = _config.fromValues[valIdx];\n          var to = _config.toValues[valIdx];\n          var position = animation.lastPosition;\n          var isAnimated = to instanceof Animated;\n          var velocity = Array.isArray(_config.initialVelocity) ? _config.initialVelocity[valIdx] : _config.initialVelocity;\n          if (isAnimated) to = to.getValue(); // Conclude animation if it's either immediate, or from-values match end-state\n\n          if (_config.immediate) {\n            animation.setValue(to);\n            animation.done = true;\n            continue;\n          } // Break animation when string values are involved\n\n\n          if (typeof from === 'string' || typeof to === 'string') {\n            animation.setValue(to);\n            animation.done = true;\n            continue;\n          }\n\n          if (_config.duration !== void 0) {\n            /** Duration easing */\n            position = from + _config.easing((time - animation.startTime) / _config.duration) * (to - from);\n            endOfAnimation = time >= animation.startTime + _config.duration;\n          } else if (_config.decay) {\n            /** Decay easing */\n            position = from + velocity / (1 - 0.998) * (1 - Math.exp(-(1 - 0.998) * (time - animation.startTime)));\n            endOfAnimation = Math.abs(animation.lastPosition - position) < 0.1;\n            if (endOfAnimation) to = position;\n          } else {\n            /** Spring easing */\n            lastTime = animation.lastTime !== void 0 ? animation.lastTime : time;\n            velocity = animation.lastVelocity !== void 0 ? animation.lastVelocity : _config.initialVelocity; // If we lost a lot of frames just jump to the end.\n\n            if (time > lastTime + 64) lastTime = time; // http://gafferongames.com/game-physics/fix-your-timestep/\n\n            var numSteps = Math.floor(time - lastTime);\n\n            for (var i = 0; i < numSteps; ++i) {\n              var force = -_config.tension * (position - to);\n              var damping = -_config.friction * velocity;\n              var acceleration = (force + damping) / _config.mass;\n              velocity = velocity + acceleration * 1 / 1000;\n              position = position + velocity * 1 / 1000;\n            } // Conditions for stopping the spring animation\n\n\n            var isOvershooting = _config.clamp && _config.tension !== 0 ? from < to ? position > to : position < to : false;\n\n            var isVelocity = Math.abs(velocity) <= _config.precision;\n\n            var isDisplacement = _config.tension !== 0 ? Math.abs(to - position) <= _config.precision : true;\n            endOfAnimation = isOvershooting || isVelocity && isDisplacement;\n            animation.lastVelocity = velocity;\n            animation.lastTime = time;\n          } // Trails aren't done until their parents conclude\n\n\n          if (isAnimated && !_config.toValues[valIdx].done) endOfAnimation = false;\n\n          if (endOfAnimation) {\n            // Ensure that we end up with a round value\n            if (animation.value !== to) position = to;\n            animation.done = true;\n          } else isActive = true;\n\n          animation.setValue(position);\n          animation.lastPosition = position;\n        } // Keep track of updated values only when necessary\n\n\n        if (controller.props.onFrame) controller.values[_config.name] = _config.interpolation.getValue();\n      } // Update callbacks in the end of the frame\n\n\n      if (controller.props.onFrame) controller.props.onFrame(controller.values); // Either call onEnd or next frame\n\n      if (!isActive) {\n        controllers.delete(controller);\n        controller.stop(true);\n      }\n    } // Loop over as long as there are controllers ...\n\n  } catch (err) {\n    _iterator.e(err);\n  } finally {\n    _iterator.f();\n  }\n\n  if (controllers.size) {\n    if (manualFrameloop) manualFrameloop();else requestFrame(update);\n  } else {\n    active = false;\n  }\n\n  return active;\n};\n\nvar _start = function start(controller) {\n  if (!controllers.has(controller)) controllers.add(controller);\n\n  if (!active) {\n    active = true;\n    if (manualFrameloop) requestFrame(manualFrameloop);else requestFrame(update);\n  }\n};\n\nvar stop = function stop(controller) {\n  if (controllers.has(controller)) controllers.delete(controller);\n};\n\nfunction createInterpolator(range, output, extrapolate) {\n  if (typeof range === 'function') {\n    return range;\n  }\n\n  if (Array.isArray(range)) {\n    return createInterpolator({\n      range: range,\n      output: output,\n      extrapolate: extrapolate\n    });\n  }\n\n  if (interpolation && typeof range.output[0] === 'string') {\n    return interpolation(range);\n  }\n\n  var config = range;\n  var outputRange = config.output;\n  var inputRange = config.range || [0, 1];\n  var extrapolateLeft = config.extrapolateLeft || config.extrapolate || 'extend';\n  var extrapolateRight = config.extrapolateRight || config.extrapolate || 'extend';\n\n  var easing = config.easing || function (t) {\n    return t;\n  };\n\n  return function (input) {\n    var range = findRange(input, inputRange);\n    return interpolate(input, inputRange[range], inputRange[range + 1], outputRange[range], outputRange[range + 1], easing, extrapolateLeft, extrapolateRight, config.map);\n  };\n}\n\nfunction interpolate(input, inputMin, inputMax, outputMin, outputMax, easing, extrapolateLeft, extrapolateRight, map) {\n  var result = map ? map(input) : input; // Extrapolate\n\n  if (result < inputMin) {\n    if (extrapolateLeft === 'identity') return result;else if (extrapolateLeft === 'clamp') result = inputMin;\n  }\n\n  if (result > inputMax) {\n    if (extrapolateRight === 'identity') return result;else if (extrapolateRight === 'clamp') result = inputMax;\n  }\n\n  if (outputMin === outputMax) return outputMin;\n  if (inputMin === inputMax) return input <= inputMin ? outputMin : outputMax; // Input Range\n\n  if (inputMin === -Infinity) result = -result;else if (inputMax === Infinity) result = result - inputMin;else result = (result - inputMin) / (inputMax - inputMin); // Easing\n\n  result = easing(result); // Output Range\n\n  if (outputMin === -Infinity) result = -result;else if (outputMax === Infinity) result = result + outputMin;else result = result * (outputMax - outputMin) + outputMin;\n  return result;\n}\n\nfunction findRange(input, inputRange) {\n  for (var i = 1; i < inputRange.length - 1; ++i) {\n    if (inputRange[i] >= input) break;\n  }\n\n  return i - 1;\n}\n\nvar AnimatedInterpolation = /*#__PURE__*/function (_AnimatedArray) {\n  _inherits(AnimatedInterpolation, _AnimatedArray);\n\n  var _super4 = _createSuper(AnimatedInterpolation);\n\n  function AnimatedInterpolation(parents, range, output, extrapolate) {\n    var _this5;\n\n    _classCallCheck(this, AnimatedInterpolation);\n\n    _this5 = _super4.call(this);\n    _this5.calc = void 0;\n    _this5.payload = parents instanceof AnimatedArray && !(parents instanceof AnimatedInterpolation) ? parents.getPayload() : Array.isArray(parents) ? parents : [parents];\n    _this5.calc = createInterpolator(range, output, extrapolate);\n    return _this5;\n  }\n\n  _createClass(AnimatedInterpolation, [{\n    key: \"getValue\",\n    value: function getValue() {\n      return this.calc.apply(this, _toConsumableArray(this.payload.map(function (value) {\n        return value.getValue();\n      })));\n    }\n  }, {\n    key: \"updateConfig\",\n    value: function updateConfig(range, output, extrapolate) {\n      this.calc = createInterpolator(range, output, extrapolate);\n    }\n  }, {\n    key: \"interpolate\",\n    value: function interpolate(range, output, extrapolate) {\n      return new AnimatedInterpolation(this, range, output, extrapolate);\n    }\n  }]);\n\n  return AnimatedInterpolation;\n}(AnimatedArray);\n\nvar interpolate$1 = function interpolate$1(parents, range, output) {\n  return parents && new AnimatedInterpolation(parents, range, output);\n};\n\nvar config = {\n  default: {\n    tension: 170,\n    friction: 26\n  },\n  gentle: {\n    tension: 120,\n    friction: 14\n  },\n  wobbly: {\n    tension: 180,\n    friction: 12\n  },\n  stiff: {\n    tension: 210,\n    friction: 20\n  },\n  slow: {\n    tension: 280,\n    friction: 60\n  },\n  molasses: {\n    tension: 280,\n    friction: 120\n  }\n};\n/** API\n *  useChain(references, timeSteps, timeFrame)\n */\n\nfunction useChain(refs, timeSteps, timeFrame) {\n  if (timeFrame === void 0) {\n    timeFrame = 1000;\n  }\n\n  var previous = useRef();\n  useEffect(function () {\n    if (is.equ(refs, previous.current)) refs.forEach(function (_ref) {\n      var current = _ref.current;\n      return current && current.start();\n    });else if (timeSteps) {\n      refs.forEach(function (_ref2, index) {\n        var current = _ref2.current;\n\n        if (current) {\n          var ctrls = current.controllers;\n\n          if (ctrls.length) {\n            var t = timeFrame * timeSteps[index];\n            ctrls.forEach(function (ctrl) {\n              ctrl.queue = ctrl.queue.map(function (e) {\n                return _extends({}, e, {\n                  delay: e.delay + t\n                });\n              });\n              ctrl.start();\n            });\n          }\n        }\n      });\n    } else refs.reduce(function (q, _ref3, rI) {\n      var current = _ref3.current;\n      return q = q.then(function () {\n        return current.start();\n      });\n    }, Promise.resolve());\n    previous.current = refs;\n  });\n}\n/**\n * Animated works by building a directed acyclic graph of dependencies\n * transparently when you render your Animated components.\n *\n *               new Animated.Value(0)\n *     .interpolate()        .interpolate()    new Animated.Value(1)\n *         opacity               translateY      scale\n *          style                         transform\n *         View#234                         style\n *                                         View#123\n *\n * A) Top Down phase\n * When an AnimatedValue is updated, we recursively go down through this\n * graph in order to find leaf nodes: the views that we flag as needing\n * an update.\n *\n * B) Bottom Up phase\n * When a view is flagged as needing an update, we recursively go back up\n * in order to build the new value that it needs. The reason why we need\n * this two-phases process is to deal with composite props such as\n * transform which can receive values from multiple parents.\n */\n\n\nfunction addAnimatedStyles(node, styles) {\n  if ('update' in node) {\n    styles.add(node);\n  } else {\n    node.getChildren().forEach(function (child) {\n      return addAnimatedStyles(child, styles);\n    });\n  }\n}\n\nvar AnimatedValue = /*#__PURE__*/function (_Animated3) {\n  _inherits(AnimatedValue, _Animated3);\n\n  var _super5 = _createSuper(AnimatedValue);\n\n  function AnimatedValue(_value) {\n    var _this6;\n\n    _classCallCheck(this, AnimatedValue);\n\n    var _this;\n\n    _this6 = _super5.call(this);\n    _this = _assertThisInitialized(_this6);\n    _this6.animatedStyles = new Set();\n    _this6.value = void 0;\n    _this6.startPosition = void 0;\n    _this6.lastPosition = void 0;\n    _this6.lastVelocity = void 0;\n    _this6.startTime = void 0;\n    _this6.lastTime = void 0;\n    _this6.done = false;\n\n    _this6.setValue = function (value, flush) {\n      if (flush === void 0) {\n        flush = true;\n      }\n\n      _this.value = value;\n      if (flush) _this.flush();\n    };\n\n    _this6.value = _value;\n    _this6.startPosition = _value;\n    _this6.lastPosition = _value;\n    return _this6;\n  }\n\n  _createClass(AnimatedValue, [{\n    key: \"flush\",\n    value: function flush() {\n      if (this.animatedStyles.size === 0) {\n        addAnimatedStyles(this, this.animatedStyles);\n      }\n\n      this.animatedStyles.forEach(function (animatedStyle) {\n        return animatedStyle.update();\n      });\n    }\n  }, {\n    key: \"clearStyles\",\n    value: function clearStyles() {\n      this.animatedStyles.clear();\n    }\n  }, {\n    key: \"getValue\",\n    value: function getValue() {\n      return this.value;\n    }\n  }, {\n    key: \"interpolate\",\n    value: function interpolate(range, output, extrapolate) {\n      return new AnimatedInterpolation(this, range, output, extrapolate);\n    }\n  }]);\n\n  return AnimatedValue;\n}(Animated);\n\nvar AnimatedValueArray = /*#__PURE__*/function (_AnimatedArray2) {\n  _inherits(AnimatedValueArray, _AnimatedArray2);\n\n  var _super6 = _createSuper(AnimatedValueArray);\n\n  function AnimatedValueArray(values) {\n    var _this7;\n\n    _classCallCheck(this, AnimatedValueArray);\n\n    _this7 = _super6.call(this);\n    _this7.payload = values.map(function (n) {\n      return new AnimatedValue(n);\n    });\n    return _this7;\n  }\n\n  _createClass(AnimatedValueArray, [{\n    key: \"setValue\",\n    value: function setValue(value, flush) {\n      var _this8 = this;\n\n      if (flush === void 0) {\n        flush = true;\n      }\n\n      if (Array.isArray(value)) {\n        if (value.length === this.payload.length) {\n          value.forEach(function (v, i) {\n            return _this8.payload[i].setValue(v, flush);\n          });\n        }\n      } else {\n        this.payload.forEach(function (p) {\n          return p.setValue(value, flush);\n        });\n      }\n    }\n  }, {\n    key: \"getValue\",\n    value: function getValue() {\n      return this.payload.map(function (v) {\n        return v.getValue();\n      });\n    }\n  }, {\n    key: \"interpolate\",\n    value: function interpolate(range, output) {\n      return new AnimatedInterpolation(this, range, output);\n    }\n  }]);\n\n  return AnimatedValueArray;\n}(AnimatedArray);\n\nvar G = 0;\n\nvar Controller = /*#__PURE__*/function () {\n  function Controller() {\n    var _this9 = this;\n\n    _classCallCheck(this, Controller);\n\n    this.id = void 0;\n    this.idle = true;\n    this.hasChanged = false;\n    this.guid = 0;\n    this.local = 0;\n    this.props = {};\n    this.merged = {};\n    this.animations = {};\n    this.interpolations = {};\n    this.values = {};\n    this.configs = [];\n    this.listeners = [];\n    this.queue = [];\n    this.localQueue = void 0;\n\n    this.getValues = function () {\n      return _this9.interpolations;\n    };\n\n    this.id = G++;\n  }\n  /** update(props)\n   *  This function filters input props and creates an array of tasks which are executed in .start()\n   *  Each task is allowed to carry a delay, which means it can execute asnychroneously */\n\n\n  _createClass(Controller, [{\n    key: \"update\",\n    value: function update(args) {\n      //this._id = n + this.id\n      if (!args) return this; // Extract delay and the to-prop from props\n\n      var _ref = interpolateTo(args),\n          _ref$delay = _ref.delay,\n          delay = _ref$delay === void 0 ? 0 : _ref$delay,\n          to = _ref.to,\n          props = _objectWithoutPropertiesLoose(_ref, [\"delay\", \"to\"]);\n\n      if (is.arr(to) || is.fun(to)) {\n        // If config is either a function or an array queue it up as is\n        this.queue.push(_extends({}, props, {\n          delay: delay,\n          to: to\n        }));\n      } else if (to) {\n        // Otherwise go through each key since it could be delayed individually\n        var ops = {};\n        Object.entries(to).forEach(function (_ref2) {\n          var k = _ref2[0],\n              v = _ref2[1]; // Fetch delay and create an entry, consisting of the to-props, the delay, and basic props\n\n          var entry = _extends({\n            to: _defineProperty({}, k, v),\n            delay: callProp(delay, k)\n          }, props);\n\n          var previous = ops[entry.delay] && ops[entry.delay].to;\n          ops[entry.delay] = _extends({}, ops[entry.delay], entry, {\n            to: _extends({}, previous, entry.to)\n          });\n        });\n        this.queue = Object.values(ops);\n      } // Sort queue, so that async calls go last\n\n\n      this.queue = this.queue.sort(function (a, b) {\n        return a.delay - b.delay;\n      }); // Diff the reduced props immediately (they'll contain the from-prop and some config)\n\n      this.diff(props);\n      return this;\n    }\n    /** start(onEnd)\n     *  This function either executes a queue, if present, or starts the frameloop, which animates */\n\n  }, {\n    key: \"start\",\n    value: function start(onEnd) {\n      var _this10 = this;\n\n      // If a queue is present we must excecute it\n      if (this.queue.length) {\n        this.idle = false; // Updates can interrupt trailing queues, in that case we just merge values\n\n        if (this.localQueue) {\n          this.localQueue.forEach(function (_ref3) {\n            var _ref3$from = _ref3.from,\n                from = _ref3$from === void 0 ? {} : _ref3$from,\n                _ref3$to = _ref3.to,\n                to = _ref3$to === void 0 ? {} : _ref3$to;\n            if (is.obj(from)) _this10.merged = _extends({}, from, _this10.merged);\n            if (is.obj(to)) _this10.merged = _extends({}, _this10.merged, to);\n          });\n        } // The guid helps us tracking frames, a new queue over an old one means an override\n        // We discard async calls in that caseÍ\n\n\n        var local = this.local = ++this.guid;\n        var queue = this.localQueue = this.queue;\n        this.queue = []; // Go through each entry and execute it\n\n        queue.forEach(function (_ref4, index) {\n          var delay = _ref4.delay,\n              props = _objectWithoutPropertiesLoose(_ref4, [\"delay\"]);\n\n          var cb = function cb(finished) {\n            if (index === queue.length - 1 && local === _this10.guid && finished) {\n              _this10.idle = true;\n              if (_this10.props.onRest) _this10.props.onRest(_this10.merged);\n            }\n\n            if (onEnd) onEnd();\n          }; // Entries can be delayed, ansyc or immediate\n\n\n          var async = is.arr(props.to) || is.fun(props.to);\n\n          if (delay) {\n            setTimeout(function () {\n              if (local === _this10.guid) {\n                if (async) _this10.runAsync(props, cb);else _this10.diff(props).start(cb);\n              }\n            }, delay);\n          } else if (async) _this10.runAsync(props, cb);else _this10.diff(props).start(cb);\n        });\n      } // Otherwise we kick of the frameloop\n      else {\n          if (is.fun(onEnd)) this.listeners.push(onEnd);\n          if (this.props.onStart) this.props.onStart();\n\n          _start(this);\n        }\n\n      return this;\n    }\n  }, {\n    key: \"stop\",\n    value: function stop(finished) {\n      this.listeners.forEach(function (onEnd) {\n        return onEnd(finished);\n      });\n      this.listeners = [];\n      return this;\n    }\n    /** Pause sets onEnd listeners free, but also removes the controller from the frameloop */\n\n  }, {\n    key: \"pause\",\n    value: function pause(finished) {\n      this.stop(true);\n      if (finished) stop(this);\n      return this;\n    }\n  }, {\n    key: \"runAsync\",\n    value: function runAsync(_ref5, onEnd) {\n      var _this11 = this;\n\n      var _this = this;\n\n      var delay = _ref5.delay,\n          props = _objectWithoutPropertiesLoose(_ref5, [\"delay\"]);\n\n      var local = this.local; // If \"to\" is either a function or an array it will be processed async, therefor \"to\" should be empty right now\n      // If the view relies on certain values \"from\" has to be present\n\n      var queue = Promise.resolve(undefined);\n\n      if (is.arr(props.to)) {\n        var _loop = function _loop(i) {\n          var index = i;\n\n          var fresh = _extends({}, props, interpolateTo(props.to[index]));\n\n          if (is.arr(fresh.config)) fresh.config = fresh.config[index];\n          queue = queue.then(function () {\n            //this.stop()\n            if (local === _this11.guid) return new Promise(function (r) {\n              return _this11.diff(fresh).start(r);\n            });\n          });\n        };\n\n        for (var i = 0; i < props.to.length; i++) {\n          _loop(i);\n        }\n      } else if (is.fun(props.to)) {\n        var index = 0;\n        var last;\n        queue = queue.then(function () {\n          return props.to( // next(props)\n          function (p) {\n            var fresh = _extends({}, props, interpolateTo(p));\n\n            if (is.arr(fresh.config)) fresh.config = fresh.config[index];\n            index++; //this.stop()\n\n            if (local === _this11.guid) return last = new Promise(function (r) {\n              return _this11.diff(fresh).start(r);\n            });\n            return;\n          }, // cancel()\n          function (finished) {\n            if (finished === void 0) {\n              finished = true;\n            }\n\n            return _this.stop(finished);\n          }).then(function () {\n            return last;\n          });\n        });\n      }\n\n      queue.then(onEnd);\n    }\n  }, {\n    key: \"diff\",\n    value: function diff(props) {\n      var _this12 = this;\n\n      this.props = _extends({}, this.props, props);\n      var _this$props = this.props,\n          _this$props$from = _this$props.from,\n          from = _this$props$from === void 0 ? {} : _this$props$from,\n          _this$props$to = _this$props.to,\n          to = _this$props$to === void 0 ? {} : _this$props$to,\n          _this$props$config = _this$props.config,\n          config = _this$props$config === void 0 ? {} : _this$props$config,\n          reverse = _this$props.reverse,\n          attach = _this$props.attach,\n          reset = _this$props.reset,\n          immediate = _this$props.immediate; // Reverse values when requested\n\n      if (reverse) {\n        var _ref6 = [to, from];\n        from = _ref6[0];\n        to = _ref6[1];\n      } // This will collect all props that were ever set, reset merged props when necessary\n\n\n      this.merged = _extends({}, from, this.merged, to);\n      this.hasChanged = false; // Attachment handling, trailed springs can \"attach\" themselves to a previous spring\n\n      var target = attach && attach(this); // Reduces input { name: value } pairs into animated values\n\n      this.animations = Object.entries(this.merged).reduce(function (acc, _ref7) {\n        var name = _ref7[0],\n            value = _ref7[1]; // Issue cached entries, except on reset\n\n        var entry = acc[name] || {}; // Figure out what the value is supposed to be\n\n        var isNumber = is.num(value);\n        var isString = is.str(value) && !value.startsWith('#') && !/\\d/.test(value) && !colorNames[value];\n        var isArray = is.arr(value);\n        var isInterpolation = !isNumber && !isArray && !isString;\n        var fromValue = !is.und(from[name]) ? from[name] : value;\n        var toValue = isNumber || isArray ? value : isString ? value : 1;\n        var toConfig = callProp(config, name);\n        if (target) toValue = target.animations[name].parent;\n        var parent = entry.parent,\n            interpolation$$1 = entry.interpolation,\n            toValues = toArray(target ? toValue.getPayload() : toValue),\n            animatedValues;\n        var newValue = value;\n        if (isInterpolation) newValue = interpolation({\n          range: [0, 1],\n          output: [value, value]\n        })(1);\n        var currentValue = interpolation$$1 && interpolation$$1.getValue(); // Change detection flags\n\n        var isFirst = is.und(parent);\n        var isActive = !isFirst && entry.animatedValues.some(function (v) {\n          return !v.done;\n        });\n        var currentValueDiffersFromGoal = !is.equ(newValue, currentValue);\n        var hasNewGoal = !is.equ(newValue, entry.previous);\n        var hasNewConfig = !is.equ(toConfig, entry.config); // Change animation props when props indicate a new goal (new value differs from previous one)\n        // and current values differ from it. Config changes trigger a new update as well (though probably shouldn't?)\n\n        if (reset || hasNewGoal && currentValueDiffersFromGoal || hasNewConfig) {\n          // Convert regular values into animated values, ALWAYS re-use if possible\n          if (isNumber || isString) parent = interpolation$$1 = entry.parent || new AnimatedValue(fromValue);else if (isArray) parent = interpolation$$1 = entry.parent || new AnimatedValueArray(fromValue);else if (isInterpolation) {\n            var prev = entry.interpolation && entry.interpolation.calc(entry.parent.value);\n            prev = prev !== void 0 && !reset ? prev : fromValue;\n\n            if (entry.parent) {\n              parent = entry.parent;\n              parent.setValue(0, false);\n            } else parent = new AnimatedValue(0);\n\n            var range = {\n              output: [prev, value]\n            };\n\n            if (entry.interpolation) {\n              interpolation$$1 = entry.interpolation;\n              entry.interpolation.updateConfig(range);\n            } else interpolation$$1 = parent.interpolate(range);\n          }\n          toValues = toArray(target ? toValue.getPayload() : toValue);\n          animatedValues = toArray(parent.getPayload());\n          if (reset && !isInterpolation) parent.setValue(fromValue, false);\n          _this12.hasChanged = true; // Reset animated values\n\n          animatedValues.forEach(function (value) {\n            value.startPosition = value.value;\n            value.lastPosition = value.value;\n            value.lastVelocity = isActive ? value.lastVelocity : undefined;\n            value.lastTime = isActive ? value.lastTime : undefined;\n            value.startTime = now();\n            value.done = false;\n            value.animatedStyles.clear();\n          }); // Set immediate values\n\n          if (callProp(immediate, name)) {\n            parent.setValue(isInterpolation ? toValue : value, false);\n          }\n\n          return _extends({}, acc, _defineProperty({}, name, _extends({}, entry, {\n            name: name,\n            parent: parent,\n            interpolation: interpolation$$1,\n            animatedValues: animatedValues,\n            toValues: toValues,\n            previous: newValue,\n            config: toConfig,\n            fromValues: toArray(parent.getValue()),\n            immediate: callProp(immediate, name),\n            initialVelocity: withDefault(toConfig.velocity, 0),\n            clamp: withDefault(toConfig.clamp, false),\n            precision: withDefault(toConfig.precision, 0.01),\n            tension: withDefault(toConfig.tension, 170),\n            friction: withDefault(toConfig.friction, 26),\n            mass: withDefault(toConfig.mass, 1),\n            duration: toConfig.duration,\n            easing: withDefault(toConfig.easing, function (t) {\n              return t;\n            }),\n            decay: toConfig.decay\n          })));\n        } else {\n          if (!currentValueDiffersFromGoal) {\n            // So ... the current target value (newValue) appears to be different from the previous value,\n            // which normally constitutes an update, but the actual value (currentValue) matches the target!\n            // In order to resolve this without causing an animation update we silently flag the animation as done,\n            // which it technically is. Interpolations also needs a config update with their target set to 1.\n            if (isInterpolation) {\n              parent.setValue(1, false);\n              interpolation$$1.updateConfig({\n                output: [newValue, newValue]\n              });\n            }\n\n            parent.done = true;\n            _this12.hasChanged = true;\n            return _extends({}, acc, _defineProperty({}, name, _extends({}, acc[name], {\n              previous: newValue\n            })));\n          }\n\n          return acc;\n        }\n      }, this.animations);\n\n      if (this.hasChanged) {\n        // Make animations available to frameloop\n        this.configs = Object.values(this.animations);\n        this.values = {};\n        this.interpolations = {};\n\n        for (var key in this.animations) {\n          this.interpolations[key] = this.animations[key].interpolation;\n          this.values[key] = this.animations[key].interpolation.getValue();\n        }\n      }\n\n      return this;\n    }\n  }, {\n    key: \"destroy\",\n    value: function destroy() {\n      this.stop();\n      this.props = {};\n      this.merged = {};\n      this.animations = {};\n      this.interpolations = {};\n      this.values = {};\n      this.configs = [];\n      this.local = 0;\n    }\n  }]);\n\n  return Controller;\n}();\n/** API\n * const props = useSprings(number, [{ ... }, { ... }, ...])\n * const [props, set] = useSprings(number, (i, controller) => ({ ... }))\n */\n\n\nvar useSprings = function useSprings(length, props) {\n  var mounted = useRef(false);\n  var ctrl = useRef();\n  var isFn = is.fun(props); // The controller maintains the animation values, starts and stops animations\n\n  var _useMemo = useMemo(function () {\n    // Remove old controllers\n    if (ctrl.current) {\n      ctrl.current.map(function (c) {\n        return c.destroy();\n      });\n      ctrl.current = undefined;\n    }\n\n    var ref;\n    return [new Array(length).fill().map(function (_, i) {\n      var ctrl = new Controller();\n      var newProps = isFn ? callProp(props, i, ctrl) : props[i];\n      if (i === 0) ref = newProps.ref;\n      ctrl.update(newProps);\n      if (!ref) ctrl.start();\n      return ctrl;\n    }), ref];\n  }, [length]),\n      controllers = _useMemo[0],\n      ref = _useMemo[1];\n\n  ctrl.current = controllers; // The hooks reference api gets defined here ...\n\n  var api = useImperativeHandle(ref, function () {\n    return {\n      start: function start() {\n        return Promise.all(ctrl.current.map(function (c) {\n          return new Promise(function (r) {\n            return c.start(r);\n          });\n        }));\n      },\n      stop: function stop(finished) {\n        return ctrl.current.forEach(function (c) {\n          return c.stop(finished);\n        });\n      },\n\n      get controllers() {\n        return ctrl.current;\n      }\n\n    };\n  }); // This function updates the controllers\n\n  var updateCtrl = useMemo(function () {\n    return function (updateProps) {\n      return ctrl.current.map(function (c, i) {\n        c.update(isFn ? callProp(updateProps, i, c) : updateProps[i]);\n        if (!ref) c.start();\n      });\n    };\n  }, [length]); // Update controller if props aren't functional\n\n  useEffect(function () {\n    if (mounted.current) {\n      if (!isFn) updateCtrl(props);\n    } else if (!ref) ctrl.current.forEach(function (c) {\n      return c.start();\n    });\n  }); // Update mounted flag and destroy controller on unmount\n\n  useEffect(function () {\n    return mounted.current = true, function () {\n      return ctrl.current.forEach(function (c) {\n        return c.destroy();\n      });\n    };\n  }, []); // Return animated props, or, anim-props + the update-setter above\n\n  var propValues = ctrl.current.map(function (c) {\n    return c.getValues();\n  });\n  return isFn ? [propValues, updateCtrl, function (finished) {\n    return ctrl.current.forEach(function (c) {\n      return c.pause(finished);\n    });\n  }] : propValues;\n};\n/** API\n * const props = useSpring({ ... })\n * const [props, set] = useSpring(() => ({ ... }))\n */\n\n\nvar useSpring = function useSpring(props) {\n  var isFn = is.fun(props);\n\n  var _useSprings = useSprings(1, isFn ? props : [props]),\n      result = _useSprings[0],\n      set = _useSprings[1],\n      pause = _useSprings[2];\n\n  return isFn ? [result[0], set, pause] : result;\n};\n/** API\n * const trails = useTrail(number, { ... })\n * const [trails, set] = useTrail(number, () => ({ ... }))\n */\n\n\nvar useTrail = function useTrail(length, props) {\n  var mounted = useRef(false);\n  var isFn = is.fun(props);\n  var updateProps = callProp(props);\n  var instances = useRef();\n\n  var _useSprings = useSprings(length, function (i, ctrl) {\n    if (i === 0) instances.current = [];\n    instances.current.push(ctrl);\n    return _extends({}, updateProps, {\n      config: callProp(updateProps.config, i),\n      attach: i > 0 && function () {\n        return instances.current[i - 1];\n      }\n    });\n  }),\n      result = _useSprings[0],\n      set = _useSprings[1],\n      pause = _useSprings[2]; // Set up function to update controller\n\n\n  var updateCtrl = useMemo(function () {\n    return function (props) {\n      return set(function (i, ctrl) {\n        var last = props.reverse ? i === 0 : length - 1 === i;\n        var attachIdx = props.reverse ? i + 1 : i - 1;\n        var attachController = instances.current[attachIdx];\n        return _extends({}, props, {\n          config: callProp(props.config || updateProps.config, i),\n          attach: attachController && function () {\n            return attachController;\n          }\n        });\n      });\n    };\n  }, [length, updateProps.reverse]); // Update controller if props aren't functional\n\n  useEffect(function () {\n    return void (mounted.current && !isFn && updateCtrl(props));\n  }); // Update mounted flag and destroy controller on unmount\n\n  useEffect(function () {\n    return void (mounted.current = true);\n  }, []);\n  return isFn ? [result, updateCtrl, pause] : result;\n};\n/** API\n * const transitions = useTransition(items, itemKeys, { ... })\n * const [transitions, update] = useTransition(items, itemKeys, () => ({ ... }))\n */\n\n\nvar guid = 0;\nvar ENTER = 'enter';\nvar LEAVE = 'leave';\nvar UPDATE = 'update';\n\nvar mapKeys = function mapKeys(items, keys) {\n  return (typeof keys === 'function' ? items.map(keys) : toArray(keys)).map(String);\n};\n\nvar get = function get(props) {\n  var items = props.items,\n      _props$keys = props.keys,\n      keys = _props$keys === void 0 ? function (item) {\n    return item;\n  } : _props$keys,\n      rest = _objectWithoutPropertiesLoose(props, [\"items\", \"keys\"]);\n\n  items = toArray(items !== void 0 ? items : null);\n  return _extends({\n    items: items,\n    keys: mapKeys(items, keys)\n  }, rest);\n};\n\nfunction useTransition(input, keyTransform, config) {\n  var props = _extends({\n    items: input,\n    keys: keyTransform || function (i) {\n      return i;\n    }\n  }, config);\n\n  var _get = get(props),\n      _get$lazy = _get.lazy,\n      lazy = _get$lazy === void 0 ? false : _get$lazy,\n      _get$unique = _get.unique,\n      _get$reset = _get.reset,\n      reset = _get$reset === void 0 ? false : _get$reset,\n      enter = _get.enter,\n      leave = _get.leave,\n      update = _get.update,\n      onDestroyed = _get.onDestroyed,\n      keys = _get.keys,\n      items = _get.items,\n      onFrame = _get.onFrame,\n      _onRest = _get.onRest,\n      onStart = _get.onStart,\n      ref = _get.ref,\n      extra = _objectWithoutPropertiesLoose(_get, [\"lazy\", \"unique\", \"reset\", \"enter\", \"leave\", \"update\", \"onDestroyed\", \"keys\", \"items\", \"onFrame\", \"onRest\", \"onStart\", \"ref\"]);\n\n  var forceUpdate = useForceUpdate();\n  var mounted = useRef(false);\n  var state = useRef({\n    mounted: false,\n    first: true,\n    deleted: [],\n    current: {},\n    transitions: [],\n    prevProps: {},\n    paused: !!props.ref,\n    instances: !mounted.current && new Map(),\n    forceUpdate: forceUpdate\n  });\n  useImperativeHandle(props.ref, function () {\n    return {\n      start: function start() {\n        return Promise.all(Array.from(state.current.instances).map(function (_ref) {\n          var c = _ref[1];\n          return new Promise(function (r) {\n            return c.start(r);\n          });\n        }));\n      },\n      stop: function stop(finished) {\n        return Array.from(state.current.instances).forEach(function (_ref2) {\n          var c = _ref2[1];\n          return c.stop(finished);\n        });\n      },\n\n      get controllers() {\n        return Array.from(state.current.instances).map(function (_ref3) {\n          var c = _ref3[1];\n          return c;\n        });\n      }\n\n    };\n  }); // Update state\n\n  state.current = diffItems(state.current, props);\n\n  if (state.current.changed) {\n    // Update state\n    state.current.transitions.forEach(function (transition) {\n      var slot = transition.slot,\n          from = transition.from,\n          to = transition.to,\n          config = transition.config,\n          trail = transition.trail,\n          key = transition.key,\n          item = transition.item;\n      if (!state.current.instances.has(key)) state.current.instances.set(key, new Controller()); // update the map object\n\n      var ctrl = state.current.instances.get(key);\n\n      var newProps = _extends({}, extra, {\n        to: to,\n        from: from,\n        config: config,\n        ref: ref,\n        onRest: function onRest(values) {\n          if (state.current.mounted) {\n            if (transition.destroyed) {\n              // If no ref is given delete destroyed items immediately\n              if (!ref && !lazy) cleanUp(state, key);\n              if (onDestroyed) onDestroyed(item);\n            } // A transition comes to rest once all its springs conclude\n\n\n            var curInstances = Array.from(state.current.instances);\n\n            var _active = curInstances.some(function (_ref4) {\n              var c = _ref4[1];\n              return !c.idle;\n            });\n\n            if (!_active && (ref || lazy) && state.current.deleted.length > 0) cleanUp(state);\n            if (_onRest) _onRest(item, slot, values);\n          }\n        },\n        onStart: onStart && function () {\n          return onStart(item, slot);\n        },\n        onFrame: onFrame && function (values) {\n          return onFrame(item, slot, values);\n        },\n        delay: trail,\n        reset: reset && slot === ENTER // Update controller\n\n      });\n\n      ctrl.update(newProps);\n      if (!state.current.paused) ctrl.start();\n    });\n  }\n\n  useEffect(function () {\n    state.current.mounted = mounted.current = true;\n    return function () {\n      state.current.mounted = mounted.current = false;\n      Array.from(state.current.instances).map(function (_ref5) {\n        var c = _ref5[1];\n        return c.destroy();\n      });\n      state.current.instances.clear();\n    };\n  }, []);\n  return state.current.transitions.map(function (_ref6) {\n    var item = _ref6.item,\n        slot = _ref6.slot,\n        key = _ref6.key;\n    return {\n      item: item,\n      key: key,\n      state: slot,\n      props: state.current.instances.get(key).getValues()\n    };\n  });\n}\n\nfunction cleanUp(state, filterKey) {\n  var deleted = state.current.deleted;\n\n  var _iterator2 = _createForOfIteratorHelper(deleted),\n      _step2;\n\n  try {\n    var _loop2 = function _loop2() {\n      var _ref7 = _step2.value;\n      var key = _ref7.key;\n\n      var filter = function filter(t) {\n        return t.key !== key;\n      };\n\n      if (is.und(filterKey) || filterKey === key) {\n        state.current.instances.delete(key);\n        state.current.transitions = state.current.transitions.filter(filter);\n        state.current.deleted = state.current.deleted.filter(filter);\n      }\n    };\n\n    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {\n      _loop2();\n    }\n  } catch (err) {\n    _iterator2.e(err);\n  } finally {\n    _iterator2.f();\n  }\n\n  state.current.forceUpdate();\n}\n\nfunction diffItems(_ref8, props) {\n  var first = _ref8.first,\n      prevProps = _ref8.prevProps,\n      state = _objectWithoutPropertiesLoose(_ref8, [\"first\", \"prevProps\"]);\n\n  var _get2 = get(props),\n      items = _get2.items,\n      keys = _get2.keys,\n      initial = _get2.initial,\n      from = _get2.from,\n      enter = _get2.enter,\n      leave = _get2.leave,\n      update = _get2.update,\n      _get2$trail = _get2.trail,\n      trail = _get2$trail === void 0 ? 0 : _get2$trail,\n      unique = _get2.unique,\n      config = _get2.config,\n      _get2$order = _get2.order,\n      order = _get2$order === void 0 ? [ENTER, LEAVE, UPDATE] : _get2$order;\n\n  var _get3 = get(prevProps),\n      _keys = _get3.keys,\n      _items = _get3.items;\n\n  var current = _extends({}, state.current);\n\n  var deleted = _toConsumableArray(state.deleted); // Compare next keys with current keys\n\n\n  var currentKeys = Object.keys(current);\n  var currentSet = new Set(currentKeys);\n  var nextSet = new Set(keys);\n  var added = keys.filter(function (item) {\n    return !currentSet.has(item);\n  });\n  var removed = state.transitions.filter(function (item) {\n    return !item.destroyed && !nextSet.has(item.originalKey);\n  }).map(function (i) {\n    return i.originalKey;\n  });\n  var updated = keys.filter(function (item) {\n    return currentSet.has(item);\n  });\n  var delay = -trail;\n\n  while (order.length) {\n    var changeType = order.shift();\n\n    switch (changeType) {\n      case ENTER:\n        {\n          added.forEach(function (key, index) {\n            // In unique mode, remove fading out transitions if their key comes in again\n            if (unique && deleted.find(function (d) {\n              return d.originalKey === key;\n            })) deleted = deleted.filter(function (t) {\n              return t.originalKey !== key;\n            });\n            var keyIndex = keys.indexOf(key);\n            var item = items[keyIndex];\n            var slot = first && initial !== void 0 ? 'initial' : ENTER;\n            current[key] = {\n              slot: slot,\n              originalKey: key,\n              key: unique ? String(key) : guid++,\n              item: item,\n              trail: delay = delay + trail,\n              config: callProp(config, item, slot),\n              from: callProp(first ? initial !== void 0 ? initial || {} : from : from, item),\n              to: callProp(enter, item)\n            };\n          });\n          break;\n        }\n\n      case LEAVE:\n        {\n          removed.forEach(function (key) {\n            var keyIndex = _keys.indexOf(key);\n\n            var item = _items[keyIndex];\n            var slot = LEAVE;\n            deleted.unshift(_extends({}, current[key], {\n              slot: slot,\n              destroyed: true,\n              left: _keys[Math.max(0, keyIndex - 1)],\n              right: _keys[Math.min(_keys.length, keyIndex + 1)],\n              trail: delay = delay + trail,\n              config: callProp(config, item, slot),\n              to: callProp(leave, item)\n            }));\n            delete current[key];\n          });\n          break;\n        }\n\n      case UPDATE:\n        {\n          updated.forEach(function (key) {\n            var keyIndex = keys.indexOf(key);\n            var item = items[keyIndex];\n            var slot = UPDATE;\n            current[key] = _extends({}, current[key], {\n              item: item,\n              slot: slot,\n              trail: delay = delay + trail,\n              config: callProp(config, item, slot),\n              to: callProp(update, item)\n            });\n          });\n          break;\n        }\n    }\n  }\n\n  var out = keys.map(function (key) {\n    return current[key];\n  }); // This tries to restore order for deleted items by finding their last known siblings\n  // only using the left sibling to keep order placement consistent for all deleted items\n\n  deleted.forEach(function (_ref9) {\n    var left = _ref9.left,\n        right = _ref9.right,\n        item = _objectWithoutPropertiesLoose(_ref9, [\"left\", \"right\"]);\n\n    var pos; // Was it the element on the left, if yes, move there ...\n\n    if ((pos = out.findIndex(function (t) {\n      return t.originalKey === left;\n    })) !== -1) pos += 1; // And if nothing else helps, move it to the start ¯\\_(ツ)_/¯\n\n    pos = Math.max(0, pos);\n    out = [].concat(_toConsumableArray(out.slice(0, pos)), [item], _toConsumableArray(out.slice(pos)));\n  });\n  return _extends({}, state, {\n    changed: added.length || removed.length || updated.length,\n    first: first && added.length === 0,\n    transitions: out,\n    current: current,\n    deleted: deleted,\n    prevProps: props\n  });\n}\n\nvar AnimatedStyle = /*#__PURE__*/function (_AnimatedObject2) {\n  _inherits(AnimatedStyle, _AnimatedObject2);\n\n  var _super7 = _createSuper(AnimatedStyle);\n\n  function AnimatedStyle(style) {\n    var _this13;\n\n    _classCallCheck(this, AnimatedStyle);\n\n    if (style === void 0) {\n      style = {};\n    }\n\n    _this13 = _super7.call(this);\n\n    if (style.transform && !(style.transform instanceof Animated)) {\n      style = applyAnimatedValues.transform(style);\n    }\n\n    _this13.payload = style;\n    return _this13;\n  }\n\n  return AnimatedStyle;\n}(AnimatedObject); // http://www.w3.org/TR/css3-color/#svg-color\n\n\nvar colors = {\n  transparent: 0x00000000,\n  aliceblue: 0xf0f8ffff,\n  antiquewhite: 0xfaebd7ff,\n  aqua: 0x00ffffff,\n  aquamarine: 0x7fffd4ff,\n  azure: 0xf0ffffff,\n  beige: 0xf5f5dcff,\n  bisque: 0xffe4c4ff,\n  black: 0x000000ff,\n  blanchedalmond: 0xffebcdff,\n  blue: 0x0000ffff,\n  blueviolet: 0x8a2be2ff,\n  brown: 0xa52a2aff,\n  burlywood: 0xdeb887ff,\n  burntsienna: 0xea7e5dff,\n  cadetblue: 0x5f9ea0ff,\n  chartreuse: 0x7fff00ff,\n  chocolate: 0xd2691eff,\n  coral: 0xff7f50ff,\n  cornflowerblue: 0x6495edff,\n  cornsilk: 0xfff8dcff,\n  crimson: 0xdc143cff,\n  cyan: 0x00ffffff,\n  darkblue: 0x00008bff,\n  darkcyan: 0x008b8bff,\n  darkgoldenrod: 0xb8860bff,\n  darkgray: 0xa9a9a9ff,\n  darkgreen: 0x006400ff,\n  darkgrey: 0xa9a9a9ff,\n  darkkhaki: 0xbdb76bff,\n  darkmagenta: 0x8b008bff,\n  darkolivegreen: 0x556b2fff,\n  darkorange: 0xff8c00ff,\n  darkorchid: 0x9932ccff,\n  darkred: 0x8b0000ff,\n  darksalmon: 0xe9967aff,\n  darkseagreen: 0x8fbc8fff,\n  darkslateblue: 0x483d8bff,\n  darkslategray: 0x2f4f4fff,\n  darkslategrey: 0x2f4f4fff,\n  darkturquoise: 0x00ced1ff,\n  darkviolet: 0x9400d3ff,\n  deeppink: 0xff1493ff,\n  deepskyblue: 0x00bfffff,\n  dimgray: 0x696969ff,\n  dimgrey: 0x696969ff,\n  dodgerblue: 0x1e90ffff,\n  firebrick: 0xb22222ff,\n  floralwhite: 0xfffaf0ff,\n  forestgreen: 0x228b22ff,\n  fuchsia: 0xff00ffff,\n  gainsboro: 0xdcdcdcff,\n  ghostwhite: 0xf8f8ffff,\n  gold: 0xffd700ff,\n  goldenrod: 0xdaa520ff,\n  gray: 0x808080ff,\n  green: 0x008000ff,\n  greenyellow: 0xadff2fff,\n  grey: 0x808080ff,\n  honeydew: 0xf0fff0ff,\n  hotpink: 0xff69b4ff,\n  indianred: 0xcd5c5cff,\n  indigo: 0x4b0082ff,\n  ivory: 0xfffff0ff,\n  khaki: 0xf0e68cff,\n  lavender: 0xe6e6faff,\n  lavenderblush: 0xfff0f5ff,\n  lawngreen: 0x7cfc00ff,\n  lemonchiffon: 0xfffacdff,\n  lightblue: 0xadd8e6ff,\n  lightcoral: 0xf08080ff,\n  lightcyan: 0xe0ffffff,\n  lightgoldenrodyellow: 0xfafad2ff,\n  lightgray: 0xd3d3d3ff,\n  lightgreen: 0x90ee90ff,\n  lightgrey: 0xd3d3d3ff,\n  lightpink: 0xffb6c1ff,\n  lightsalmon: 0xffa07aff,\n  lightseagreen: 0x20b2aaff,\n  lightskyblue: 0x87cefaff,\n  lightslategray: 0x778899ff,\n  lightslategrey: 0x778899ff,\n  lightsteelblue: 0xb0c4deff,\n  lightyellow: 0xffffe0ff,\n  lime: 0x00ff00ff,\n  limegreen: 0x32cd32ff,\n  linen: 0xfaf0e6ff,\n  magenta: 0xff00ffff,\n  maroon: 0x800000ff,\n  mediumaquamarine: 0x66cdaaff,\n  mediumblue: 0x0000cdff,\n  mediumorchid: 0xba55d3ff,\n  mediumpurple: 0x9370dbff,\n  mediumseagreen: 0x3cb371ff,\n  mediumslateblue: 0x7b68eeff,\n  mediumspringgreen: 0x00fa9aff,\n  mediumturquoise: 0x48d1ccff,\n  mediumvioletred: 0xc71585ff,\n  midnightblue: 0x191970ff,\n  mintcream: 0xf5fffaff,\n  mistyrose: 0xffe4e1ff,\n  moccasin: 0xffe4b5ff,\n  navajowhite: 0xffdeadff,\n  navy: 0x000080ff,\n  oldlace: 0xfdf5e6ff,\n  olive: 0x808000ff,\n  olivedrab: 0x6b8e23ff,\n  orange: 0xffa500ff,\n  orangered: 0xff4500ff,\n  orchid: 0xda70d6ff,\n  palegoldenrod: 0xeee8aaff,\n  palegreen: 0x98fb98ff,\n  paleturquoise: 0xafeeeeff,\n  palevioletred: 0xdb7093ff,\n  papayawhip: 0xffefd5ff,\n  peachpuff: 0xffdab9ff,\n  peru: 0xcd853fff,\n  pink: 0xffc0cbff,\n  plum: 0xdda0ddff,\n  powderblue: 0xb0e0e6ff,\n  purple: 0x800080ff,\n  rebeccapurple: 0x663399ff,\n  red: 0xff0000ff,\n  rosybrown: 0xbc8f8fff,\n  royalblue: 0x4169e1ff,\n  saddlebrown: 0x8b4513ff,\n  salmon: 0xfa8072ff,\n  sandybrown: 0xf4a460ff,\n  seagreen: 0x2e8b57ff,\n  seashell: 0xfff5eeff,\n  sienna: 0xa0522dff,\n  silver: 0xc0c0c0ff,\n  skyblue: 0x87ceebff,\n  slateblue: 0x6a5acdff,\n  slategray: 0x708090ff,\n  slategrey: 0x708090ff,\n  snow: 0xfffafaff,\n  springgreen: 0x00ff7fff,\n  steelblue: 0x4682b4ff,\n  tan: 0xd2b48cff,\n  teal: 0x008080ff,\n  thistle: 0xd8bfd8ff,\n  tomato: 0xff6347ff,\n  turquoise: 0x40e0d0ff,\n  violet: 0xee82eeff,\n  wheat: 0xf5deb3ff,\n  white: 0xffffffff,\n  whitesmoke: 0xf5f5f5ff,\n  yellow: 0xffff00ff,\n  yellowgreen: 0x9acd32ff\n}; // const INTEGER = '[-+]?\\\\d+';\n\nvar NUMBER = '[-+]?\\\\d*\\\\.?\\\\d+';\nvar PERCENTAGE = NUMBER + '%';\n\nfunction call() {\n  for (var _len = arguments.length, parts = new Array(_len), _key = 0; _key < _len; _key++) {\n    parts[_key] = arguments[_key];\n  }\n\n  return '\\\\(\\\\s*(' + parts.join(')\\\\s*,\\\\s*(') + ')\\\\s*\\\\)';\n}\n\nvar rgb = new RegExp('rgb' + call(NUMBER, NUMBER, NUMBER));\nvar rgba = new RegExp('rgba' + call(NUMBER, NUMBER, NUMBER, NUMBER));\nvar hsl = new RegExp('hsl' + call(NUMBER, PERCENTAGE, PERCENTAGE));\nvar hsla = new RegExp('hsla' + call(NUMBER, PERCENTAGE, PERCENTAGE, NUMBER));\nvar hex3 = /^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/;\nvar hex4 = /^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/;\nvar hex6 = /^#([0-9a-fA-F]{6})$/;\nvar hex8 = /^#([0-9a-fA-F]{8})$/;\n/*\nhttps://github.com/react-community/normalize-css-color\n\nBSD 3-Clause License\n\nCopyright (c) 2016, React Community\nAll rights reserved.\n\nRedistribution and use in source and binary forms, with or without\nmodification, are permitted provided that the following conditions are met:\n\n* Redistributions of source code must retain the above copyright notice, this\n  list of conditions and the following disclaimer.\n\n* Redistributions in binary form must reproduce the above copyright notice,\n  this list of conditions and the following disclaimer in the documentation\n  and/or other materials provided with the distribution.\n\n* Neither the name of the copyright holder nor the names of its\n  contributors may be used to endorse or promote products derived from\n  this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\nAND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\nIMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\nFOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\nDAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\nSERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\nCAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\nOR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\nOF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n*/\n\nfunction normalizeColor(color) {\n  var match;\n\n  if (typeof color === 'number') {\n    return color >>> 0 === color && color >= 0 && color <= 0xffffffff ? color : null;\n  } // Ordered based on occurrences on Facebook codebase\n\n\n  if (match = hex6.exec(color)) return parseInt(match[1] + 'ff', 16) >>> 0;\n  if (colors.hasOwnProperty(color)) return colors[color];\n\n  if (match = rgb.exec(color)) {\n    return (parse255(match[1]) << 24 | // r\n    parse255(match[2]) << 16 | // g\n    parse255(match[3]) << 8 | // b\n    0x000000ff) >>> // a\n    0;\n  }\n\n  if (match = rgba.exec(color)) {\n    return (parse255(match[1]) << 24 | // r\n    parse255(match[2]) << 16 | // g\n    parse255(match[3]) << 8 | // b\n    parse1(match[4])) >>> // a\n    0;\n  }\n\n  if (match = hex3.exec(color)) {\n    return parseInt(match[1] + match[1] + // r\n    match[2] + match[2] + // g\n    match[3] + match[3] + // b\n    'ff', // a\n    16) >>> 0;\n  } // https://drafts.csswg.org/css-color-4/#hex-notation\n\n\n  if (match = hex8.exec(color)) return parseInt(match[1], 16) >>> 0;\n\n  if (match = hex4.exec(color)) {\n    return parseInt(match[1] + match[1] + // r\n    match[2] + match[2] + // g\n    match[3] + match[3] + // b\n    match[4] + match[4], // a\n    16) >>> 0;\n  }\n\n  if (match = hsl.exec(color)) {\n    return (hslToRgb(parse360(match[1]), // h\n    parsePercentage(match[2]), // s\n    parsePercentage(match[3]) // l\n    ) | 0x000000ff) >>> // a\n    0;\n  }\n\n  if (match = hsla.exec(color)) {\n    return (hslToRgb(parse360(match[1]), // h\n    parsePercentage(match[2]), // s\n    parsePercentage(match[3]) // l\n    ) | parse1(match[4])) >>> // a\n    0;\n  }\n\n  return null;\n}\n\nfunction hue2rgb(p, q, t) {\n  if (t < 0) t += 1;\n  if (t > 1) t -= 1;\n  if (t < 1 / 6) return p + (q - p) * 6 * t;\n  if (t < 1 / 2) return q;\n  if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6;\n  return p;\n}\n\nfunction hslToRgb(h, s, l) {\n  var q = l < 0.5 ? l * (1 + s) : l + s - l * s;\n  var p = 2 * l - q;\n  var r = hue2rgb(p, q, h + 1 / 3);\n  var g = hue2rgb(p, q, h);\n  var b = hue2rgb(p, q, h - 1 / 3);\n  return Math.round(r * 255) << 24 | Math.round(g * 255) << 16 | Math.round(b * 255) << 8;\n}\n\nfunction parse255(str) {\n  var int = parseInt(str, 10);\n  if (int < 0) return 0;\n  if (int > 255) return 255;\n  return int;\n}\n\nfunction parse360(str) {\n  var int = parseFloat(str);\n  return (int % 360 + 360) % 360 / 360;\n}\n\nfunction parse1(str) {\n  var num = parseFloat(str);\n  if (num < 0) return 0;\n  if (num > 1) return 255;\n  return Math.round(num * 255);\n}\n\nfunction parsePercentage(str) {\n  // parseFloat conveniently ignores the final %\n  var int = parseFloat(str);\n  if (int < 0) return 0;\n  if (int > 100) return 1;\n  return int / 100;\n}\n\nfunction colorToRgba(input) {\n  var int32Color = normalizeColor(input);\n  if (int32Color === null) return input;\n  int32Color = int32Color || 0;\n  var r = (int32Color & 0xff000000) >>> 24;\n  var g = (int32Color & 0x00ff0000) >>> 16;\n  var b = (int32Color & 0x0000ff00) >>> 8;\n  var a = (int32Color & 0x000000ff) / 255;\n  return \"rgba(\".concat(r, \", \").concat(g, \", \").concat(b, \", \").concat(a, \")\");\n} // Problem: https://github.com/animatedjs/animated/pull/102\n// Solution: https://stackoverflow.com/questions/638565/parsing-scientific-notation-sensibly/658662\n\n\nvar stringShapeRegex = /[+\\-]?(?:0|[1-9]\\d*)(?:\\.\\d*)?(?:[eE][+\\-]?\\d+)?/g; // Covers rgb, rgba, hsl, hsla\n// Taken from https://gist.github.com/olmokramer/82ccce673f86db7cda5e\n\nvar colorRegex = /(#(?:[0-9a-f]{2}){2,4}|(#[0-9a-f]{3})|(rgb|hsl)a?\\((-?\\d+%?[,\\s]+){2,3}\\s*[\\d\\.]+%?\\))/gi; // Covers color names (transparent, blue, etc.)\n\nvar colorNamesRegex = new RegExp(\"(\".concat(Object.keys(colors).join('|'), \")\"), 'g');\n/**\n * Supports string shapes by extracting numbers so new values can be computed,\n * and recombines those values into new strings of the same shape.  Supports\n * things like:\n *\n *   rgba(123, 42, 99, 0.36)           // colors\n *   -45deg                            // values with units\n *   0 2px 2px 0px rgba(0, 0, 0, 0.12) // box shadows\n */\n\nvar createStringInterpolator = function createStringInterpolator(config) {\n  // Replace colors with rgba\n  var outputRange = config.output.map(function (rangeValue) {\n    return rangeValue.replace(colorRegex, colorToRgba);\n  }).map(function (rangeValue) {\n    return rangeValue.replace(colorNamesRegex, colorToRgba);\n  });\n  var outputRanges = outputRange[0].match(stringShapeRegex).map(function () {\n    return [];\n  });\n  outputRange.forEach(function (value) {\n    value.match(stringShapeRegex).forEach(function (number, i) {\n      return outputRanges[i].push(+number);\n    });\n  });\n  var interpolations = outputRange[0].match(stringShapeRegex).map(function (_value, i) {\n    return createInterpolator(_extends({}, config, {\n      output: outputRanges[i]\n    }));\n  });\n  return function (input) {\n    var i = 0;\n    return outputRange[0] // 'rgba(0, 100, 200, 0)'\n    // ->\n    // 'rgba(${interpolations[0](input)}, ${interpolations[1](input)}, ...'\n    .replace(stringShapeRegex, function () {\n      return interpolations[i++](input);\n    }) // rgba requires that the r,g,b are integers.... so we want to round them, but we *dont* want to\n    // round the opacity (4th column).\n    .replace(/rgba\\(([0-9\\.-]+), ([0-9\\.-]+), ([0-9\\.-]+), ([0-9\\.-]+)\\)/gi, function (_, p1, p2, p3, p4) {\n      return \"rgba(\".concat(Math.round(p1), \", \").concat(Math.round(p2), \", \").concat(Math.round(p3), \", \").concat(p4, \")\");\n    });\n  };\n};\n\nvar isUnitlessNumber = {\n  animationIterationCount: true,\n  borderImageOutset: true,\n  borderImageSlice: true,\n  borderImageWidth: true,\n  boxFlex: true,\n  boxFlexGroup: true,\n  boxOrdinalGroup: true,\n  columnCount: true,\n  columns: true,\n  flex: true,\n  flexGrow: true,\n  flexPositive: true,\n  flexShrink: true,\n  flexNegative: true,\n  flexOrder: true,\n  gridRow: true,\n  gridRowEnd: true,\n  gridRowSpan: true,\n  gridRowStart: true,\n  gridColumn: true,\n  gridColumnEnd: true,\n  gridColumnSpan: true,\n  gridColumnStart: true,\n  fontWeight: true,\n  lineClamp: true,\n  lineHeight: true,\n  opacity: true,\n  order: true,\n  orphans: true,\n  tabSize: true,\n  widows: true,\n  zIndex: true,\n  zoom: true,\n  // SVG-related properties\n  fillOpacity: true,\n  floodOpacity: true,\n  stopOpacity: true,\n  strokeDasharray: true,\n  strokeDashoffset: true,\n  strokeMiterlimit: true,\n  strokeOpacity: true,\n  strokeWidth: true\n};\n\nvar prefixKey = function prefixKey(prefix, key) {\n  return prefix + key.charAt(0).toUpperCase() + key.substring(1);\n};\n\nvar prefixes = ['Webkit', 'Ms', 'Moz', 'O'];\nisUnitlessNumber = Object.keys(isUnitlessNumber).reduce(function (acc, prop) {\n  prefixes.forEach(function (prefix) {\n    return acc[prefixKey(prefix, prop)] = acc[prop];\n  });\n  return acc;\n}, isUnitlessNumber);\n\nfunction dangerousStyleValue(name, value, isCustomProperty) {\n  if (value == null || typeof value === 'boolean' || value === '') return '';\n  if (!isCustomProperty && typeof value === 'number' && value !== 0 && !(isUnitlessNumber.hasOwnProperty(name) && isUnitlessNumber[name])) return value + 'px'; // Presumes implicit 'px' suffix for unitless numbers\n\n  return ('' + value).trim();\n}\n\nvar attributeCache = {};\ninjectCreateAnimatedStyle(function (style) {\n  return new AnimatedStyle(style);\n});\ninjectDefaultElement('div');\ninjectStringInterpolator(createStringInterpolator);\ninjectColorNames(colors);\ninjectApplyAnimatedValues(function (instance, props) {\n  if (instance.nodeType && instance.setAttribute !== undefined) {\n    var style = props.style,\n        children = props.children,\n        scrollTop = props.scrollTop,\n        scrollLeft = props.scrollLeft,\n        attributes = _objectWithoutPropertiesLoose(props, [\"style\", \"children\", \"scrollTop\", \"scrollLeft\"]);\n\n    var filter = instance.nodeName === 'filter' || instance.parentNode && instance.parentNode.nodeName === 'filter';\n    if (scrollTop !== void 0) instance.scrollTop = scrollTop;\n    if (scrollLeft !== void 0) instance.scrollLeft = scrollLeft; // Set textContent, if children is an animatable value\n\n    if (children !== void 0) instance.textContent = children; // Set styles ...\n\n    for (var styleName in style) {\n      if (!style.hasOwnProperty(styleName)) continue;\n      var isCustomProperty = styleName.indexOf('--') === 0;\n      var styleValue = dangerousStyleValue(styleName, style[styleName], isCustomProperty);\n      if (styleName === 'float') styleName = 'cssFloat';\n      if (isCustomProperty) instance.style.setProperty(styleName, styleValue);else instance.style[styleName] = styleValue;\n    } // Set attributes ...\n\n\n    for (var name in attributes) {\n      // Attributes are written in dash case\n      var dashCase = filter ? name : attributeCache[name] || (attributeCache[name] = name.replace(/([A-Z])/g, function (n) {\n        return '-' + n.toLowerCase();\n      }));\n      if (typeof instance.getAttribute(dashCase) !== 'undefined') instance.setAttribute(dashCase, attributes[name]);\n    }\n\n    return;\n  } else return false;\n}, function (style) {\n  return style;\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', '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', 'mask', 'path', 'pattern', 'polygon', 'polyline', 'radialGradient', 'rect', 'stop', 'svg', 'text', 'tspan']; // Extend animated with all the available THREE elements\n\nvar apply = merge(createAnimatedComponent, false);\nvar extendedAnimated = apply(domElements);\nexport { apply, config, update, extendedAnimated as animated, extendedAnimated as a, interpolate$1 as interpolate, Globals, useSpring, useTrail, useTransition, useChain, useSprings };","import React from 'react'\r\nimport { useSpring, animated } from 'react-spring'\r\nimport { t } from 'ttag'\r\nimport { useInView } from 'react-intersection-observer'\r\nimport { motion } from 'framer-motion'\r\n\r\nexport interface CollapseItemProps {\r\n    contentItemId: string\r\n    puxDesignCollapseItemColor: string\r\n    puxDesignCollapseItemDescription: {\r\n        html: string\r\n    }\r\n    puxDesignCollapseItemDisplayTitle: string\r\n    puxDesignCollapseItemDuration: string\r\n    puxDesignCollapseItemOutput: string\r\n    puxDesignCollapseItemIsOptional: boolean\r\n    puxDesignCollapseItemtOpened: boolean\r\n    puxDesignCollapseItemNestedCollapses: {\r\n        contentItems: [CollapseItemProps]\r\n    }\r\n}\r\n\r\nconst CollapseItem = (props: CollapseItemProps) => {\r\n    const [isOpen, setOpen] = React.useState(props.puxDesignCollapseItemtOpened)\r\n\r\n    const springAnim = useSpring({\r\n        maxHeight: isOpen ? 400 : 0,\r\n        from: {\r\n            maxHeight: isOpen ? 0 : 400,\r\n        },\r\n    })\r\n\r\n    const [ref, inView] = useInView({\r\n        threshold: 0.5,\r\n        triggerOnce: true,\r\n    })\r\n\r\n    const variants = {\r\n        visible: { opacity: 1, scale: 1, x: 0 },\r\n        hidden: {\r\n            opacity: 0,\r\n            x: 50,\r\n        },\r\n    }\r\n\r\n    return (\r\n        <motion.div\r\n            ref={ref}\r\n            className={`collapse-wrap ${props.puxDesignCollapseItemColor}${isOpen ? ` open` : ``}`}\r\n            key={props.contentItemId}\r\n            animate={inView ? `visible` : `hidden`}\r\n            variants={variants}\r\n            transition={{ duration: 1, ease: `easeOut` }}\r\n        >\r\n            <div className=\"collapse\">\r\n                <div className=\"collapse-title\" onClick={() => setOpen(!isOpen)}>\r\n                    {props.puxDesignCollapseItemDisplayTitle}\r\n                    <span>{props.puxDesignCollapseItemIsOptional ? t`PuxDesign.HowDoWeWork.Optional` : ``}</span>\r\n                </div>\r\n                <animated.div\r\n                    className=\"collapse-description\"\r\n                    style={springAnim}\r\n                    dangerouslySetInnerHTML={{\r\n                        __html: props.puxDesignCollapseItemDescription.html?.replace(/font-size: 1rem;/g, ``),\r\n                    }}\r\n                ></animated.div>\r\n            </div>\r\n            <div className=\"collapse-info\">\r\n                <div className=\"collapse-info-item\">\r\n                    <span className=\"label\">{t`PuxDesign.HowDoWeWork.Duration`}</span>\r\n                    <span className=\"value\">{props.puxDesignCollapseItemDuration}</span>\r\n                </div>\r\n                <div className=\"collapse-info-item\">\r\n                    <span className=\"label\">{t`PuxDesign.HowDoWeWork.Output`}</span>\r\n                    <span className=\"value\">{props.puxDesignCollapseItemOutput}</span>\r\n                </div>\r\n            </div>\r\n            {props.puxDesignCollapseItemNestedCollapses ? (\r\n                <div className=\"nested-collapses\">\r\n                    {props.puxDesignCollapseItemNestedCollapses.contentItems.map((collapse: CollapseItemProps) => (\r\n                        <CollapseItem {...collapse} key={collapse.contentItemId} />\r\n                    ))}\r\n                </div>\r\n            ) : null}\r\n        </motion.div>\r\n    )\r\n}\r\n\r\nexport default CollapseItem\r\n","import React from 'react'\r\nimport { graphql } from 'gatsby'\r\nimport Layout from '../components/layout/layout'\r\nimport WidgetBuilder from '../components/builders/widget-builder'\r\nimport PuxMetaTags from '../components/shared/PuxMetaTags'\r\nimport CollapseItem, { CollapseItemProps } from '../components/CollapseItem'\r\nimport { useSpring, animated } from 'react-spring'\r\nimport { Sticky } from 'react-sticky'\r\nimport { t } from 'ttag'\r\nimport BreadCrumbs from '../components/BreadCrumbs'\r\n\r\nconst HowDoWeWork = ({ data, pageContext }: any) => {\r\n  const page = data.orchard.puxDesignHowDoWeWork[0]\r\n  const collapses = page.puxDesignHowDoWeWorkCollapses.contentItems\r\n  const [isOpen, setOpen] = React.useState(true)\r\n  const pmRef = React.useRef<HTMLDivElement>(null)\r\n  const [navPos, setNavPos] = React.useState<number | undefined>(0)\r\n\r\n  React.useEffect(() => {\r\n    pmRef.current?.clientHeight\r\n      ? setNavPos(0 - document.getElementsByTagName(`header`)[0].offsetHeight + pmRef.current?.offsetTop)\r\n      : setNavPos(0 - document.getElementsByTagName(`header`)[0].offsetHeight)\r\n  }, [])\r\n\r\n  const springAnim = useSpring({\r\n    maxHeight: isOpen ? 400 : 0,\r\n    from: {\r\n      maxHeight: isOpen ? 0 : 400,\r\n    },\r\n  })\r\n\r\n  return (\r\n    <Layout localizedPath={page.localization?.localizations}>\r\n      <PuxMetaTags {...pageContext.metaTagsData} />\r\n      <BreadCrumbs\r\n        default={true}\r\n        center={false}\r\n        items={[\r\n          {\r\n            path: page.path,\r\n            displayText: page.displayText,\r\n          },\r\n        ]}\r\n      />\r\n\r\n      <div className=\"pux-container\">\r\n        <div className=\"pux-container\">\r\n          <h1 className=\"center-content\">{page.puxDesignHowDoWeWorkDisplayTitle}</h1>\r\n        </div>\r\n\r\n        <div className=\"how-do-we-work\" ref={pmRef}>\r\n          <div className=\"left\">\r\n            <div className={`collapse-wrap ${isOpen ? ` open` : ``}`}>\r\n              <Sticky topOffset={navPos} disableCompensation>\r\n                {({ style, isSticky }: { style: React.CSSProperties; isSticky: boolean }) => (\r\n                  <div className={`pm-collapse-wrap` + (isSticky ? ` fixed` : ``)} style={style}>\r\n                    <div className=\"collapse\">\r\n                      <div\r\n                        className=\"collapse-title\"\r\n                        onClick={() => setOpen(!isOpen)}\r\n                      >{t`PuxDesign.HowDoWeWork.PM`}</div>\r\n                      <animated.div\r\n                        className=\"collapse-description\"\r\n                        style={springAnim}\r\n                        dangerouslySetInnerHTML={{\r\n                          __html: page.puxDesignHowDoWeWorkPMDescription?.replace(/font-size: 1rem;/g, ``),\r\n                        }}\r\n                      ></animated.div>\r\n                    </div>\r\n                    <div className=\"collapse-info\">\r\n                      <div className=\"collapse-info-item\">\r\n                        <span className=\"label\">{t`PuxDesign.HowDoWeWork.Duration`}</span>\r\n                        <span className=\"value\">{page.puxDesignHowDoWeWorkPMDuration}</span>\r\n                      </div>\r\n                      <div className=\"collapse-info-item\">\r\n                        <span className=\"label\">{t`PuxDesign.HowDoWeWork.Output`}</span>\r\n                        <span className=\"value\">{page.puxDesignHowDoWeWorkPMOutput}</span>\r\n                      </div>\r\n                    </div>\r\n                  </div>\r\n                )}\r\n              </Sticky>\r\n            </div>\r\n          </div>\r\n          <div className=\"right\">\r\n            {collapses.map((collapse: CollapseItemProps) => (\r\n              <CollapseItem {...collapse} />\r\n            ))}\r\n          </div>\r\n        </div>\r\n      </div>\r\n\r\n      <div className=\"text-block\">\r\n        <WidgetBuilder widgetBuilderData={pageContext.widgets} />\r\n      </div>\r\n    </Layout>\r\n  )\r\n}\r\n\r\nexport default HowDoWeWork\r\n\r\nexport const query = graphql`\r\n  query($pagePath: String = \"\") {\r\n    orchard {\r\n      puxDesignHowDoWeWork(first: 1, where: { path: $pagePath }) {\r\n        displayText\r\n        path\r\n        puxDesignHowDoWeWorkDisplayTitle\r\n        puxDesignHowDoWeWorkPMDescription\r\n        puxDesignHowDoWeWorkPMDuration\r\n        puxDesignHowDoWeWorkPMOutput\r\n        localization {\r\n          localizations {\r\n            ... on Orchard_PuxDesignHowDoWeWork {\r\n              path\r\n              published\r\n              localization {\r\n                culture\r\n              }\r\n            }\r\n          }\r\n        }\r\n        puxDesignHowDoWeWorkCollapses {\r\n          contentItems {\r\n            ... on Orchard_PuxDesignCollapseItem {\r\n              contentItemId\r\n              puxDesignCollapseItemColor\r\n              puxDesignCollapseItemDescription {\r\n                html\r\n              }\r\n              puxDesignCollapseItemDisplayTitle\r\n              puxDesignCollapseItemDuration\r\n              puxDesignCollapseItemOutput\r\n              puxDesignCollapseItemIsOptional\r\n              puxDesignCollapseItemtOpened\r\n              puxDesignCollapseItemNestedCollapses {\r\n                contentItems {\r\n                  ... on Orchard_PuxDesignCollapseItem {\r\n                    contentItemId\r\n                    puxDesignCollapseItemColor\r\n                    puxDesignCollapseItemDescription {\r\n                      html\r\n                    }\r\n                    puxDesignCollapseItemDisplayTitle\r\n                    puxDesignCollapseItemDuration\r\n                    puxDesignCollapseItemOutput\r\n                    puxDesignCollapseItemIsOptional\r\n                    puxDesignCollapseItemtOpened\r\n                  }\r\n                }\r\n              }\r\n            }\r\n          }\r\n        }\r\n      }\r\n    }\r\n  }\r\n`\r\n"],"sourceRoot":""}