{"version":3,"sources":["webpack:///./src/components/panels/ComponentHeader.js","webpack:///./src/components/non-panels/cards/ArtificialIntelligence.js","webpack:///./src/components/non-panels/react-modal-video/modal-video.module.scss","webpack:///./node_modules/babel-preset-gatsby/node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js","webpack:///./node_modules/@react-spring/shared/esm/createInterpolator.js","webpack:///./src/components/panels/ComponentHeader.module.scss","webpack:///./node_modules/@react-spring/shared/esm/helpers.js","webpack:///./src/images/intro-video-thumbnail.jpg","webpack:///./node_modules/@react-spring/shared/esm/globals.js","webpack:///./node_modules/core-js/modules/es6.number.is-nan.js","webpack:///./node_modules/babel-preset-gatsby/node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js","webpack:///./node_modules/@react-spring/core/index.js","webpack:///./node_modules/process/browser.js","webpack:///./node_modules/core-js/modules/es6.string.starts-with.js","webpack:///./node_modules/react-layout-effect/dist/esm/useLayoutEffect.js","webpack:///./node_modules/@react-spring/animated/index.js","webpack:///./node_modules/fluids/dist/esm/index.js","webpack:///./src/components/non-panels/react-modal-video/normal-video.js","webpack:///./node_modules/@react-spring/web/index.js","webpack:///./src/components/non-panels/cards/card.module.scss","webpack:///./node_modules/babel-preset-gatsby/node_modules/@babel/runtime/helpers/esm/typeof.js","webpack:///./node_modules/babel-preset-gatsby/node_modules/@babel/runtime/helpers/esm/possibleConstructorReturn.js","webpack:///./node_modules/babel-preset-gatsby/node_modules/regenerator-runtime/runtime.js","webpack:///./node_modules/babel-preset-gatsby/node_modules/@babel/runtime/helpers/esm/toConsumableArray.js","webpack:///./node_modules/babel-preset-gatsby/node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js","webpack:///./node_modules/babel-preset-gatsby/node_modules/@babel/runtime/helpers/esm/iterableToArray.js","webpack:///./node_modules/babel-preset-gatsby/node_modules/@babel/runtime/helpers/esm/nonIterableSpread.js","webpack:///./src/components/non-panels/cards/Chatbots.js","webpack:///./src/pages/index.module.scss","webpack:///./src/components/panels/TabToAccordion.js","webpack:///./src/utils/SalesIntelScript.js","webpack:///./src/pages/index.js","webpack:///./node_modules/babel-preset-gatsby/node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js","webpack:///./node_modules/@react-spring/shared/esm/index.js","webpack:///./node_modules/react-device-detect/main.js","webpack:///./node_modules/@react-spring/shared/esm/deprecations.js","webpack:///./node_modules/babel-preset-gatsby/node_modules/@babel/runtime/helpers/esm/assertThisInitialized.js","webpack:///./node_modules/resize-observer-polyfill/dist/ResizeObserver.es.js","webpack:///./node_modules/@react-spring/shared/esm/hooks.js","webpack:///./node_modules/babel-preset-gatsby/node_modules/@babel/runtime/helpers/esm/inherits.js","webpack:///./node_modules/@react-spring/shared/esm/FrameLoop.js","webpack:///./node_modules/babel-preset-gatsby/node_modules/@babel/runtime/helpers/esm/createClass.js","webpack:///./node_modules/@react-spring/shared/esm/colors.js","webpack:///./node_modules/core-js/modules/es7.object.get-own-property-descriptors.js","webpack:///./src/images/play-button-2138735_640.png","webpack:///./node_modules/@react-spring/shared/node_modules/tslib/tslib.es6.js","webpack:///./node_modules/@react-spring/shared/esm/colorMatchers.js","webpack:///./node_modules/@react-spring/shared/esm/normalizeColor.js","webpack:///./node_modules/@react-spring/shared/esm/colorToRgba.js","webpack:///./node_modules/@react-spring/shared/esm/stringInterpolation.js","webpack:///./node_modules/babel-preset-gatsby/node_modules/@babel/runtime/helpers/esm/get.js","webpack:///./node_modules/babel-preset-gatsby/node_modules/@babel/runtime/helpers/esm/superPropBase.js","webpack:///./node_modules/regenerator-runtime/runtime.js","webpack:///./node_modules/use-memo-one/dist/use-memo-one.esm.js","webpack:///./node_modules/core-js/modules/_own-keys.js","webpack:///./node_modules/babel-preset-gatsby/node_modules/@babel/runtime/regenerator/index.js","webpack:///./node_modules/babel-preset-gatsby/node_modules/@babel/runtime/helpers/esm/getPrototypeOf.js","webpack:///./node_modules/babel-preset-gatsby/node_modules/@babel/runtime/helpers/esm/isNativeReflectConstruct.js","webpack:///./node_modules/babel-preset-gatsby/node_modules/@babel/runtime/helpers/esm/construct.js","webpack:///./node_modules/babel-preset-gatsby/node_modules/@babel/runtime/helpers/esm/wrapNativeSuper.js","webpack:///./node_modules/babel-preset-gatsby/node_modules/@babel/runtime/helpers/esm/isNativeFunction.js","webpack:///./node_modules/ua-parser-js/dist/ua-parser.min.js","webpack:///./src/components/panels/Partners.js","webpack:///./src/utils/useMeasure.js","webpack:///./src/utils/useSetPageData.js","webpack:///./node_modules/babel-preset-gatsby/node_modules/@babel/runtime/helpers/esm/classCallCheck.js","webpack:///./node_modules/react-spring/web.js","webpack:///./src/components/non-panels/cards/RPA.js","webpack:///./node_modules/babel-preset-gatsby/node_modules/@babel/runtime/helpers/esm/setPrototypeOf.js","webpack:///./src/components/panels/Partners.module.scss","webpack:///./src/components/panels/TabToAccordion.module.scss","webpack:///./node_modules/babel-preset-gatsby/node_modules/@babel/runtime/helpers/esm/slicedToArray.js","webpack:///./node_modules/babel-preset-gatsby/node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js","webpack:///./node_modules/babel-preset-gatsby/node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js","webpack:///./node_modules/babel-preset-gatsby/node_modules/@babel/runtime/helpers/esm/nonIterableRest.js"],"names":["ComponentHeader","id","rootClassName","rootStyle","rowClassName","rowStyle","overlay","overlayStyle","overlayColor","rootGatsbyBackgroundImageFluid","lineTop","text","textAlign","textClassName","textStyle","toLowerCase","margin","s","headerPanelPadding","sm","className","style","itemClassName","query","render","data","hero","strapiPsAi","industry","to","fixed","service_icon","childImageSharp","icon","main_heading","button","module","exports","_unsupportedIterableToArray","o","minLen","n","Object","prototype","toString","call","slice","constructor","name","Array","from","test","createInterpolator","range","output","extrapolate","fun","arr","str","config","outputRange","inputRange","extrapolateLeft","extrapolateRight","easing","t","input","i","length","findRange","inputMin","inputMax","outputMin","outputMax","map","result","Infinity","interpolate","noop","defineHidden","obj","key","value","defineProperty","writable","configurable","is","isArray","a","num","und","undefined","isEqual","b","isAnimatedString","each","cb","ctx","forEach","keys","toArray","flush","queue","iterator","size","items","clear","createStringInterpolator","frameLoop","now","performance","colorNames","skipAnimation","requestAnimationFrame","window","batchedUpdates","callback","willAdvance","assign","globals","_a","defined","pluckDefined","$export","S","isNaN","number","_arrayLikeToArray","len","arr2","_createSuper","Derived","Super","_isNativeReflectConstruct","NewTarget","this","Reflect","construct","arguments","apply","sham","Proxy","Date","e","_createForOfIteratorHelper","Symbol","F","done","_e","f","TypeError","it","err","normalCompletion","didErr","step","next","_e2","return","default","tension","friction","gentle","wobbly","stiff","slow","molasses","defaults","mass","damping","clamp","AnimationConfig","frequency","velocity","restVelocity","precision","progress","duration","bounce","decay","round","sanitizeConfig","props","isTensionConfig","emptyArray","Animation","changed","values","toValues","fromValues","immediate","onStart","onChange","onRest","useMemo","create","deps","callProp","_len","args","_key","matchProp","includes","getProps","arg","getDefaultProp","getDefaultProps","omitKeys","DEFAULT_PROPS","_step","_iterator","RESERVED_PROPS","ref","loop","reset","pause","cancel","reverse","delay","onDelayEnd","onProps","trail","sort","expires","initial","enter","update","leave","children","callId","parentId","inferTo","forward","count","prop","getForwardProps","out","val","computeGoal","get","scheduleProps","_ref3","state","actions","Promise","resolve","reject","timeout","onPause","resumeQueue","add","onResume","time","pauseQueue","setTimeout","delete","cancelId","start","resume","getCombinedResult","target","results","some","cancelled","getCancelledResult","every","getNoopResult","getFinishedResult","finished","runAsync","_x","_x2","_x3","_x4","_runAsync","mark","_callee6","prevTo","prevPromise","wrap","_context6","prev","asyncTo","promise","abrupt","_callee5","defaultProps","preventBail","bail","bailPromise","bailIfEnded","animate","animating","_context5","asyncId","bailSignal","bailResult","fn","onError","BailSignal","catch","withBailHandler","arg1","arg2","then","_ref15","_callee3","_context3","stop","_x7","_ref16","_callee4","_iterator2","_step2","_props2","_context4","t0","finish","_x8","bind","all","cancelAsync","_Error","_super","_this","Error","isFrameValue","FrameValue","nextId","_FluidValue","_super2","_this2","_len2","_key2","concat","_priority","_children","Set","node","getValue","_len3","_key3","_len4","_key4","child","_attach","_detach","_ref4","type","idle","_reset","_start","_emit","parent","priority","event","onParentChange","set","_onPriorityChange","ACTIVE","SpringValue","_FrameValue","_start2","_super3","_this3","animation","_phase","_state","_defaultProps","_lastCallId","_lastToId","dt","_this4","anim","payload","toConfig","lastPosition","position","elapsed","elapsedTime","v0","Math","exp","abs","lastVelocity","min","bounceFactor","canBounce","isGrowing","numSteps","ceil","p","Number","console","warn","setValue","_onChange","phase","_this5","_focus","_set","_stop","checkDisposed","_this6","push","_callee","_this7","_context","_update","sent","_x5","_x6","_this8","_ref5","_ref6","_updateNode","nodeType","_getNodeType","parentNode","isLoop","_this9","mergeDefaultProp","_prepareNode","_merge","nextProps","createLoopUpdate","hasToProp","hasFromProp","coerceEventProp","mergeDefaultProps","prevFrom","_range$to","_range$from","_ref7","hasFromChanged","hasToChanged","fromConfig","hasAsyncTo","newConfig","defaultConfig","pow","PI","mergeConfig","goal","isAnimatable","goalType","started","hasValueChanged","getPayload","onRestQueue","checkFinishedOnRest","onRestIndex","_config","removeChild","addChild","oldValue","spring","loopRet","overrides","createUpdate","_props","findDefined","declareUpdate","BATCHED_EVENTS","nextId$1","Controller","springs","_flush","_initialProps","_lastAsyncId","_active","_events","Map","_onFrame","prepareKeys","flushUpdateQueue","dispose","_this10","_this$_events","isActive","_ref8","_ref9","onFrame","ctrl","flushUpdate","handler","_ref10","promises","hasDefaultProp","getSprings","prepareSprings","createSpring","setSprings","observer","SpringContext","_ref","inherited","Provider","Consumer","useSpringContext","SpringHandle","getControllers","_callee2","_context2","useSprings","propsFn","layoutId","forceUpdate","_useState","ctrls","updates","current","_useState2","refProp","prevLength","disposed","declareUpdates","startIndex","endIndex","_update2","api","context","x","useSpring","isFn","_useSprings","_useSprings2","_useSprings2$","Interpolation","_FrameValue2","_super4","source","_this11","calc","_get","_dt","inputs","advance","_this12","max","_this13","reduce","cachedSetTimeout","cachedClearTimeout","process","defaultSetTimout","defaultClearTimeout","runTimeout","clearTimeout","currentQueue","draining","queueIndex","cleanUpNextTick","drainQueue","run","marker","runClearTimeout","Item","array","nextTick","title","browser","env","argv","version","versions","on","addListener","once","off","removeListener","removeAllListeners","emit","prependListener","prependOnceListener","listeners","binding","cwd","chdir","dir","umask","toLength","$startsWith","P","startsWith","searchString","that","index","search","String","useLayoutEffect","document","createElement","$node","for","getAnimated","owner","setAnimated","Animated","AnimatedValue","_Animated","_value","_to","AnimatedString","_AnimatedValue","_string","_toString","TreeContext","AnimatedObject","_Animated2","animated","_makePayload","_addToPayload","dependencies","AnimatedArray","_AnimatedObject","_makeAnimated","newValue","AnimatedProps","_AnimatedObject2","_super5","dirty","createAnimatedStyle","host","withAnimated","Component","rawProps","instanceRef","hasInstance","isReactComponent","instance","applyAnimatedValues","dep","getComponentProps","updateRef","cacheKey","createHost","components","_ref2","_ref2$applyAnimatedVa","_ref2$createAnimatedS","_ref2$getComponentPro","hostConfig","displayName","getDisplayName","$config","getFluidValue","getFluidConfig","FluidValue","ModalVideo","isOpen","closeModal","updateFocus","openModal","setState","onClose","keydownHandler","keyCode","getDerivedStateFromProps","componentDidUpdate","modal","focus","preventDefault","stopPropagation","activeElement","modalbtn","getQueryString","url","hasOwnProperty","substr","getYoutubeUrl","youtube","videoId","getVimeoUrl","vimeo","getYoukuUrl","youku","getVideoUrl","opt","channel","getPadding","ratio","split","width","paddingBottom","classNames","modalVideoIframeWrap","height","src","frameBorder","allowFullScreen","tabIndex","React","autoplay","cc_load_policy","color","controls","disablekb","enablejsapi","end","fs","h1","iv_load_policy","list","listType","modestbranding","origin","playlist","playsinline","rel","showinfo","wmode","theme","autopause","byline","maxheight","maxwidth","player_id","portrait","xhtml","show_related","animationSpeed","modalVideoEffect","modalVideo","modalVideoClose","modalVideoBody","modalVideoInner","modalVideoMovieWrap","modalVideoCloseBtn","aria","openMessage","dismissBtnMessage","isCustomPropRE","dangerousStyleValue","isUnitlessNumber","trim","attributeCache","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","acc","prefix","charAt","toUpperCase","substring","prefixKey","domTransforms","pxTransforms","degTransforms","addUnit","unit","isValueIdentity","v","parseFloat","AnimatedStyle","y","z","transforms","xyz","join","transform","deg","FluidTransform","identity","_this2$transforms$i","_this2$transforms$i2","setAttribute","isFilterElement","nodeName","scrollTop","scrollLeft","attributes","names","hasAttribute","replace","onWrite","textContent","setProperty","_typeof","_possibleConstructorReturn","self","assertThisInitialized","runtime","Op","hasOwn","$Symbol","iteratorSymbol","asyncIteratorSymbol","asyncIterator","toStringTagSymbol","toStringTag","innerFn","outerFn","tryLocsList","protoGenerator","Generator","generator","Context","_invoke","method","doneResult","delegate","delegateResult","maybeInvokeDelegate","ContinueSentinel","_sent","dispatchException","record","tryCatch","makeInvokeMethod","GeneratorFunction","GeneratorFunctionPrototype","IteratorPrototype","getProto","getPrototypeOf","NativeIteratorPrototype","Gp","defineIteratorMethods","AsyncIterator","PromiseImpl","previousPromise","callInvokeWithMethodAndArg","invoke","__await","unwrapped","error","info","resultName","nextLoc","pushTryEntry","locs","entry","tryLoc","catchLoc","finallyLoc","afterLoc","tryEntries","resetTryEntry","completion","iterable","iteratorMethod","isGeneratorFunction","genFun","ctor","setPrototypeOf","__proto__","awrap","async","iter","object","pop","skipTempReset","rootRecord","rval","exception","handle","loc","caught","hasCatch","hasFinally","finallyEntry","complete","thrown","delegateYield","regeneratorRuntime","accidentalStrictMode","Function","_toConsumableArray","arrayLikeToArray","unsupportedIterableToArray","strapiPsVirtual","TabToAccordion","itemStates","fill","useState","itemSelect","setItemSelect","bg","benefits","padding","benefitsOverlay","tabletCenter","item","useTransitionHeight","toggle","chevronRotate","btn","active","onClick","isMobile","visibleMdDown","heading","div","content","para","visibleLg","indexOf","paraDesk","SalesIntelScript","Helmet","charset","pageQuery","IndexPage","location","useSetPageData","strapiHomePage","main_subheading","main_conversion_link_url","main_conversion_link_text","we_deliver","description","SEO","PanelFoundation","spaceAboveHook","marginBottom","Col","lg","md","salePoint","header","solutionHeader","ArtificialIntelligence","Chatbots","Partners","asyncGeneratorStep","gen","_next","_throw","_asyncToGenerator","ex","React__default","UA","getBrowser","device","getCPU","getDevice","engine","getEngine","os","getOS","ua","getUA","setDefaults","d","getNavigatorInstance","navigator","isIOS13Check","nav","platform","maxTouchPoints","MSStream","_defineProperties","descriptor","enumerable","_defineProperty","_extends","ownKeys","enumerableOnly","getOwnPropertySymbols","symbols","filter","sym","getOwnPropertyDescriptor","_getPrototypeOf","_setPrototypeOf","_assertThisInitialized","ReferenceError","DEVICE_TYPES","BROWSER_TYPES","OS_TYPES","initialData","isTablet","isBrowser","isSmartTV","isConsole","isWearable","mobilePayload","getOwnPropertyDescriptors","defineProperties","_objectSpread2","vendor","model","osVersion","checkType","isEdgeChromiumType","isEdgeType","getIPad13","isMobileSafari","isChromium","isMobileAndTabletType","isMobileOnly","isAndroid","isWinPhone","isIOS","isChrome","isFirefox","isSafari","isOpera","isIE","osName","fullBrowserVersion","browserVersion","major","browserName","mobileVendor","mobileModel","engineName","engineVersion","isEdge","isYandex","deviceType","isIOS13","isIPad13","isIPhone13","isIPod13","isElectron","userAgent","isElectronType","isEdgeChromium","isLegacyEdge","isWindows","isMacOs","AndroidView","renderWithFragment","viewClassName","Fragment","BrowserView","ConsoleView","CustomView","_ref12","condition","IEView","IOSView","MobileOnlyView","MobileView","SmartTVView","TabletView","WearableView","_ref11","WinPhoneView","deviceDetect","browserMajorVersion","browserFullVersion","broPayload","stvPayload","consolePayload","wearPayload","withOrientationChange","WrappedComponent","_React$Component","_class","Constructor","_classCallCheck","isEventListenerAdded","handleOrientationChange","onOrientationChange","onPageLoad","isLandscape","isPortrait","protoProps","staticProps","subClass","superClass","_inherits","orientation","innerWidth","innerHeight","removeEventListener","addEventListener","flagInterpolate","deprecateInterpolate","MapShim","getIndex","class_1","__entries__","entries","splice","has","_i","global$1","global","requestAnimationFrame$1","transitionKeys","mutationObserverSupported","MutationObserver","ResizeObserverController","connected_","mutationEventsAdded_","mutationsObserver_","observers_","onTransitionEnd_","refresh","leadingCall","trailingCall","lastCallTime","resolvePending","proxy","timeoutCallback","timeStamp","throttle","addObserver","connect_","removeObserver","observers","disconnect_","updateObservers_","activeObservers","gatherActive","hasActive","broadcastActive","observe","childList","characterData","subtree","disconnect","_b","propertyName","getInstance","instance_","defineConfigurable","getWindowOf","ownerDocument","defaultView","emptyRect","createRectInit","toFloat","getBordersSize","styles","positions","getHTMLElementContentRect","clientWidth","clientHeight","getComputedStyle","paddings","positions_1","getPaddings","horizPad","left","right","vertPad","top","bottom","boxSizing","documentElement","isDocumentElement","vertScrollbar","horizScrollbar","isSVGGraphicsElement","SVGGraphicsElement","SVGElement","getBBox","getContentRect","bbox","getSVGContentRect","ResizeObservation","broadcastWidth","broadcastHeight","contentRect_","rect","broadcastRect","ResizeObserverEntry","rectInit","Constr","contentRect","DOMRectReadOnly","ResizeObserverSPI","controller","callbackCtx","activeObservations_","observations_","callback_","controller_","callbackCtx_","Element","observations","unobserve","clearActive","observation","WeakMap","ResizeObserver","useOnce","effect","useForceUpdate","unmounted","usePrev","prevRef","FrameLoop","raf","writing","lastTime","animations","startQueue","frameQueue","writeQueue","findIndex","other","kickoff","timeoutQueue","ms","dt_1","write","_createClass","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","toIObject","gOPD","createProperty","desc","O","getDesc","_assign","NUMBER","parts","rgb","RegExp","rgba","hsl","hsla","hex3","hex4","hex6","hex8","hslToRgb","h","l","C","M","c","hue2rgb","R1","G1","B1","parse255","int","parseInt","parse360","parse1","parsePercentage","colorToRgba","match","int32Color","exec","colorNamesRegex","numberRegex","colorRegex","rgbaRegex","rgbaRound","_","p1","p2","p3","p4","keyframes","interpolators","property","receiver","base","useMemoOne","getResult","committed","cache","Boolean","newInputs","lastInputs","areInputsEqual","useCallbackOne","gOPN","gOPS","anObject","getSymbols","Parent","Class","_cache","Wrapper","MODEL","NAME","TYPE","VENDOR","VERSION","MOBILE","TABLET","SMARTTV","util","extend","regexes","extensions","mergedRegexes","str1","str2","lowerize","mapper","rgx","arrays","j","k","q","matches","regex","_str","maps","oldsafari","1.2","1.3","amazon","sprint","HTC","Sprint","windows","ME","2000","XP","Vista","7","8","8.1","10","RT","cpu","UAParser","uastring","rgxmap","architecture","setUA","BROWSER","MAJOR","CPU","ARCHITECTURE","DEVICE","CONSOLE","WEARABLE","EMBEDDED","ENGINE","OS","$","jQuery","Zepto","parser","partners","strapiPaCompany","fluid","partners_image","link","alt","partnerContainer","href","partner","border","image","initialValue","previous","useRef","useEffect","bounds","ro","viewHeight","viewWidth","useMeasure","overflow","bool","setPageData","useContext","layoutContext","strapiPsRpa","_slicedToArray","_arr","_n","_d","_s"],"mappings":"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","file":"component---src-pages-index-js-e9e6c3a12766f8f46bc7.js","sourcesContent":["import React from \"react\";\nimport { Col } from \"react-bootstrap\";\n\n//conpoments\nimport PanelFoundation from \"./PanelFoundation\";\n\n//styles\nimport s from \"./ComponentHeader.module.scss\";\n\nconst ComponentHeader = ({\n  //from PanelFoundation\n  id,\n  rootClassName = \"bg-white\",\n  rootStyle,\n  rowClassName,\n  rowStyle,\n  overlay,\n  overlayStyle,\n  overlayColor,\n  rootGatsbyBackgroundImageFluid,\n  //component specific\n  lineTop = true,\n  text = \"Header\",\n  textAlign = \"center\",\n  textClassName = \"text-primary\"\n}) => {\n\n  const textStyle = {};\n\n  switch (textAlign.toLowerCase()) {\n    case \"center\":\n      textStyle.margin = \"0 auto\";\n      break;\n    case \"left\":\n      textStyle.margin = \"0 auto 0 0\";\n      break;\n    case \"right\":\n      textStyle.margin = \"0 0 0 auto\";\n      break;\n  }\n\n  return (\n    <PanelFoundation\n      id={id}\n      rootClassName={`${s.headerPanelPadding} ${rootClassName || \"\"}`}\n      rootStyle={rootStyle}\n      rowClassName={rowClassName}\n      rowStyle={rowStyle}\n      overlay={overlay}\n      overlayStyle={overlayStyle}\n      overlayColor={overlayColor}\n      rootGatsbyBackgroundImageFluid={rootGatsbyBackgroundImageFluid}\n    >\n      <Col sm={12}>\n        <h2\n          className={`${lineTop ? s.lineTop : \"\"} ${textClassName || \"\"} text-center`}\n          style={textStyle}\n        >\n          {text}\n        </h2>\n      </Col>\n    </PanelFoundation>\n  );\n};\n\nexport default ComponentHeader;\n","import React from 'react'\nimport { Link } from 'gatsby'\nimport Image from \"gatsby-image\";\nimport { StaticQuery, graphql } from \"gatsby\"\n\n//styles\nimport s from './card.module.scss'\n\nexport default ({ itemClassName }) => (\n\t<StaticQuery\n\t\tquery={graphql`\n      query {\n        strapiPsAi {\n          hero {\n            main_heading\n            service_icon {\n              childImageSharp {\n                fixed(width: 100, height: 100) {\n                  ...GatsbyImageSharpFixed\n                }\n              }\n            }\n          }\n        }\n      }\n    `}\n\t\trender={data => {\n\n\t\t\tconst { hero } = data.strapiPsAi;\n\n\t\t\treturn (\n\t\t\t\t<div className={`${itemClassName} ${s.industry}`}>\n\t\t\t\t\t<Link to=\"/solutions/artificial-intelligence/\">\n\t\t\t\t\t\t<div>\n\t\t\t\t\t\t\t<div className={`hero-circle m-auto`}>\n\t\t\t\t\t\t\t\t<Image fixed={hero[0].service_icon.childImageSharp.fixed}  className={`${s.icon}`} />\n\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t\t<h3 className=\"text-center\">{hero[0].main_heading}</h3>\n\t\t\t\t\t\t</div>\n\t\t\t\t\t\t<span className={`btn btn-secondary btn-lg ${s.button}`}>Learn More</span>\n\t\t\t\t\t</Link>\n\t\t\t\t</div>\n\t\t\t)\n\t\t}\n\t\t}\n\t/>\n)\n","// extracted by mini-css-extract-plugin\nmodule.exports = {\"modalVideo\":\"modal-video-module--modal-video--P3mOt\",\"modalVideoEffectExit\":\"modal-video-module--modal-video-effect-exit--1lIBd\",\"modalVideoMovieWrap\":\"modal-video-module--modal-video-movie-wrap--3B6nV\",\"modalVideoBody\":\"modal-video-module--modal-video-body--c2CSQ\",\"modalVideoInner\":\"modal-video-module--modal-video-inner--2pFXH\",\"modalVideoCloseBtn\":\"modal-video-module--modal-video-close-btn--3iz7H\"};","import arrayLikeToArray from \"./arrayLikeToArray\";\nexport default function _unsupportedIterableToArray(o, minLen) {\n  if (!o) return;\n  if (typeof o === \"string\") return arrayLikeToArray(o, minLen);\n  var n = Object.prototype.toString.call(o).slice(8, -1);\n  if (n === \"Object\" && o.constructor) n = o.constructor.name;\n  if (n === \"Map\" || n === \"Set\") return Array.from(n);\n  if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return arrayLikeToArray(o, minLen);\n}","import * as G from './globals';\nimport { is } from './helpers';\nexport var createInterpolator = function createInterpolator(range, output, extrapolate) {\n  if (is.fun(range)) {\n    return range;\n  }\n\n  if (is.arr(range)) {\n    return createInterpolator({\n      range: range,\n      output: output,\n      extrapolate: extrapolate\n    });\n  }\n\n  if (is.str(range.output[0])) {\n    return G.createStringInterpolator(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}","// extracted by mini-css-extract-plugin\nmodule.exports = {\"headerPanelPadding\":\"ComponentHeader-module--header-panel-padding--2f2QN\"};","import \"core-js/modules/es6.string.iterator\";\nimport \"core-js/modules/es6.array.from\";\nimport \"core-js/modules/web.dom.iterable\";\nimport \"core-js/modules/es6.array.iterator\";\nimport \"core-js/modules/es6.object.to-string\";\nimport \"core-js/modules/es6.object.keys\";\nimport \"core-js/modules/es6.function.name\";\nimport * as G from './globals';\nexport var noop = function noop() {};\nexport var defineHidden = function defineHidden(obj, key, value) {\n  return Object.defineProperty(obj, key, {\n    value: value,\n    writable: true,\n    configurable: true\n  });\n};\nexport var is = {\n  arr: Array.isArray,\n  obj: function obj(a) {\n    return !!a && a.constructor.name === '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 === undefined;\n  }\n};\n/** Compare animatable values */\n\nexport function isEqual(a, b) {\n  if (is.arr(a)) {\n    if (!is.arr(b) || a.length !== b.length) return false;\n\n    for (var i = 0; i < a.length; i++) {\n      if (a[i] !== b[i]) return false;\n    }\n\n    return true;\n  }\n\n  return a === b;\n} // Not all strings can be animated (eg: {display: \"none\"})\n\nexport var isAnimatedString = function isAnimatedString(value) {\n  return is.str(value) && (value[0] == '#' || /\\d/.test(value) || !!(G.colorNames && G.colorNames[value]));\n};\n/** An unsafe object/array/set iterator that allows for better minification */\n\nexport var each = function each(obj, cb, ctx) {\n  if (is.fun(obj.forEach)) {\n    obj.forEach(cb, ctx);\n  } else {\n    Object.keys(obj).forEach(function (key) {\n      return cb.call(ctx, obj[key], key);\n    });\n  }\n};\nexport var toArray = function toArray(a) {\n  return is.und(a) ? [] : is.arr(a) ? a : [a];\n};\nexport function flush(queue, iterator) {\n  if (queue.size) {\n    var items = Array.from(queue);\n    queue.clear();\n    each(items, iterator);\n  }\n}","module.exports = __webpack_public_path__ + \"static/intro-video-thumbnail-720b157f38082c9028779a8f5d9f6011.jpg\";","import \"core-js/modules/es6.object.assign\";\nimport { FrameLoop } from './FrameLoop';\nimport { noop } from './helpers'; //\n// Required\n//\n\nexport var createStringInterpolator;\nexport var frameLoop = new FrameLoop(); //\n// Optional\n//\n\nexport var to;\nexport var now = function now() {\n  return performance.now();\n};\nexport var colorNames = null;\nexport var skipAnimation = false;\nexport var requestAnimationFrame = typeof window !== 'undefined' ? window.requestAnimationFrame : function () {\n  return -1;\n};\nexport var batchedUpdates = function batchedUpdates(callback) {\n  return callback();\n};\nexport var willAdvance = noop;\nexport var assign = function assign(globals) {\n  var _a;\n\n  return _a = Object.assign({\n    to: to,\n    now: now,\n    frameLoop: frameLoop,\n    colorNames: colorNames,\n    skipAnimation: skipAnimation,\n    createStringInterpolator: createStringInterpolator,\n    requestAnimationFrame: requestAnimationFrame,\n    batchedUpdates: batchedUpdates,\n    willAdvance: willAdvance\n  }, pluckDefined(globals)), to = _a.to, now = _a.now, frameLoop = _a.frameLoop, colorNames = _a.colorNames, skipAnimation = _a.skipAnimation, createStringInterpolator = _a.createStringInterpolator, requestAnimationFrame = _a.requestAnimationFrame, batchedUpdates = _a.batchedUpdates, willAdvance = _a.willAdvance, _a;\n}; // Ignore undefined values\n\nfunction pluckDefined(globals) {\n  var defined = {};\n\n  for (var key in globals) {\n    if (globals[key] !== undefined) defined[key] = globals[key];\n  }\n\n  return defined;\n}","// 20.1.2.4 Number.isNaN(number)\nvar $export = require('./_export');\n\n$export($export.S, 'Number', {\n  isNaN: function isNaN(number) {\n    // eslint-disable-next-line no-self-compare\n    return number != number;\n  }\n});\n","export default function _arrayLikeToArray(arr, len) {\n  if (len == null || len > arr.length) len = arr.length;\n\n  for (var i = 0, arr2 = new Array(len); i < len; i++) {\n    arr2[i] = arr[i];\n  }\n\n  return arr2;\n}","import \"core-js/modules/es7.symbol.async-iterator\";\nimport \"core-js/modules/es6.symbol\";\nimport _assertThisInitialized from \"/home/vsts/work/1/s/node_modules/babel-preset-gatsby/node_modules/@babel/runtime/helpers/esm/assertThisInitialized\";\nimport \"core-js/modules/es6.array.find\";\nimport \"core-js/modules/es7.object.values\";\nimport _slicedToArray from \"/home/vsts/work/1/s/node_modules/babel-preset-gatsby/node_modules/@babel/runtime/helpers/esm/slicedToArray\";\nimport \"core-js/modules/es6.map\";\nimport \"core-js/modules/es6.function.name\";\nimport _regeneratorRuntime from \"/home/vsts/work/1/s/node_modules/babel-preset-gatsby/node_modules/@babel/runtime/regenerator\";\nimport \"regenerator-runtime/runtime\";\nimport \"core-js/modules/es6.number.constructor\";\nimport \"core-js/modules/es6.number.is-nan\";\nimport _get from \"/home/vsts/work/1/s/node_modules/babel-preset-gatsby/node_modules/@babel/runtime/helpers/esm/get\";\nimport \"core-js/modules/es6.array.from\";\nimport \"core-js/modules/es6.string.iterator\";\nimport \"core-js/modules/es6.set\";\nimport _createClass from \"/home/vsts/work/1/s/node_modules/babel-preset-gatsby/node_modules/@babel/runtime/helpers/esm/createClass\";\nimport \"core-js/modules/es6.regexp.to-string\";\nimport \"core-js/modules/es6.reflect.construct\";\nimport _possibleConstructorReturn from \"/home/vsts/work/1/s/node_modules/babel-preset-gatsby/node_modules/@babel/runtime/helpers/esm/possibleConstructorReturn\";\nimport _getPrototypeOf from \"/home/vsts/work/1/s/node_modules/babel-preset-gatsby/node_modules/@babel/runtime/helpers/esm/getPrototypeOf\";\nimport _inherits from \"/home/vsts/work/1/s/node_modules/babel-preset-gatsby/node_modules/@babel/runtime/helpers/esm/inherits\";\nimport _wrapNativeSuper from \"/home/vsts/work/1/s/node_modules/babel-preset-gatsby/node_modules/@babel/runtime/helpers/esm/wrapNativeSuper\";\nimport _asyncToGenerator from \"/home/vsts/work/1/s/node_modules/babel-preset-gatsby/node_modules/@babel/runtime/helpers/esm/asyncToGenerator\";\nimport \"core-js/modules/es6.object.keys\";\nimport \"core-js/modules/es7.array.includes\";\nimport \"core-js/modules/es6.string.includes\";\nimport \"core-js/modules/web.dom.iterable\";\nimport \"core-js/modules/es6.array.iterator\";\nimport \"core-js/modules/es6.object.assign\";\nimport _classCallCheck from \"/home/vsts/work/1/s/node_modules/babel-preset-gatsby/node_modules/@babel/runtime/helpers/esm/classCallCheck\";\nimport _toConsumableArray from \"/home/vsts/work/1/s/node_modules/babel-preset-gatsby/node_modules/@babel/runtime/helpers/esm/toConsumableArray\";\nimport \"core-js/modules/es6.promise\";\nimport \"core-js/modules/es6.object.to-string\";\n\nfunction _createSuper(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct()) { 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 { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }\n\nfunction _createForOfIteratorHelper(o) { if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (o = _unsupportedIterableToArray(o))) { 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 it, normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, 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(n); 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\nimport { useLayoutEffect } from 'react-layout-effect';\nimport { each as _each, is, toArray, isAnimatedString, getFluidConfig, Globals, FluidValue, getFluidValue, flush, isEqual, noop, useForceUpdate, usePrev, useOnce, createInterpolator } from '@react-spring/shared';\nexport { FrameLoop, Globals, createInterpolator } from '@react-spring/shared';\nimport _extends from '@babel/runtime/helpers/esm/extends';\nimport { createContext, useContext, createElement, useRef, useState, useMemo as useMemo$1, useImperativeHandle, Fragment } from 'react';\nimport { getAnimated, AnimatedValue, getPayload, setAnimated, AnimatedArray, AnimatedString } from '@react-spring/animated';\nimport { createStringInterpolator, batchedUpdates, to as to$1, frameLoop, skipAnimation } from '@react-spring/shared/globals';\nimport { useMemoOne, useCallbackOne } from 'use-memo-one';\nimport { deprecateInterpolate } from '@react-spring/shared/deprecations';\nimport _objectWithoutPropertiesLoose from '@babel/runtime/helpers/esm/objectWithoutPropertiesLoose';\nimport { createStringInterpolator as createStringInterpolator$1 } from '@react-spring/shared/stringInterpolation';\nexport * from '@react-spring/shared/types';\n/** API\n *  useChain(references, timeSteps, timeFrame)\n */\n\nfunction useChain(refs, timeSteps) {\n  var timeFrame = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1000;\n  useLayoutEffect(function () {\n    if (timeSteps) {\n      var prevDelay = 0;\n\n      _each(refs, function (ref, i) {\n        if (!ref.current) return;\n        var controllers = ref.current.controllers;\n\n        if (controllers.length) {\n          var delay = timeFrame * timeSteps[i]; // Use the previous delay if none exists.\n\n          if (isNaN(delay)) delay = prevDelay;else prevDelay = delay;\n\n          _each(controllers, function (ctrl) {\n            _each(ctrl.queue, function (props) {\n              props.delay = delay + (props.delay || 0);\n            });\n\n            ctrl.start();\n          });\n        }\n      });\n    } else {\n      var p = Promise.resolve();\n\n      _each(refs, function (ref) {\n        var _ref2 = ref.current || {},\n            controllers = _ref2.controllers,\n            start = _ref2.start;\n\n        if (controllers && controllers.length) {\n          // Take the queue of each controller\n          var updates = controllers.map(function (ctrl) {\n            var q = ctrl.queue;\n            ctrl.queue = [];\n            return q;\n          }); // Apply the queue when the previous ref stops animating\n\n          p = p.then(function () {\n            _each(controllers, function (ctrl, i) {\n              var _ctrl$queue;\n\n              return (_ctrl$queue = ctrl.queue).push.apply(_ctrl$queue, _toConsumableArray(updates[i]));\n            });\n\n            return start();\n          });\n        }\n      });\n    }\n  });\n} // The `mass` prop defaults to 1\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\nvar linear = function linear(t) {\n  return t;\n};\n\nvar defaults = _extends(_extends({}, config.default), {}, {\n  mass: 1,\n  damping: 1,\n  easing: linear,\n  clamp: false\n});\n\nvar AnimationConfig =\n/**\n * With higher tension, the spring will resist bouncing and try harder to stop at its end value.\n *\n * When tension is zero, no animation occurs.\n */\n\n/**\n * The damping ratio coefficient, or just the damping ratio when `speed` is defined.\n *\n * When `speed` is defined, this value should be between 0 and 1.\n *\n * Higher friction means the spring will slow down faster.\n */\n\n/**\n * The natural frequency (in seconds), which dictates the number of bounces\n * per second when no damping exists.\n *\n * When defined, `tension` is derived from this, and `friction` is derived\n * from `tension` and `damping`.\n */\n\n/**\n * The damping ratio, which dictates how the spring slows down.\n *\n * Set to `0` to never slow down. Set to `1` to slow down without bouncing.\n * Between `0` and `1` is for you to explore.\n *\n * Only works when `frequency` is defined.\n *\n * Defaults to 1\n */\n\n/**\n * Higher mass means more friction is required to slow down.\n *\n * Defaults to 1, which works fine most of the time.\n */\n\n/**\n * The initial velocity of one or more values.\n */\n\n/**\n * The smallest velocity before the animation is considered \"not moving\".\n *\n * When undefined, `precision` is used instead.\n */\n\n/**\n * The smallest distance from a value before that distance is essentially zero.\n *\n * This helps in deciding when a spring is \"at rest\". The spring must be within\n * this distance from its final value, and its velocity must be lower than this\n * value too (unless `restVelocity` is defined).\n */\n\n/**\n * For `duration` animations only. Note: The `duration` is not affected\n * by this property.\n *\n * Defaults to `0`, which means \"start from the beginning\".\n *\n * Setting to `1+` makes an immediate animation.\n *\n * Setting to `0.5` means \"start from the middle of the easing function\".\n *\n * Any number `>= 0` and `<= 1` makes sense here.\n */\n\n/**\n * Animation length in number of milliseconds.\n */\n\n/**\n * The animation curve. Only used when `duration` is defined.\n *\n * Defaults to quadratic ease-in-out.\n */\n\n/**\n * Avoid overshooting by ending abruptly at the goal value.\n */\n\n/**\n * When above zero, the spring will bounce instead of overshooting when\n * exceeding its goal value. Its velocity is multiplied by `-1 + bounce`\n * whenever its current value equals or exceeds its goal. For example,\n * setting `bounce` to `0.5` chops the velocity in half on each bounce,\n * in addition to any friction.\n */\n\n/**\n * \"Decay animations\" decelerate without an explicit goal value.\n * Useful for scrolling animations.\n *\n * Use `true` for the default exponential decay factor (`0.998`).\n *\n * When a `number` between `0` and `1` is given, a lower number makes the\n * animation slow down faster. And setting to `1` would make an unending\n * animation.\n */\n\n/**\n * While animating, round to the nearest multiple of this number.\n * The `from` and `to` values are never rounded, as well as any value\n * passed to the `set` method of an animated value.\n */\nfunction AnimationConfig() {\n  _classCallCheck(this, AnimationConfig);\n\n  this.tension = void 0;\n  this.friction = void 0;\n  this.frequency = void 0;\n  this.damping = void 0;\n  this.mass = void 0;\n  this.velocity = 0;\n  this.restVelocity = void 0;\n  this.precision = void 0;\n  this.progress = void 0;\n  this.duration = void 0;\n  this.easing = void 0;\n  this.clamp = void 0;\n  this.bounce = void 0;\n  this.decay = void 0;\n  this.round = void 0;\n  Object.assign(this, defaults);\n};\n\nfunction mergeConfig(config, newConfig, defaultConfig) {\n  if (defaultConfig) {\n    defaultConfig = _extends({}, defaultConfig);\n    sanitizeConfig(defaultConfig, newConfig);\n    newConfig = _extends(_extends({}, defaultConfig), newConfig);\n  }\n\n  sanitizeConfig(config, newConfig);\n  Object.assign(config, newConfig);\n\n  for (var key in defaults) {\n    if (config[key] == null) {\n      config[key] = defaults[key];\n    }\n  }\n\n  var mass = config.mass,\n      frequency = config.frequency,\n      damping = config.damping;\n\n  if (!is.und(frequency)) {\n    if (frequency < 0.01) frequency = 0.01;\n    if (damping < 0) damping = 0;\n    config.tension = Math.pow(2 * Math.PI / frequency, 2) * mass;\n    config.friction = 4 * Math.PI * damping * mass / frequency;\n  }\n\n  return config;\n} // Prevent a config from accidentally overriding new props.\n// This depends on which \"config\" props take precedence when defined.\n\n\nfunction sanitizeConfig(config, props) {\n  if (!is.und(props.decay)) {\n    config.duration = undefined;\n  } else {\n    var isTensionConfig = !is.und(props.tension) || !is.und(props.friction);\n\n    if (isTensionConfig || !is.und(props.frequency) || !is.und(props.damping) || !is.und(props.mass)) {\n      config.duration = undefined;\n      config.decay = undefined;\n    }\n\n    if (isTensionConfig) {\n      config.frequency = undefined;\n    }\n  }\n}\n\nvar emptyArray = [];\n/** @internal */\n\n/** An animation being executed by the frameloop */\n\nvar Animation = function Animation() {\n  _classCallCheck(this, Animation);\n\n  this.changed = false;\n  this.values = emptyArray;\n  this.toValues = null;\n  this.fromValues = emptyArray;\n  this.to = void 0;\n  this.from = void 0;\n  this.config = new AnimationConfig();\n  this.immediate = false;\n  this.onStart = void 0;\n  this.onChange = void 0;\n  this.onRest = [];\n}; // @see https://github.com/alexreardon/use-memo-one/pull/10\n\n\nvar useMemo = function useMemo(create, deps) {\n  return useMemoOne(create, deps || [{}]);\n};\n\nfunction callProp(value) {\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(value) ? value.apply(void 0, args) : value;\n}\n/** Try to coerce the given value into a boolean using the given key */\n\n\nvar matchProp = function matchProp(value, key) {\n  return value === true || !!(key && value && (is.fun(value) ? value(key) : toArray(value).includes(key)));\n};\n\nvar getProps = function getProps(props, i, arg) {\n  return props && (is.fun(props) ? props(i, arg) : is.arr(props) ? props[i] : _extends({}, props));\n};\n/** Returns `true` if the given prop is having its default value set. */\n\n\nvar hasDefaultProp = function hasDefaultProp(props, key) {\n  return !is.und(getDefaultProp(props, key));\n};\n/** Get the default value being set for the given `key` */\n\n\nvar getDefaultProp = function getDefaultProp(props, key) {\n  return props.default === true ? props[key] : props.default ? props.default[key] : undefined;\n};\n/**\n * Extract the default props from an update.\n *\n * When the `default` prop is falsy, this function still behaves as if\n * `default: true` was used. The `default` prop is always respected when\n * truthy.\n */\n\n\nvar getDefaultProps = function getDefaultProps(props) {\n  var omitKeys = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];\n  var defaults = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n  var keys = DEFAULT_PROPS;\n\n  if (props.default && props.default !== true) {\n    props = props.default;\n    keys = Object.keys(props);\n  }\n\n  var _iterator = _createForOfIteratorHelper(keys),\n      _step;\n\n  try {\n    for (_iterator.s(); !(_step = _iterator.n()).done;) {\n      var key = _step.value;\n      var value = props[key];\n\n      if (!is.und(value) && !omitKeys.includes(key)) {\n        defaults[key] = value;\n      }\n    }\n  } catch (err) {\n    _iterator.e(err);\n  } finally {\n    _iterator.f();\n  }\n\n  return defaults;\n};\n/** Merge the default props of an update into a props cache. */\n\n\nvar mergeDefaultProps = function mergeDefaultProps(defaults, props, omitKeys) {\n  return getDefaultProps(props, omitKeys, defaults);\n};\n/** These props can have default values */\n\n\nvar DEFAULT_PROPS = ['pause', 'cancel', 'config', 'immediate', 'onDelayEnd', 'onProps', 'onStart', 'onChange', 'onRest'];\nvar RESERVED_PROPS = {\n  config: 1,\n  from: 1,\n  to: 1,\n  ref: 1,\n  loop: 1,\n  reset: 1,\n  pause: 1,\n  cancel: 1,\n  reverse: 1,\n  immediate: 1,\n  default: 1,\n  delay: 1,\n  onDelayEnd: 1,\n  onProps: 1,\n  onStart: 1,\n  onChange: 1,\n  onRest: 1,\n  // Transition props\n  items: 1,\n  trail: 1,\n  sort: 1,\n  expires: 1,\n  initial: 1,\n  enter: 1,\n  update: 1,\n  leave: 1,\n  children: 1,\n  // Internal props\n  keys: 1,\n  callId: 1,\n  parentId: 1\n};\n/**\n * Extract any properties whose keys are *not* reserved for customizing your\n * animations. All hooks use this function, which means `useTransition` props\n * are reserved for `useSpring` calls, etc.\n */\n\nfunction getForwardProps(props) {\n  var forward = {};\n  var count = 0;\n\n  _each(props, function (value, prop) {\n    if (!RESERVED_PROPS[prop]) {\n      forward[prop] = value;\n      count++;\n    }\n  });\n\n  if (count) {\n    return forward;\n  }\n}\n/**\n * Clone the given `props` and move all non-reserved props\n * into the `to` prop.\n */\n\n\nfunction inferTo(props) {\n  var to = getForwardProps(props);\n\n  if (to) {\n    var out = {\n      to: to\n    };\n\n    _each(props, function (val, key) {\n      return key in to || (out[key] = val);\n    });\n\n    return out;\n  }\n\n  return _extends({}, props);\n} // Compute the goal value, converting \"red\" to \"rgba(255, 0, 0, 1)\" in the process\n\n\nfunction computeGoal(value) {\n  var config = getFluidConfig(value);\n  return config ? computeGoal(config.get()) : is.arr(value) ? value.map(computeGoal) : isAnimatedString(value) ? createStringInterpolator({\n    range: [0, 1],\n    output: [value, value]\n  })(1) : value;\n}\n/**\n * This function sets a timeout if both the `delay` prop exists and\n * the `cancel` prop is not `true`.\n *\n * The `actions.start` function must handle the `cancel` prop itself,\n * but the `pause` prop is taken care of.\n */\n\n\nfunction scheduleProps(callId, _ref3) {\n  var key = _ref3.key,\n      props = _ref3.props,\n      state = _ref3.state,\n      actions = _ref3.actions;\n  return new Promise(function (resolve, reject) {\n    var delay;\n    var timeout;\n    var pause = false;\n    var cancel = matchProp(props.cancel, key);\n\n    if (cancel) {\n      onStart();\n    } else {\n      delay = callProp(props.delay || 0, key);\n      pause = matchProp(props.pause, key);\n\n      if (pause) {\n        state.resumeQueue.add(onResume);\n        actions.pause();\n      } else {\n        actions.resume();\n        onResume();\n      }\n    }\n\n    function onPause() {\n      state.resumeQueue.add(onResume);\n      timeout.cancel(); // Cache the remaining delay.\n\n      delay = timeout.time - Globals.now();\n    }\n\n    function onResume() {\n      if (delay > 0) {\n        state.pauseQueue.add(onPause);\n        timeout = Globals.frameLoop.setTimeout(onStart, delay);\n      } else {\n        onStart();\n      }\n    }\n\n    function onStart() {\n      state.pauseQueue.delete(onPause); // Maybe cancelled during its delay.\n\n      if (callId <= (state.cancelId || 0)) {\n        cancel = true;\n      }\n\n      try {\n        actions.start(_extends(_extends({}, props), {}, {\n          callId: callId,\n          delay: delay,\n          cancel: cancel,\n          pause: pause\n        }), resolve);\n      } catch (err) {\n        reject(err);\n      }\n    }\n  });\n}\n/** @internal */\n\n/** The object given to the `onRest` prop and `start` promise. */\n\n/** The promised result of an animation. */\n\n/** @internal */\n\n\nvar getCombinedResult = function getCombinedResult(target, results) {\n  return results.length == 1 ? results[0] : results.some(function (result) {\n    return result.cancelled;\n  }) ? getCancelledResult(target) : results.every(function (result) {\n    return result.noop;\n  }) ? getNoopResult(target) : getFinishedResult(target, results.every(function (result) {\n    return result.finished;\n  }));\n};\n/** No-op results are for updates that never start an animation. */\n\n\nvar getNoopResult = function getNoopResult(target) {\n  var value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : target.get();\n  return {\n    value: value,\n    noop: true,\n    finished: true,\n    target: target\n  };\n};\n\nvar getFinishedResult = function getFinishedResult(target, finished) {\n  var value = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : target.get();\n  return {\n    value: value,\n    finished: finished,\n    target: target\n  };\n};\n\nvar getCancelledResult = function getCancelledResult(target) {\n  var value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : target.get();\n  return {\n    value: value,\n    cancelled: true,\n    target: target\n  };\n};\n/**\n * Start an async chain or an async script.\n *\n * Always call `runAsync` in the action callback of a `scheduleProps` call.\n *\n * The `T` parameter can be a set of animated values (as an object type)\n * or a primitive type for a single animated value.\n */\n\n\nfunction runAsync(_x, _x2, _x3, _x4) {\n  return _runAsync.apply(this, arguments);\n}\n\nfunction _runAsync() {\n  _runAsync = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee6(to, props, state, target) {\n    var callId, parentId, onRest, prevTo, prevPromise;\n    return _regeneratorRuntime.wrap(function _callee6$(_context6) {\n      while (1) {\n        switch (_context6.prev = _context6.next) {\n          case 0:\n            if (!props.pause) {\n              _context6.next = 3;\n              break;\n            }\n\n            _context6.next = 3;\n            return new Promise(function (resume) {\n              state.resumeQueue.add(resume);\n            });\n\n          case 3:\n            callId = props.callId, parentId = props.parentId, onRest = props.onRest;\n            prevTo = state.asyncTo, prevPromise = state.promise;\n\n            if (!(!parentId && to === prevTo && !props.reset)) {\n              _context6.next = 7;\n              break;\n            }\n\n            return _context6.abrupt(\"return\", prevPromise);\n\n          case 7:\n            return _context6.abrupt(\"return\", state.promise = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5() {\n              var defaultProps, preventBail, bail, bailPromise, withBailHandler, bailIfEnded, animate, result, animating;\n              return _regeneratorRuntime.wrap(function _callee5$(_context5) {\n                while (1) {\n                  switch (_context5.prev = _context5.next) {\n                    case 0:\n                      state.asyncId = callId;\n                      state.asyncTo = to; // The default props of any `animate` calls.\n\n                      defaultProps = getDefaultProps(props, [// The `onRest` prop is only called when the `runAsync` promise is resolved.\n                      'onRest']);\n                      // This promise is rejected when the animation is interrupted.\n                      bailPromise = new Promise(function (resolve, reject) {\n                        return preventBail = resolve, bail = reject;\n                      }); // Stop animating when an error is caught.\n\n                      withBailHandler = function withBailHandler(fn) {\n                        return function () {\n                          var onError = function onError(err) {\n                            if (err instanceof BailSignal) {\n                              bail(err); // Stop animating.\n                            }\n\n                            throw err;\n                          };\n\n                          try {\n                            return fn.apply(void 0, arguments).catch(onError);\n                          } catch (err) {\n                            onError(err);\n                          }\n                        };\n                      };\n\n                      bailIfEnded = function bailIfEnded(bailSignal) {\n                        var bailResult = // The `cancel` prop or `stop` method was used.\n                        callId <= (state.cancelId || 0) && getCancelledResult(target) || // The async `to` prop was replaced.\n                        callId !== state.asyncId && getFinishedResult(target, false);\n\n                        if (bailResult) {\n                          bailSignal.result = bailResult;\n                          throw bailSignal;\n                        }\n                      }; // Note: This function cannot use the `async` keyword, because we want the\n                      // `throw` statements to interrupt the caller.\n\n\n                      animate = withBailHandler(function (arg1, arg2) {\n                        var bailSignal = new BailSignal();\n                        bailIfEnded(bailSignal);\n                        var props = is.obj(arg1) ? _extends({}, arg1) : _extends(_extends({}, arg2), {}, {\n                          to: arg1\n                        });\n                        props.parentId = callId;\n\n                        _each(defaultProps, function (value, key) {\n                          if (is.und(props[key])) {\n                            props[key] = value;\n                          }\n                        });\n\n                        return target.start(props).then( /*#__PURE__*/function () {\n                          var _ref15 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(result) {\n                            return _regeneratorRuntime.wrap(function _callee3$(_context3) {\n                              while (1) {\n                                switch (_context3.prev = _context3.next) {\n                                  case 0:\n                                    bailIfEnded(bailSignal);\n\n                                    if (!target.is('PAUSED')) {\n                                      _context3.next = 4;\n                                      break;\n                                    }\n\n                                    _context3.next = 4;\n                                    return new Promise(function (resume) {\n                                      state.resumeQueue.add(resume);\n                                    });\n\n                                  case 4:\n                                    return _context3.abrupt(\"return\", result);\n\n                                  case 5:\n                                  case \"end\":\n                                    return _context3.stop();\n                                }\n                              }\n                            }, _callee3);\n                          }));\n\n                          return function (_x7) {\n                            return _ref15.apply(this, arguments);\n                          };\n                        }());\n                      });\n                      _context5.prev = 7;\n\n                      // Async sequence\n                      if (is.arr(to)) {\n                        animating = function () {\n                          var _ref16 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4(queue) {\n                            var _iterator2, _step2, _props2;\n\n                            return _regeneratorRuntime.wrap(function _callee4$(_context4) {\n                              while (1) {\n                                switch (_context4.prev = _context4.next) {\n                                  case 0:\n                                    _iterator2 = _createForOfIteratorHelper(queue);\n                                    _context4.prev = 1;\n\n                                    _iterator2.s();\n\n                                  case 3:\n                                    if ((_step2 = _iterator2.n()).done) {\n                                      _context4.next = 9;\n                                      break;\n                                    }\n\n                                    _props2 = _step2.value;\n                                    _context4.next = 7;\n                                    return animate(_props2);\n\n                                  case 7:\n                                    _context4.next = 3;\n                                    break;\n\n                                  case 9:\n                                    _context4.next = 14;\n                                    break;\n\n                                  case 11:\n                                    _context4.prev = 11;\n                                    _context4.t0 = _context4[\"catch\"](1);\n\n                                    _iterator2.e(_context4.t0);\n\n                                  case 14:\n                                    _context4.prev = 14;\n\n                                    _iterator2.f();\n\n                                    return _context4.finish(14);\n\n                                  case 17:\n                                  case \"end\":\n                                    return _context4.stop();\n                                }\n                              }\n                            }, _callee4, null, [[1, 11, 14, 17]]);\n                          }));\n\n                          return function (_x8) {\n                            return _ref16.apply(this, arguments);\n                          };\n                        }()(to);\n                      } // Async script\n                      else if (is.fun(to)) {\n                          animating = Promise.resolve(to(animate, target.stop.bind(target)));\n                        }\n\n                      _context5.next = 11;\n                      return Promise.all([animating.then(preventBail), bailPromise]);\n\n                    case 11:\n                      result = getFinishedResult(target, true); // Bail handling\n\n                      _context5.next = 21;\n                      break;\n\n                    case 14:\n                      _context5.prev = 14;\n                      _context5.t0 = _context5[\"catch\"](7);\n\n                      if (!(_context5.t0 instanceof BailSignal)) {\n                        _context5.next = 20;\n                        break;\n                      }\n\n                      result = _context5.t0.result;\n                      _context5.next = 21;\n                      break;\n\n                    case 20:\n                      throw _context5.t0;\n\n                    case 21:\n                      _context5.prev = 21;\n\n                      if (callId == state.asyncId) {\n                        state.asyncId = parentId;\n                        state.asyncTo = parentId ? prevTo : undefined;\n                        state.promise = parentId ? prevPromise : undefined;\n                      }\n\n                      return _context5.finish(21);\n\n                    case 24:\n                      if (is.fun(onRest)) {\n                        batchedUpdates(function () {\n                          onRest(result);\n                        });\n                      }\n\n                      return _context5.abrupt(\"return\", result);\n\n                    case 26:\n                    case \"end\":\n                      return _context5.stop();\n                  }\n                }\n              }, _callee5, null, [[7, 14, 21, 24]]);\n            }))());\n\n          case 8:\n          case \"end\":\n            return _context6.stop();\n        }\n      }\n    }, _callee6);\n  }));\n  return _runAsync.apply(this, arguments);\n}\n\nfunction cancelAsync(state, callId) {\n  state.cancelId = callId;\n  state.asyncId = state.asyncTo = state.promise = undefined;\n}\n/** This error is thrown to signal an interrupted async animation. */\n\n\nvar BailSignal = /*#__PURE__*/function (_Error) {\n  _inherits(BailSignal, _Error);\n\n  var _super = _createSuper(BailSignal);\n\n  function BailSignal() {\n    var _this;\n\n    _classCallCheck(this, BailSignal);\n\n    _this = _super.call(this, 'An async animation has been interrupted. You see this error because you ' + 'forgot to use `await` or `.catch(...)` on its returned promise.');\n    _this.result = void 0;\n    return _this;\n  }\n\n  return BailSignal;\n}( /*#__PURE__*/_wrapNativeSuper(Error));\n\nvar isFrameValue = function isFrameValue(value) {\n  return value instanceof FrameValue;\n};\n\nvar nextId = 1;\n/**\n * A kind of `FluidValue` that manages an `AnimatedValue` node.\n *\n * Its underlying value can be accessed and even observed.\n */\n\nvar FrameValue = /*#__PURE__*/function (_FluidValue) {\n  _inherits(FrameValue, _FluidValue);\n\n  var _super2 = _createSuper(FrameValue);\n\n  function FrameValue() {\n    var _this2;\n\n    _classCallCheck(this, FrameValue);\n\n    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n      args[_key2] = arguments[_key2];\n    }\n\n    _this2 = _super2.call.apply(_super2, [this].concat(args));\n    _this2.id = nextId++;\n    _this2.key = void 0;\n    _this2._priority = 0;\n    _this2._children = new Set();\n    return _this2;\n  }\n\n  _createClass(FrameValue, [{\n    key: \"get\",\n\n    /** Get the current value */\n    value: function get() {\n      var node = getAnimated(this);\n      return node && node.getValue();\n    }\n    /** Create a spring that maps our value to another value */\n\n  }, {\n    key: \"to\",\n    value: function to() {\n      for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {\n        args[_key3] = arguments[_key3];\n      }\n\n      return to$1(this, args);\n    }\n    /** @deprecated Use the `to` method instead. */\n\n  }, {\n    key: \"interpolate\",\n    value: function interpolate() {\n      deprecateInterpolate();\n\n      for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {\n        args[_key4] = arguments[_key4];\n      }\n\n      return to$1(this, args);\n    }\n    /** @internal */\n\n    /** @internal */\n\n  }, {\n    key: \"addChild\",\n    value: function addChild(child) {\n      if (!this._children.size) this._attach();\n\n      this._children.add(child);\n    }\n    /** @internal */\n\n  }, {\n    key: \"removeChild\",\n    value: function removeChild(child) {\n      this._children.delete(child);\n\n      if (!this._children.size) this._detach();\n    }\n    /** @internal */\n\n  }, {\n    key: \"onParentChange\",\n    value: function onParentChange(_ref4) {\n      var type = _ref4.type;\n\n      if (this.idle) {\n        // Start animating when a parent does.\n        if (type == 'start') {\n          this._reset();\n\n          this._start();\n        }\n      } // Reset our animation state when a parent does, but only when\n      // our animation is active.\n      else if (type == 'reset') {\n          this._reset();\n        }\n    }\n    /** Called when the first child is added. */\n\n  }, {\n    key: \"_attach\",\n    value: function _attach() {}\n    /** Called when the last child is removed. */\n\n  }, {\n    key: \"_detach\",\n    value: function _detach() {}\n    /**\n     * Reset our animation state (eg: start values, velocity, etc)\n     * and tell our children to do the same.\n     *\n     * This is called when our goal value is changed during (or before)\n     * an animation.\n     */\n\n  }, {\n    key: \"_reset\",\n    value: function _reset() {\n      this._emit({\n        type: 'reset',\n        parent: this\n      });\n    }\n    /**\n     * Start animating if possible.\n     *\n     * Note: Be sure to call `_reset` first, or the animation will break.\n     * This method would like to call `_reset` for you, but that would\n     * interfere with paused animations.\n     */\n\n  }, {\n    key: \"_start\",\n    value: function _start() {\n      this._emit({\n        type: 'start',\n        parent: this\n      });\n    }\n    /** Tell our children about our new value */\n\n  }, {\n    key: \"_onChange\",\n    value: function _onChange(value) {\n      var idle = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n\n      this._emit({\n        type: 'change',\n        parent: this,\n        value: value,\n        idle: idle\n      });\n    }\n    /** Tell our children about our new priority */\n\n  }, {\n    key: \"_onPriorityChange\",\n    value: function _onPriorityChange(priority) {\n      if (!this.idle) {\n        // Make the frameloop aware of our new priority.\n        frameLoop.start(this);\n      }\n\n      this._emit({\n        type: 'priority',\n        parent: this,\n        priority: priority\n      });\n    }\n  }, {\n    key: \"_emit\",\n    value: function _emit(event) {\n      // Clone \"_children\" so it can be safely mutated inside the loop.\n      _each(Array.from(this._children), function (child) {\n        child.onParentChange(event);\n      });\n    }\n  }, {\n    key: \"priority\",\n    get: function get() {\n      return this._priority;\n    },\n    set: function set(priority) {\n      if (this._priority != priority) {\n        this._priority = priority;\n\n        this._onPriorityChange(priority);\n      }\n    }\n  }]);\n\n  return FrameValue;\n}(FluidValue); // TODO: use \"const enum\" when Babel supports it\n\n/** The spring has not animated yet */\n\n\nvar CREATED = 'CREATED';\n/** The spring has animated before */\n\nvar IDLE = 'IDLE';\n/** The spring is animating */\n\nvar ACTIVE = 'ACTIVE';\n/** The spring is frozen in time */\n\nvar PAUSED = 'PAUSED';\n/** The spring cannot be animated */\n\nvar DISPOSED = 'DISPOSED';\n/**\n * Only numbers, strings, and arrays of numbers/strings are supported.\n * Non-animatable strings are also supported.\n */\n\nvar SpringValue = /*#__PURE__*/function (_FrameValue) {\n  _inherits(SpringValue, _FrameValue);\n\n  var _super3 = _createSuper(SpringValue);\n\n  /** The property name used when `to` or `from` is an object. Useful when debugging too. */\n\n  /** The animation state */\n\n  /** The queue of pending props */\n\n  /** The lifecycle phase of this spring */\n\n  /** The state for `runAsync` calls */\n\n  /** Some props have customizable default values */\n\n  /** The counter for tracking `scheduleProps` calls */\n\n  /** The last `scheduleProps` call that changed the `to` prop */\n  function SpringValue(arg1, arg2) {\n    var _this3;\n\n    _classCallCheck(this, SpringValue);\n\n    _this3 = _super3.call(this);\n    _this3.key = void 0;\n    _this3.animation = new Animation();\n    _this3.queue = void 0;\n    _this3._phase = CREATED;\n    _this3._state = {\n      pauseQueue: new Set(),\n      resumeQueue: new Set()\n    };\n    _this3._defaultProps = {};\n    _this3._lastCallId = 0;\n    _this3._lastToId = 0;\n\n    if (!is.und(arg1) || !is.und(arg2)) {\n      var props = is.obj(arg1) ? _extends({}, arg1) : _extends(_extends({}, arg2), {}, {\n        from: arg1\n      });\n      props.default = true;\n\n      _this3.start(props);\n    }\n\n    return _this3;\n  }\n\n  _createClass(SpringValue, [{\n    key: \"advance\",\n\n    /** Advance the current animation by a number of milliseconds */\n    value: function advance(dt) {\n      var _this4 = this;\n\n      var idle = true;\n      var changed = false;\n      var anim = this.animation;\n      var config = anim.config,\n          toValues = anim.toValues;\n      var payload = getPayload(anim.to);\n\n      if (!payload) {\n        var toConfig = getFluidConfig(anim.to);\n\n        if (toConfig) {\n          toValues = toArray(toConfig.get());\n        }\n      }\n\n      anim.values.forEach(function (node, i) {\n        if (node.done) return; // The \"anim.toValues\" array must exist when no parent exists.\n\n        var to = payload ? payload[i].lastPosition : toValues[i];\n        var finished = anim.immediate;\n        var position = to;\n\n        if (!finished) {\n          position = node.lastPosition; // Loose springs never move.\n\n          if (config.tension <= 0) {\n            node.done = true;\n            return;\n          }\n\n          var elapsed = node.elapsedTime += dt;\n          var from = anim.fromValues[i];\n          var v0 = node.v0 != null ? node.v0 : node.v0 = is.arr(config.velocity) ? config.velocity[i] : config.velocity;\n          var velocity; // Duration easing\n\n          if (!is.und(config.duration)) {\n            var p = config.progress || 0;\n            if (config.duration <= 0) p = 1;else p += (1 - p) * Math.min(1, elapsed / config.duration);\n            position = from + config.easing(p) * (to - from);\n            velocity = (position - node.lastPosition) / dt;\n            finished = p == 1;\n          } // Decay easing\n          else if (config.decay) {\n              var decay = config.decay === true ? 0.998 : config.decay;\n              var e = Math.exp(-(1 - decay) * elapsed);\n              position = from + v0 / (1 - decay) * (1 - e);\n              finished = Math.abs(node.lastPosition - position) < 0.1; // derivative of position\n\n              velocity = v0 * e;\n            } // Spring easing\n            else {\n                velocity = node.lastVelocity == null ? v0 : node.lastVelocity;\n                /** The smallest distance from a value before being treated like said value. */\n\n                var precision = config.precision || (from == to ? 0.005 : Math.min(1, Math.abs(to - from) * 0.001));\n                /** The velocity at which movement is essentially none */\n\n                var restVelocity = config.restVelocity || precision / 10; // Bouncing is opt-in (not to be confused with overshooting)\n\n                var bounceFactor = config.clamp ? 0 : config.bounce;\n                var canBounce = !is.und(bounceFactor);\n                /** When `true`, the value is increasing over time */\n\n                var isGrowing = from == to ? node.v0 > 0 : from < to;\n                /** When `true`, the velocity is considered moving */\n\n                var isMoving;\n                /** When `true`, the velocity is being deflected or clamped */\n\n                var isBouncing = false;\n                var step = 1; // 1ms\n\n                var numSteps = Math.ceil(dt / step);\n\n                for (var n = 0; n < numSteps; ++n) {\n                  isMoving = Math.abs(velocity) > restVelocity;\n\n                  if (!isMoving) {\n                    finished = Math.abs(to - position) <= precision;\n\n                    if (finished) {\n                      break;\n                    }\n                  }\n\n                  if (canBounce) {\n                    isBouncing = position == to || position > to == isGrowing; // Invert the velocity with a magnitude, or clamp it.\n\n                    if (isBouncing) {\n                      velocity = -velocity * bounceFactor;\n                      position = to;\n                    }\n                  }\n\n                  var springForce = -config.tension * 0.000001 * (position - to);\n                  var dampingForce = -config.friction * 0.001 * velocity;\n                  var acceleration = (springForce + dampingForce) / config.mass; // pt/ms^2\n\n                  velocity = velocity + acceleration * step; // pt/ms\n\n                  position = position + velocity * step;\n                }\n              }\n\n          node.lastVelocity = velocity;\n\n          if (Number.isNaN(position)) {\n            console.warn(\"Got NaN while animating:\", _this4);\n            finished = true;\n          }\n        } // Parent springs must finish before their children can.\n\n\n        if (payload && !payload[i].done) {\n          finished = false;\n        }\n\n        if (finished) {\n          node.done = true;\n        } else {\n          idle = false;\n        }\n\n        if (node.setValue(position, config.round)) {\n          changed = true;\n        }\n      });\n\n      if (idle) {\n        this.finish();\n      } else if (changed) {\n        this._onChange(this.get());\n      }\n\n      return idle;\n    }\n    /** Check the current phase */\n\n  }, {\n    key: \"is\",\n    value: function is(phase) {\n      return this._phase == phase;\n    }\n    /** Set the current value, while stopping the current animation */\n\n  }, {\n    key: \"set\",\n    value: function set(value) {\n      var _this5 = this;\n\n      batchedUpdates(function () {\n        _this5._focus(value);\n\n        if (_this5._set(value)) {\n          // Ensure change observers are notified. When active,\n          // the \"_stop\" method handles this.\n          if (!_this5.is(ACTIVE)) {\n            return _this5._onChange(_this5.get(), true);\n          }\n        }\n\n        _this5._stop();\n      });\n      return this;\n    }\n    /**\n     * Freeze the active animation in time.\n     * This does nothing when not animating.\n     */\n\n  }, {\n    key: \"pause\",\n    value: function pause() {\n      checkDisposed(this, 'pause');\n\n      if (!this.is(PAUSED)) {\n        this._phase = PAUSED;\n        flush(this._state.pauseQueue, function (onPause) {\n          return onPause();\n        });\n      }\n    }\n    /** Resume the animation if paused. */\n\n  }, {\n    key: \"resume\",\n    value: function resume() {\n      checkDisposed(this, 'resume');\n\n      if (this.is(PAUSED)) {\n        this._start();\n\n        flush(this._state.resumeQueue, function (onResume) {\n          return onResume();\n        });\n      }\n    }\n    /**\n     * Skip to the end of the current animation.\n     *\n     * All `onRest` callbacks are passed `{finished: true}`\n     */\n\n  }, {\n    key: \"finish\",\n    value: function finish(to) {\n      var _this6 = this;\n\n      this.resume();\n\n      if (this.is(ACTIVE)) {\n        var anim = this.animation; // Decay animations have an implicit goal.\n\n        if (!anim.config.decay && is.und(to)) {\n          to = anim.to;\n        } // Set the value if we can.\n\n\n        if (!is.und(to)) {\n          this._set(to);\n        }\n\n        batchedUpdates(function () {\n          // Ensure the \"onStart\" and \"onRest\" props are called.\n          if (!anim.changed) {\n            anim.changed = true;\n\n            if (anim.onStart) {\n              anim.onStart(_this6);\n            }\n          } // Exit the frameloop.\n\n\n          _this6._stop();\n        });\n      }\n\n      return this;\n    }\n    /** Push props into the pending queue. */\n\n  }, {\n    key: \"update\",\n    value: function update(props) {\n      checkDisposed(this, 'update');\n      var queue = this.queue || (this.queue = []);\n      queue.push(props);\n      return this;\n    }\n    /**\n     * Update this value's animation using the queue of pending props,\n     * and unpause the current animation (if one is frozen).\n     *\n     * When arguments are passed, a new animation is created, and the\n     * queued animations are left alone.\n     */\n\n  }, {\n    key: \"start\",\n    value: function () {\n      var _start2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(to, arg2) {\n        var _this7 = this;\n\n        var queue, results;\n        return _regeneratorRuntime.wrap(function _callee$(_context) {\n          while (1) {\n            switch (_context.prev = _context.next) {\n              case 0:\n                checkDisposed(this, 'start');\n\n                if (!is.und(to)) {\n                  queue = [is.obj(to) ? to : _extends(_extends({}, arg2), {}, {\n                    to: to\n                  })];\n                } else {\n                  queue = this.queue || [];\n                  this.queue = [];\n                }\n\n                _context.next = 4;\n                return Promise.all(queue.map(function (props) {\n                  return _this7._update(props);\n                }));\n\n              case 4:\n                results = _context.sent;\n                return _context.abrupt(\"return\", getCombinedResult(this, results));\n\n              case 6:\n              case \"end\":\n                return _context.stop();\n            }\n          }\n        }, _callee, this);\n      }));\n\n      function start(_x5, _x6) {\n        return _start2.apply(this, arguments);\n      }\n\n      return start;\n    }()\n    /**\n     * Stop the current animation, and cancel any delayed updates.\n     *\n     * Pass `true` to call `onRest` with `cancelled: true`.\n     */\n\n  }, {\n    key: \"stop\",\n    value: function stop(cancel) {\n      var _this8 = this;\n\n      if (!this.is(DISPOSED)) {\n        cancelAsync(this._state, this._lastCallId); // Ensure the `to` value equals the current value.\n\n        this._focus(this.get()); // Exit the frameloop and notify `onRest` listeners.\n\n\n        batchedUpdates(function () {\n          return _this8._stop(cancel);\n        });\n      }\n\n      return this;\n    }\n    /** Restart the animation. */\n\n  }, {\n    key: \"reset\",\n    value: function reset() {\n      this._update({\n        reset: true\n      });\n    }\n    /** Prevent future animations, and stop the current animation */\n\n  }, {\n    key: \"dispose\",\n    value: function dispose() {\n      if (!this.is(DISPOSED)) {\n        if (this.animation) {\n          // Prevent \"onRest\" calls when disposed.\n          this.animation.onRest = [];\n        }\n\n        this.stop();\n        this._phase = DISPOSED;\n      }\n    }\n    /** @internal */\n\n  }, {\n    key: \"onParentChange\",\n    value: function onParentChange(event) {\n      _get(_getPrototypeOf(SpringValue.prototype), \"onParentChange\", this).call(this, event);\n\n      if (event.type == 'change') {\n        if (!this.is(ACTIVE)) {\n          this._reset();\n\n          if (!this.is(PAUSED)) {\n            this._start();\n          }\n        }\n      } else if (event.type == 'priority') {\n        this.priority = event.priority + 1;\n      }\n    }\n    /**\n     * Parse the `to` and `from` range from the given `props` object.\n     *\n     * This also ensures the initial value is available to animated components\n     * during the render phase.\n     */\n\n  }, {\n    key: \"_prepareNode\",\n    value: function _prepareNode(_ref5) {\n      var to = _ref5.to,\n          from = _ref5.from,\n          reverse = _ref5.reverse;\n      var key = this.key || '';\n      to = !is.obj(to) || getFluidConfig(to) ? to : to[key];\n      from = !is.obj(from) || getFluidConfig(from) ? from : from[key]; // Create the range now to avoid \"reverse\" logic.\n\n      var range = {\n        to: to,\n        from: from\n      }; // Before ever animating, this method ensures an `Animated` node\n      // exists and keeps its value in sync with the \"from\" prop.\n\n      if (this.is(CREATED)) {\n        if (reverse) {\n          var _ref6 = [from, to];\n          to = _ref6[0];\n          from = _ref6[1];\n        }\n\n        from = getFluidValue(from);\n\n        var node = this._updateNode(is.und(from) ? getFluidValue(to) : from);\n\n        if (node && !is.und(from)) {\n          node.setValue(from);\n        }\n      }\n\n      return range;\n    }\n    /**\n     * Create an `Animated` node if none exists or the given value has an\n     * incompatible type. Do nothing if `value` is undefined.\n     *\n     * The newest `Animated` node is returned.\n     */\n\n  }, {\n    key: \"_updateNode\",\n    value: function _updateNode(value) {\n      var node = getAnimated(this);\n\n      if (!is.und(value)) {\n        var nodeType = this._getNodeType(value);\n\n        if (!node || node.constructor !== nodeType) {\n          setAnimated(this, node = nodeType.create(value));\n        }\n      }\n\n      return node;\n    }\n    /** Return the `Animated` node constructor for a given value */\n\n  }, {\n    key: \"_getNodeType\",\n    value: function _getNodeType(value) {\n      var parentNode = getAnimated(value);\n      return parentNode ? parentNode.constructor : is.arr(value) ? AnimatedArray : isAnimatedString(value) ? AnimatedString : AnimatedValue;\n    }\n    /** Schedule an animation to run after an optional delay */\n\n  }, {\n    key: \"_update\",\n    value: function _update(props, isLoop) {\n      var _this9 = this;\n\n      var defaultProps = this._defaultProps;\n\n      var mergeDefaultProp = function mergeDefaultProp(key) {\n        var value = getDefaultProp(props, key);\n\n        if (!is.und(value)) {\n          defaultProps[key] = value;\n        } // For `cancel` and `pause`, a truthy default always wins.\n\n\n        if (defaultProps[key]) {\n          props[key] = defaultProps[key];\n        }\n      }; // These props are coerced into booleans by the `scheduleProps` function,\n      // so they need their default values processed before then.\n\n\n      mergeDefaultProp('cancel');\n      mergeDefaultProp('pause'); // Ensure the initial value can be accessed by animated components.\n\n      var range = this._prepareNode(props);\n\n      return scheduleProps(++this._lastCallId, {\n        key: this.key,\n        props: props,\n        state: this._state,\n        actions: {\n          pause: this.pause.bind(this),\n          resume: this.resume.bind(this),\n          start: this._merge.bind(this, range)\n        }\n      }).then(function (result) {\n        if (props.loop && result.finished && !(isLoop && result.noop)) {\n          var nextProps = createLoopUpdate(props);\n\n          if (nextProps) {\n            return _this9._update(nextProps, true);\n          }\n        }\n\n        return result;\n      });\n    }\n    /** Merge props into the current animation */\n\n  }, {\n    key: \"_merge\",\n    value: function _merge(range, props, resolve) {\n      // The \"cancel\" prop cancels all pending delays and it forces the\n      // active animation to stop where it is.\n      if (props.cancel) {\n        this.stop(true);\n        return resolve(getCancelledResult(this));\n      }\n\n      var key = this.key,\n          anim = this.animation;\n      var defaultProps = this._defaultProps;\n      /** The \"to\" prop is defined. */\n\n      var hasToProp = !is.und(range.to);\n      /** The \"from\" prop is defined. */\n\n      var hasFromProp = !is.und(range.from); // Avoid merging other props if implicitly prevented, except\n      // when both the \"to\" and \"from\" props are undefined.\n\n      if (hasToProp || hasFromProp) {\n        if (props.callId > this._lastToId) {\n          this._lastToId = props.callId;\n        } else {\n          return resolve(getCancelledResult(this));\n        }\n      }\n      /** Get the value of a prop, or its default value */\n\n\n      var get = function get(prop) {\n        return !is.und(props[prop]) ? props[prop] : defaultProps[prop];\n      }; // Call \"onDelayEnd\" before merging props, but after cancellation checks.\n\n\n      var onDelayEnd = coerceEventProp(get('onDelayEnd'), key);\n\n      if (onDelayEnd) {\n        onDelayEnd(props, this);\n      }\n\n      if (props.default) {\n        mergeDefaultProps(defaultProps, props, ['pause', 'cancel']);\n      }\n\n      var prevTo = anim.to,\n          prevFrom = anim.from;\n      var _range$to = range.to,\n          to = _range$to === void 0 ? prevTo : _range$to,\n          _range$from = range.from,\n          from = _range$from === void 0 ? prevFrom : _range$from; // Focus the \"from\" value if changing without a \"to\" value.\n\n      if (hasFromProp && !hasToProp) {\n        to = from;\n      } // Flip the current range if \"reverse\" is true.\n\n\n      if (props.reverse) {\n        var _ref7 = [from, to];\n        to = _ref7[0];\n        from = _ref7[1];\n      }\n      /** The \"from\" value is changing. */\n\n\n      var hasFromChanged = !isEqual(from, prevFrom);\n\n      if (hasFromChanged) {\n        anim.from = from;\n      }\n      /** The \"to\" value is changing. */\n\n\n      var hasToChanged = !isEqual(to, prevTo);\n\n      if (hasToChanged) {\n        this._focus(to);\n      } // Both \"from\" and \"to\" can use a fluid config (thanks to http://npmjs.org/fluids).\n\n\n      var toConfig = getFluidConfig(to);\n      var fromConfig = getFluidConfig(from);\n\n      if (fromConfig) {\n        from = fromConfig.get();\n      }\n      /** The \"to\" prop is async. */\n\n\n      var hasAsyncTo = is.arr(props.to) || is.fun(props.to);\n      var config = anim.config;\n      var decay = config.decay,\n          velocity = config.velocity; // The \"runAsync\" function treats the \"config\" prop as a default,\n      // so we must avoid merging it when the \"to\" prop is async.\n\n      if (props.config && !hasAsyncTo) {\n        mergeConfig(config, callProp(props.config, key), // Avoid calling the same \"config\" prop twice.\n        props.config !== defaultProps.config ? callProp(defaultProps.config, key) : void 0);\n      } // This instance might not have its Animated node yet. For example,\n      // the constructor can be given props without a \"to\" or \"from\" value.\n\n\n      var node = getAnimated(this);\n\n      if (!node || is.und(to)) {\n        return resolve(getFinishedResult(this, true));\n      }\n      /** When true, start at the \"from\" value. */\n\n\n      var reset = // When `reset` is undefined, the `from` prop implies `reset: true`,\n      // except for declarative updates. When `reset` is defined, there\n      // must exist a value to animate from.\n      is.und(props.reset) ? hasFromProp && !props.default : !is.und(from) && matchProp(props.reset, key); // The current value, where the animation starts from.\n\n      var value = reset ? from : this.get(); // The animation ends at this value, unless \"to\" is fluid.\n\n      var goal = computeGoal(to); // Only specific types can be animated to/from.\n\n      var isAnimatable = is.num(goal) || is.arr(goal) || isAnimatedString(goal); // When true, the value changes instantly on the next frame.\n\n      var immediate = !hasAsyncTo && (!isAnimatable || matchProp(defaultProps.immediate || props.immediate, key));\n\n      if (hasToChanged) {\n        if (immediate) {\n          node = this._updateNode(goal);\n        } else {\n          var nodeType = this._getNodeType(to);\n\n          if (nodeType !== node.constructor) {\n            throw Error(\"Cannot animate between \" + node.constructor.name + \" and \" + nodeType.name + \", as the \\\"to\\\" prop suggests\");\n          }\n        }\n      } // The type of Animated node for the goal value.\n\n\n      var goalType = node.constructor; // When the goal value is fluid, we don't know if its value\n      // will change before the next animation frame, so it always\n      // starts the animation to be safe.\n\n      var started = !!toConfig;\n      var finished = false;\n\n      if (!started) {\n        // When true, the current value has probably changed.\n        var hasValueChanged = reset || this.is(CREATED) && hasFromChanged; // When the \"to\" value or current value are changed,\n        // start animating if not already finished.\n\n        if (hasToChanged || hasValueChanged) {\n          finished = isEqual(computeGoal(value), goal);\n          started = !finished;\n        } // Changing \"decay\" or \"velocity\" starts the animation.\n\n\n        if (!isEqual(config.decay, decay) || !isEqual(config.velocity, velocity)) {\n          started = true;\n        }\n      } // When an active animation changes its goal to its current value:\n\n\n      if (finished && this.is(ACTIVE)) {\n        // Avoid an abrupt stop unless the animation is being reset.\n        if (anim.changed && !reset) {\n          started = true;\n        } // Stop the animation before its first frame.\n        else if (!started) {\n            this._stop();\n          }\n      }\n\n      if (!hasAsyncTo) {\n        // Make sure our \"toValues\" are updated even if our previous\n        // \"to\" prop is a fluid value whose current value is also ours.\n        if (started || getFluidConfig(prevTo)) {\n          anim.values = node.getPayload();\n          anim.toValues = toConfig ? null : goalType == AnimatedString ? [1] : toArray(goal);\n        }\n\n        anim.immediate = immediate;\n        anim.onStart = coerceEventProp(get('onStart'), key);\n        anim.onChange = coerceEventProp(get('onChange'), key); // The \"reset\" prop tries to reuse the old \"onRest\" prop,\n        // unless you defined a new \"onRest\" prop.\n\n        var onRestQueue = anim.onRest;\n        var onRest = reset && !props.onRest ? onRestQueue[0] || noop : checkFinishedOnRest(coerceEventProp(get('onRest'), key), this); // In most cases, the animation after this one won't reuse our\n        // \"onRest\" prop. Instead, the _default_ \"onRest\" prop is used\n        // when the next animation has an undefined \"onRest\" prop.\n\n        if (started) {\n          anim.onRest = [onRest, checkFinishedOnRest(resolve, this)]; // Flush the \"onRest\" queue for the previous animation.\n\n          var onRestIndex = reset ? 0 : 1;\n\n          if (onRestIndex < onRestQueue.length) {\n            batchedUpdates(function () {\n              for (; onRestIndex < onRestQueue.length; onRestIndex++) {\n                onRestQueue[onRestIndex]();\n              }\n            });\n          }\n        } // The \"onRest\" prop is always first, and it can be updated even\n        // if a new animation is not started by this update.\n        else if (reset || props.onRest) {\n            anim.onRest[0] = onRest;\n          }\n      } // By this point, every prop has been merged.\n\n\n      var onProps = coerceEventProp(get('onProps'), key);\n\n      if (onProps) {\n        onProps(props, this);\n      } // Update our node even if the animation is idle.\n\n\n      if (reset) {\n        node.setValue(value);\n      }\n\n      if (hasAsyncTo) {\n        resolve(runAsync(props.to, props, this._state, this));\n      } // Start an animation\n      else if (started) {\n          // Must be idle for \"onStart\" to be called again.\n          if (reset) this._phase = IDLE;\n\n          this._reset();\n\n          this._start();\n        } // Postpone promise resolution until the animation is finished,\n        // so that no-op updates still resolve at the expected time.\n        else if (this.is(ACTIVE) && !hasToChanged) {\n            anim.onRest.push(checkFinishedOnRest(resolve, this));\n          } // Resolve our promise immediately.\n          else {\n              resolve(getNoopResult(this, value));\n            }\n    }\n    /** Update the `animation.to` value, which might be a `FluidValue` */\n\n  }, {\n    key: \"_focus\",\n    value: function _focus(value) {\n      var anim = this.animation;\n\n      if (value !== anim.to) {\n        var _config = getFluidConfig(anim.to);\n\n        if (_config) {\n          _config.removeChild(this);\n        }\n\n        anim.to = value;\n        var priority = 0;\n\n        if (_config = getFluidConfig(value)) {\n          _config.addChild(this);\n\n          if (isFrameValue(value)) {\n            priority = (value.priority || 0) + 1;\n          }\n        }\n\n        this.priority = priority;\n      }\n    }\n    /** Set the current value and our `node` if necessary. The `_onChange` method is *not* called. */\n\n  }, {\n    key: \"_set\",\n    value: function _set(value) {\n      var config = getFluidConfig(value);\n\n      if (config) {\n        value = config.get();\n      }\n\n      var node = getAnimated(this);\n      var oldValue = node && node.getValue();\n\n      if (node) {\n        node.setValue(value);\n      } else {\n        this._updateNode(value);\n      }\n\n      return !isEqual(value, oldValue);\n    }\n  }, {\n    key: \"_onChange\",\n    value: function _onChange(value) {\n      var idle = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n      var anim = this.animation; // The \"onStart\" prop is called on the first change after entering the\n      // frameloop, but never for immediate animations.\n\n      if (!anim.changed && !idle) {\n        anim.changed = true;\n\n        if (anim.onStart) {\n          anim.onStart(this);\n        }\n      }\n\n      if (anim.onChange) {\n        anim.onChange(value, this);\n      }\n\n      _get(_getPrototypeOf(SpringValue.prototype), \"_onChange\", this).call(this, value, idle);\n    }\n  }, {\n    key: \"_reset\",\n    value: function _reset() {\n      var anim = this.animation; // Reset the state of each Animated node.\n\n      getAnimated(this).reset(anim.to); // Ensure the `onStart` prop will be called.\n\n      if (!this.is(ACTIVE)) {\n        anim.changed = false;\n      } // Use the current values as the from values.\n\n\n      if (!anim.immediate) {\n        anim.fromValues = anim.values.map(function (node) {\n          return node.lastPosition;\n        });\n      }\n\n      _get(_getPrototypeOf(SpringValue.prototype), \"_reset\", this).call(this);\n    }\n  }, {\n    key: \"_start\",\n    value: function _start() {\n      if (!this.is(ACTIVE)) {\n        this._phase = ACTIVE;\n\n        _get(_getPrototypeOf(SpringValue.prototype), \"_start\", this).call(this); // The \"skipAnimation\" global avoids the frameloop.\n\n\n        if (skipAnimation) {\n          this.finish();\n        } else {\n          frameLoop.start(this);\n        }\n      }\n    }\n    /**\n     * Exit the frameloop and notify `onRest` listeners.\n     *\n     * Always wrap `_stop` calls with `batchedUpdates`.\n     */\n\n  }, {\n    key: \"_stop\",\n    value: function _stop(cancel) {\n      this.resume();\n\n      if (this.is(ACTIVE)) {\n        this._phase = IDLE; // Always let change observers know when a spring becomes idle.\n\n        this._onChange(this.get(), true);\n\n        var anim = this.animation;\n\n        _each(anim.values, function (node) {\n          node.done = true;\n        });\n\n        var onRestQueue = anim.onRest;\n\n        if (onRestQueue.length) {\n          // Preserve the \"onRest\" prop when the goal is dynamic.\n          anim.onRest = [anim.toValues ? noop : onRestQueue[0]]; // Never call the \"onRest\" prop for no-op animations.\n\n          if (!anim.changed) {\n            onRestQueue[0] = noop;\n          }\n\n          _each(onRestQueue, function (onRest) {\n            return onRest(cancel);\n          });\n        }\n      }\n    }\n  }, {\n    key: \"idle\",\n    get: function get() {\n      return !this.is(ACTIVE) && !this._state.asyncTo;\n    }\n  }, {\n    key: \"goal\",\n    get: function get() {\n      return getFluidValue(this.animation.to);\n    }\n  }, {\n    key: \"velocity\",\n    get: function get() {\n      var node = getAnimated(this);\n      return node instanceof AnimatedValue ? node.lastVelocity || 0 : node.getPayload().map(function (node) {\n        return node.lastVelocity || 0;\n      });\n    }\n  }]);\n\n  return SpringValue;\n}(FrameValue);\n\nfunction checkDisposed(spring, name) {\n  if (spring.is(DISPOSED)) {\n    throw Error(\"Cannot call \\\"\" + name + \"\\\" of disposed \\\"\" + spring.constructor.name + \"\\\" object\");\n  }\n}\n/** Coerce an event prop to an event handler */\n\n\nfunction coerceEventProp(prop, key) {\n  return is.fun(prop) ? prop : key && prop ? prop[key] : undefined;\n}\n/**\n * The \"finished\" value is determined by each \"onRest\" handler,\n * based on whether the current value equals the goal value that\n * was calculated at the time the \"onRest\" handler was set.\n */\n\n\nvar checkFinishedOnRest = function checkFinishedOnRest(onRest, spring) {\n  var to = spring.animation.to;\n  return onRest ? function (cancel) {\n    if (cancel) {\n      onRest(getCancelledResult(spring));\n    } else {\n      var goal = computeGoal(to);\n      var value = computeGoal(spring.get());\n      var finished = isEqual(value, goal);\n      onRest(getFinishedResult(spring, finished));\n    }\n  } : noop;\n};\n\nfunction createLoopUpdate(props) {\n  var loop = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : props.loop;\n  var to = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : props.to;\n  var loopRet = callProp(loop);\n\n  if (loopRet) {\n    var overrides = loopRet !== true && inferTo(loopRet);\n    var reverse = (overrides || props).reverse;\n    var reset = !overrides || overrides.reset;\n    return createUpdate(_extends(_extends({}, props), {}, {\n      loop: loop,\n      // Avoid updating default props when looping.\n      default: false,\n      // For the \"reverse\" prop to loop as expected, the \"to\" prop\n      // must be undefined. The \"reverse\" prop is ignored when the\n      // \"to\" prop is an array or function.\n      to: !reverse || is.arr(to) || is.fun(to) ? to : undefined,\n      // Avoid defining the \"from\" prop if a reset is unwanted.\n      from: reset ? props.from : undefined,\n      reset: reset\n    }, overrides));\n  }\n}\n/**\n * Return a new object based on the given `props`.\n *\n * - All unreserved props are moved into the `to` prop object.\n * - The `to` and `from` props are deleted when falsy.\n * - The `keys` prop is set to an array of affected keys,\n *   or `null` if all keys are affected.\n */\n\n\nfunction createUpdate(props) {\n  var _props = props = inferTo(props),\n      to = _props.to,\n      from = _props.from; // Collect the keys affected by this update.\n\n\n  var keys = new Set();\n\n  if (from) {\n    findDefined(from, keys);\n  } else {\n    // Falsy values are deleted to avoid merging issues.\n    delete props.from;\n  }\n\n  if (is.obj(to)) {\n    findDefined(to, keys);\n  } else if (!to) {\n    // Falsy values are deleted to avoid merging issues.\n    delete props.to;\n  } // The \"keys\" prop helps in applying updates to affected keys only.\n\n\n  props.keys = keys.size ? Array.from(keys) : null;\n  return props;\n}\n/**\n * A modified version of `createUpdate` meant for declarative APIs.\n */\n\n\nfunction declareUpdate(props) {\n  var update = createUpdate(props);\n\n  if (is.und(update.default)) {\n    update.default = getDefaultProps(update, [// Avoid forcing `immediate: true` onto imperative updates.\n    update.immediate === true && 'immediate']);\n  }\n\n  return update;\n}\n/** Find keys with defined values */\n\n\nfunction findDefined(values, keys) {\n  _each(values, function (value, key) {\n    return value != null && keys.add(key);\n  });\n}\n/** Events batched by the `Controller` class */\n\n\nvar BATCHED_EVENTS = ['onStart', 'onChange', 'onRest'];\nvar nextId$1 = 1;\n/** Queue of pending updates for a `Controller` instance. */\n\nvar Controller = /*#__PURE__*/function () {\n  /** The animated values */\n\n  /** The queue of props passed to the `update` method. */\n\n  /** Custom handler for flushing update queues */\n\n  /** These props are used by all future spring values */\n\n  /** The combined phase of our spring values */\n\n  /** The counter for tracking `scheduleProps` calls */\n\n  /** The values currently being animated */\n\n  /** State used by the `runAsync` function */\n\n  /** The event queues that are flushed once per frame maximum */\n  function Controller(props, flush) {\n    _classCallCheck(this, Controller);\n\n    this.id = nextId$1++;\n    this.springs = {};\n    this.queue = [];\n    this._flush = void 0;\n    this._initialProps = void 0;\n    this._phase = CREATED;\n    this._lastAsyncId = 0;\n    this._active = new Set();\n    this._state = {\n      pauseQueue: new Set(),\n      resumeQueue: new Set()\n    };\n    this._events = {\n      onStart: new Set(),\n      onChange: new Set(),\n      onRest: new Map()\n    };\n    this._onFrame = this._onFrame.bind(this);\n\n    if (flush) {\n      this._flush = flush;\n    }\n\n    if (props) {\n      this.start(props);\n    }\n  }\n  /**\n   * Equals `true` when no spring values are in the frameloop, and\n   * no async animation is currently active.\n   */\n\n\n  _createClass(Controller, [{\n    key: \"is\",\n\n    /** Check the current phase */\n    value: function is(phase) {\n      return this._phase == phase;\n    }\n    /** Get the current values of our springs */\n\n  }, {\n    key: \"get\",\n    value: function get() {\n      var values = {};\n      this.each(function (spring, key) {\n        return values[key] = spring.get();\n      });\n      return values;\n    }\n    /** Push an update onto the queue of each value. */\n\n  }, {\n    key: \"update\",\n    value: function update(props) {\n      if (props) this.queue.push(createUpdate(props));\n      return this;\n    }\n    /**\n     * Start the queued animations for every spring, and resolve the returned\n     * promise once all queued animations have finished or been cancelled.\n     *\n     * When you pass a queue (instead of nothing), that queue is used instead of\n     * the queued animations added with the `update` method, which are left alone.\n     */\n\n  }, {\n    key: \"start\",\n    value: function start(props) {\n      var queue = props ? toArray(props).map(createUpdate) : this.queue;\n\n      if (!props) {\n        this.queue = [];\n      }\n\n      if (this._flush) {\n        return this._flush(this, queue);\n      }\n\n      prepareKeys(this, queue);\n      return flushUpdateQueue(this, queue);\n    }\n    /** Stop one animation, some animations, or all animations */\n\n  }, {\n    key: \"stop\",\n    value: function stop(keys) {\n      if (is.und(keys)) {\n        this.each(function (spring) {\n          return spring.stop();\n        });\n        cancelAsync(this._state, this._lastAsyncId);\n      } else {\n        var springs = this.springs;\n\n        _each(toArray(keys), function (key) {\n          return springs[key].stop();\n        });\n      }\n\n      return this;\n    }\n    /** Freeze the active animation in time */\n\n  }, {\n    key: \"pause\",\n    value: function pause(keys) {\n      if (is.und(keys)) {\n        this.each(function (spring) {\n          return spring.pause();\n        });\n      } else {\n        var springs = this.springs;\n\n        _each(toArray(keys), function (key) {\n          return springs[key].pause();\n        });\n      }\n\n      return this;\n    }\n    /** Resume the animation if paused. */\n\n  }, {\n    key: \"resume\",\n    value: function resume(keys) {\n      if (is.und(keys)) {\n        this.each(function (spring) {\n          return spring.resume();\n        });\n      } else {\n        var springs = this.springs;\n\n        _each(toArray(keys), function (key) {\n          return springs[key].resume();\n        });\n      }\n\n      return this;\n    }\n    /** Restart every animation. */\n\n  }, {\n    key: \"reset\",\n    value: function reset() {\n      this.each(function (spring) {\n        return spring.reset();\n      }); // TODO: restart async \"to\" prop\n\n      return this;\n    }\n    /** Call a function once per spring value */\n\n  }, {\n    key: \"each\",\n    value: function each(iterator) {\n      _each(this.springs, iterator);\n    }\n    /** Destroy every spring in this controller */\n\n  }, {\n    key: \"dispose\",\n    value: function dispose() {\n      this._state.asyncTo = undefined;\n      this.each(function (spring) {\n        return spring.dispose();\n      });\n      this.springs = {};\n    }\n    /** @internal Called at the end of every animation frame */\n\n  }, {\n    key: \"_onFrame\",\n    value: function _onFrame() {\n      var _this10 = this;\n\n      var _this$_events = this._events,\n          onStart = _this$_events.onStart,\n          onChange = _this$_events.onChange,\n          onRest = _this$_events.onRest;\n      var isActive = this._active.size > 0;\n\n      if (isActive && this._phase != ACTIVE) {\n        this._phase = ACTIVE;\n        flush(onStart, function (onStart) {\n          return onStart(_this10);\n        });\n      }\n\n      var values = (onChange.size || !isActive && onRest.size) && this.get();\n      flush(onChange, function (onChange) {\n        return onChange(values);\n      }); // The \"onRest\" queue is only flushed when all springs are idle.\n\n      if (!isActive) {\n        this._phase = IDLE;\n        flush(onRest, function (_ref8) {\n          var _ref9 = _slicedToArray(_ref8, 2),\n              onRest = _ref9[0],\n              result = _ref9[1];\n\n          result.value = values;\n          onRest(result);\n        });\n      }\n    }\n    /** @internal */\n\n  }, {\n    key: \"onParentChange\",\n    value: function onParentChange(event) {\n      if (event.type == 'change') {\n        this._active[event.idle ? 'delete' : 'add'](event.parent);\n\n        frameLoop.onFrame(this._onFrame);\n      }\n    }\n  }, {\n    key: \"idle\",\n    get: function get() {\n      return !this._state.asyncTo && Object.values(this.springs).every(function (spring) {\n        return spring.idle;\n      });\n    }\n  }]);\n\n  return Controller;\n}();\n/**\n * Warning: Props might be mutated.\n */\n\n\nfunction flushUpdateQueue(ctrl, queue) {\n  return Promise.all(queue.map(function (props) {\n    return flushUpdate(ctrl, props);\n  })).then(function (results) {\n    return getCombinedResult(ctrl, results);\n  });\n}\n/**\n * Warning: Props might be mutated.\n *\n * Process a single set of props using the given controller.\n *\n * The returned promise resolves to `true` once the update is\n * applied and any animations it starts are finished without being\n * stopped or cancelled.\n */\n\n\nfunction flushUpdate(ctrl, props, isLoop) {\n  var to = props.to,\n      loop = props.loop,\n      onRest = props.onRest; // Looping must be handled in this function, or else the values\n  // would end up looping out-of-sync in many common cases.\n\n  if (loop) {\n    props.loop = false;\n  }\n\n  var asyncTo = is.arr(to) || is.fun(to) ? to : undefined;\n\n  if (asyncTo) {\n    props.to = undefined;\n    props.onRest = undefined;\n  } else {\n    // For certain events, use batching to prevent multiple calls per frame.\n    // However, batching is avoided when the `to` prop is async, because any\n    // event props are used as default props instead.\n    _each(BATCHED_EVENTS, function (key) {\n      var handler = props[key];\n\n      if (is.fun(handler)) {\n        var queue = ctrl['_events'][key];\n\n        if (queue instanceof Set) {\n          props[key] = function () {\n            return queue.add(handler);\n          };\n        } else {\n          props[key] = function (_ref10) {\n            var finished = _ref10.finished,\n                cancelled = _ref10.cancelled;\n            var result = queue.get(handler);\n\n            if (result) {\n              if (!finished) result.finished = false;\n              if (cancelled) result.cancelled = true;\n            } else {\n              // The \"value\" is set before the \"handler\" is called.\n              queue.set(handler, {\n                value: null,\n                finished: finished,\n                cancelled: cancelled\n              });\n            }\n          };\n        }\n      }\n    });\n  }\n\n  var keys = props.keys || Object.keys(ctrl.springs);\n  var promises = keys.map(function (key) {\n    return ctrl.springs[key].start(props);\n  }); // Schedule the \"asyncTo\" if defined.\n\n  var state = ctrl['_state'];\n\n  if (asyncTo) {\n    promises.push(scheduleProps(++ctrl['_lastAsyncId'], {\n      props: props,\n      state: state,\n      actions: {\n        pause: noop,\n        resume: noop,\n        start: function start(props, resolve) {\n          props.onRest = onRest;\n\n          if (!props.cancel) {\n            resolve(runAsync(asyncTo, props, state, ctrl));\n          } // Prevent `cancel: true` from ending the current `runAsync` call,\n          // except when the default `cancel` prop is being set.\n          else if (hasDefaultProp(props, 'cancel')) {\n              cancelAsync(state, props.callId);\n            }\n        }\n      }\n    }));\n  } // Respect the `cancel` prop when no keys are affected.\n  else if (!props.keys && props.cancel === true) {\n      cancelAsync(state, ctrl['_lastAsyncId']);\n    }\n\n  return Promise.all(promises).then(function (results) {\n    var result = getCombinedResult(ctrl, results);\n\n    if (loop && result.finished && !(isLoop && result.noop)) {\n      var nextProps = createLoopUpdate(props, loop, to);\n\n      if (nextProps) {\n        prepareKeys(ctrl, [nextProps]);\n        return flushUpdate(ctrl, nextProps, true);\n      }\n    }\n\n    return result;\n  });\n}\n/**\n * From an array of updates, get the map of `SpringValue` objects\n * by their keys. Springs are created when any update wants to\n * animate a new key.\n *\n * Springs created by `getSprings` are neither cached nor observed\n * until they're given to `setSprings`.\n */\n\n\nfunction getSprings(ctrl, props) {\n  var springs = _extends({}, ctrl.springs);\n\n  if (props) {\n    _each(toArray(props), function (props) {\n      if (is.und(props.keys)) {\n        props = createUpdate(props);\n      }\n\n      if (!is.obj(props.to)) {\n        // Avoid passing array/function to each spring.\n        props = _extends(_extends({}, props), {}, {\n          to: undefined\n        });\n      }\n\n      prepareSprings(springs, props, function (key) {\n        return createSpring(key);\n      });\n    });\n  }\n\n  return springs;\n}\n/**\n * Tell a controller to manage the given `SpringValue` objects\n * whose key is not already in use.\n */\n\n\nfunction setSprings(ctrl, springs) {\n  _each(springs, function (spring, key) {\n    if (!ctrl.springs[key]) {\n      ctrl.springs[key] = spring;\n      spring.addChild(ctrl);\n    }\n  });\n}\n\nfunction createSpring(key, observer) {\n  var spring = new SpringValue();\n  spring.key = key;\n\n  if (observer) {\n    spring.addChild(observer);\n  }\n\n  return spring;\n}\n/**\n * Ensure spring objects exist for each defined key.\n *\n * Using the `props`, the `Animated` node of each `SpringValue` may\n * be created or updated.\n */\n\n\nfunction prepareSprings(springs, props, create) {\n  if (props.keys) {\n    _each(props.keys, function (key) {\n      var spring = springs[key] || (springs[key] = create(key));\n      spring['_prepareNode'](props);\n    });\n  }\n}\n/**\n * Ensure spring objects exist for each defined key, and attach the\n * `ctrl` to them for observation.\n *\n * The queue is expected to contain `createUpdate` results.\n */\n\n\nfunction prepareKeys(ctrl, queue) {\n  _each(queue, function (props) {\n    prepareSprings(ctrl.springs, props, function (key) {\n      return createSpring(key, ctrl);\n    });\n  });\n}\n/**\n * This context affects all new and existing `SpringValue` objects\n * created with the hook API or the renderprops API.\n */\n\n\nvar ctx = createContext({});\n\nvar SpringContext = function SpringContext(_ref) {\n  var children = _ref.children,\n      props = _objectWithoutPropertiesLoose(_ref, [\"children\"]);\n\n  var inherited = useContext(ctx); // Memoize the context to avoid unwanted renders.\n\n  props = useMemo(function () {\n    return _extends(_extends({}, inherited), props);\n  }, [inherited, props.pause, props.cancel, props.immediate, props.config]);\n  var Provider = ctx.Provider;\n  return /*#__PURE__*/createElement(Provider, {\n    value: props\n  }, children);\n};\n\nSpringContext.Provider = ctx.Provider;\nSpringContext.Consumer = ctx.Consumer;\n/** Get the current values of nearest `SpringContext` component. */\n\nvar useSpringContext = function useSpringContext() {\n  return useContext(ctx);\n};\n/** Create an imperative API for manipulating an array of `Controller` objects. */\n\n\nvar SpringHandle = {\n  create: function create(getControllers) {\n    return {\n      get controllers() {\n        return getControllers();\n      },\n\n      update: function update(props) {\n        _each(getControllers(), function (ctrl, i) {\n          ctrl.update(getProps(props, i, ctrl));\n        });\n\n        return this;\n      },\n      start: function start(props) {\n        return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {\n          var results;\n          return _regeneratorRuntime.wrap(function _callee2$(_context2) {\n            while (1) {\n              switch (_context2.prev = _context2.next) {\n                case 0:\n                  _context2.next = 2;\n                  return Promise.all(getControllers().map(function (ctrl, i) {\n                    var update = getProps(props, i, ctrl);\n                    return ctrl.start(update);\n                  }));\n\n                case 2:\n                  results = _context2.sent;\n                  return _context2.abrupt(\"return\", {\n                    value: results.map(function (result) {\n                      return result.value;\n                    }),\n                    finished: results.every(function (result) {\n                      return result.finished;\n                    })\n                  });\n\n                case 4:\n                case \"end\":\n                  return _context2.stop();\n              }\n            }\n          }, _callee2);\n        }))();\n      },\n      stop: function stop(keys) {\n        return _each(getControllers(), function (ctrl) {\n          return ctrl.stop(keys);\n        });\n      },\n      pause: function pause(keys) {\n        return _each(getControllers(), function (ctrl) {\n          return ctrl.pause(keys);\n        });\n      },\n      resume: function resume(keys) {\n        return _each(getControllers(), function (ctrl) {\n          return ctrl.resume(keys);\n        });\n      }\n    };\n  }\n};\n/** @internal */\n\nfunction useSprings(length, props, deps) {\n  var propsFn = is.fun(props) && props;\n  if (propsFn && !deps) deps = []; // Set to 0 to prevent sync flush.\n\n  var layoutId = useRef(0);\n  var forceUpdate = useForceUpdate(); // State is updated on commit.\n\n  var _useState = useState(function () {\n    return {\n      ctrls: [],\n      queue: [],\n      flush: function flush(ctrl, updates) {\n        var springs = getSprings(ctrl, updates); // Flushing is postponed until the component's commit phase\n        // if a spring was created since the last commit.\n\n        var canFlushSync = layoutId.current > 0 && !state.queue.length && !Object.keys(springs).some(function (key) {\n          return !ctrl.springs[key];\n        });\n        return canFlushSync ? flushUpdateQueue(ctrl, updates) : new Promise(function (resolve) {\n          setSprings(ctrl, springs);\n          state.queue.push(function () {\n            resolve(flushUpdateQueue(ctrl, updates));\n          });\n          forceUpdate();\n        });\n      }\n    };\n  }),\n      _useState2 = _slicedToArray(_useState, 1),\n      state = _useState2[0]; // The imperative API ref from the props of the first controller.\n\n\n  var refProp = useRef();\n\n  var ctrls = _toConsumableArray(state.ctrls);\n\n  var updates = []; // Cache old controllers to dispose in the commit phase.\n\n  var prevLength = usePrev(length) || 0;\n  var disposed = ctrls.slice(length, prevLength); // Create new controllers when \"length\" increases, and destroy\n  // the affected controllers when \"length\" decreases.\n\n  useMemo(function () {\n    ctrls.length = length;\n    declareUpdates(prevLength, length);\n  }, [length]); // Update existing controllers when \"deps\" are changed.\n\n  useMemo(function () {\n    declareUpdates(0, Math.min(prevLength, length));\n  }, deps);\n  /** Fill the `updates` array with declarative updates for the given index range. */\n\n  function declareUpdates(startIndex, endIndex) {\n    for (var i = startIndex; i < endIndex; i++) {\n      var ctrl = ctrls[i] || (ctrls[i] = new Controller(null, state.flush));\n\n      var _update2 = propsFn ? propsFn(i, ctrl) : props[i];\n\n      if (_update2) {\n        _update2 = updates[i] = declareUpdate(_update2);\n\n        if (i == 0) {\n          refProp.current = _update2.ref;\n          _update2.ref = undefined;\n        }\n      }\n    }\n  }\n\n  var api = useMemo$1(function () {\n    return SpringHandle.create(function () {\n      return state.ctrls;\n    });\n  }, []); // New springs are created during render so users can pass them to\n  // their animated components, but new springs aren't cached until the\n  // commit phase (see the `useLayoutEffect` callback below).\n\n  var springs = ctrls.map(function (ctrl, i) {\n    return getSprings(ctrl, updates[i]);\n  });\n  var context = useSpringContext();\n  useLayoutEffect(function () {\n    layoutId.current++; // Replace the cached controllers.\n\n    state.ctrls = ctrls; // Update the ref prop.\n\n    if (refProp.current) {\n      refProp.current.current = api;\n    } // Flush the commit queue.\n\n\n    var queue = state.queue;\n\n    if (queue.length) {\n      state.queue = [];\n\n      _each(queue, function (cb) {\n        return cb();\n      });\n    } // Dispose unused controllers.\n\n\n    _each(disposed, function (ctrl) {\n      return ctrl.dispose();\n    }); // Update existing controllers.\n\n\n    _each(ctrls, function (ctrl, i) {\n      var values = springs[i];\n      setSprings(ctrl, values); // Update the default props.\n\n      ctrl.start({\n        default: context\n      }); // Apply updates created during render.\n\n      var update = updates[i];\n\n      if (update) {\n        // Start animating unless a ref exists.\n        if (refProp.current) {\n          ctrl.queue.push(update);\n        } else {\n          ctrl.start(update);\n        }\n      }\n    });\n  }); // Dispose all controllers on unmount.\n\n  useOnce(function () {\n    return function () {\n      _each(state.ctrls, function (ctrl) {\n        return ctrl.dispose();\n      });\n    };\n  }); // Return a deep copy of the `springs` array so the caller can\n  // safely mutate it during render.\n\n  var values = springs.map(function (x) {\n    return _extends({}, x);\n  });\n  return propsFn || arguments.length == 3 ? [values, api.start, api.stop] : values;\n}\n/**\n * The props that `useSpring` recognizes.\n */\n\n/** @internal */\n\n\nfunction useSpring(props, deps) {\n  var isFn = is.fun(props);\n\n  var _useSprings = useSprings(1, isFn ? props : [props], isFn ? deps || [] : deps),\n      _useSprings2 = _slicedToArray(_useSprings, 3),\n      _useSprings2$ = _slicedToArray(_useSprings2[0], 1),\n      values = _useSprings2$[0],\n      update = _useSprings2[1],\n      stop = _useSprings2[2];\n\n  return isFn || arguments.length == 2 ? [values, update, stop] : values;\n}\n\nfunction useTrail(length, propsArg, deps) {\n  var propsFn = is.fun(propsArg) && propsArg;\n  if (propsFn && !deps) deps = [];\n  var ctrls = [];\n  var result = useSprings(length, function (i, ctrl) {\n    ctrls[i] = ctrl;\n    return getProps(propsArg, i, ctrl);\n  }, // Ensure the props function is called when no deps exist.\n  // This works around the 3 argument rule.\n  deps || [{}]);\n  useLayoutEffect(function () {\n    var reverse = is.obj(propsArg) && propsArg.reverse;\n\n    for (var i = 0; i < ctrls.length; i++) {\n      var parent = ctrls[i + (reverse ? 1 : -1)];\n      if (parent) ctrls[i].update({\n        to: parent.springs\n      }).start();\n    }\n  }, deps);\n\n  if (propsFn || arguments.length == 3) {\n    var _update3 = result[1];\n    result[1] = useCallbackOne(function (propsArg) {\n      var reverse = is.obj(propsArg) && propsArg.reverse;\n      return _update3(function (i, ctrl) {\n        var props = getProps(propsArg, i, ctrl);\n        var parent = ctrls[i + (reverse ? 1 : -1)];\n        if (parent) props.to = parent.springs;\n        return props;\n      });\n    }, deps);\n    return result;\n  }\n\n  return result[0];\n} // TODO: convert to \"const enum\" once Babel supports it\n\n/** This transition is being mounted */\n\n\nvar MOUNT = 'mount';\n/** This transition is entering or has entered */\n\nvar ENTER = 'enter';\n/** This transition had its animations updated */\n\nvar UPDATE = 'update';\n/** This transition will expire after animating */\n\nvar LEAVE = 'leave';\n\nfunction useTransition(data, props, deps) {\n  var ref = props.ref,\n      reset = props.reset,\n      sort = props.sort,\n      _props$trail = props.trail,\n      trail = _props$trail === void 0 ? 0 : _props$trail,\n      _props$expires = props.expires,\n      expires = _props$expires === void 0 ? true : _props$expires; // Every item has its own transition.\n\n  var items = toArray(data);\n  var transitions = []; // Keys help with reusing transitions between renders.\n  // The `key` prop can be undefined (which means the items themselves are used\n  // as keys), or a function (which maps each item to its key), or an array of\n  // keys (which are assigned to each item by index).\n\n  var keys = getKeys(items, props); // The \"onRest\" callbacks need a ref to the latest transitions.\n\n  var usedTransitions = useRef(null);\n  var prevTransitions = reset ? null : usedTransitions.current;\n  useLayoutEffect(function () {\n    usedTransitions.current = transitions;\n  }); // Destroy all transitions on dismount.\n\n  useOnce(function () {\n    return function () {\n      return _each(usedTransitions.current, function (t) {\n        if (t.expired) {\n          clearTimeout(t.expirationId);\n        }\n\n        t.ctrl.dispose();\n      });\n    };\n  }); // Map old indices to new indices.\n\n  var reused = [];\n  if (prevTransitions) _each(prevTransitions, function (t, i) {\n    // Expired transitions are not rendered.\n    if (t.expired) {\n      clearTimeout(t.expirationId);\n    } else {\n      i = reused[i] = keys.indexOf(t.key);\n      if (~i) transitions[i] = t;\n    }\n  }); // Mount new items with fresh transitions.\n\n  _each(items, function (item, i) {\n    transitions[i] || (transitions[i] = {\n      key: keys[i],\n      item: item,\n      phase: MOUNT,\n      ctrl: new Controller()\n    });\n  }); // Update the item of any transition whose key still exists,\n  // and ensure leaving transitions are rendered until they finish.\n\n\n  if (reused.length) {\n    var i = -1;\n\n    _each(reused, function (keyIndex, prevIndex) {\n      var t = prevTransitions[prevIndex];\n\n      if (~keyIndex) {\n        i = transitions.indexOf(t);\n        transitions[i] = _extends(_extends({}, t), {}, {\n          item: items[keyIndex]\n        });\n      } else if (props.leave) {\n        transitions.splice(++i, 0, t);\n      }\n    });\n  }\n\n  if (is.fun(sort)) {\n    transitions.sort(function (a, b) {\n      return sort(a.item, b.item);\n    });\n  } // Track cumulative delay for the \"trail\" prop.\n\n\n  var delay = -trail; // Expired transitions use this to dismount.\n\n  var forceUpdate = useForceUpdate(); // These props are inherited by every phase change.\n\n  var defaultProps = getDefaultProps(props); // Generate changes to apply in useEffect.\n\n  var changes = new Map();\n\n  _each(transitions, function (t, i) {\n    var key = t.key;\n    var prevPhase = t.phase;\n    var to;\n    var phase;\n\n    if (prevPhase == MOUNT) {\n      to = props.enter;\n      phase = ENTER;\n    } else {\n      var isLeave = keys.indexOf(key) < 0;\n\n      if (prevPhase != LEAVE) {\n        if (isLeave) {\n          to = props.leave;\n          phase = LEAVE;\n        } else if (to = props.update) {\n          phase = UPDATE;\n        } else return;\n      } else if (!isLeave) {\n        to = props.enter;\n        phase = ENTER;\n      } else return;\n    } // When \"to\" is a function, it can return (1) an array of \"useSpring\" props,\n    // (2) an async function, or (3) an object with any \"useSpring\" props.\n\n\n    to = callProp(to, t.item, i);\n    to = is.obj(to) ? inferTo(to) : {\n      to: to\n    };\n\n    if (!to.config) {\n      var _config2 = props.config || defaultProps.config;\n\n      to.config = callProp(_config2, t.item, i);\n    } // The payload is used to update the spring props once the current render is committed.\n\n\n    var payload = _extends(_extends({}, defaultProps), {}, {\n      delay: delay += trail,\n      // This prevents implied resets.\n      reset: false\n    }, to);\n\n    if (phase == ENTER && is.und(payload.from)) {\n      // The `initial` prop is used on the first render of our parent component,\n      // as well as when `reset: true` is passed. It overrides the `from` prop\n      // when defined, and it makes `enter` instant when null.\n      var from = is.und(props.initial) || prevTransitions ? props.from : props.initial;\n      payload.from = callProp(from, t.item, i);\n    }\n\n    var onRest = payload.onRest;\n\n    payload.onRest = function (result) {\n      var transitions = usedTransitions.current;\n      var t = transitions.find(function (t) {\n        return t.key === key;\n      });\n      if (!t) return;\n\n      if (is.fun(onRest)) {\n        onRest(result, t);\n      } // Reset the phase of a cancelled enter/leave transition, so it can\n      // retry the animation on the next render.\n\n\n      if (result.cancelled && t.phase != UPDATE) {\n        t.phase = prevPhase;\n        return;\n      }\n\n      if (t.ctrl.idle) {\n        var idle = transitions.every(function (t) {\n          return t.ctrl.idle;\n        });\n\n        if (t.phase == LEAVE) {\n          var expiry = callProp(expires, t.item);\n\n          if (expiry !== false) {\n            var expiryMs = expiry === true ? 0 : expiry;\n            t.expired = true; // Force update once the expiration delay ends.\n\n            if (!idle && expiryMs > 0) {\n              // The maximum timeout is 2^31-1\n              if (expiryMs <= 0x7fffffff) t.expirationId = setTimeout(forceUpdate, expiryMs);\n              return;\n            }\n          }\n        } // Force update once idle and expired items exist.\n\n\n        if (idle && transitions.some(function (t) {\n          return t.expired;\n        })) {\n          forceUpdate();\n        }\n      }\n    };\n\n    var springs = getSprings(t.ctrl, payload);\n    changes.set(t, {\n      phase: phase,\n      springs: springs,\n      payload: payload\n    });\n  }); // The prop overrides from an ancestor.\n\n\n  var context = useSpringContext(); // Merge the context into each transition.\n\n  useLayoutEffect(function () {\n    _each(transitions, function (t) {\n      t.ctrl.start({\n        default: context\n      });\n    });\n  }, [context]);\n  var api = useMemo$1(function () {\n    return SpringHandle.create(function () {\n      return usedTransitions.current.map(function (t) {\n        return t.ctrl;\n      });\n    });\n  }, []);\n  useImperativeHandle(ref, function () {\n    return api;\n  });\n  useLayoutEffect(function () {\n    _each(changes, function (_ref11, t) {\n      var phase = _ref11.phase,\n          springs = _ref11.springs,\n          payload = _ref11.payload;\n      setSprings(t.ctrl, springs);\n\n      if (!context.cancel) {\n        t.phase = phase;\n\n        if (phase == ENTER) {\n          t.ctrl.start({\n            default: context\n          });\n        }\n\n        t.ctrl[ref ? 'update' : 'start'](payload);\n      }\n    });\n  }, reset ? void 0 : deps);\n\n  var renderTransitions = function renderTransitions(render) {\n    return /*#__PURE__*/createElement(Fragment, null, transitions.map(function (t, i) {\n      var _ref12 = changes.get(t) || t.ctrl,\n          springs = _ref12.springs;\n\n      var elem = render(_extends({}, springs), t.item, t, i);\n      return elem && elem.type ? /*#__PURE__*/createElement(elem.type, _extends({}, elem.props, {\n        key: is.str(t.key) || is.num(t.key) ? t.key : t.ctrl.id,\n        ref: elem.ref\n      })) : elem;\n    }));\n  };\n\n  return arguments.length == 3 ? [renderTransitions, api.start, api.stop] : renderTransitions;\n}\n\nfunction getKeys(items, _ref13) {\n  var key = _ref13.key,\n      _ref13$keys = _ref13.keys,\n      keys = _ref13$keys === void 0 ? key : _ref13$keys;\n  return is.und(keys) ? items : is.fun(keys) ? items.map(keys) : toArray(keys);\n}\n/**\n * The `Spring` component passes `SpringValue` objects to your render prop.\n */\n\n\nfunction Spring(_ref) {\n  var children = _ref.children,\n      props = _objectWithoutPropertiesLoose(_ref, [\"children\"]);\n\n  return children(useSpring(props));\n}\n\nfunction Trail(_ref) {\n  var items = _ref.items,\n      children = _ref.children,\n      props = _objectWithoutPropertiesLoose(_ref, [\"items\", \"children\"]);\n\n  var trails = useTrail(items.length, props);\n  return items.map(function (item, index) {\n    var result = children(item, index);\n    return is.fun(result) ? result(trails[index]) : result;\n  });\n}\n\nfunction Transition(_ref) {\n  var items = _ref.items,\n      children = _ref.children,\n      props = _objectWithoutPropertiesLoose(_ref, [\"items\", \"children\"]);\n\n  return /*#__PURE__*/createElement(Fragment, null, useTransition(items, props)(children));\n}\n/**\n * An `Interpolation` is a memoized value that's computed whenever one of its\n * `FluidValue` dependencies has its value changed.\n *\n * Other `FrameValue` objects can depend on this. For example, passing an\n * `Interpolation` as the `to` prop of a `useSpring` call will trigger an\n * animation toward the memoized value.\n */\n\n\nvar Interpolation = /*#__PURE__*/function (_FrameValue2) {\n  _inherits(Interpolation, _FrameValue2);\n\n  var _super4 = _createSuper(Interpolation);\n\n  /** Useful for debugging. */\n\n  /** Equals false when in the frameloop */\n\n  /** The function that maps inputs values to output */\n  function Interpolation(source, args) {\n    var _this11;\n\n    _classCallCheck(this, Interpolation);\n\n    _this11 = _super4.call(this);\n    _this11.source = source;\n    _this11.key = void 0;\n    _this11.idle = true;\n    _this11.calc = void 0;\n    _this11.calc = createInterpolator.apply(void 0, _toConsumableArray(args));\n\n    var value = _this11._get();\n\n    var nodeType = is.arr(value) ? AnimatedArray : AnimatedValue; // Assume the computed value never changes type.\n\n    setAnimated(_assertThisInitialized(_this11), nodeType.create(value));\n    return _this11;\n  }\n\n  _createClass(Interpolation, [{\n    key: \"advance\",\n    value: function advance(_dt) {\n      var value = this._get();\n\n      var oldValue = this.get();\n\n      if (!isEqual(value, oldValue)) {\n        getAnimated(this).setValue(value);\n\n        this._onChange(value, this.idle);\n      }\n    }\n  }, {\n    key: \"_get\",\n    value: function _get() {\n      var inputs = is.arr(this.source) ? this.source.map(function (node) {\n        return node.get();\n      }) : toArray(this.source.get());\n      return this.calc.apply(this, _toConsumableArray(inputs));\n    }\n  }, {\n    key: \"_reset\",\n    value: function _reset() {\n      _each(getPayload(this), function (node) {\n        return node.reset();\n      });\n\n      _get(_getPrototypeOf(Interpolation.prototype), \"_reset\", this).call(this);\n    }\n  }, {\n    key: \"_start\",\n    value: function _start() {\n      this.idle = false;\n\n      _get(_getPrototypeOf(Interpolation.prototype), \"_start\", this).call(this);\n\n      if (skipAnimation) {\n        this.idle = true;\n        this.advance();\n      } else {\n        frameLoop.start(this);\n      }\n    }\n  }, {\n    key: \"_attach\",\n    value: function _attach() {\n      var _this12 = this;\n\n      // Start observing our \"source\" once we have an observer.\n      var idle = true;\n      var priority = 1;\n\n      _each(toArray(this.source), function (source) {\n        if (isFrameValue(source)) {\n          if (!source.idle) idle = false;\n          priority = Math.max(priority, source.priority + 1);\n        }\n\n        source.addChild(_this12);\n      });\n\n      this.priority = priority;\n\n      if (!idle) {\n        this._reset();\n\n        this._start();\n      }\n    }\n  }, {\n    key: \"_detach\",\n    value: function _detach() {\n      var _this13 = this;\n\n      // Stop observing our \"source\" once we have no observers.\n      _each(toArray(this.source), function (source) {\n        source.removeChild(_this13);\n      }); // This removes us from the frameloop.\n\n\n      this.idle = true;\n    }\n    /** @internal */\n\n  }, {\n    key: \"onParentChange\",\n    value: function onParentChange(event) {\n      // Ensure our start value respects our parent values, in case\n      // any of their animations were restarted with the \"reset\" prop.\n      if (event.type == 'start') {\n        this.advance();\n      } // Change events are useful for (1) reacting to non-animated parents\n      // and (2) reacting to the last change in a parent animation.\n      else if (event.type == 'change') {\n          // If we're idle, we know for sure that this change is *not*\n          // caused by an animation.\n          if (this.idle) {\n            this.advance();\n          } // Leave the frameloop when all parents are done animating.\n          else if (event.idle) {\n              this.idle = toArray(this.source).every(function (source) {\n                return source.idle !== false;\n              });\n\n              if (this.idle) {\n                this.advance();\n\n                _each(getPayload(this), function (node) {\n                  node.done = true;\n                });\n              }\n            }\n        } // Ensure our priority is greater than all parents, which means\n        // our value won't be updated until our parents have updated.\n        else if (event.type == 'priority') {\n            this.priority = toArray(this.source).reduce(function (max, source) {\n              return Math.max(max, (source.priority || 0) + 1);\n            }, 0);\n          }\n\n      _get(_getPrototypeOf(Interpolation.prototype), \"onParentChange\", this).call(this, event);\n    }\n  }]);\n\n  return Interpolation;\n}(FrameValue);\n/** Map the value of one or more dependencies */\n\n\nvar to = function to(source) {\n  for (var _len5 = arguments.length, args = new Array(_len5 > 1 ? _len5 - 1 : 0), _key5 = 1; _key5 < _len5; _key5++) {\n    args[_key5 - 1] = arguments[_key5];\n  }\n\n  return new Interpolation(source, args);\n};\n/** @deprecated Use the `to` export instead */\n\n\nvar interpolate = function interpolate(source) {\n  for (var _len6 = arguments.length, args = new Array(_len6 > 1 ? _len6 - 1 : 0), _key6 = 1; _key6 < _len6; _key6++) {\n    args[_key6 - 1] = arguments[_key6];\n  }\n\n  return deprecateInterpolate(), new Interpolation(source, args);\n};\n/** Extract the raw value types that are being interpolated */\n\n\nGlobals.assign({\n  createStringInterpolator: createStringInterpolator$1,\n  to: function to(source, args) {\n    return new Interpolation(source, args);\n  }\n});\n/** Advance all animations forward one frame */\n\nvar update = function update() {\n  return Globals.frameLoop.advance();\n};\n\nexport { BailSignal, Controller, FrameValue, Interpolation, Spring, SpringContext, SpringHandle, SpringValue, Trail, Transition, config, inferTo, interpolate, to, update, useChain, useSpring, useSprings, useTrail, useTransition };","// shim for using process in browser\nvar process = module.exports = {}; // cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n  throw new Error('setTimeout has not been defined');\n}\n\nfunction defaultClearTimeout() {\n  throw new Error('clearTimeout has not been defined');\n}\n\n(function () {\n  try {\n    if (typeof setTimeout === 'function') {\n      cachedSetTimeout = setTimeout;\n    } else {\n      cachedSetTimeout = defaultSetTimout;\n    }\n  } catch (e) {\n    cachedSetTimeout = defaultSetTimout;\n  }\n\n  try {\n    if (typeof clearTimeout === 'function') {\n      cachedClearTimeout = clearTimeout;\n    } else {\n      cachedClearTimeout = defaultClearTimeout;\n    }\n  } catch (e) {\n    cachedClearTimeout = defaultClearTimeout;\n  }\n})();\n\nfunction runTimeout(fun) {\n  if (cachedSetTimeout === setTimeout) {\n    //normal enviroments in sane situations\n    return setTimeout(fun, 0);\n  } // if setTimeout wasn't available but was latter defined\n\n\n  if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n    cachedSetTimeout = setTimeout;\n    return setTimeout(fun, 0);\n  }\n\n  try {\n    // when when somebody has screwed with setTimeout but no I.E. maddness\n    return cachedSetTimeout(fun, 0);\n  } catch (e) {\n    try {\n      // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n      return cachedSetTimeout.call(null, fun, 0);\n    } catch (e) {\n      // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n      return cachedSetTimeout.call(this, fun, 0);\n    }\n  }\n}\n\nfunction runClearTimeout(marker) {\n  if (cachedClearTimeout === clearTimeout) {\n    //normal enviroments in sane situations\n    return clearTimeout(marker);\n  } // if clearTimeout wasn't available but was latter defined\n\n\n  if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n    cachedClearTimeout = clearTimeout;\n    return clearTimeout(marker);\n  }\n\n  try {\n    // when when somebody has screwed with setTimeout but no I.E. maddness\n    return cachedClearTimeout(marker);\n  } catch (e) {\n    try {\n      // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n      return cachedClearTimeout.call(null, marker);\n    } catch (e) {\n      // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n      // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n      return cachedClearTimeout.call(this, marker);\n    }\n  }\n}\n\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n  if (!draining || !currentQueue) {\n    return;\n  }\n\n  draining = false;\n\n  if (currentQueue.length) {\n    queue = currentQueue.concat(queue);\n  } else {\n    queueIndex = -1;\n  }\n\n  if (queue.length) {\n    drainQueue();\n  }\n}\n\nfunction drainQueue() {\n  if (draining) {\n    return;\n  }\n\n  var timeout = runTimeout(cleanUpNextTick);\n  draining = true;\n  var len = queue.length;\n\n  while (len) {\n    currentQueue = queue;\n    queue = [];\n\n    while (++queueIndex < len) {\n      if (currentQueue) {\n        currentQueue[queueIndex].run();\n      }\n    }\n\n    queueIndex = -1;\n    len = queue.length;\n  }\n\n  currentQueue = null;\n  draining = false;\n  runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n  var args = new Array(arguments.length - 1);\n\n  if (arguments.length > 1) {\n    for (var i = 1; i < arguments.length; i++) {\n      args[i - 1] = arguments[i];\n    }\n  }\n\n  queue.push(new Item(fun, args));\n\n  if (queue.length === 1 && !draining) {\n    runTimeout(drainQueue);\n  }\n}; // v8 likes predictible objects\n\n\nfunction Item(fun, array) {\n  this.fun = fun;\n  this.array = array;\n}\n\nItem.prototype.run = function () {\n  this.fun.apply(null, this.array);\n};\n\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\n\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) {\n  return [];\n};\n\nprocess.binding = function (name) {\n  throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () {\n  return '/';\n};\n\nprocess.chdir = function (dir) {\n  throw new Error('process.chdir is not supported');\n};\n\nprocess.umask = function () {\n  return 0;\n};","// 21.1.3.18 String.prototype.startsWith(searchString [, position ])\n'use strict';\nvar $export = require('./_export');\nvar toLength = require('./_to-length');\nvar context = require('./_string-context');\nvar STARTS_WITH = 'startsWith';\nvar $startsWith = ''[STARTS_WITH];\n\n$export($export.P + $export.F * require('./_fails-is-regexp')(STARTS_WITH), 'String', {\n  startsWith: function startsWith(searchString /* , position = 0 */) {\n    var that = context(this, searchString, STARTS_WITH);\n    var index = toLength(Math.min(arguments.length > 1 ? arguments[1] : undefined, that.length));\n    var search = String(searchString);\n    return $startsWith\n      ? $startsWith.call(that, search, index)\n      : that.slice(index, index + search.length) === search;\n  }\n});\n","import * as React from 'react';\nexport var useLayoutEffect = typeof window !== 'undefined' && window.document && window.document.createElement ? React.useLayoutEffect : React.useEffect;","import \"core-js/modules/es6.function.name\";\nimport _assertThisInitialized from \"/home/vsts/work/1/s/node_modules/babel-preset-gatsby/node_modules/@babel/runtime/helpers/esm/assertThisInitialized\";\nimport \"core-js/modules/es6.array.from\";\nimport \"core-js/modules/web.dom.iterable\";\nimport \"core-js/modules/es6.array.iterator\";\nimport \"core-js/modules/es6.string.iterator\";\nimport \"core-js/modules/es6.set\";\nimport _get from \"/home/vsts/work/1/s/node_modules/babel-preset-gatsby/node_modules/@babel/runtime/helpers/esm/get\";\nimport \"core-js/modules/es6.regexp.to-string\";\nimport \"core-js/modules/es6.object.to-string\";\nimport \"core-js/modules/es6.reflect.construct\";\nimport _possibleConstructorReturn from \"/home/vsts/work/1/s/node_modules/babel-preset-gatsby/node_modules/@babel/runtime/helpers/esm/possibleConstructorReturn\";\nimport _getPrototypeOf from \"/home/vsts/work/1/s/node_modules/babel-preset-gatsby/node_modules/@babel/runtime/helpers/esm/getPrototypeOf\";\nimport _inherits from \"/home/vsts/work/1/s/node_modules/babel-preset-gatsby/node_modules/@babel/runtime/helpers/esm/inherits\";\nimport _classCallCheck from \"/home/vsts/work/1/s/node_modules/babel-preset-gatsby/node_modules/@babel/runtime/helpers/esm/classCallCheck\";\nimport _createClass from \"/home/vsts/work/1/s/node_modules/babel-preset-gatsby/node_modules/@babel/runtime/helpers/esm/createClass\";\nimport \"core-js/modules/es7.symbol.async-iterator\";\nimport \"core-js/modules/es6.symbol\";\n\nfunction _createSuper(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct()) { 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 { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }\n\nimport { defineHidden, is, createInterpolator, each, getFluidConfig, isAnimatedString, useForceUpdate } from '@react-spring/shared';\nimport _extends from '@babel/runtime/helpers/esm/extends';\nimport { frameLoop } from '@react-spring/shared/globals';\nimport { forwardRef, useRef, createElement } from 'react';\nimport { useLayoutEffect } from 'react-layout-effect';\nvar $node = Symbol.for('Animated:node');\n\nvar isAnimated = function isAnimated(value) {\n  return !!value && value[$node] === value;\n};\n/** Get the owner's `Animated` node. */\n\n\nvar getAnimated = function getAnimated(owner) {\n  return owner && owner[$node];\n};\n/** Set the owner's `Animated` node. */\n\n\nvar setAnimated = function setAnimated(owner, node) {\n  return defineHidden(owner, $node, node);\n};\n/** Get every `AnimatedValue` in the owner's `Animated` node. */\n\n\nvar getPayload = function getPayload(owner) {\n  return owner && owner[$node] && owner[$node].getPayload();\n};\n\nvar Animated = /*#__PURE__*/function () {\n  /** The cache of animated values */\n  function Animated() {\n    _classCallCheck(this, Animated);\n\n    this.payload = void 0; // This makes \"isAnimated\" return true.\n\n    setAnimated(this, this);\n  }\n  /** Get the current value. Pass `true` for only animated values. */\n\n  /** Get every `AnimatedValue` used by this node. */\n\n\n  _createClass(Animated, [{\n    key: \"getPayload\",\n    value: function getPayload() {\n      return this.payload || [];\n    }\n  }]);\n\n  return Animated;\n}();\n/** An animated number or a native attribute value */\n\n\nvar AnimatedValue = /*#__PURE__*/function (_Animated) {\n  _inherits(AnimatedValue, _Animated);\n\n  var _super = _createSuper(AnimatedValue);\n\n  function AnimatedValue(_value) {\n    var _this;\n\n    _classCallCheck(this, AnimatedValue);\n\n    _this = _super.call(this);\n    _this._value = _value;\n    _this.done = true;\n    _this.elapsedTime = void 0;\n    _this.lastPosition = void 0;\n    _this.lastVelocity = void 0;\n    _this.v0 = void 0;\n\n    if (is.num(_this._value)) {\n      _this.lastPosition = _this._value;\n    }\n\n    return _this;\n  }\n\n  _createClass(AnimatedValue, [{\n    key: \"getPayload\",\n    value: function getPayload() {\n      return [this];\n    }\n  }, {\n    key: \"getValue\",\n    value: function getValue() {\n      return this._value;\n    }\n    /**\n     * Set the current value and optionally round it.\n     *\n     * The `step` argument does nothing whenever it equals `undefined` or `0`.\n     * It works with fractions and whole numbers. The best use case is (probably)\n     * rounding to the pixel grid with a step of:\n     *\n     *      1 / window.devicePixelRatio\n     */\n\n  }, {\n    key: \"setValue\",\n    value: function setValue(value, step) {\n      if (is.num(value)) {\n        this.lastPosition = value;\n\n        if (step) {\n          value = Math.round(value / step) * step;\n\n          if (this.done) {\n            this.lastPosition = value;\n          }\n        }\n      }\n\n      if (this._value === value) {\n        return false;\n      }\n\n      this._value = value;\n      return true;\n    }\n  }, {\n    key: \"reset\",\n    value: function reset() {\n      var done = this.done;\n      this.done = false;\n\n      if (is.num(this._value)) {\n        this.elapsedTime = 0;\n        this.lastPosition = this._value;\n        if (done) this.lastVelocity = null;\n        this.v0 = null;\n      }\n    }\n  }], [{\n    key: \"create\",\n    value: function create(from, _to) {\n      return new AnimatedValue(from);\n    }\n  }]);\n\n  return AnimatedValue;\n}(Animated);\n\nvar AnimatedString = /*#__PURE__*/function (_AnimatedValue) {\n  _inherits(AnimatedString, _AnimatedValue);\n\n  var _super2 = _createSuper(AnimatedString);\n\n  function AnimatedString(from, to) {\n    var _this2;\n\n    _classCallCheck(this, AnimatedString);\n\n    _this2 = _super2.call(this, 0);\n    _this2._value = void 0;\n    _this2._string = null;\n    _this2._toString = void 0;\n    _this2._toString = createInterpolator({\n      output: [from, to]\n    });\n    return _this2;\n  }\n\n  _createClass(AnimatedString, [{\n    key: \"getValue\",\n    value: function getValue() {\n      var value = this._string;\n      return value == null ? this._string = this._toString(this._value) : value;\n    }\n  }, {\n    key: \"setValue\",\n    value: function setValue(value) {\n      if (!is.num(value)) {\n        this._string = value;\n        this._value = 1;\n      } else if (_get(_getPrototypeOf(AnimatedString.prototype), \"setValue\", this).call(this, value)) {\n        this._string = null;\n      } else {\n        return false;\n      }\n\n      return true;\n    }\n  }, {\n    key: \"reset\",\n    value: function reset(goal) {\n      if (goal) {\n        this._toString = createInterpolator({\n          output: [this.getValue(), goal]\n        });\n      }\n\n      this._value = 0;\n\n      _get(_getPrototypeOf(AnimatedString.prototype), \"reset\", this).call(this);\n    }\n  }], [{\n    key: \"create\",\n    value: function create(from) {\n      var to = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : from;\n\n      if (is.str(from) && is.str(to)) {\n        return new AnimatedString(from, to);\n      }\n\n      throw TypeError('Expected \"from\" and \"to\" to be strings');\n    }\n  }]);\n\n  return AnimatedString;\n}(AnimatedValue);\n\nvar TreeContext = {\n  current: null\n};\n/** An object containing `Animated` nodes */\n\nvar AnimatedObject = /*#__PURE__*/function (_Animated2) {\n  _inherits(AnimatedObject, _Animated2);\n\n  var _super3 = _createSuper(AnimatedObject);\n\n  function AnimatedObject() {\n    var _this3;\n\n    var source = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;\n\n    _classCallCheck(this, AnimatedObject);\n\n    _this3 = _super3.call(this);\n    _this3.source = void 0;\n\n    _this3.setValue(source);\n\n    return _this3;\n  }\n\n  _createClass(AnimatedObject, [{\n    key: \"getValue\",\n    value: function getValue(animated) {\n      if (!this.source) return null;\n      var values = {};\n      each(this.source, function (source, key) {\n        if (isAnimated(source)) {\n          values[key] = source.getValue(animated);\n        } else {\n          var config = getFluidConfig(source);\n\n          if (config) {\n            values[key] = config.get();\n          } else if (!animated) {\n            values[key] = source;\n          }\n        }\n      });\n      return values;\n    }\n    /** Replace the raw object data */\n\n  }, {\n    key: \"setValue\",\n    value: function setValue(source) {\n      this.source = source;\n      this.payload = this._makePayload(source);\n    }\n  }, {\n    key: \"reset\",\n    value: function reset() {\n      if (this.payload) {\n        each(this.payload, function (node) {\n          return node.reset();\n        });\n      }\n    }\n    /** Create a payload set. */\n\n  }, {\n    key: \"_makePayload\",\n    value: function _makePayload(source) {\n      if (source) {\n        var payload = new Set();\n        each(source, this._addToPayload, payload);\n        return Array.from(payload);\n      }\n    }\n    /** Add to a payload set. */\n\n  }, {\n    key: \"_addToPayload\",\n    value: function _addToPayload(source) {\n      var _this4 = this;\n\n      var config = getFluidConfig(source);\n\n      if (config && TreeContext.current) {\n        TreeContext.current.dependencies.add(source);\n      }\n\n      var payload = getPayload(source);\n\n      if (payload) {\n        each(payload, function (node) {\n          return _this4.add(node);\n        });\n      }\n    }\n  }]);\n\n  return AnimatedObject;\n}(Animated);\n/** An array of animated nodes */\n\n\nvar AnimatedArray = /*#__PURE__*/function (_AnimatedObject) {\n  _inherits(AnimatedArray, _AnimatedObject);\n\n  var _super4 = _createSuper(AnimatedArray);\n\n  function AnimatedArray(from, to) {\n    var _this5;\n\n    _classCallCheck(this, AnimatedArray);\n\n    _this5 = _super4.call(this, null);\n    _this5.source = void 0;\n\n    _get(_getPrototypeOf(AnimatedArray.prototype), \"setValue\", _assertThisInitialized(_this5)).call(_assertThisInitialized(_this5), _this5._makeAnimated(from, to));\n\n    return _this5;\n  }\n\n  _createClass(AnimatedArray, [{\n    key: \"getValue\",\n    value: function getValue() {\n      return this.source.map(function (node) {\n        return node.getValue();\n      });\n    }\n  }, {\n    key: \"setValue\",\n    value: function setValue(newValue) {\n      var payload = this.getPayload(); // Reuse the payload when lengths are equal.\n\n      if (newValue && newValue.length == payload.length) {\n        each(payload, function (node, i) {\n          return node.setValue(newValue[i]);\n        });\n      } else {\n        // Remake the payload when length changes.\n        this.source = this._makeAnimated(newValue);\n        this.payload = this._makePayload(this.source);\n      }\n    }\n    /** Convert the `from` and `to` values to an array of `Animated` nodes */\n\n  }, {\n    key: \"_makeAnimated\",\n    value: function _makeAnimated(from) {\n      var to = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : from;\n      return from ? from.map(function (from, i) {\n        return (isAnimatedString(from) ? AnimatedString : AnimatedValue).create(from, to[i]);\n      }) : [];\n    }\n  }], [{\n    key: \"create\",\n    value: function create(from, to) {\n      return new AnimatedArray(from, to);\n    }\n  }]);\n\n  return AnimatedArray;\n}(AnimatedObject);\n\nvar AnimatedProps = /*#__PURE__*/function (_AnimatedObject2) {\n  _inherits(AnimatedProps, _AnimatedObject2);\n\n  var _super5 = _createSuper(AnimatedProps);\n\n  /** Equals true when an update is scheduled for \"end of frame\" */\n  function AnimatedProps(update) {\n    var _this6;\n\n    _classCallCheck(this, AnimatedProps);\n\n    _this6 = _super5.call(this, null);\n    _this6.update = update;\n    _this6.dirty = false;\n    return _this6;\n  }\n\n  _createClass(AnimatedProps, [{\n    key: \"setValue\",\n    value: function setValue(props, context) {\n      if (!props) return; // The constructor passes null.\n\n      if (context) {\n        TreeContext.current = context;\n\n        if (props.style) {\n          var createAnimatedStyle = context.host.createAnimatedStyle;\n          props = _extends(_extends({}, props), {}, {\n            style: createAnimatedStyle(props.style)\n          });\n        }\n      }\n\n      _get(_getPrototypeOf(AnimatedProps.prototype), \"setValue\", this).call(this, props);\n\n      TreeContext.current = null;\n    }\n    /** @internal */\n\n  }, {\n    key: \"onParentChange\",\n    value: function onParentChange(_ref) {\n      var _this7 = this;\n\n      var type = _ref.type;\n\n      if (!this.dirty && type === 'change') {\n        this.dirty = true;\n        frameLoop.onFrame(function () {\n          _this7.dirty = false;\n\n          _this7.update();\n        });\n      }\n    }\n  }]);\n\n  return AnimatedProps;\n}(AnimatedObject);\n\nvar withAnimated = function withAnimated(Component, host) {\n  return forwardRef(function (rawProps, ref) {\n    var instanceRef = useRef(null);\n    var hasInstance = // Function components must use \"forwardRef\" to avoid being\n    // re-rendered on every animation frame.\n    !is.fun(Component) || Component.prototype && Component.prototype.isReactComponent;\n    var forceUpdate = useForceUpdate();\n    var props = new AnimatedProps(function () {\n      var instance = instanceRef.current;\n\n      if (hasInstance && !instance) {\n        return; // The wrapped component forgot to forward its ref.\n      }\n\n      var didUpdate = instance ? host.applyAnimatedValues(instance, props.getValue(true)) : false; // Re-render the component when native updates fail.\n\n      if (didUpdate === false) {\n        forceUpdate();\n      }\n    });\n    var dependencies = new Set();\n    props.setValue(rawProps, {\n      dependencies: dependencies,\n      host: host\n    });\n    useLayoutEffect(function () {\n      each(dependencies, function (dep) {\n        return dep.addChild(props);\n      });\n      return function () {\n        return each(dependencies, function (dep) {\n          return dep.removeChild(props);\n        });\n      };\n    });\n    return /*#__PURE__*/createElement(Component, _extends({}, host.getComponentProps(props.getValue()), {\n      ref: hasInstance && function (value) {\n        instanceRef.current = updateRef(ref, value);\n      }\n    }));\n  });\n};\n\nfunction updateRef(ref, value) {\n  if (ref) {\n    if (is.fun(ref)) ref(value);else ref.current = value;\n  }\n\n  return value;\n} // For storing the animated version on the original component\n\n\nvar cacheKey = Symbol.for('AnimatedComponent');\n\nvar createHost = function createHost(components) {\n  var _ref2 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},\n      _ref2$applyAnimatedVa = _ref2.applyAnimatedValues,\n      applyAnimatedValues = _ref2$applyAnimatedVa === void 0 ? function () {\n    return false;\n  } : _ref2$applyAnimatedVa,\n      _ref2$createAnimatedS = _ref2.createAnimatedStyle,\n      createAnimatedStyle = _ref2$createAnimatedS === void 0 ? function (style) {\n    return new AnimatedObject(style);\n  } : _ref2$createAnimatedS,\n      _ref2$getComponentPro = _ref2.getComponentProps,\n      getComponentProps = _ref2$getComponentPro === void 0 ? function (props) {\n    return props;\n  } : _ref2$getComponentPro;\n\n  var hostConfig = {\n    applyAnimatedValues: applyAnimatedValues,\n    createAnimatedStyle: createAnimatedStyle,\n    getComponentProps: getComponentProps\n  };\n\n  var animated = function animated(Component) {\n    var displayName = getDisplayName(Component) || 'Anonymous';\n\n    if (is.str(Component)) {\n      Component = withAnimated(Component, hostConfig);\n    } else {\n      Component = Component[cacheKey] || (Component[cacheKey] = withAnimated(Component, hostConfig));\n    }\n\n    Component.displayName = \"Animated(\" + displayName + \")\";\n    return Component;\n  };\n\n  each(components, function (Component, key) {\n    if (!is.str(key)) {\n      key = getDisplayName(Component);\n    }\n\n    animated[key] = animated(Component);\n  });\n  return {\n    animated: animated\n  };\n};\n\nvar getDisplayName = function getDisplayName(arg) {\n  return is.str(arg) ? arg : arg && is.str(arg.displayName) ? arg.displayName : is.fun(arg) && arg.name || null;\n};\n\nexport { Animated, AnimatedArray, AnimatedObject, AnimatedProps, AnimatedString, AnimatedValue, createHost, getAnimated, getPayload, isAnimated, setAnimated };","import \"core-js/modules/es7.symbol.async-iterator\";\nimport \"core-js/modules/es6.symbol\";\nvar $config = Symbol.for('FluidValue:config');\nexport { hasFluidValue, getFluidValue, getFluidConfig, setFluidConfig, addFluidObserver };\n/** Does the given value have a `FluidConfig` object? */\n\nvar hasFluidValue = function hasFluidValue(arg) {\n  return !!getFluidConfig(arg);\n};\n\nfunction getFluidValue(arg) {\n  var config = getFluidConfig(arg);\n  return config ? config.get() : arg;\n}\n\nfunction getFluidConfig(arg) {\n  if (arg) return arg[$config];\n}\n/** Set the methods for observing the given object. */\n\n\nfunction setFluidConfig(target, config) {\n  Object.defineProperty(target, $config, {\n    value: config,\n    configurable: true\n  });\n}\n/** Add an observer to a fluid object. Returns an unsubscribe function if the target is a fluid object, otherwise undefined. */\n\n\nfunction addFluidObserver(target, observer) {\n  var config = getFluidConfig(target);\n\n  if (config) {\n    config.addChild(observer);\n    return function () {\n      return config.removeChild(observer);\n    };\n  }\n}\n/**\n * This class stores a single dynamic value, which can be observed by multiple `FluidObserver` objects.\n *\n * In order to support non-writable streams, this class doesn't expect a `set` method to exist.\n *\n * It can send *any* event to observers, not only change events.\n */\n\n\nvar FluidValue =\n/** @class */\nfunction () {\n  function FluidValue() {\n    setFluidConfig(this, this);\n  }\n\n  return FluidValue;\n}();\n\nexport { FluidValue };","import React from \"react\";\nimport CSSTransition from \"react-transition-group/CSSTransition\";\n\n//styles\nimport s from \"./modal-video.module.scss\";\n\nexport default class ModalVideo extends React.Component {\n  constructor(props) {\n    super(props);\n    this.state = {\n      isOpen: false\n    };\n    this.closeModal = this.closeModal.bind(this);\n    this.updateFocus = this.updateFocus.bind(this);\n  }\n\n  openModal() {\n    this.setState({ isOpen: true });\n  }\n\n  closeModal() {\n    this.setState({ isOpen: false });\n    if (typeof this.props.onClose === \"function\") {\n      this.props.onClose();\n    }\n  }\n\n  keydownHandler(e) {\n    if (e.keyCode === 27) {\n      this.closeModal();\n    }\n  }\n\n  //   componentDidMount() {\n  //     document.addEventListener(\"keydown\", this.keydownHandler.bind(this));\n  //   }\n\n  //   componentWillUnmount() {\n  //     document.removeEventListener(\"keydown\", this.keydownHandler.bind(this));\n  //   }\n\n  static getDerivedStateFromProps(props) {\n    return { isOpen: props.isOpen };\n  }\n\n  componentDidUpdate() {\n    if (this.state.isOpen && this.modal) {\n      this.modal.focus();\n    }\n  }\n\n  updateFocus(e) {\n    if (e.keyCode === 9) {\n      e.preventDefault();\n      e.stopPropagation();\n      if (this.modal === document.activeElement) {\n        this.modalbtn.focus();\n      } else {\n        this.modal.focus();\n      }\n    }\n  }\n\n  getQueryString(obj) {\n    let url = \"\";\n    for (var key in obj) {\n      if (obj.hasOwnProperty(key)) {\n        if (obj[key] !== null) {\n          url += key + \"=\" + obj[key] + \"&\";\n        }\n      }\n    }\n    return url.substr(0, url.length - 1);\n  }\n\n  getYoutubeUrl(youtube, videoId) {\n    const query = this.getQueryString(youtube);\n    return \"//www.youtube.com/embed/\" + videoId + \"?\" + query;\n  }\n\n  getVimeoUrl(vimeo, videoId) {\n    const query = this.getQueryString(vimeo);\n    return \"//player.vimeo.com/video/\" + videoId + \"?\" + query;\n  }\n\n  getYoukuUrl(youku, videoId) {\n    const query = this.getQueryString(youku);\n    return \"//player.youku.com/embed/\" + videoId + \"?\" + query;\n  }\n\n  getVideoUrl(opt, videoId) {\n    if (opt.channel === \"youtube\") {\n      return this.getYoutubeUrl(opt.youtube, videoId);\n    } else if (opt.channel === \"vimeo\") {\n      return this.getVimeoUrl(opt.vimeo, videoId);\n    } else if (opt.channel === \"youku\") {\n      return this.getYoukuUrl(opt.youku, videoId);\n    } else if (opt.channel === \"custom\") {\n      return opt.url;\n    }\n  }\n\n  getPadding(ratio) {\n    const arr = ratio.split(\":\");\n    const width = Number(arr[0]);\n    const height = Number(arr[1]);\n    const padding = (height * 100) / width;\n    return padding + \"%\";\n  }\n\n  render() {\n    const style = {\n      paddingBottom: this.getPadding(this.props.ratio)\n    };\n\n    return (\n      // <div className={this.props.classNames.modalVideo} tabIndex='-1' role='dialog'\n      //     aria-label={this.props.aria.openMessage} onClick={this.closeModal} ref={node => { this.modal = node; }} onKeyDown={this.updateFocus}>\n      //     <div className={this.props.classNames.modalVideoBody}>\n      //         <div className={this.props.classNames.modalVideoInner}>\n      <div className={this.props.classNames.modalVideoIframeWrap} style={style}>\n        <iframe\n          width=\"460\"\n          height=\"230\"\n          src={this.getVideoUrl(this.props, this.props.videoId)}\n          frameBorder=\"0\"\n          allowFullScreen={this.props.allowFullScreen}\n          tabIndex=\"-1\"\n        />\n      </div>\n      //         </div>\n      //     </div>\n      // </div>\n    );\n  }\n}\n\nModalVideo.defaultProps = {\n  channel: \"youtube\",\n  isOpen: false,\n  youtube: {\n    autoplay: 1,\n    cc_load_policy: 1,\n    color: null,\n    controls: 1,\n    disablekb: 0,\n    enablejsapi: 0,\n    end: null,\n    fs: 1,\n    h1: null,\n    iv_load_policy: 1,\n    list: null,\n    listType: null,\n    loop: 0,\n    modestbranding: null,\n    origin: null,\n    playlist: null,\n    playsinline: null,\n    rel: 0,\n    showinfo: 1,\n    start: 0,\n    wmode: \"transparent\",\n    theme: \"dark\"\n  },\n  ratio: \"16:9\",\n  vimeo: {\n    api: false,\n    autopause: true,\n    autoplay: false,\n    byline: true,\n    callback: null,\n    color: null,\n    height: null,\n    loop: false,\n    maxheight: null,\n    maxwidth: null,\n    player_id: null,\n    portrait: true,\n    title: true,\n    width: null,\n    xhtml: false\n  },\n  youku: {\n    autoplay: 1,\n    show_related: 0\n  },\n  allowFullScreen: true,\n  animationSpeed: 300,\n  classNames: {\n    modalVideoEffect: s.modalVideoEffect, //'modal-video-effect',\n    modalVideo: s.modalVideo, //'modal-video',\n    modalVideoClose: s.modalVideoClose, //'modal-video-close',\n    modalVideoBody: s.modalVideoBody, //'modal-video-body',\n    modalVideoInner: s.modalVideoInner, //'modal-video-inner',\n    modalVideoIframeWrap: s.modalVideoMovieWrap, //'modal-video-movie-wrap',\n    modalVideoCloseBtn: s.modalVideoCloseBtn //'modal-video-close-btn'\n  },\n  aria: {\n    openMessage: \"You just openned the modal video\",\n    dismissBtnMessage: \"Close the modal by clicking here\"\n  }\n};\n","import \"core-js/modules/es6.string.iterator\";\nimport \"core-js/modules/es6.set\";\nimport _createClass from \"/home/vsts/work/1/s/node_modules/babel-preset-gatsby/node_modules/@babel/runtime/helpers/esm/createClass\";\nimport \"core-js/modules/es6.regexp.to-string\";\nimport \"core-js/modules/es6.reflect.construct\";\nimport \"core-js/modules/es6.string.starts-with\";\nimport _slicedToArray from \"/home/vsts/work/1/s/node_modules/babel-preset-gatsby/node_modules/@babel/runtime/helpers/esm/slicedToArray\";\nimport _classCallCheck from \"/home/vsts/work/1/s/node_modules/babel-preset-gatsby/node_modules/@babel/runtime/helpers/esm/classCallCheck\";\nimport _possibleConstructorReturn from \"/home/vsts/work/1/s/node_modules/babel-preset-gatsby/node_modules/@babel/runtime/helpers/esm/possibleConstructorReturn\";\nimport _getPrototypeOf from \"/home/vsts/work/1/s/node_modules/babel-preset-gatsby/node_modules/@babel/runtime/helpers/esm/getPrototypeOf\";\nimport _inherits from \"/home/vsts/work/1/s/node_modules/babel-preset-gatsby/node_modules/@babel/runtime/helpers/esm/inherits\";\nimport \"core-js/modules/es6.regexp.replace\";\nimport \"core-js/modules/es6.object.keys\";\nimport \"core-js/modules/web.dom.iterable\";\nimport \"core-js/modules/es6.array.iterator\";\nimport \"core-js/modules/es6.object.to-string\";\nimport \"core-js/modules/es7.object.values\";\n\nfunction _createSuper(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct()) { 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 { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }\n\nimport _objectWithoutPropertiesLoose from '@babel/runtime/helpers/esm/objectWithoutPropertiesLoose';\nimport { Globals as Globals$1 } from '@react-spring/core';\nexport * from '@react-spring/core';\nimport { unstable_batchedUpdates } from 'react-dom';\nimport { createStringInterpolator } from '@react-spring/shared/stringInterpolation';\nimport colorNames from '@react-spring/shared/colors';\nimport { AnimatedObject, createHost } from '@react-spring/animated';\nimport { Globals, each, is, toArray, FluidValue, getFluidValue, getFluidConfig } from '@react-spring/shared';\nvar isCustomPropRE = /^--/;\n\nfunction dangerousStyleValue(name, value) {\n  if (value == null || typeof value === 'boolean' || value === '') return '';\n  if (typeof value === 'number' && value !== 0 && !isCustomPropRE.test(name) && !(isUnitlessNumber.hasOwnProperty(name) && isUnitlessNumber[name])) return value + 'px'; // Presumes implicit 'px' suffix for unitless numbers\n\n  return ('' + value).trim();\n}\n\nvar attributeCache = {};\n\nfunction applyAnimatedValues(instance, props) {\n  if (!instance.nodeType || !instance.setAttribute) {\n    return false;\n  }\n\n  var isFilterElement = instance.nodeName === 'filter' || instance.parentNode && instance.parentNode.nodeName === 'filter';\n\n  var _ref = props,\n      style = _ref.style,\n      children = _ref.children,\n      scrollTop = _ref.scrollTop,\n      scrollLeft = _ref.scrollLeft,\n      attributes = _objectWithoutPropertiesLoose(_ref, [\"style\", \"children\", \"scrollTop\", \"scrollLeft\"]);\n\n  var values = Object.values(attributes);\n  var names = Object.keys(attributes).map(function (name) {\n    return isFilterElement || instance.hasAttribute(name) ? name : attributeCache[name] || (attributeCache[name] = name.replace(/([A-Z])/g, // Attributes are written in dash case\n    function (n) {\n      return '-' + n.toLowerCase();\n    }));\n  });\n  Globals.frameLoop.onWrite(function () {\n    if (children !== void 0) {\n      instance.textContent = children;\n    } // Apply CSS styles\n\n\n    for (var name in style) {\n      if (style.hasOwnProperty(name)) {\n        var value = dangerousStyleValue(name, style[name]);\n        if (name === 'float') name = 'cssFloat';else if (isCustomPropRE.test(name)) {\n          instance.style.setProperty(name, value);\n        } else {\n          instance.style[name] = value;\n        }\n      }\n    } // Apply DOM attributes\n\n\n    names.forEach(function (name, i) {\n      instance.setAttribute(name, values[i]);\n    });\n\n    if (scrollTop !== void 0) {\n      instance.scrollTop = scrollTop;\n    }\n\n    if (scrollLeft !== void 0) {\n      instance.scrollLeft = scrollLeft;\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/** The transform-functions\n * (https://developer.mozilla.org/fr/docs/Web/CSS/transform-function)\n * that you can pass as keys to your animated component style and that will be\n * animated. Perspective has been left out as it would conflict with the\n * non-transform perspective style.\n */\n\nvar domTransforms = /^(matrix|translate|scale|rotate|skew)/; // These keys have \"px\" units by default\n\nvar pxTransforms = /^(translate)/; // These keys have \"deg\" units by default\n\nvar degTransforms = /^(rotate|skew)/;\n/** Add a unit to the value when the value is unit-less (eg: a number) */\n\nvar addUnit = function addUnit(value, unit) {\n  return is.num(value) && value !== 0 ? value + unit : value;\n};\n/**\n * Checks if the input value matches the identity value.\n *\n *     isValueIdentity(0, 0)              // => true\n *     isValueIdentity('0px', 0)          // => true\n *     isValueIdentity([0, '0px', 0], 0)  // => true\n */\n\n\nvar isValueIdentity = function isValueIdentity(value, id) {\n  return is.arr(value) ? value.every(function (v) {\n    return isValueIdentity(v, id);\n  }) : is.num(value) ? value === id : parseFloat(value) === id;\n};\n/**\n * This AnimatedStyle will simplify animated components transforms by\n * interpolating all transform function passed as keys in the style object\n * including shortcuts such as x, y and z for translateX/Y/Z\n */\n\n\nvar AnimatedStyle = /*#__PURE__*/function (_AnimatedObject) {\n  _inherits(AnimatedStyle, _AnimatedObject);\n\n  var _super = _createSuper(AnimatedStyle);\n\n  function AnimatedStyle(_ref) {\n    _classCallCheck(this, AnimatedStyle);\n\n    var x = _ref.x,\n        y = _ref.y,\n        z = _ref.z,\n        style = _objectWithoutPropertiesLoose(_ref, [\"x\", \"y\", \"z\"]);\n    /**\n     * An array of arrays that contains the values (static or fluid)\n     * used by each transform function.\n     */\n\n\n    var inputs = [];\n    /**\n     * An array of functions that take a list of values (static or fluid)\n     * and returns (1) a CSS transform string and (2) a boolean that's true\n     * when the transform has no effect (eg: an identity transform).\n     */\n\n    var transforms = []; // Combine x/y/z into translate3d\n\n    if (x || y || z) {\n      inputs.push([x || 0, y || 0, z || 0]);\n      transforms.push(function (xyz) {\n        return [\"translate3d(\" + xyz.map(function (v) {\n          return addUnit(v, 'px');\n        }).join(',') + \")\", // prettier-ignore\n        isValueIdentity(xyz, 0)];\n      });\n    } // Pluck any other transform-related props\n\n\n    each(style, function (value, key) {\n      if (key === 'transform') {\n        inputs.push([value || '']);\n        transforms.push(function (transform) {\n          return [transform, transform === ''];\n        });\n      } else if (domTransforms.test(key)) {\n        delete style[key];\n        if (is.und(value)) return;\n        var unit = pxTransforms.test(key) ? 'px' : degTransforms.test(key) ? 'deg' : '';\n        inputs.push(toArray(value));\n        transforms.push(key === 'rotate3d' ? function (_ref2) {\n          var _ref3 = _slicedToArray(_ref2, 4),\n              x = _ref3[0],\n              y = _ref3[1],\n              z = _ref3[2],\n              deg = _ref3[3];\n\n          return [\"rotate3d(\" + x + \",\" + y + \",\" + z + \",\" + addUnit(deg, unit) + \")\", isValueIdentity(deg, 0)];\n        } : function (input) {\n          return [key + \"(\" + input.map(function (v) {\n            return addUnit(v, unit);\n          }).join(',') + \")\", isValueIdentity(input, key.startsWith('scale') ? 1 : 0)];\n        });\n      }\n    });\n\n    if (inputs.length) {\n      style.transform = new FluidTransform(inputs, transforms);\n    }\n\n    return _super.call(this, style);\n  }\n\n  return AnimatedStyle;\n}(AnimatedObject);\n/** @internal */\n\n\nvar FluidTransform = /*#__PURE__*/function (_FluidValue) {\n  _inherits(FluidTransform, _FluidValue);\n\n  var _super2 = _createSuper(FluidTransform);\n\n  function FluidTransform(inputs, transforms) {\n    var _this;\n\n    _classCallCheck(this, FluidTransform);\n\n    _this = _super2.call(this);\n    _this.inputs = inputs;\n    _this.transforms = transforms;\n    _this._value = null;\n    _this._children = new Set();\n    return _this;\n  }\n\n  _createClass(FluidTransform, [{\n    key: \"get\",\n    value: function get() {\n      return this._value || (this._value = this._get());\n    }\n  }, {\n    key: \"_get\",\n    value: function _get() {\n      var _this2 = this;\n\n      var transform = '';\n      var identity = true;\n      each(this.inputs, function (input, i) {\n        var arg1 = getFluidValue(input[0]);\n\n        var _this2$transforms$i = _this2.transforms[i](is.arr(arg1) ? arg1 : input.map(getFluidValue)),\n            _this2$transforms$i2 = _slicedToArray(_this2$transforms$i, 2),\n            t = _this2$transforms$i2[0],\n            id = _this2$transforms$i2[1];\n\n        transform += ' ' + t;\n        identity = identity && id;\n      });\n      return identity ? 'none' : transform;\n    }\n  }, {\n    key: \"addChild\",\n    value: function addChild(child) {\n      var _this3 = this;\n\n      if (!this._children.size) {\n        // Start observing our inputs once we have an observer.\n        each(this.inputs, function (input) {\n          return each(input, function (value) {\n            var config = getFluidConfig(value);\n            if (config) config.addChild(_this3);\n          });\n        });\n      }\n\n      this._children.add(child);\n    }\n  }, {\n    key: \"removeChild\",\n    value: function removeChild(child) {\n      var _this4 = this;\n\n      this._children.delete(child);\n\n      if (!this._children.size) {\n        // Stop observing our inputs once we have no observers.\n        each(this.inputs, function (input) {\n          return each(input, function (value) {\n            var config = getFluidConfig(value);\n            if (config) config.removeChild(_this4);\n          });\n        });\n      }\n    }\n  }, {\n    key: \"onParentChange\",\n    value: function onParentChange(event) {\n      if (event.type == 'change') {\n        this._value = null;\n      }\n\n      each(this._children, function (child) {\n        child.onParentChange(event);\n      });\n    }\n  }]);\n\n  return FluidTransform;\n}(FluidValue);\n\nvar primitives = ['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'];\nGlobals$1.assign({\n  colorNames: colorNames,\n  createStringInterpolator: createStringInterpolator,\n  batchedUpdates: unstable_batchedUpdates\n});\nvar host = createHost(primitives, {\n  applyAnimatedValues: applyAnimatedValues,\n  createAnimatedStyle: function createAnimatedStyle(style) {\n    return new AnimatedStyle(style);\n  },\n  getComponentProps: function getComponentProps(_ref) {\n    var props = _objectWithoutPropertiesLoose(_ref, [\"scrollTop\", \"scrollLeft\"]);\n\n    return props;\n  }\n});\nvar animated = host.animated;\nexport { animated as a, animated };","// extracted by mini-css-extract-plugin\nmodule.exports = {\"industry\":\"card-module--industry--IFwws\",\"button\":\"card-module--button--1OBfT\",\"iconHolder\":\"card-module--icon-holder--2bs7K\",\"icon\":\"card-module--icon--1jHl-\"};","export default function _typeof(obj) {\n  \"@babel/helpers - typeof\";\n\n  if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n    _typeof = function _typeof(obj) {\n      return typeof obj;\n    };\n  } else {\n    _typeof = function _typeof(obj) {\n      return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n    };\n  }\n\n  return _typeof(obj);\n}","import _typeof from \"../../helpers/esm/typeof\";\nimport assertThisInitialized from \"./assertThisInitialized\";\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}","require(\"core-js/modules/web.dom.iterable\");\n\nrequire(\"core-js/modules/es6.array.iterator\");\n\nrequire(\"core-js/modules/es6.regexp.to-string\");\n\nrequire(\"core-js/modules/es6.promise\");\n\nrequire(\"core-js/modules/es6.object.to-string\");\n\nrequire(\"core-js/modules/es6.function.name\");\n\nrequire(\"core-js/modules/es7.symbol.async-iterator\");\n\nrequire(\"core-js/modules/es6.symbol\");\n\n/**\n * Copyright (c) 2014-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\nvar runtime = function (exports) {\n  \"use strict\";\n\n  var Op = Object.prototype;\n  var hasOwn = Op.hasOwnProperty;\n  var undefined; // More compressible than void 0.\n\n  var $Symbol = typeof Symbol === \"function\" ? Symbol : {};\n  var iteratorSymbol = $Symbol.iterator || \"@@iterator\";\n  var asyncIteratorSymbol = $Symbol.asyncIterator || \"@@asyncIterator\";\n  var toStringTagSymbol = $Symbol.toStringTag || \"@@toStringTag\";\n\n  function wrap(innerFn, outerFn, self, tryLocsList) {\n    // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.\n    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;\n    var generator = Object.create(protoGenerator.prototype);\n    var context = new Context(tryLocsList || []); // The ._invoke method unifies the implementations of the .next,\n    // .throw, and .return methods.\n\n    generator._invoke = makeInvokeMethod(innerFn, self, context);\n    return generator;\n  }\n\n  exports.wrap = wrap; // Try/catch helper to minimize deoptimizations. Returns a completion\n  // record like context.tryEntries[i].completion. This interface could\n  // have been (and was previously) designed to take a closure to be\n  // invoked without arguments, but in all the cases we care about we\n  // already have an existing method we want to call, so there's no need\n  // to create a new function object. We can even get away with assuming\n  // the method takes exactly one argument, since that happens to be true\n  // in every case, so we don't have to touch the arguments object. The\n  // only additional allocation required is the completion record, which\n  // has a stable shape and so hopefully should be cheap to allocate.\n\n  function tryCatch(fn, obj, arg) {\n    try {\n      return {\n        type: \"normal\",\n        arg: fn.call(obj, arg)\n      };\n    } catch (err) {\n      return {\n        type: \"throw\",\n        arg: err\n      };\n    }\n  }\n\n  var GenStateSuspendedStart = \"suspendedStart\";\n  var GenStateSuspendedYield = \"suspendedYield\";\n  var GenStateExecuting = \"executing\";\n  var GenStateCompleted = \"completed\"; // Returning this object from the innerFn has the same effect as\n  // breaking out of the dispatch switch statement.\n\n  var ContinueSentinel = {}; // Dummy constructor functions that we use as the .constructor and\n  // .constructor.prototype properties for functions that return Generator\n  // objects. For full spec compliance, you may wish to configure your\n  // minifier not to mangle the names of these two functions.\n\n  function Generator() {}\n\n  function GeneratorFunction() {}\n\n  function GeneratorFunctionPrototype() {} // This is a polyfill for %IteratorPrototype% for environments that\n  // don't natively support it.\n\n\n  var IteratorPrototype = {};\n\n  IteratorPrototype[iteratorSymbol] = function () {\n    return this;\n  };\n\n  var getProto = Object.getPrototypeOf;\n  var NativeIteratorPrototype = getProto && getProto(getProto(values([])));\n\n  if (NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {\n    // This environment has a native %IteratorPrototype%; use it instead\n    // of the polyfill.\n    IteratorPrototype = NativeIteratorPrototype;\n  }\n\n  var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);\n  GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;\n  GeneratorFunctionPrototype.constructor = GeneratorFunction;\n  GeneratorFunctionPrototype[toStringTagSymbol] = GeneratorFunction.displayName = \"GeneratorFunction\"; // Helper for defining the .next, .throw, and .return methods of the\n  // Iterator interface in terms of a single ._invoke method.\n\n  function defineIteratorMethods(prototype) {\n    [\"next\", \"throw\", \"return\"].forEach(function (method) {\n      prototype[method] = function (arg) {\n        return this._invoke(method, arg);\n      };\n    });\n  }\n\n  exports.isGeneratorFunction = function (genFun) {\n    var ctor = typeof genFun === \"function\" && genFun.constructor;\n    return ctor ? ctor === GeneratorFunction || // For the native GeneratorFunction constructor, the best we can\n    // do is to check its .name property.\n    (ctor.displayName || ctor.name) === \"GeneratorFunction\" : false;\n  };\n\n  exports.mark = function (genFun) {\n    if (Object.setPrototypeOf) {\n      Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);\n    } else {\n      genFun.__proto__ = GeneratorFunctionPrototype;\n\n      if (!(toStringTagSymbol in genFun)) {\n        genFun[toStringTagSymbol] = \"GeneratorFunction\";\n      }\n    }\n\n    genFun.prototype = Object.create(Gp);\n    return genFun;\n  }; // Within the body of any async function, `await x` is transformed to\n  // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test\n  // `hasOwn.call(value, \"__await\")` to determine if the yielded value is\n  // meant to be awaited.\n\n\n  exports.awrap = function (arg) {\n    return {\n      __await: arg\n    };\n  };\n\n  function AsyncIterator(generator, PromiseImpl) {\n    function invoke(method, arg, resolve, reject) {\n      var record = tryCatch(generator[method], generator, arg);\n\n      if (record.type === \"throw\") {\n        reject(record.arg);\n      } else {\n        var result = record.arg;\n        var value = result.value;\n\n        if (value && typeof value === \"object\" && hasOwn.call(value, \"__await\")) {\n          return PromiseImpl.resolve(value.__await).then(function (value) {\n            invoke(\"next\", value, resolve, reject);\n          }, function (err) {\n            invoke(\"throw\", err, resolve, reject);\n          });\n        }\n\n        return PromiseImpl.resolve(value).then(function (unwrapped) {\n          // When a yielded Promise is resolved, its final value becomes\n          // the .value of the Promise<{value,done}> result for the\n          // current iteration.\n          result.value = unwrapped;\n          resolve(result);\n        }, function (error) {\n          // If a rejected Promise was yielded, throw the rejection back\n          // into the async generator function so it can be handled there.\n          return invoke(\"throw\", error, resolve, reject);\n        });\n      }\n    }\n\n    var previousPromise;\n\n    function enqueue(method, arg) {\n      function callInvokeWithMethodAndArg() {\n        return new PromiseImpl(function (resolve, reject) {\n          invoke(method, arg, resolve, reject);\n        });\n      }\n\n      return previousPromise = // If enqueue has been called before, then we want to wait until\n      // all previous Promises have been resolved before calling invoke,\n      // so that results are always delivered in the correct order. If\n      // enqueue has not been called before, then it is important to\n      // call invoke immediately, without waiting on a callback to fire,\n      // so that the async generator function has the opportunity to do\n      // any necessary setup in a predictable way. This predictability\n      // is why the Promise constructor synchronously invokes its\n      // executor callback, and why async functions synchronously\n      // execute code before the first await. Since we implement simple\n      // async functions in terms of async generators, it is especially\n      // important to get this right, even though it requires care.\n      previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, // Avoid propagating failures to Promises returned by later\n      // invocations of the iterator.\n      callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();\n    } // Define the unified helper method that is used to implement .next,\n    // .throw, and .return (see defineIteratorMethods).\n\n\n    this._invoke = enqueue;\n  }\n\n  defineIteratorMethods(AsyncIterator.prototype);\n\n  AsyncIterator.prototype[asyncIteratorSymbol] = function () {\n    return this;\n  };\n\n  exports.AsyncIterator = AsyncIterator; // Note that simple async functions are implemented on top of\n  // AsyncIterator objects; they just return a Promise for the value of\n  // the final result produced by the iterator.\n\n  exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) {\n    if (PromiseImpl === void 0) PromiseImpl = Promise;\n    var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl);\n    return exports.isGeneratorFunction(outerFn) ? iter // If outerFn is a generator, return the full iterator.\n    : iter.next().then(function (result) {\n      return result.done ? result.value : iter.next();\n    });\n  };\n\n  function makeInvokeMethod(innerFn, self, context) {\n    var state = GenStateSuspendedStart;\n    return function invoke(method, arg) {\n      if (state === GenStateExecuting) {\n        throw new Error(\"Generator is already running\");\n      }\n\n      if (state === GenStateCompleted) {\n        if (method === \"throw\") {\n          throw arg;\n        } // Be forgiving, per 25.3.3.3.3 of the spec:\n        // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume\n\n\n        return doneResult();\n      }\n\n      context.method = method;\n      context.arg = arg;\n\n      while (true) {\n        var delegate = context.delegate;\n\n        if (delegate) {\n          var delegateResult = maybeInvokeDelegate(delegate, context);\n\n          if (delegateResult) {\n            if (delegateResult === ContinueSentinel) continue;\n            return delegateResult;\n          }\n        }\n\n        if (context.method === \"next\") {\n          // Setting context._sent for legacy support of Babel's\n          // function.sent implementation.\n          context.sent = context._sent = context.arg;\n        } else if (context.method === \"throw\") {\n          if (state === GenStateSuspendedStart) {\n            state = GenStateCompleted;\n            throw context.arg;\n          }\n\n          context.dispatchException(context.arg);\n        } else if (context.method === \"return\") {\n          context.abrupt(\"return\", context.arg);\n        }\n\n        state = GenStateExecuting;\n        var record = tryCatch(innerFn, self, context);\n\n        if (record.type === \"normal\") {\n          // If an exception is thrown from innerFn, we leave state ===\n          // GenStateExecuting and loop back for another invocation.\n          state = context.done ? GenStateCompleted : GenStateSuspendedYield;\n\n          if (record.arg === ContinueSentinel) {\n            continue;\n          }\n\n          return {\n            value: record.arg,\n            done: context.done\n          };\n        } else if (record.type === \"throw\") {\n          state = GenStateCompleted; // Dispatch the exception by looping back around to the\n          // context.dispatchException(context.arg) call above.\n\n          context.method = \"throw\";\n          context.arg = record.arg;\n        }\n      }\n    };\n  } // Call delegate.iterator[context.method](context.arg) and handle the\n  // result, either by returning a { value, done } result from the\n  // delegate iterator, or by modifying context.method and context.arg,\n  // setting context.delegate to null, and returning the ContinueSentinel.\n\n\n  function maybeInvokeDelegate(delegate, context) {\n    var method = delegate.iterator[context.method];\n\n    if (method === undefined) {\n      // A .throw or .return when the delegate iterator has no .throw\n      // method always terminates the yield* loop.\n      context.delegate = null;\n\n      if (context.method === \"throw\") {\n        // Note: [\"return\"] must be used for ES3 parsing compatibility.\n        if (delegate.iterator[\"return\"]) {\n          // If the delegate iterator has a return method, give it a\n          // chance to clean up.\n          context.method = \"return\";\n          context.arg = undefined;\n          maybeInvokeDelegate(delegate, context);\n\n          if (context.method === \"throw\") {\n            // If maybeInvokeDelegate(context) changed context.method from\n            // \"return\" to \"throw\", let that override the TypeError below.\n            return ContinueSentinel;\n          }\n        }\n\n        context.method = \"throw\";\n        context.arg = new TypeError(\"The iterator does not provide a 'throw' method\");\n      }\n\n      return ContinueSentinel;\n    }\n\n    var record = tryCatch(method, delegate.iterator, context.arg);\n\n    if (record.type === \"throw\") {\n      context.method = \"throw\";\n      context.arg = record.arg;\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    var info = record.arg;\n\n    if (!info) {\n      context.method = \"throw\";\n      context.arg = new TypeError(\"iterator result is not an object\");\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    if (info.done) {\n      // Assign the result of the finished delegate to the temporary\n      // variable specified by delegate.resultName (see delegateYield).\n      context[delegate.resultName] = info.value; // Resume execution at the desired location (see delegateYield).\n\n      context.next = delegate.nextLoc; // If context.method was \"throw\" but the delegate handled the\n      // exception, let the outer generator proceed normally. If\n      // context.method was \"next\", forget context.arg since it has been\n      // \"consumed\" by the delegate iterator. If context.method was\n      // \"return\", allow the original .return call to continue in the\n      // outer generator.\n\n      if (context.method !== \"return\") {\n        context.method = \"next\";\n        context.arg = undefined;\n      }\n    } else {\n      // Re-yield the result returned by the delegate method.\n      return info;\n    } // The delegate iterator is finished, so forget it and continue with\n    // the outer generator.\n\n\n    context.delegate = null;\n    return ContinueSentinel;\n  } // Define Generator.prototype.{next,throw,return} in terms of the\n  // unified ._invoke helper method.\n\n\n  defineIteratorMethods(Gp);\n  Gp[toStringTagSymbol] = \"Generator\"; // A Generator should always return itself as the iterator object when the\n  // @@iterator function is called on it. Some browsers' implementations of the\n  // iterator prototype chain incorrectly implement this, causing the Generator\n  // object to not be returned from this call. This ensures that doesn't happen.\n  // See https://github.com/facebook/regenerator/issues/274 for more details.\n\n  Gp[iteratorSymbol] = function () {\n    return this;\n  };\n\n  Gp.toString = function () {\n    return \"[object Generator]\";\n  };\n\n  function pushTryEntry(locs) {\n    var entry = {\n      tryLoc: locs[0]\n    };\n\n    if (1 in locs) {\n      entry.catchLoc = locs[1];\n    }\n\n    if (2 in locs) {\n      entry.finallyLoc = locs[2];\n      entry.afterLoc = locs[3];\n    }\n\n    this.tryEntries.push(entry);\n  }\n\n  function resetTryEntry(entry) {\n    var record = entry.completion || {};\n    record.type = \"normal\";\n    delete record.arg;\n    entry.completion = record;\n  }\n\n  function Context(tryLocsList) {\n    // The root entry object (effectively a try statement without a catch\n    // or a finally block) gives us a place to store values thrown from\n    // locations where there is no enclosing try statement.\n    this.tryEntries = [{\n      tryLoc: \"root\"\n    }];\n    tryLocsList.forEach(pushTryEntry, this);\n    this.reset(true);\n  }\n\n  exports.keys = function (object) {\n    var keys = [];\n\n    for (var key in object) {\n      keys.push(key);\n    }\n\n    keys.reverse(); // Rather than returning an object with a next method, we keep\n    // things simple and return the next function itself.\n\n    return function next() {\n      while (keys.length) {\n        var key = keys.pop();\n\n        if (key in object) {\n          next.value = key;\n          next.done = false;\n          return next;\n        }\n      } // To avoid creating an additional object, we just hang the .value\n      // and .done properties off the next function object itself. This\n      // also ensures that the minifier will not anonymize the function.\n\n\n      next.done = true;\n      return next;\n    };\n  };\n\n  function values(iterable) {\n    if (iterable) {\n      var iteratorMethod = iterable[iteratorSymbol];\n\n      if (iteratorMethod) {\n        return iteratorMethod.call(iterable);\n      }\n\n      if (typeof iterable.next === \"function\") {\n        return iterable;\n      }\n\n      if (!isNaN(iterable.length)) {\n        var i = -1,\n            next = function next() {\n          while (++i < iterable.length) {\n            if (hasOwn.call(iterable, i)) {\n              next.value = iterable[i];\n              next.done = false;\n              return next;\n            }\n          }\n\n          next.value = undefined;\n          next.done = true;\n          return next;\n        };\n\n        return next.next = next;\n      }\n    } // Return an iterator with no values.\n\n\n    return {\n      next: doneResult\n    };\n  }\n\n  exports.values = values;\n\n  function doneResult() {\n    return {\n      value: undefined,\n      done: true\n    };\n  }\n\n  Context.prototype = {\n    constructor: Context,\n    reset: function reset(skipTempReset) {\n      this.prev = 0;\n      this.next = 0; // Resetting context._sent for legacy support of Babel's\n      // function.sent implementation.\n\n      this.sent = this._sent = undefined;\n      this.done = false;\n      this.delegate = null;\n      this.method = \"next\";\n      this.arg = undefined;\n      this.tryEntries.forEach(resetTryEntry);\n\n      if (!skipTempReset) {\n        for (var name in this) {\n          // Not sure about the optimal order of these conditions:\n          if (name.charAt(0) === \"t\" && hasOwn.call(this, name) && !isNaN(+name.slice(1))) {\n            this[name] = undefined;\n          }\n        }\n      }\n    },\n    stop: function stop() {\n      this.done = true;\n      var rootEntry = this.tryEntries[0];\n      var rootRecord = rootEntry.completion;\n\n      if (rootRecord.type === \"throw\") {\n        throw rootRecord.arg;\n      }\n\n      return this.rval;\n    },\n    dispatchException: function dispatchException(exception) {\n      if (this.done) {\n        throw exception;\n      }\n\n      var context = this;\n\n      function handle(loc, caught) {\n        record.type = \"throw\";\n        record.arg = exception;\n        context.next = loc;\n\n        if (caught) {\n          // If the dispatched exception was caught by a catch block,\n          // then let that catch block handle the exception normally.\n          context.method = \"next\";\n          context.arg = undefined;\n        }\n\n        return !!caught;\n      }\n\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        var record = entry.completion;\n\n        if (entry.tryLoc === \"root\") {\n          // Exception thrown outside of any try block that could handle\n          // it, so set the completion value of the entire function to\n          // throw the exception.\n          return handle(\"end\");\n        }\n\n        if (entry.tryLoc <= this.prev) {\n          var hasCatch = hasOwn.call(entry, \"catchLoc\");\n          var hasFinally = hasOwn.call(entry, \"finallyLoc\");\n\n          if (hasCatch && hasFinally) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            } else if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n          } else if (hasCatch) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            }\n          } else if (hasFinally) {\n            if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n          } else {\n            throw new Error(\"try statement without catch or finally\");\n          }\n        }\n      }\n    },\n    abrupt: function abrupt(type, arg) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n\n        if (entry.tryLoc <= this.prev && hasOwn.call(entry, \"finallyLoc\") && this.prev < entry.finallyLoc) {\n          var finallyEntry = entry;\n          break;\n        }\n      }\n\n      if (finallyEntry && (type === \"break\" || type === \"continue\") && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc) {\n        // Ignore the finally entry if control is not jumping to a\n        // location outside the try/catch block.\n        finallyEntry = null;\n      }\n\n      var record = finallyEntry ? finallyEntry.completion : {};\n      record.type = type;\n      record.arg = arg;\n\n      if (finallyEntry) {\n        this.method = \"next\";\n        this.next = finallyEntry.finallyLoc;\n        return ContinueSentinel;\n      }\n\n      return this.complete(record);\n    },\n    complete: function complete(record, afterLoc) {\n      if (record.type === \"throw\") {\n        throw record.arg;\n      }\n\n      if (record.type === \"break\" || record.type === \"continue\") {\n        this.next = record.arg;\n      } else if (record.type === \"return\") {\n        this.rval = this.arg = record.arg;\n        this.method = \"return\";\n        this.next = \"end\";\n      } else if (record.type === \"normal\" && afterLoc) {\n        this.next = afterLoc;\n      }\n\n      return ContinueSentinel;\n    },\n    finish: function finish(finallyLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n\n        if (entry.finallyLoc === finallyLoc) {\n          this.complete(entry.completion, entry.afterLoc);\n          resetTryEntry(entry);\n          return ContinueSentinel;\n        }\n      }\n    },\n    \"catch\": function _catch(tryLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n\n        if (entry.tryLoc === tryLoc) {\n          var record = entry.completion;\n\n          if (record.type === \"throw\") {\n            var thrown = record.arg;\n            resetTryEntry(entry);\n          }\n\n          return thrown;\n        }\n      } // The context.catch method must only be called with a location\n      // argument that corresponds to a known catch block.\n\n\n      throw new Error(\"illegal catch attempt\");\n    },\n    delegateYield: function delegateYield(iterable, resultName, nextLoc) {\n      this.delegate = {\n        iterator: values(iterable),\n        resultName: resultName,\n        nextLoc: nextLoc\n      };\n\n      if (this.method === \"next\") {\n        // Deliberately forget the last sent value so that we don't\n        // accidentally pass it on to the delegate.\n        this.arg = undefined;\n      }\n\n      return ContinueSentinel;\n    }\n  }; // Regardless of whether this script is executing as a CommonJS module\n  // or not, return the runtime object so that we can declare the variable\n  // regeneratorRuntime in the outer scope, which allows this module to be\n  // injected easily by `bin/regenerator --include-runtime script.js`.\n\n  return exports;\n}( // If this script is executing as a CommonJS module, use module.exports\n// as the regeneratorRuntime namespace. Otherwise create a new empty\n// object. Either way, the resulting object will be used to initialize\n// the regeneratorRuntime variable at the top of this file.\ntypeof module === \"object\" ? module.exports : {});\n\ntry {\n  regeneratorRuntime = runtime;\n} catch (accidentalStrictMode) {\n  // This module should not be running in strict mode, so the above\n  // assignment should always work unless something is misconfigured. Just\n  // in case runtime.js accidentally runs in strict mode, we can escape\n  // strict mode using a global Function call. This could conceivably fail\n  // if a Content Security Policy forbids using Function, but in that case\n  // the proper solution is to fix the accidental strict mode problem. If\n  // you've misconfigured your bundler to force strict mode and applied a\n  // CSP to forbid Function, and you're not willing to fix either of those\n  // problems, please detail your unique predicament in a GitHub issue.\n  Function(\"r\", \"regeneratorRuntime = r\")(runtime);\n}","import arrayWithoutHoles from \"./arrayWithoutHoles\";\nimport iterableToArray from \"./iterableToArray\";\nimport unsupportedIterableToArray from \"./unsupportedIterableToArray\";\nimport nonIterableSpread from \"./nonIterableSpread\";\nexport default function _toConsumableArray(arr) {\n  return arrayWithoutHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableSpread();\n}","import arrayLikeToArray from \"./arrayLikeToArray\";\nexport default function _arrayWithoutHoles(arr) {\n  if (Array.isArray(arr)) return arrayLikeToArray(arr);\n}","export default function _iterableToArray(iter) {\n  if (typeof Symbol !== \"undefined\" && Symbol.iterator in Object(iter)) return Array.from(iter);\n}","export default function _nonIterableSpread() {\n  throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}","import React from \"react\";\nimport { Link } from \"gatsby\";\nimport Image from \"gatsby-image\";\nimport { StaticQuery, graphql } from \"gatsby\";\n\n//styles\nimport s from \"./card.module.scss\";\n\nexport default ({ itemClassName }) => (\n  <StaticQuery\n    query={graphql`\n      query {\n        strapiPsVirtual {\n          hero {\n            main_heading\n            service_icon {\n              childImageSharp {\n                fixed(width: 100, height: 100) {\n                  ...GatsbyImageSharpFixed\n                }\n              }\n            }\n          }\n        }\n      }\n    `}\n    render={data => {\n      const { hero } = data.strapiPsVirtual;\n\n      return (\n        <div className={`${itemClassName} ${s.industry}`}>\n          <Link to=\"/solutions/chatbots/\">\n            <div>\n              <div className={`hero-circle m-auto`}>\n                <Image\n                  fixed={hero[0].service_icon.childImageSharp.fixed}\n                  className={s.icon}\n                />\n              </div>\n              <h3 className={`text-center`}>{hero[0].main_heading}</h3>\n            </div>\n            <span className={`btn btn-secondary btn-lg ${s.button}`}>\n              Learn More\n            </span>\n          </Link>\n        </div>\n      );\n    }}\n  />\n);\n","// extracted by mini-css-extract-plugin\nmodule.exports = {\"thumbnailWraper\":\"index-module--thumbnail-wraper--3LxLs\",\"playButton\":\"index-module--play-button--3qQrZ\",\"cardStack\":\"index-module--card-stack--2Qf3T\",\"solutionHeader\":\"index-module--solution-header--10psT\",\"cardStackTop\":\"index-module--cardStackTop--2i2Db\",\"leftColumn\":\"index-module--left-column--1sU95\",\"header\":\"index-module--header--2Pp1r\",\"link\":\"index-module--link--3RCnp\",\"heroWhatIsThisLink\":\"index-module--heroWhatIsThisLink--3ExN_\",\"salePoint\":\"index-module--sale-point--3cK_D\",\"heroImage\":\"index-module--hero-image--2fWvJ\",\"rightColumn\":\"index-module--right-column--3mKDF\",\"hero\":\"index-module--hero--nkUhx\",\"content\":\"index-module--content--1f4nN\",\"fService\":\"index-module--f-service--1fqFK\",\"spaceAboveHook\":\"index-module--space-above-hook--3FiFn\",\"noBottomPaddingOnMobile\":\"index-module--no-bottom-padding-on-mobile--7GTcY\",\"card\":\"index-module--card--ihL20\",\"insightCard\":\"index-module--insight-card--lKiKl\",\"insightType\":\"index-module--insight-type--1j7Me\",\"insightCaption\":\"index-module--insight-caption--3vOzi\",\"carouselFilter\":\"index-module--carousel-filter--2rswS\",\"sideWrapper\":\"index-module--side-wrapper--3rnvj\",\"bgSecondaryGray\":\"index-module--bg-secondary-gray--2lfsQ\",\"bgPurple\":\"index-module--bg-purple--XUaKs\",\"info\":\"index-module--info--P8YwS\"};","import React, { useState } from \"react\";\nimport { useSpring, animated, config } from \"react-spring\";\nimport { useTransitionHeight } from \"../../utils/useMeasure\";\nimport { isMobile } from \"react-device-detect\";\n\n\n//styles\nimport s from \"./TabToAccordion.module.scss\";\n\nfunction TabToAccordion({data}) {\n  // const data = [\n  //   {\n  //     heading: \"Optimized Integration\",\n  //     content:\n  //       \"Gain fully optimized services and solutions for your business needs through Nitco. As the world is transforming into the digital age, become a leading business in your industry with custom technology integrations that bring more value to your organization.\",\n  //     link: \"link\"\n  //   },\n  //   {\n  //     heading: \"Process Enhancement\",\n  //     content:\n  //       \"Leave inefficient process in the past and gain enhanced processes through Nitco’s AI and automation services. Bring digital technologies into your business operations and improve performance while securing future scalability.\",\n  //     link: \"link\"\n  //   },\n  //   {\n  //     heading: \"End-To-End support\",\n  //     content:\n  //       \"Allow Nitco professionals to implement cutting edge technology solutions into your business operations without hassle. We provide specialists to assist your company’s transition and provide support at each step so you worry less, and flourish more.\",\n  //     link: \"link\"\n  //   },\n  //   {\n  //     heading: \"Best Practices\",\n  //     content:\n  //       \"Offering our expertise, we can provide assistance in improving your company operations and enhance the value produced by your processes. With our insight, gain a partner to set your business up for future success through establishing a foundation of best practices.\",\n  //     link: \"link\"\n  //   },\n  //   {\n  //     heading: \"Strategized Implementation\",\n  //     content:\n  //       \"From proof of concept to pushing to production, our specialists ensure a thorough end-to-end strategy to implement our digital solutions into your existing environment with little to no interruption. Nitco provides in-depth implementation plans to improve your applications and processes. We strive to enhance efficiency across your organization bringing greater business agility and value.\",\n  //     link: \"link\"\n  //   }\n  // ];\n\n  let itemStates = new Array(data.length).fill(false);\n  itemStates[0] = true;\n\n  let toggleArray = [];\n\n  const [itemSelect, setItemSelect] = useState(itemStates);\n\n  const itemClickHandler = index => {\n    if (!isMobile) {\n      setItemSelect(\n        itemSelect.map((item, i) => {\n          const isOpened = i === index ? true : false;\n          return isOpened;\n        })\n      );\n    } else {\n      setItemSelect(\n        itemSelect.map((item, i) => {\n          const isOpened = i === index ? !item : item;\n          return isOpened;\n        })\n      );\n    }\n  };\n\n  //   const handleCollapsibleToggle = (index) => {\n  //     setItemSelect(\n  //       itemSelect.map((item, i) => {\n  //         return i === index ? !item : item;\n  //       })\n  //     );\n  //   };\n\n  return (\n    <div\n      className={`container-fluid  ${s.bg}  ${s.benefits} mb-5`}\n      // ${layoutStyle.panelPadding}\n      style={{ padding: 0 }}\n    >\n      <div className={`${s.benefitsOverlay}`}>\n        <div className={`container`}>\n          <div className={`row pt-5`}>\n            {/* <div className={`${s.benefitsOverlay}`}> */}\n            <div\n              className={`col-lg-6 col-md-8 ${s.tabletCenter}`}\n            >\n              <div className={`row`}>\n                <div\n                  className={`col-lg-12 col-md-12 col-sm-12`}\n                >\n                  {data &&\n                    itemSelect.map((item, i) => {\n                      const [\n                        style,\n                        bind,\n                        toggle\n                      ] = useTransitionHeight(i === 0);\n                      // setToggle(item);\n                      const chevronRotate = useSpring({\n                        from: {\n                          transform: \"rotateZ(0deg)\"\n                        },\n                        to: {\n                          transform: item ? \"rotateZ(90deg)\" : \"rotateZ(0deg)\"\n                        }\n                      });\n\n\n                      return (\n                        <div key={i}>\n                          <h2\n                            className={`${s.btn} ${item ? s.active : \"\"}`}\n                            onClick={() => {\n                              itemClickHandler(i);\n                              toggle();\n                            }}\n                          >\n                            <animated.i\n                              className={`fas fa-chevron-right ${s.visibleMdDown}`}\n                              style={chevronRotate}\n                            ></animated.i>\n                            {data[i].heading}\n                          </h2>\n\n                          <animated.div\n                            style={style}\n                            className={`${s.visibleMdDown} ${s.content} mb-5`}\n                          >\n                            <div {...bind} className={``}>\n                              <p className={`${s.para}`}>{data[i].content}</p>\n                            </div>\n                            {/* {i ===0 && toggle()} */}\n                          </animated.div>\n                        </div>\n                      );\n                    })}\n                </div>\n              </div>\n            </div>\n            <div\n              className={`col-lg-6 col-md-12 pb-5 ${s.visibleLg}`}\n            >\n              <h3 className={`mb-5`}>\n                {!isMobile && data[itemSelect.indexOf(true)].heading}\n              </h3>\n\n              <p className={`${s.paraDesk} mb-5`}>\n                {!isMobile && data[itemSelect.indexOf(true)].content}\n              </p>\n            </div>\n          </div>\n        </div>\n      </div>\n    </div>\n  );\n}\n\nexport default TabToAccordion;\n","import React from \"react\";\nimport { Helmet } from \"react-helmet\";\n\nconst SalesIntelScript = () => {\n  return (\n    <Helmet>\n      <script charset=\"utf-8\" type=\"text/javascript\" src=\"https://api-gateway.scriptintel.io/service/visitorintel/visitorTag/221764/script.js?apiKey=MjIxNzY0NDMyOWE4NDUtZDMxYy00MjEwLThkYzEtYTM5NzNlNTFjYjVj\"></script>\n    </Helmet>\n  );\n};\n\nexport default SalesIntelScript;\n","import React, { useState } from \"react\";\r\nimport { Link, graphql, navigate } from \"gatsby\";\r\nimport { Col } from \"react-bootstrap\";\r\n\r\n//components\r\nimport useSetPageData from \"../utils/useSetPageData\";\r\nimport { addTrailingSlash } from \"../utils/utilities\";\r\nimport PanelFoundation from \"../components/panels/PanelFoundation\";\r\n// import Computer from \"../components/animations/computer\";\r\nimport ComponentHeader from \"../components/panels/ComponentHeader\";\r\nimport SEO from \"../components/seo\";\r\nimport Video from \"../components/non-panels/react-modal-video/normal-video\";\r\n\r\n// // import FeaturedArticles from \"../components/in-pages/featuredArticles\";\r\n\r\n// //cards\r\nimport ArtificialIntelligenceCard from \"../components/non-panels/cards/ArtificialIntelligence\";\r\nimport RpaCard from \"../components/non-panels/cards/RPA\";\r\nimport ChatbotsCard from \"../components/non-panels/cards/Chatbots\";\r\nimport Partners from \"../components/panels/Partners\";\r\n// import Testimonies from \"../components/non-panels/Testimonies\";\r\n\r\n//style\r\nimport s from \"./index.module.scss\";\r\n// // import layoutStyle from \"../components/layouts/layout.module.scss\";\r\n\r\n//images\r\n// import computerGif from \"../images/home-computer-reduced2.gif\";\r\nimport playButton from \"../images/play-button-2138735_640.png\";\r\nimport introVideoThumbnail from \"../images/intro-video-thumbnail.jpg\";\r\nimport TabToAccordion from \"../components/panels/TabToAccordion\";\r\n\r\n// utils\r\nimport SalesIntelScript from \"../utils/SalesIntelScript\";\r\n\r\nconst IndexPage = ({ location, data }) => {\r\n  useSetPageData(location);\r\n\r\n  const {\r\n    main_heading,\r\n    main_subheading,\r\n    main_conversion_link_url,\r\n    main_conversion_link_text,\r\n    we_deliver\r\n  } = data.strapiHomePage;\r\n\r\n  // const [isVideoModelOpen, setIsVideoModelOpen] = useState(false);\r\n\r\n  // const featuredArray = [\r\n  //   ...data.allStrapiPostBlog.edges.map(item => {\r\n  //     item.node.type = \"Blog\";\r\n  //     item.node.url = addTrailingSlash(`/blog/${item.node.slug}`);\r\n  //     return item.node;\r\n  //   }),\r\n  //   ...data.allStrapiPostCase.edges.map(item => {\r\n  //     item.node.type = \"Case Study\";\r\n  //     item.node.url = addTrailingSlash(`/case-studies/${item.node.slug}`);\r\n  //     return item.node;\r\n  //   }),\r\n  //   ...data.allStrapiPostNews.edges.map(item => {\r\n  //     item.node.type = \"News\";\r\n  //     item.node.url = addTrailingSlash(`/news/${item.node.slug}`);\r\n  //     return item.node;\r\n  //   }),\r\n  //   ...data.allStrapiPostWebinar.edges.map(item => {\r\n  //     item.node.type = \"Webinar\";\r\n  //     item.node.url = addTrailingSlash(`/webinar/${item.node.slug}`);\r\n  //     return item.node;\r\n  //   }),\r\n  //   ...data.allStrapiPostWhitePapers.edges.map(item => {\r\n  //     item.node.type = \"White Paper\";\r\n  //     item.node.url = addTrailingSlash(`/whitepapers/${item.node.slug}`);\r\n  //     return item.node;\r\n  //   })\r\n  // ];\r\n\r\n  // const featuredCardClickHandler = url => {\r\n  //   navigate(url);\r\n  // };\r\n\r\n  return (\r\n    <>\r\n      <SalesIntelScript />\r\n      <SEO\r\n        {...{\r\n          title: \"Technology Solutions Provider - AI, RPA, and More\",\r\n          description: data.strapiHomePage.SEO.description\r\n        }}\r\n      />\r\n      <PanelFoundation\r\n        rowClassName={`${s.spaceAboveHook}`}\r\n        rowStyle={{ marginBottom: \"4rem\" }}\r\n      >\r\n        <Col lg={7} md={12}>\r\n          <Video\r\n            channel={\"vimeo\"}\r\n            ratio=\"16:9\"\r\n            autoplay={1}\r\n            allowFullScreen={true}\r\n            videoId={`526327463`}\r\n          // url={`http://vimeo.com/manage/videos/526327463`}\r\n          />\r\n          {/* <div className={`${s.thumbnailWraper}`}\r\n            onClick={() => setIsVideoModelOpen(true)}>\r\n\r\n            <img\r\n              src={introVideoThumbnail}\r\n              className={`mb-3`}\r\n              style={{\r\n                width: \"100%\"\r\n              }}\r\n            />\r\n            <img src={playButton} className={s.playButton} />\r\n          </div> */}\r\n        </Col>\r\n        <Col lg={5} md={12}>\r\n          <div className={s.salePoint}>\r\n            <h1 className={`text-primary mb-5`}>{main_heading}</h1>\r\n            <p className={`text-justify text-muted mb-5`}>{main_subheading}</p>\r\n            <Link\r\n              className={`btn btn-secondary btn-lg`}\r\n              to={main_conversion_link_url}\r\n            >\r\n              {main_conversion_link_text}\r\n            </Link>\r\n          </div>\r\n        </Col>\r\n      </PanelFoundation>\r\n      <ComponentHeader\r\n        // style={{ marginTop: \"1rem\" }}\r\n        lineTop={false}\r\n        rootClassName={`bg-white ${s.header}`}\r\n        textClassName={`text-primary`}\r\n        text=\"What We Deliver\"\r\n      />\r\n      <TabToAccordion data={we_deliver} />\r\n      <ComponentHeader\r\n        // style={{ marginTop: \"1rem\" }}\r\n        lineTop={false}\r\n        rootClassName={`bg-white ${s.header} mt-5 pt-5`}\r\n        textClassName={`text-primary ${s.solutionHeader}`}\r\n        text=\"Featured Solutions\"\r\n      />\r\n      <PanelFoundation rootClassName={`panel-padding pt-0 pb-5 mb-4`}>\r\n        <Col lg={4} md={4} sm={12}>\r\n          <ArtificialIntelligenceCard />\r\n        </Col>\r\n        <Col lg={4} md={4} sm={12}>\r\n          <ChatbotsCard />\r\n        </Col>\r\n        <Col lg={4} md={4} sm={12}>\r\n          <RpaCard />\r\n        </Col>\r\n      </PanelFoundation>\r\n      {/* <ComponentHeader\r\n        // style={{ marginTop: \"1rem\" }}\r\n        lineTop={false}\r\n        rootClassName={`bg-white ${s.header}`}\r\n        textClassName={`text-primary`}\r\n        text=\"Featured Insights\"\r\n      />\r\n      <PanelFoundation rootClassName={`panel-padding pt-0`}>\r\n        {featuredArray.map((featured, i) => (\r\n          <div\r\n            className={`col-lg-6 offset-lg-0 col-md-10 offset-md-1 col-sm-12`}\r\n            onClick={() => featuredCardClickHandler(featured.url)}\r\n          >\r\n            <div\r\n              className={`card card-body ${s.insightCard}`}\r\n              style={{\r\n                backgroundImage: `url(${featured.cover_image.childImageSharp.fluid.src})`\r\n              }}\r\n            >\r\n              <div\r\n                className={`${s.insightCaption} p-5`}\r\n                style={{\r\n                  backgroundColor: \"rgba(0, 0, 0, 0.732)\",\r\n                  // background:\r\n                  //   \"linear-gradient(23deg, rgba(89, 18, 16, 0.9) 0%, rgba(220, 74, 70, 0.9) 100%)\",\r\n                  top: 0,\r\n                  left: 0,\r\n                  right: 0,\r\n                  bottom: 0,\r\n                  width: \"auto\",\r\n                  borderRadius: \"10px 10px 0 0\"\r\n                }}\r\n              >\r\n                <div\r\n                  className={`${s.insightType}`}\r\n                  style={{ right: \"10px\", left: \"auto\" }}\r\n                >\r\n                  {featured.type}\r\n                </div>\r\n                <h4 className={`text-white`} style={{ paddingTop: \"75px\" }}>\r\n                  {featured.heading}\r\n                </h4>\r\n                <Link\r\n                  to={addTrailingSlash(featured.url)}\r\n                  className={`text-white`}\r\n                  style={\r\n                    {\r\n                      // position: \"absolute\",\r\n                      // bottom: \"25px\",\r\n                      // left: \"10px\"\r\n                    }\r\n                  }\r\n                >\r\n                  Read More\r\n                </Link>\r\n              </div>\r\n            </div>\r\n          </div>\r\n        ))}\r\n      </PanelFoundation> */}\r\n\r\n      {/* <ComponentHeader\r\n        // style={{ marginTop: \"1rem\" }}\r\n        lineTop={false}\r\n        rootClassName={`${s.header} pt-0`}\r\n        textClassName={`text-primary`}\r\n        text=\"Testimonials\"\r\n      /> */}\r\n      {/* <PanelFoundation rootClassName={`panel-padding pt-1 mb-4`}>\r\n        <Col\r\n          lg={6}\r\n          sm={12}\r\n        >\r\n        <div className={`col-lg-8 offset-lg-2 col-sm-8 offset-sm-2`}>\r\n          <div className={`${s.cardStack}`} />\r\n          <div className={`${s.cardStack}`} />\r\n          <div className={`${s.cardStack}`} />\r\n          <div className={`${s.cardStack}`} />\r\n          <div className={`${s.cardStack}`} />\r\n          <Testimonies rootClassName={`${s.cardStackTop}`} />\r\n        </div>\r\n        </Col>\r\n      </PanelFoundation> */}\r\n      <ComponentHeader\r\n        // style={{ marginTop: \"1rem\" }}\r\n        lineTop={false}\r\n        rootClassName={`bg-white ${s.header}`}\r\n        textClassName={`text-primary`}\r\n        text=\"Partners\"\r\n      />\r\n      <Partners />\r\n      {/* <ModalVideo\r\n        channel={\"vimeo\"}\r\n        ratio=\"16:9\"\r\n        autoplay={1}\r\n        allowFullScreen={true}\r\n        videoId={`526327463`}\r\n        // url={`http://vimeo.com/manage/videos/526327463`}\r\n        isOpen={isVideoModelOpen}\r\n        onClose={() => setIsVideoModelOpen(false)}\r\n      /> */}\r\n      {/* <div\r\n        className={`${layoutStyle.containerFluid} ${layoutStyle.panelPadding} ${indexStyles.noBottomPaddingOnMobile}`}\r\n      >\r\n        <div className={layoutStyle.container}>\r\n          <div\r\n            className={`${layoutStyle.row} ${indexStyles.spaceAboveHook}`}\r\n            style={{ marginBottom: \"4rem\" }}\r\n          >\r\n            <div className={`${layoutStyle.colLg6} ${layoutStyle.colMd12}`}>\r\n              <img\r\n                src={computerGif}\r\n                style={{\r\n                  width: \"100%\"\r\n                }}\r\n              />\r\n            </div>\r\n            <div className={`${layoutStyle.colLg6} ${layoutStyle.colMd12}`}>\r\n              <div className={indexStyles.salePoint}>\r\n                <h1>{main_heading}</h1>\r\n                <p className={`${layoutStyle.textJustify}`}>\r\n                  {main_subheading}\r\n                </p>\r\n\r\n                <Link\r\n                  className={`${layoutStyle.btn} ${layoutStyle.btnPrimary} ${layoutStyle.btnLg}`}\r\n                  to={main_conversion_link_url}\r\n                >\r\n                  {main_conversion_link_text}\r\n                </Link>\r\n              </div>\r\n            </div>\r\n          </div>\r\n        </div>\r\n      </div> */}\r\n      {/* <ComponentHeader\r\n        style={{ marginTop: \"1rem\" }}\r\n        bgColor=\"white\"\r\n        textColor=\"purple\"\r\n        text=\"What We Deliver\"\r\n        className={`${indexStyles.header}`}\r\n      />\r\n      <TabToAccordion data={we_deliver}/>\r\n      <ComponentHeader\r\n        style={{ marginTop: \"1rem\" }}\r\n        bgColor=\"white\"\r\n        textColor=\"purple\"\r\n        text=\"Featured Services\"\r\n        className={`${indexStyles.header}`}\r\n      />\r\n      <div\r\n        className={`${layoutStyle.containerFluid} ${layoutStyle.panelPadding}`}\r\n      >\r\n        <div className={layoutStyle.container}>\r\n          <div className={layoutStyle.row}>\r\n            <div className={`${layoutStyle.colLg4} ${layoutStyle.colMd4}`}>\r\n              <ServicesAI bgClassName={`${indexStyles.card}`} />\r\n            </div>\r\n            <div className={`${layoutStyle.colLg4} ${layoutStyle.colMd4}`}>\r\n              <ServicesVirtualAssistant bgClassName={`${indexStyles.card}`} />\r\n            </div>\r\n            <div className={`${layoutStyle.colLg4} ${layoutStyle.colMd4}`}>\r\n              <ServicesRPA bgClassName={`${indexStyles.card}`} />\r\n            </div>\r\n          </div>\r\n        </div>\r\n      </div>\r\n      <ComponentHeader\r\n        style={{ marginTop: \"1rem\" }}\r\n        bgColor=\"white\"\r\n        textColor=\"purple\"\r\n        text=\"Featured Insights\"\r\n        className={`${indexStyles.header}`}\r\n      />\r\n\r\n      <div\r\n        className={`${layoutStyle.containerFluid} ${layoutStyle.panelPadding}`}\r\n      >\r\n        <div className={layoutStyle.container}>\r\n          <div className={layoutStyle.row}>\r\n            {featuredArray.map((featured, i) => (\r\n              <div\r\n                className={`${layoutStyle.colLg6} ${layoutStyle.colSm12}`}\r\n                onClick={() => featuredCardClickHandler(featured.url)}\r\n              >\r\n                <div\r\n                  className={` ${layoutStyle.card} ${layoutStyle.cardBody} ${indexStyles.insightCard}`}\r\n                  style={{\r\n                    backgroundImage: `url(${featured.cover_image.childImageSharp.fluid.src})`\r\n                  }}\r\n                >\r\n                  <div className={`${indexStyles.insightType}`}>\r\n                    {featured.type}\r\n                  </div>\r\n                  <div className={`${indexStyles.insightCaption}`}>\r\n                    <h3 className={`${layoutStyle.textWhite}`}>\r\n                      {featured.heading}\r\n                    </h3>\r\n                    <Link\r\n                      to={featured.url}\r\n                      className={`${layoutStyle.textWhite}`}\r\n                    >\r\n                      Read More\r\n                    </Link>\r\n                  </div>\r\n                </div>\r\n              </div>\r\n            ))}\r\n          </div>\r\n        </div>\r\n      </div>\r\n\r\n      <ComponentHeader\r\n        style={{ marginTop: \"1rem\" }}\r\n        bgColor=\"white\"\r\n        textColor=\"purple\"\r\n        text=\"Our Partners\"\r\n        className={`${indexStyles.header}`}\r\n      />\r\n\r\n      <Partners /> */}\r\n    </>\r\n  );\r\n};\r\n\r\nexport default IndexPage;\r\n\r\nexport const pageQuery = graphql`\r\n  query {\r\n    strapiHomePage {\r\n      SEO {\r\n        description\r\n      }\r\n      main_heading\r\n      main_subheading\r\n      main_conversion_link_url\r\n      main_conversion_link_text\r\n      we_deliver {\r\n        heading\r\n        content\r\n      }\r\n    }\r\n\r\n    allStrapiPostBlog(filter: { featured: { eq: true } }) {\r\n      edges {\r\n        node {\r\n          heading\r\n          slug\r\n          cover_image: blog_cover_image {\r\n            childImageSharp {\r\n              fluid {\r\n                src\r\n              }\r\n            }\r\n          }\r\n        }\r\n      }\r\n    }\r\n    allStrapiPostCase(filter: { featured: { eq: true } }) {\r\n      edges {\r\n        node {\r\n          heading\r\n          slug\r\n          cover_image: case_image {\r\n            childImageSharp {\r\n              fluid {\r\n                src\r\n              }\r\n            }\r\n          }\r\n        }\r\n      }\r\n    }\r\n    allStrapiPostNews(filter: { featured: { eq: true } }) {\r\n      edges {\r\n        node {\r\n          heading\r\n          slug\r\n          cover_image: media_image {\r\n            childImageSharp {\r\n              fluid {\r\n                src\r\n              }\r\n            }\r\n          }\r\n        }\r\n      }\r\n    }\r\n    allStrapiPostWebinar(filter: { featured: { eq: true } }) {\r\n      edges {\r\n        node {\r\n          heading\r\n          slug\r\n          cover_image: webinar_image {\r\n            childImageSharp {\r\n              fluid {\r\n                src\r\n              }\r\n            }\r\n          }\r\n        }\r\n      }\r\n    }\r\n    allStrapiPostWhitePapers(filter: { featured: { eq: true } }) {\r\n      edges {\r\n        node {\r\n          heading\r\n          slug\r\n          cover_image: white_papers_media_image {\r\n            childImageSharp {\r\n              fluid {\r\n                src\r\n              }\r\n            }\r\n          }\r\n        }\r\n      }\r\n    }\r\n  }\r\n`;\r\n","function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {\n  try {\n    var info = gen[key](arg);\n    var value = info.value;\n  } catch (error) {\n    reject(error);\n    return;\n  }\n\n  if (info.done) {\n    resolve(value);\n  } else {\n    Promise.resolve(value).then(_next, _throw);\n  }\n}\n\nexport default function _asyncToGenerator(fn) {\n  return function () {\n    var self = this,\n        args = arguments;\n    return new Promise(function (resolve, reject) {\n      var gen = fn.apply(self, args);\n\n      function _next(value) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"next\", value);\n      }\n\n      function _throw(err) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"throw\", err);\n      }\n\n      _next(undefined);\n    });\n  };\n}","import * as Globals from './globals';\nexport { Globals };\nexport * from './types.util';\nexport * from './hooks';\nexport * from './helpers';\nexport * from './FrameLoop';\nexport * from './createInterpolator';\nexport * from 'fluids';","'use strict';\n\nrequire(\"core-js/modules/es6.function.name\");\n\nrequire(\"core-js/modules/es7.object.get-own-property-descriptors\");\n\nrequire(\"core-js/modules/web.dom.iterable\");\n\nrequire(\"core-js/modules/es6.array.iterator\");\n\nrequire(\"core-js/modules/es6.object.to-string\");\n\nrequire(\"core-js/modules/es6.object.keys\");\n\nrequire(\"core-js/modules/es6.object.assign\");\n\nrequire(\"core-js/modules/es7.symbol.async-iterator\");\n\nrequire(\"core-js/modules/es6.symbol\");\n\nObject.defineProperty(exports, '__esModule', {\n  value: true\n});\n\nfunction _interopDefault(ex) {\n  return ex && typeof ex === 'object' && 'default' in ex ? ex['default'] : ex;\n}\n\nvar React = require('react');\n\nvar React__default = _interopDefault(React);\n\nvar UAParser = require('ua-parser-js/dist/ua-parser.min');\n\nvar UA = new UAParser();\nvar browser = UA.getBrowser();\nvar cpu = UA.getCPU();\nvar device = UA.getDevice();\nvar engine = UA.getEngine();\nvar os = UA.getOS();\nvar ua = UA.getUA();\n\nvar setDefaults = function setDefaults(p) {\n  var d = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'none';\n  return p ? p : d;\n};\n\nvar getNavigatorInstance = function getNavigatorInstance() {\n  if (typeof window !== 'undefined') {\n    if (window.navigator || navigator) {\n      return window.navigator || navigator;\n    }\n  }\n\n  return false;\n};\n\nvar isIOS13Check = function isIOS13Check(type) {\n  var nav = getNavigatorInstance();\n  return nav && nav.platform && (nav.platform.indexOf(type) !== -1 || nav.platform === 'MacIntel' && nav.maxTouchPoints > 1 && !window.MSStream);\n};\n\nfunction _typeof(obj) {\n  if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n    _typeof = function _typeof(obj) {\n      return typeof obj;\n    };\n  } else {\n    _typeof = function _typeof(obj) {\n      return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n    };\n  }\n\n  return _typeof(obj);\n}\n\nfunction _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}\n\nfunction _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\nfunction _createClass(Constructor, protoProps, staticProps) {\n  if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n  if (staticProps) _defineProperties(Constructor, staticProps);\n  return Constructor;\n}\n\nfunction _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}\n\nfunction _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}\n\nfunction ownKeys(object, enumerableOnly) {\n  var keys = Object.keys(object);\n\n  if (Object.getOwnPropertySymbols) {\n    var symbols = Object.getOwnPropertySymbols(object);\n    if (enumerableOnly) symbols = symbols.filter(function (sym) {\n      return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n    });\n    keys.push.apply(keys, symbols);\n  }\n\n  return keys;\n}\n\nfunction _objectSpread2(target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i] != null ? arguments[i] : {};\n\n    if (i % 2) {\n      ownKeys(source, true).forEach(function (key) {\n        _defineProperty(target, key, source[key]);\n      });\n    } else if (Object.getOwnPropertyDescriptors) {\n      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));\n    } else {\n      ownKeys(source).forEach(function (key) {\n        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));\n      });\n    }\n  }\n\n  return target;\n}\n\nfunction _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}\n\nfunction _getPrototypeOf(o) {\n  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {\n    return o.__proto__ || Object.getPrototypeOf(o);\n  };\n  return _getPrototypeOf(o);\n}\n\nfunction _setPrototypeOf(o, p) {\n  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {\n    o.__proto__ = p;\n    return o;\n  };\n\n  return _setPrototypeOf(o, p);\n}\n\nfunction _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}\n\nfunction _possibleConstructorReturn(self, call) {\n  if (call && (typeof call === \"object\" || typeof call === \"function\")) {\n    return call;\n  }\n\n  return _assertThisInitialized(self);\n}\n\nvar DEVICE_TYPES = {\n  MOBILE: 'mobile',\n  TABLET: 'tablet',\n  SMART_TV: 'smarttv',\n  CONSOLE: 'console',\n  WEARABLE: 'wearable',\n  BROWSER: undefined\n};\nvar BROWSER_TYPES = {\n  CHROME: 'Chrome',\n  FIREFOX: \"Firefox\",\n  OPERA: \"Opera\",\n  YANDEX: \"Yandex\",\n  SAFARI: \"Safari\",\n  INTERNET_EXPLORER: \"Internet Explorer\",\n  EDGE: \"Edge\",\n  CHROMIUM: \"Chromium\",\n  IE: 'IE',\n  MOBILE_SAFARI: \"Mobile Safari\",\n  EDGE_CHROMIUM: \"Edge Chromium\"\n};\nvar OS_TYPES = {\n  IOS: 'iOS',\n  ANDROID: \"Android\",\n  WINDOWS_PHONE: \"Windows Phone\",\n  WINDOWS: 'Windows',\n  MAC_OS: 'Mac OS'\n};\nvar initialData = {\n  isMobile: false,\n  isTablet: false,\n  isBrowser: false,\n  isSmartTV: false,\n  isConsole: false,\n  isWearable: false\n};\n\nvar checkType = function checkType(type) {\n  switch (type) {\n    case DEVICE_TYPES.MOBILE:\n      return {\n        isMobile: true\n      };\n\n    case DEVICE_TYPES.TABLET:\n      return {\n        isTablet: true\n      };\n\n    case DEVICE_TYPES.SMART_TV:\n      return {\n        isSmartTV: true\n      };\n\n    case DEVICE_TYPES.CONSOLE:\n      return {\n        isConsole: true\n      };\n\n    case DEVICE_TYPES.WEARABLE:\n      return {\n        isWearable: true\n      };\n\n    case DEVICE_TYPES.BROWSER:\n      return {\n        isBrowser: true\n      };\n\n    default:\n      return initialData;\n  }\n};\n\nvar broPayload = function broPayload(isBrowser, browser, engine, os, ua) {\n  return {\n    isBrowser: isBrowser,\n    browserMajorVersion: setDefaults(browser.major),\n    browserFullVersion: setDefaults(browser.version),\n    browserName: setDefaults(browser.name),\n    engineName: setDefaults(engine.name),\n    engineVersion: setDefaults(engine.version),\n    osName: setDefaults(os.name),\n    osVersion: setDefaults(os.version),\n    userAgent: setDefaults(ua)\n  };\n};\n\nvar mobilePayload = function mobilePayload(type, device, os, ua) {\n  return _objectSpread2({}, type, {\n    vendor: setDefaults(device.vendor),\n    model: setDefaults(device.model),\n    os: setDefaults(os.name),\n    osVersion: setDefaults(os.version),\n    ua: setDefaults(ua)\n  });\n};\n\nvar stvPayload = function stvPayload(isSmartTV, engine, os, ua) {\n  return {\n    isSmartTV: isSmartTV,\n    engineName: setDefaults(engine.name),\n    engineVersion: setDefaults(engine.version),\n    osName: setDefaults(os.name),\n    osVersion: setDefaults(os.version),\n    userAgent: setDefaults(ua)\n  };\n};\n\nvar consolePayload = function consolePayload(isConsole, engine, os, ua) {\n  return {\n    isConsole: isConsole,\n    engineName: setDefaults(engine.name),\n    engineVersion: setDefaults(engine.version),\n    osName: setDefaults(os.name),\n    osVersion: setDefaults(os.version),\n    userAgent: setDefaults(ua)\n  };\n};\n\nvar wearPayload = function wearPayload(isWearable, engine, os, ua) {\n  return {\n    isWearable: isWearable,\n    engineName: setDefaults(engine.name),\n    engineVersion: setDefaults(engine.version),\n    osName: setDefaults(os.name),\n    osVersion: setDefaults(os.version),\n    userAgent: setDefaults(ua)\n  };\n};\n\nvar type = checkType(device.type);\n\nfunction deviceDetect() {\n  var isBrowser = type.isBrowser,\n      isMobile = type.isMobile,\n      isTablet = type.isTablet,\n      isSmartTV = type.isSmartTV,\n      isConsole = type.isConsole,\n      isWearable = type.isWearable;\n\n  if (isBrowser) {\n    return broPayload(isBrowser, browser, engine, os, ua);\n  }\n\n  if (isSmartTV) {\n    return stvPayload(isSmartTV, engine, os, ua);\n  }\n\n  if (isConsole) {\n    return consolePayload(isConsole, engine, os, ua);\n  }\n\n  if (isMobile) {\n    return mobilePayload(type, device, os, ua);\n  }\n\n  if (isTablet) {\n    return mobilePayload(type, device, os, ua);\n  }\n\n  if (isWearable) {\n    return wearPayload(isWearable, engine, os, ua);\n  }\n}\n\nvar isMobileType = function isMobileType() {\n  return device.type === DEVICE_TYPES.MOBILE;\n};\n\nvar isTabletType = function isTabletType() {\n  return device.type === DEVICE_TYPES.TABLET;\n};\n\nvar isMobileAndTabletType = function isMobileAndTabletType() {\n  switch (device.type) {\n    case DEVICE_TYPES.MOBILE:\n    case DEVICE_TYPES.TABLET:\n      return true;\n\n    default:\n      return false;\n  }\n};\n\nvar isEdgeChromiumType = function isEdgeChromiumType() {\n  if (os.name === OS_TYPES.WINDOWS && os.version === '10') {\n    return typeof ua === 'string' && ua.indexOf('Edg/') !== -1;\n  }\n\n  return false;\n};\n\nvar isSmartTVType = function isSmartTVType() {\n  return device.type === DEVICE_TYPES.SMART_TV;\n};\n\nvar isBrowserType = function isBrowserType() {\n  return device.type === DEVICE_TYPES.BROWSER;\n};\n\nvar isWearableType = function isWearableType() {\n  return device.type === DEVICE_TYPES.WEARABLE;\n};\n\nvar isConsoleType = function isConsoleType() {\n  return device.type === DEVICE_TYPES.CONSOLE;\n};\n\nvar isAndroidType = function isAndroidType() {\n  return os.name === OS_TYPES.ANDROID;\n};\n\nvar isWindowsType = function isWindowsType() {\n  return os.name === OS_TYPES.WINDOWS;\n};\n\nvar isMacOsType = function isMacOsType() {\n  return os.name === OS_TYPES.MAC_OS;\n};\n\nvar isWinPhoneType = function isWinPhoneType() {\n  return os.name === OS_TYPES.WINDOWS_PHONE;\n};\n\nvar isIOSType = function isIOSType() {\n  return os.name === OS_TYPES.IOS;\n};\n\nvar isChromeType = function isChromeType() {\n  return browser.name === BROWSER_TYPES.CHROME;\n};\n\nvar isFirefoxType = function isFirefoxType() {\n  return browser.name === BROWSER_TYPES.FIREFOX;\n};\n\nvar isChromiumType = function isChromiumType() {\n  return browser.name === BROWSER_TYPES.CHROMIUM;\n};\n\nvar isEdgeType = function isEdgeType() {\n  return browser.name === BROWSER_TYPES.EDGE;\n};\n\nvar isYandexType = function isYandexType() {\n  return browser.name === BROWSER_TYPES.YANDEX;\n};\n\nvar isSafariType = function isSafariType() {\n  return browser.name === BROWSER_TYPES.SAFARI || browser.name === BROWSER_TYPES.MOBILE_SAFARI;\n};\n\nvar isMobileSafariType = function isMobileSafariType() {\n  return browser.name === BROWSER_TYPES.MOBILE_SAFARI;\n};\n\nvar isOperaType = function isOperaType() {\n  return browser.name === BROWSER_TYPES.OPERA;\n};\n\nvar isIEType = function isIEType() {\n  return browser.name === BROWSER_TYPES.INTERNET_EXPLORER || browser.name === BROWSER_TYPES.IE;\n};\n\nvar isElectronType = function isElectronType() {\n  var nav = getNavigatorInstance();\n  var ua = nav && nav.userAgent.toLowerCase();\n  return typeof ua === 'string' ? /electron/.test(ua) : false;\n};\n\nvar getIOS13 = function getIOS13() {\n  var nav = getNavigatorInstance();\n  return nav && (/iPad|iPhone|iPod/.test(nav.platform) || nav.platform === 'MacIntel' && nav.maxTouchPoints > 1) && !window.MSStream;\n};\n\nvar getIPad13 = function getIPad13() {\n  return isIOS13Check('iPad');\n};\n\nvar getIphone13 = function getIphone13() {\n  return isIOS13Check('iPhone');\n};\n\nvar getIPod13 = function getIPod13() {\n  return isIOS13Check('iPod');\n};\n\nvar getBrowserFullVersion = function getBrowserFullVersion() {\n  return setDefaults(browser.version);\n};\n\nvar getBrowserVersion = function getBrowserVersion() {\n  return setDefaults(browser.major);\n};\n\nvar getOsVersion = function getOsVersion() {\n  return setDefaults(os.version);\n};\n\nvar getOsName = function getOsName() {\n  return setDefaults(os.name);\n};\n\nvar getBrowserName = function getBrowserName() {\n  return setDefaults(browser.name);\n};\n\nvar getMobileVendor = function getMobileVendor() {\n  return setDefaults(device.vendor);\n};\n\nvar getMobileModel = function getMobileModel() {\n  return setDefaults(device.model);\n};\n\nvar getEngineName = function getEngineName() {\n  return setDefaults(engine.name);\n};\n\nvar getEngineVersion = function getEngineVersion() {\n  return setDefaults(engine.version);\n};\n\nvar getUseragent = function getUseragent() {\n  return setDefaults(ua);\n};\n\nvar getDeviceType = function getDeviceType() {\n  return setDefaults(device.type, 'browser');\n};\n\nvar isSmartTV = isSmartTVType();\nvar isConsole = isConsoleType();\nvar isWearable = isWearableType();\nvar isMobileSafari = isMobileSafariType() || getIPad13();\nvar isChromium = isChromiumType();\nvar isMobile = isMobileAndTabletType() || getIPad13();\nvar isMobileOnly = isMobileType();\nvar isTablet = isTabletType() || getIPad13();\nvar isBrowser = isBrowserType();\nvar isAndroid = isAndroidType();\nvar isWinPhone = isWinPhoneType();\nvar isIOS = isIOSType() || getIPad13();\nvar isChrome = isChromeType();\nvar isFirefox = isFirefoxType();\nvar isSafari = isSafariType();\nvar isOpera = isOperaType();\nvar isIE = isIEType();\nvar osVersion = getOsVersion();\nvar osName = getOsName();\nvar fullBrowserVersion = getBrowserFullVersion();\nvar browserVersion = getBrowserVersion();\nvar browserName = getBrowserName();\nvar mobileVendor = getMobileVendor();\nvar mobileModel = getMobileModel();\nvar engineName = getEngineName();\nvar engineVersion = getEngineVersion();\nvar getUA = getUseragent();\nvar isEdge = isEdgeType() || isEdgeChromiumType();\nvar isYandex = isYandexType();\nvar deviceType = getDeviceType();\nvar isIOS13 = getIOS13();\nvar isIPad13 = getIPad13();\nvar isIPhone13 = getIphone13();\nvar isIPod13 = getIPod13();\nvar isElectron = isElectronType();\nvar isEdgeChromium = isEdgeChromiumType();\nvar isLegacyEdge = isEdgeType();\nvar isWindows = isWindowsType();\nvar isMacOs = isMacOsType();\n\nvar AndroidView = function AndroidView(_ref) {\n  var renderWithFragment = _ref.renderWithFragment,\n      children = _ref.children,\n      viewClassName = _ref.viewClassName,\n      style = _ref.style;\n  return isAndroid ? renderWithFragment ? React__default.createElement(React.Fragment, null, children) : React__default.createElement(\"div\", {\n    className: viewClassName,\n    style: style\n  }, children) : null;\n};\n\nvar BrowserView = function BrowserView(_ref2) {\n  var renderWithFragment = _ref2.renderWithFragment,\n      children = _ref2.children,\n      viewClassName = _ref2.viewClassName,\n      style = _ref2.style;\n  return isBrowser ? renderWithFragment ? React__default.createElement(React.Fragment, null, children) : React__default.createElement(\"div\", {\n    className: viewClassName,\n    style: style\n  }, children) : null;\n};\n\nvar IEView = function IEView(_ref3) {\n  var renderWithFragment = _ref3.renderWithFragment,\n      children = _ref3.children,\n      viewClassName = _ref3.viewClassName,\n      style = _ref3.style;\n  return isIE ? renderWithFragment ? React__default.createElement(React.Fragment, null, children) : React__default.createElement(\"div\", {\n    className: viewClassName,\n    style: style\n  }, children) : null;\n};\n\nvar IOSView = function IOSView(_ref4) {\n  var renderWithFragment = _ref4.renderWithFragment,\n      children = _ref4.children,\n      viewClassName = _ref4.viewClassName,\n      style = _ref4.style;\n  return isIOS ? renderWithFragment ? React__default.createElement(React.Fragment, null, children) : React__default.createElement(\"div\", {\n    className: viewClassName,\n    style: style\n  }, children) : null;\n};\n\nvar MobileView = function MobileView(_ref5) {\n  var renderWithFragment = _ref5.renderWithFragment,\n      children = _ref5.children,\n      viewClassName = _ref5.viewClassName,\n      style = _ref5.style;\n  return isMobile ? renderWithFragment ? React__default.createElement(React.Fragment, null, children) : React__default.createElement(\"div\", {\n    className: viewClassName,\n    style: style\n  }, children) : null;\n};\n\nvar TabletView = function TabletView(_ref6) {\n  var renderWithFragment = _ref6.renderWithFragment,\n      children = _ref6.children,\n      viewClassName = _ref6.viewClassName,\n      style = _ref6.style;\n  return isTablet ? renderWithFragment ? React__default.createElement(React.Fragment, null, children) : React__default.createElement(\"div\", {\n    className: viewClassName,\n    style: style\n  }, children) : null;\n};\n\nvar WinPhoneView = function WinPhoneView(_ref7) {\n  var renderWithFragment = _ref7.renderWithFragment,\n      children = _ref7.children,\n      viewClassName = _ref7.viewClassName,\n      style = _ref7.style;\n  return isWinPhone ? renderWithFragment ? React__default.createElement(React.Fragment, null, children) : React__default.createElement(\"div\", {\n    className: viewClassName,\n    style: style\n  }, children) : null;\n};\n\nvar MobileOnlyView = function MobileOnlyView(_ref8) {\n  var renderWithFragment = _ref8.renderWithFragment,\n      children = _ref8.children,\n      viewClassName = _ref8.viewClassName,\n      style = _ref8.style;\n  return isMobileOnly ? renderWithFragment ? React__default.createElement(React.Fragment, null, children) : React__default.createElement(\"div\", {\n    className: viewClassName,\n    style: style\n  }, children) : null;\n};\n\nvar SmartTVView = function SmartTVView(_ref9) {\n  var renderWithFragment = _ref9.renderWithFragment,\n      children = _ref9.children,\n      viewClassName = _ref9.viewClassName,\n      style = _ref9.style;\n  return isSmartTV ? renderWithFragment ? React__default.createElement(React.Fragment, null, children) : React__default.createElement(\"div\", {\n    className: viewClassName,\n    style: style\n  }, children) : null;\n};\n\nvar ConsoleView = function ConsoleView(_ref10) {\n  var renderWithFragment = _ref10.renderWithFragment,\n      children = _ref10.children,\n      viewClassName = _ref10.viewClassName,\n      style = _ref10.style;\n  return isConsole ? renderWithFragment ? React__default.createElement(React.Fragment, null, children) : React__default.createElement(\"div\", {\n    className: viewClassName,\n    style: style\n  }, children) : null;\n};\n\nvar WearableView = function WearableView(_ref11) {\n  var renderWithFragment = _ref11.renderWithFragment,\n      children = _ref11.children,\n      viewClassName = _ref11.viewClassName,\n      style = _ref11.style;\n  return isWearable ? renderWithFragment ? React__default.createElement(React.Fragment, null, children) : React__default.createElement(\"div\", {\n    className: viewClassName,\n    style: style\n  }, children) : null;\n};\n\nvar CustomView = function CustomView(_ref12) {\n  var renderWithFragment = _ref12.renderWithFragment,\n      children = _ref12.children,\n      viewClassName = _ref12.viewClassName,\n      style = _ref12.style,\n      condition = _ref12.condition;\n  return condition ? renderWithFragment ? React__default.createElement(React.Fragment, null, children) : React__default.createElement(\"div\", {\n    className: viewClassName,\n    style: style\n  }, children) : null;\n};\n\nfunction withOrientationChange(WrappedComponent) {\n  return /*#__PURE__*/function (_React$Component) {\n    _inherits(_class, _React$Component);\n\n    function _class(props) {\n      var _this;\n\n      _classCallCheck(this, _class);\n\n      _this = _possibleConstructorReturn(this, _getPrototypeOf(_class).call(this, props));\n      _this.isEventListenerAdded = false;\n      _this.handleOrientationChange = _this.handleOrientationChange.bind(_assertThisInitialized(_this));\n      _this.onOrientationChange = _this.onOrientationChange.bind(_assertThisInitialized(_this));\n      _this.onPageLoad = _this.onPageLoad.bind(_assertThisInitialized(_this));\n      _this.state = {\n        isLandscape: false,\n        isPortrait: false\n      };\n      return _this;\n    }\n\n    _createClass(_class, [{\n      key: \"handleOrientationChange\",\n      value: function handleOrientationChange() {\n        if (!this.isEventListenerAdded) {\n          this.isEventListenerAdded = true;\n        }\n\n        var orientation = window.innerWidth > window.innerHeight ? 90 : 0;\n        this.setState({\n          isPortrait: orientation === 0,\n          isLandscape: orientation === 90\n        });\n      }\n    }, {\n      key: \"onOrientationChange\",\n      value: function onOrientationChange() {\n        this.handleOrientationChange();\n      }\n    }, {\n      key: \"onPageLoad\",\n      value: function onPageLoad() {\n        this.handleOrientationChange();\n      }\n    }, {\n      key: \"componentDidMount\",\n      value: function componentDidMount() {\n        if ((typeof window === \"undefined\" ? \"undefined\" : _typeof(window)) !== undefined && isMobile) {\n          if (!this.isEventListenerAdded) {\n            this.handleOrientationChange();\n            window.addEventListener(\"load\", this.onPageLoad, false);\n          } else {\n            window.removeEventListener(\"load\", this.onPageLoad, false);\n          }\n\n          window.addEventListener(\"resize\", this.onOrientationChange, false);\n        }\n      }\n    }, {\n      key: \"componentWillUnmount\",\n      value: function componentWillUnmount() {\n        window.removeEventListener(\"resize\", this.onOrientationChange, false);\n      }\n    }, {\n      key: \"render\",\n      value: function render() {\n        return React__default.createElement(WrappedComponent, _extends({}, this.props, {\n          isLandscape: this.state.isLandscape,\n          isPortrait: this.state.isPortrait\n        }));\n      }\n    }]);\n\n    return _class;\n  }(React__default.Component);\n}\n\nexports.AndroidView = AndroidView;\nexports.BrowserView = BrowserView;\nexports.ConsoleView = ConsoleView;\nexports.CustomView = CustomView;\nexports.IEView = IEView;\nexports.IOSView = IOSView;\nexports.MobileOnlyView = MobileOnlyView;\nexports.MobileView = MobileView;\nexports.SmartTVView = SmartTVView;\nexports.TabletView = TabletView;\nexports.WearableView = WearableView;\nexports.WinPhoneView = WinPhoneView;\nexports.browserName = browserName;\nexports.browserVersion = browserVersion;\nexports.deviceDetect = deviceDetect;\nexports.deviceType = deviceType;\nexports.engineName = engineName;\nexports.engineVersion = engineVersion;\nexports.fullBrowserVersion = fullBrowserVersion;\nexports.getUA = getUA;\nexports.isAndroid = isAndroid;\nexports.isBrowser = isBrowser;\nexports.isChrome = isChrome;\nexports.isChromium = isChromium;\nexports.isConsole = isConsole;\nexports.isEdge = isEdge;\nexports.isEdgeChromium = isEdgeChromium;\nexports.isElectron = isElectron;\nexports.isFirefox = isFirefox;\nexports.isIE = isIE;\nexports.isIOS = isIOS;\nexports.isIOS13 = isIOS13;\nexports.isIPad13 = isIPad13;\nexports.isIPhone13 = isIPhone13;\nexports.isIPod13 = isIPod13;\nexports.isLegacyEdge = isLegacyEdge;\nexports.isMacOs = isMacOs;\nexports.isMobile = isMobile;\nexports.isMobileOnly = isMobileOnly;\nexports.isMobileSafari = isMobileSafari;\nexports.isOpera = isOpera;\nexports.isSafari = isSafari;\nexports.isSmartTV = isSmartTV;\nexports.isTablet = isTablet;\nexports.isWearable = isWearable;\nexports.isWinPhone = isWinPhone;\nexports.isWindows = isWindows;\nexports.isYandex = isYandex;\nexports.mobileModel = mobileModel;\nexports.mobileVendor = mobileVendor;\nexports.osName = osName;\nexports.osVersion = osVersion;\nexports.withOrientationChange = withOrientationChange;","var prefix = 'react-spring: ';\nvar flagInterpolate = false;\nexport function deprecateInterpolate() {\n  if (!flagInterpolate) {\n    flagInterpolate = true;\n    console.warn(prefix + 'The \"interpolate\" function is deprecated in v10 (use \"to\" instead)');\n  }\n}","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 \"core-js/modules/es6.weak-map\";\nimport \"core-js/modules/es6.object.keys\";\nimport \"core-js/modules/web.dom.iterable\";\nimport \"core-js/modules/es6.array.iterator\";\nimport \"core-js/modules/es6.object.to-string\";\nimport \"core-js/modules/es6.string.iterator\";\nimport \"core-js/modules/es6.map\";\n\n/**\r\n * A collection of shims that provide minimal functionality of the ES6 collections.\r\n *\r\n * These implementations are not meant to be used outside of the ResizeObserver\r\n * modules as they cover only a limited range of use cases.\r\n */\n\n/* eslint-disable require-jsdoc, valid-jsdoc */\nvar MapShim = function () {\n  if (typeof Map !== 'undefined') {\n    return Map;\n  }\n  /**\r\n   * Returns index in provided array that matches the specified key.\r\n   *\r\n   * @param {Array<Array>} arr\r\n   * @param {*} key\r\n   * @returns {number}\r\n   */\n\n\n  function getIndex(arr, key) {\n    var result = -1;\n    arr.some(function (entry, index) {\n      if (entry[0] === key) {\n        result = index;\n        return true;\n      }\n\n      return false;\n    });\n    return result;\n  }\n\n  return (\n    /** @class */\n    function () {\n      function class_1() {\n        this.__entries__ = [];\n      }\n\n      Object.defineProperty(class_1.prototype, \"size\", {\n        /**\r\n         * @returns {boolean}\r\n         */\n        get: function get() {\n          return this.__entries__.length;\n        },\n        enumerable: true,\n        configurable: true\n      });\n      /**\r\n       * @param {*} key\r\n       * @returns {*}\r\n       */\n\n      class_1.prototype.get = function (key) {\n        var index = getIndex(this.__entries__, key);\n        var entry = this.__entries__[index];\n        return entry && entry[1];\n      };\n      /**\r\n       * @param {*} key\r\n       * @param {*} value\r\n       * @returns {void}\r\n       */\n\n\n      class_1.prototype.set = function (key, value) {\n        var index = getIndex(this.__entries__, key);\n\n        if (~index) {\n          this.__entries__[index][1] = value;\n        } else {\n          this.__entries__.push([key, value]);\n        }\n      };\n      /**\r\n       * @param {*} key\r\n       * @returns {void}\r\n       */\n\n\n      class_1.prototype.delete = function (key) {\n        var entries = this.__entries__;\n        var index = getIndex(entries, key);\n\n        if (~index) {\n          entries.splice(index, 1);\n        }\n      };\n      /**\r\n       * @param {*} key\r\n       * @returns {void}\r\n       */\n\n\n      class_1.prototype.has = function (key) {\n        return !!~getIndex(this.__entries__, key);\n      };\n      /**\r\n       * @returns {void}\r\n       */\n\n\n      class_1.prototype.clear = function () {\n        this.__entries__.splice(0);\n      };\n      /**\r\n       * @param {Function} callback\r\n       * @param {*} [ctx=null]\r\n       * @returns {void}\r\n       */\n\n\n      class_1.prototype.forEach = function (callback, ctx) {\n        if (ctx === void 0) {\n          ctx = null;\n        }\n\n        for (var _i = 0, _a = this.__entries__; _i < _a.length; _i++) {\n          var entry = _a[_i];\n          callback.call(ctx, entry[1], entry[0]);\n        }\n      };\n\n      return class_1;\n    }()\n  );\n}();\n/**\r\n * Detects whether window and document objects are available in current environment.\r\n */\n\n\nvar isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined' && window.document === document; // Returns global object of a current environment.\n\nvar global$1 = function () {\n  if (typeof global !== 'undefined' && global.Math === Math) {\n    return global;\n  }\n\n  if (typeof self !== 'undefined' && self.Math === Math) {\n    return self;\n  }\n\n  if (typeof window !== 'undefined' && window.Math === Math) {\n    return window;\n  } // eslint-disable-next-line no-new-func\n\n\n  return Function('return this')();\n}();\n/**\r\n * A shim for the requestAnimationFrame which falls back to the setTimeout if\r\n * first one is not supported.\r\n *\r\n * @returns {number} Requests' identifier.\r\n */\n\n\nvar requestAnimationFrame$1 = function () {\n  if (typeof requestAnimationFrame === 'function') {\n    // It's required to use a bounded function because IE sometimes throws\n    // an \"Invalid calling object\" error if rAF is invoked without the global\n    // object on the left hand side.\n    return requestAnimationFrame.bind(global$1);\n  }\n\n  return function (callback) {\n    return setTimeout(function () {\n      return callback(Date.now());\n    }, 1000 / 60);\n  };\n}(); // Defines minimum timeout before adding a trailing call.\n\n\nvar trailingTimeout = 2;\n/**\r\n * Creates a wrapper function which ensures that provided callback will be\r\n * invoked only once during the specified delay period.\r\n *\r\n * @param {Function} callback - Function to be invoked after the delay period.\r\n * @param {number} delay - Delay after which to invoke callback.\r\n * @returns {Function}\r\n */\n\nfunction throttle(callback, delay) {\n  var leadingCall = false,\n      trailingCall = false,\n      lastCallTime = 0;\n  /**\r\n   * Invokes the original callback function and schedules new invocation if\r\n   * the \"proxy\" was called during current request.\r\n   *\r\n   * @returns {void}\r\n   */\n\n  function resolvePending() {\n    if (leadingCall) {\n      leadingCall = false;\n      callback();\n    }\n\n    if (trailingCall) {\n      proxy();\n    }\n  }\n  /**\r\n   * Callback invoked after the specified delay. It will further postpone\r\n   * invocation of the original function delegating it to the\r\n   * requestAnimationFrame.\r\n   *\r\n   * @returns {void}\r\n   */\n\n\n  function timeoutCallback() {\n    requestAnimationFrame$1(resolvePending);\n  }\n  /**\r\n   * Schedules invocation of the original function.\r\n   *\r\n   * @returns {void}\r\n   */\n\n\n  function proxy() {\n    var timeStamp = Date.now();\n\n    if (leadingCall) {\n      // Reject immediately following calls.\n      if (timeStamp - lastCallTime < trailingTimeout) {\n        return;\n      } // Schedule new call to be in invoked when the pending one is resolved.\n      // This is important for \"transitions\" which never actually start\n      // immediately so there is a chance that we might miss one if change\n      // happens amids the pending invocation.\n\n\n      trailingCall = true;\n    } else {\n      leadingCall = true;\n      trailingCall = false;\n      setTimeout(timeoutCallback, delay);\n    }\n\n    lastCallTime = timeStamp;\n  }\n\n  return proxy;\n} // Minimum delay before invoking the update of observers.\n\n\nvar REFRESH_DELAY = 20; // A list of substrings of CSS properties used to find transition events that\n// might affect dimensions of observed elements.\n\nvar transitionKeys = ['top', 'right', 'bottom', 'left', 'width', 'height', 'size', 'weight']; // Check if MutationObserver is available.\n\nvar mutationObserverSupported = typeof MutationObserver !== 'undefined';\n/**\r\n * Singleton controller class which handles updates of ResizeObserver instances.\r\n */\n\nvar ResizeObserverController =\n/** @class */\nfunction () {\n  /**\r\n   * Creates a new instance of ResizeObserverController.\r\n   *\r\n   * @private\r\n   */\n  function ResizeObserverController() {\n    /**\r\n     * Indicates whether DOM listeners have been added.\r\n     *\r\n     * @private {boolean}\r\n     */\n    this.connected_ = false;\n    /**\r\n     * Tells that controller has subscribed for Mutation Events.\r\n     *\r\n     * @private {boolean}\r\n     */\n\n    this.mutationEventsAdded_ = false;\n    /**\r\n     * Keeps reference to the instance of MutationObserver.\r\n     *\r\n     * @private {MutationObserver}\r\n     */\n\n    this.mutationsObserver_ = null;\n    /**\r\n     * A list of connected observers.\r\n     *\r\n     * @private {Array<ResizeObserverSPI>}\r\n     */\n\n    this.observers_ = [];\n    this.onTransitionEnd_ = this.onTransitionEnd_.bind(this);\n    this.refresh = throttle(this.refresh.bind(this), REFRESH_DELAY);\n  }\n  /**\r\n   * Adds observer to observers list.\r\n   *\r\n   * @param {ResizeObserverSPI} observer - Observer to be added.\r\n   * @returns {void}\r\n   */\n\n\n  ResizeObserverController.prototype.addObserver = function (observer) {\n    if (!~this.observers_.indexOf(observer)) {\n      this.observers_.push(observer);\n    } // Add listeners if they haven't been added yet.\n\n\n    if (!this.connected_) {\n      this.connect_();\n    }\n  };\n  /**\r\n   * Removes observer from observers list.\r\n   *\r\n   * @param {ResizeObserverSPI} observer - Observer to be removed.\r\n   * @returns {void}\r\n   */\n\n\n  ResizeObserverController.prototype.removeObserver = function (observer) {\n    var observers = this.observers_;\n    var index = observers.indexOf(observer); // Remove observer if it's present in registry.\n\n    if (~index) {\n      observers.splice(index, 1);\n    } // Remove listeners if controller has no connected observers.\n\n\n    if (!observers.length && this.connected_) {\n      this.disconnect_();\n    }\n  };\n  /**\r\n   * Invokes the update of observers. It will continue running updates insofar\r\n   * it detects changes.\r\n   *\r\n   * @returns {void}\r\n   */\n\n\n  ResizeObserverController.prototype.refresh = function () {\n    var changesDetected = this.updateObservers_(); // Continue running updates if changes have been detected as there might\n    // be future ones caused by CSS transitions.\n\n    if (changesDetected) {\n      this.refresh();\n    }\n  };\n  /**\r\n   * Updates every observer from observers list and notifies them of queued\r\n   * entries.\r\n   *\r\n   * @private\r\n   * @returns {boolean} Returns \"true\" if any observer has detected changes in\r\n   *      dimensions of it's elements.\r\n   */\n\n\n  ResizeObserverController.prototype.updateObservers_ = function () {\n    // Collect observers that have active observations.\n    var activeObservers = this.observers_.filter(function (observer) {\n      return observer.gatherActive(), observer.hasActive();\n    }); // Deliver notifications in a separate cycle in order to avoid any\n    // collisions between observers, e.g. when multiple instances of\n    // ResizeObserver are tracking the same element and the callback of one\n    // of them changes content dimensions of the observed target. Sometimes\n    // this may result in notifications being blocked for the rest of observers.\n\n    activeObservers.forEach(function (observer) {\n      return observer.broadcastActive();\n    });\n    return activeObservers.length > 0;\n  };\n  /**\r\n   * Initializes DOM listeners.\r\n   *\r\n   * @private\r\n   * @returns {void}\r\n   */\n\n\n  ResizeObserverController.prototype.connect_ = function () {\n    // Do nothing if running in a non-browser environment or if listeners\n    // have been already added.\n    if (!isBrowser || this.connected_) {\n      return;\n    } // Subscription to the \"Transitionend\" event is used as a workaround for\n    // delayed transitions. This way it's possible to capture at least the\n    // final state of an element.\n\n\n    document.addEventListener('transitionend', this.onTransitionEnd_);\n    window.addEventListener('resize', this.refresh);\n\n    if (mutationObserverSupported) {\n      this.mutationsObserver_ = new MutationObserver(this.refresh);\n      this.mutationsObserver_.observe(document, {\n        attributes: true,\n        childList: true,\n        characterData: true,\n        subtree: true\n      });\n    } else {\n      document.addEventListener('DOMSubtreeModified', this.refresh);\n      this.mutationEventsAdded_ = true;\n    }\n\n    this.connected_ = true;\n  };\n  /**\r\n   * Removes DOM listeners.\r\n   *\r\n   * @private\r\n   * @returns {void}\r\n   */\n\n\n  ResizeObserverController.prototype.disconnect_ = function () {\n    // Do nothing if running in a non-browser environment or if listeners\n    // have been already removed.\n    if (!isBrowser || !this.connected_) {\n      return;\n    }\n\n    document.removeEventListener('transitionend', this.onTransitionEnd_);\n    window.removeEventListener('resize', this.refresh);\n\n    if (this.mutationsObserver_) {\n      this.mutationsObserver_.disconnect();\n    }\n\n    if (this.mutationEventsAdded_) {\n      document.removeEventListener('DOMSubtreeModified', this.refresh);\n    }\n\n    this.mutationsObserver_ = null;\n    this.mutationEventsAdded_ = false;\n    this.connected_ = false;\n  };\n  /**\r\n   * \"Transitionend\" event handler.\r\n   *\r\n   * @private\r\n   * @param {TransitionEvent} event\r\n   * @returns {void}\r\n   */\n\n\n  ResizeObserverController.prototype.onTransitionEnd_ = function (_a) {\n    var _b = _a.propertyName,\n        propertyName = _b === void 0 ? '' : _b; // Detect whether transition may affect dimensions of an element.\n\n    var isReflowProperty = transitionKeys.some(function (key) {\n      return !!~propertyName.indexOf(key);\n    });\n\n    if (isReflowProperty) {\n      this.refresh();\n    }\n  };\n  /**\r\n   * Returns instance of the ResizeObserverController.\r\n   *\r\n   * @returns {ResizeObserverController}\r\n   */\n\n\n  ResizeObserverController.getInstance = function () {\n    if (!this.instance_) {\n      this.instance_ = new ResizeObserverController();\n    }\n\n    return this.instance_;\n  };\n  /**\r\n   * Holds reference to the controller's instance.\r\n   *\r\n   * @private {ResizeObserverController}\r\n   */\n\n\n  ResizeObserverController.instance_ = null;\n  return ResizeObserverController;\n}();\n/**\r\n * Defines non-writable/enumerable properties of the provided target object.\r\n *\r\n * @param {Object} target - Object for which to define properties.\r\n * @param {Object} props - Properties to be defined.\r\n * @returns {Object} Target object.\r\n */\n\n\nvar defineConfigurable = function defineConfigurable(target, props) {\n  for (var _i = 0, _a = Object.keys(props); _i < _a.length; _i++) {\n    var key = _a[_i];\n    Object.defineProperty(target, key, {\n      value: props[key],\n      enumerable: false,\n      writable: false,\n      configurable: true\n    });\n  }\n\n  return target;\n};\n/**\r\n * Returns the global object associated with provided element.\r\n *\r\n * @param {Object} target\r\n * @returns {Object}\r\n */\n\n\nvar getWindowOf = function getWindowOf(target) {\n  // Assume that the element is an instance of Node, which means that it\n  // has the \"ownerDocument\" property from which we can retrieve a\n  // corresponding global object.\n  var ownerGlobal = target && target.ownerDocument && target.ownerDocument.defaultView; // Return the local global object if it's not possible extract one from\n  // provided element.\n\n  return ownerGlobal || global$1;\n}; // Placeholder of an empty content rectangle.\n\n\nvar emptyRect = createRectInit(0, 0, 0, 0);\n/**\r\n * Converts provided string to a number.\r\n *\r\n * @param {number|string} value\r\n * @returns {number}\r\n */\n\nfunction toFloat(value) {\n  return parseFloat(value) || 0;\n}\n/**\r\n * Extracts borders size from provided styles.\r\n *\r\n * @param {CSSStyleDeclaration} styles\r\n * @param {...string} positions - Borders positions (top, right, ...)\r\n * @returns {number}\r\n */\n\n\nfunction getBordersSize(styles) {\n  var positions = [];\n\n  for (var _i = 1; _i < arguments.length; _i++) {\n    positions[_i - 1] = arguments[_i];\n  }\n\n  return positions.reduce(function (size, position) {\n    var value = styles['border-' + position + '-width'];\n    return size + toFloat(value);\n  }, 0);\n}\n/**\r\n * Extracts paddings sizes from provided styles.\r\n *\r\n * @param {CSSStyleDeclaration} styles\r\n * @returns {Object} Paddings box.\r\n */\n\n\nfunction getPaddings(styles) {\n  var positions = ['top', 'right', 'bottom', 'left'];\n  var paddings = {};\n\n  for (var _i = 0, positions_1 = positions; _i < positions_1.length; _i++) {\n    var position = positions_1[_i];\n    var value = styles['padding-' + position];\n    paddings[position] = toFloat(value);\n  }\n\n  return paddings;\n}\n/**\r\n * Calculates content rectangle of provided SVG element.\r\n *\r\n * @param {SVGGraphicsElement} target - Element content rectangle of which needs\r\n *      to be calculated.\r\n * @returns {DOMRectInit}\r\n */\n\n\nfunction getSVGContentRect(target) {\n  var bbox = target.getBBox();\n  return createRectInit(0, 0, bbox.width, bbox.height);\n}\n/**\r\n * Calculates content rectangle of provided HTMLElement.\r\n *\r\n * @param {HTMLElement} target - Element for which to calculate the content rectangle.\r\n * @returns {DOMRectInit}\r\n */\n\n\nfunction getHTMLElementContentRect(target) {\n  // Client width & height properties can't be\n  // used exclusively as they provide rounded values.\n  var clientWidth = target.clientWidth,\n      clientHeight = target.clientHeight; // By this condition we can catch all non-replaced inline, hidden and\n  // detached elements. Though elements with width & height properties less\n  // than 0.5 will be discarded as well.\n  //\n  // Without it we would need to implement separate methods for each of\n  // those cases and it's not possible to perform a precise and performance\n  // effective test for hidden elements. E.g. even jQuery's ':visible' filter\n  // gives wrong results for elements with width & height less than 0.5.\n\n  if (!clientWidth && !clientHeight) {\n    return emptyRect;\n  }\n\n  var styles = getWindowOf(target).getComputedStyle(target);\n  var paddings = getPaddings(styles);\n  var horizPad = paddings.left + paddings.right;\n  var vertPad = paddings.top + paddings.bottom; // Computed styles of width & height are being used because they are the\n  // only dimensions available to JS that contain non-rounded values. It could\n  // be possible to utilize the getBoundingClientRect if only it's data wasn't\n  // affected by CSS transformations let alone paddings, borders and scroll bars.\n\n  var width = toFloat(styles.width),\n      height = toFloat(styles.height); // Width & height include paddings and borders when the 'border-box' box\n  // model is applied (except for IE).\n\n  if (styles.boxSizing === 'border-box') {\n    // Following conditions are required to handle Internet Explorer which\n    // doesn't include paddings and borders to computed CSS dimensions.\n    //\n    // We can say that if CSS dimensions + paddings are equal to the \"client\"\n    // properties then it's either IE, and thus we don't need to subtract\n    // anything, or an element merely doesn't have paddings/borders styles.\n    if (Math.round(width + horizPad) !== clientWidth) {\n      width -= getBordersSize(styles, 'left', 'right') + horizPad;\n    }\n\n    if (Math.round(height + vertPad) !== clientHeight) {\n      height -= getBordersSize(styles, 'top', 'bottom') + vertPad;\n    }\n  } // Following steps can't be applied to the document's root element as its\n  // client[Width/Height] properties represent viewport area of the window.\n  // Besides, it's as well not necessary as the <html> itself neither has\n  // rendered scroll bars nor it can be clipped.\n\n\n  if (!isDocumentElement(target)) {\n    // In some browsers (only in Firefox, actually) CSS width & height\n    // include scroll bars size which can be removed at this step as scroll\n    // bars are the only difference between rounded dimensions + paddings\n    // and \"client\" properties, though that is not always true in Chrome.\n    var vertScrollbar = Math.round(width + horizPad) - clientWidth;\n    var horizScrollbar = Math.round(height + vertPad) - clientHeight; // Chrome has a rather weird rounding of \"client\" properties.\n    // E.g. for an element with content width of 314.2px it sometimes gives\n    // the client width of 315px and for the width of 314.7px it may give\n    // 314px. And it doesn't happen all the time. So just ignore this delta\n    // as a non-relevant.\n\n    if (Math.abs(vertScrollbar) !== 1) {\n      width -= vertScrollbar;\n    }\n\n    if (Math.abs(horizScrollbar) !== 1) {\n      height -= horizScrollbar;\n    }\n  }\n\n  return createRectInit(paddings.left, paddings.top, width, height);\n}\n/**\r\n * Checks whether provided element is an instance of the SVGGraphicsElement.\r\n *\r\n * @param {Element} target - Element to be checked.\r\n * @returns {boolean}\r\n */\n\n\nvar isSVGGraphicsElement = function () {\n  // Some browsers, namely IE and Edge, don't have the SVGGraphicsElement\n  // interface.\n  if (typeof SVGGraphicsElement !== 'undefined') {\n    return function (target) {\n      return target instanceof getWindowOf(target).SVGGraphicsElement;\n    };\n  } // If it's so, then check that element is at least an instance of the\n  // SVGElement and that it has the \"getBBox\" method.\n  // eslint-disable-next-line no-extra-parens\n\n\n  return function (target) {\n    return target instanceof getWindowOf(target).SVGElement && typeof target.getBBox === 'function';\n  };\n}();\n/**\r\n * Checks whether provided element is a document element (<html>).\r\n *\r\n * @param {Element} target - Element to be checked.\r\n * @returns {boolean}\r\n */\n\n\nfunction isDocumentElement(target) {\n  return target === getWindowOf(target).document.documentElement;\n}\n/**\r\n * Calculates an appropriate content rectangle for provided html or svg element.\r\n *\r\n * @param {Element} target - Element content rectangle of which needs to be calculated.\r\n * @returns {DOMRectInit}\r\n */\n\n\nfunction getContentRect(target) {\n  if (!isBrowser) {\n    return emptyRect;\n  }\n\n  if (isSVGGraphicsElement(target)) {\n    return getSVGContentRect(target);\n  }\n\n  return getHTMLElementContentRect(target);\n}\n/**\r\n * Creates rectangle with an interface of the DOMRectReadOnly.\r\n * Spec: https://drafts.fxtf.org/geometry/#domrectreadonly\r\n *\r\n * @param {DOMRectInit} rectInit - Object with rectangle's x/y coordinates and dimensions.\r\n * @returns {DOMRectReadOnly}\r\n */\n\n\nfunction createReadOnlyRect(_a) {\n  var x = _a.x,\n      y = _a.y,\n      width = _a.width,\n      height = _a.height; // If DOMRectReadOnly is available use it as a prototype for the rectangle.\n\n  var Constr = typeof DOMRectReadOnly !== 'undefined' ? DOMRectReadOnly : Object;\n  var rect = Object.create(Constr.prototype); // Rectangle's properties are not writable and non-enumerable.\n\n  defineConfigurable(rect, {\n    x: x,\n    y: y,\n    width: width,\n    height: height,\n    top: y,\n    right: x + width,\n    bottom: height + y,\n    left: x\n  });\n  return rect;\n}\n/**\r\n * Creates DOMRectInit object based on the provided dimensions and the x/y coordinates.\r\n * Spec: https://drafts.fxtf.org/geometry/#dictdef-domrectinit\r\n *\r\n * @param {number} x - X coordinate.\r\n * @param {number} y - Y coordinate.\r\n * @param {number} width - Rectangle's width.\r\n * @param {number} height - Rectangle's height.\r\n * @returns {DOMRectInit}\r\n */\n\n\nfunction createRectInit(x, y, width, height) {\n  return {\n    x: x,\n    y: y,\n    width: width,\n    height: height\n  };\n}\n/**\r\n * Class that is responsible for computations of the content rectangle of\r\n * provided DOM element and for keeping track of it's changes.\r\n */\n\n\nvar ResizeObservation =\n/** @class */\nfunction () {\n  /**\r\n   * Creates an instance of ResizeObservation.\r\n   *\r\n   * @param {Element} target - Element to be observed.\r\n   */\n  function ResizeObservation(target) {\n    /**\r\n     * Broadcasted width of content rectangle.\r\n     *\r\n     * @type {number}\r\n     */\n    this.broadcastWidth = 0;\n    /**\r\n     * Broadcasted height of content rectangle.\r\n     *\r\n     * @type {number}\r\n     */\n\n    this.broadcastHeight = 0;\n    /**\r\n     * Reference to the last observed content rectangle.\r\n     *\r\n     * @private {DOMRectInit}\r\n     */\n\n    this.contentRect_ = createRectInit(0, 0, 0, 0);\n    this.target = target;\n  }\n  /**\r\n   * Updates content rectangle and tells whether it's width or height properties\r\n   * have changed since the last broadcast.\r\n   *\r\n   * @returns {boolean}\r\n   */\n\n\n  ResizeObservation.prototype.isActive = function () {\n    var rect = getContentRect(this.target);\n    this.contentRect_ = rect;\n    return rect.width !== this.broadcastWidth || rect.height !== this.broadcastHeight;\n  };\n  /**\r\n   * Updates 'broadcastWidth' and 'broadcastHeight' properties with a data\r\n   * from the corresponding properties of the last observed content rectangle.\r\n   *\r\n   * @returns {DOMRectInit} Last observed content rectangle.\r\n   */\n\n\n  ResizeObservation.prototype.broadcastRect = function () {\n    var rect = this.contentRect_;\n    this.broadcastWidth = rect.width;\n    this.broadcastHeight = rect.height;\n    return rect;\n  };\n\n  return ResizeObservation;\n}();\n\nvar ResizeObserverEntry =\n/** @class */\nfunction () {\n  /**\r\n   * Creates an instance of ResizeObserverEntry.\r\n   *\r\n   * @param {Element} target - Element that is being observed.\r\n   * @param {DOMRectInit} rectInit - Data of the element's content rectangle.\r\n   */\n  function ResizeObserverEntry(target, rectInit) {\n    var contentRect = createReadOnlyRect(rectInit); // According to the specification following properties are not writable\n    // and are also not enumerable in the native implementation.\n    //\n    // Property accessors are not being used as they'd require to define a\n    // private WeakMap storage which may cause memory leaks in browsers that\n    // don't support this type of collections.\n\n    defineConfigurable(this, {\n      target: target,\n      contentRect: contentRect\n    });\n  }\n\n  return ResizeObserverEntry;\n}();\n\nvar ResizeObserverSPI =\n/** @class */\nfunction () {\n  /**\r\n   * Creates a new instance of ResizeObserver.\r\n   *\r\n   * @param {ResizeObserverCallback} callback - Callback function that is invoked\r\n   *      when one of the observed elements changes it's content dimensions.\r\n   * @param {ResizeObserverController} controller - Controller instance which\r\n   *      is responsible for the updates of observer.\r\n   * @param {ResizeObserver} callbackCtx - Reference to the public\r\n   *      ResizeObserver instance which will be passed to callback function.\r\n   */\n  function ResizeObserverSPI(callback, controller, callbackCtx) {\n    /**\r\n     * Collection of resize observations that have detected changes in dimensions\r\n     * of elements.\r\n     *\r\n     * @private {Array<ResizeObservation>}\r\n     */\n    this.activeObservations_ = [];\n    /**\r\n     * Registry of the ResizeObservation instances.\r\n     *\r\n     * @private {Map<Element, ResizeObservation>}\r\n     */\n\n    this.observations_ = new MapShim();\n\n    if (typeof callback !== 'function') {\n      throw new TypeError('The callback provided as parameter 1 is not a function.');\n    }\n\n    this.callback_ = callback;\n    this.controller_ = controller;\n    this.callbackCtx_ = callbackCtx;\n  }\n  /**\r\n   * Starts observing provided element.\r\n   *\r\n   * @param {Element} target - Element to be observed.\r\n   * @returns {void}\r\n   */\n\n\n  ResizeObserverSPI.prototype.observe = function (target) {\n    if (!arguments.length) {\n      throw new TypeError('1 argument required, but only 0 present.');\n    } // Do nothing if current environment doesn't have the Element interface.\n\n\n    if (typeof Element === 'undefined' || !(Element instanceof Object)) {\n      return;\n    }\n\n    if (!(target instanceof getWindowOf(target).Element)) {\n      throw new TypeError('parameter 1 is not of type \"Element\".');\n    }\n\n    var observations = this.observations_; // Do nothing if element is already being observed.\n\n    if (observations.has(target)) {\n      return;\n    }\n\n    observations.set(target, new ResizeObservation(target));\n    this.controller_.addObserver(this); // Force the update of observations.\n\n    this.controller_.refresh();\n  };\n  /**\r\n   * Stops observing provided element.\r\n   *\r\n   * @param {Element} target - Element to stop observing.\r\n   * @returns {void}\r\n   */\n\n\n  ResizeObserverSPI.prototype.unobserve = function (target) {\n    if (!arguments.length) {\n      throw new TypeError('1 argument required, but only 0 present.');\n    } // Do nothing if current environment doesn't have the Element interface.\n\n\n    if (typeof Element === 'undefined' || !(Element instanceof Object)) {\n      return;\n    }\n\n    if (!(target instanceof getWindowOf(target).Element)) {\n      throw new TypeError('parameter 1 is not of type \"Element\".');\n    }\n\n    var observations = this.observations_; // Do nothing if element is not being observed.\n\n    if (!observations.has(target)) {\n      return;\n    }\n\n    observations.delete(target);\n\n    if (!observations.size) {\n      this.controller_.removeObserver(this);\n    }\n  };\n  /**\r\n   * Stops observing all elements.\r\n   *\r\n   * @returns {void}\r\n   */\n\n\n  ResizeObserverSPI.prototype.disconnect = function () {\n    this.clearActive();\n    this.observations_.clear();\n    this.controller_.removeObserver(this);\n  };\n  /**\r\n   * Collects observation instances the associated element of which has changed\r\n   * it's content rectangle.\r\n   *\r\n   * @returns {void}\r\n   */\n\n\n  ResizeObserverSPI.prototype.gatherActive = function () {\n    var _this = this;\n\n    this.clearActive();\n    this.observations_.forEach(function (observation) {\n      if (observation.isActive()) {\n        _this.activeObservations_.push(observation);\n      }\n    });\n  };\n  /**\r\n   * Invokes initial callback function with a list of ResizeObserverEntry\r\n   * instances collected from active resize observations.\r\n   *\r\n   * @returns {void}\r\n   */\n\n\n  ResizeObserverSPI.prototype.broadcastActive = function () {\n    // Do nothing if observer doesn't have active observations.\n    if (!this.hasActive()) {\n      return;\n    }\n\n    var ctx = this.callbackCtx_; // Create ResizeObserverEntry instance for every active observation.\n\n    var entries = this.activeObservations_.map(function (observation) {\n      return new ResizeObserverEntry(observation.target, observation.broadcastRect());\n    });\n    this.callback_.call(ctx, entries, ctx);\n    this.clearActive();\n  };\n  /**\r\n   * Clears the collection of active observations.\r\n   *\r\n   * @returns {void}\r\n   */\n\n\n  ResizeObserverSPI.prototype.clearActive = function () {\n    this.activeObservations_.splice(0);\n  };\n  /**\r\n   * Tells whether observer has active observations.\r\n   *\r\n   * @returns {boolean}\r\n   */\n\n\n  ResizeObserverSPI.prototype.hasActive = function () {\n    return this.activeObservations_.length > 0;\n  };\n\n  return ResizeObserverSPI;\n}(); // Registry of internal observers. If WeakMap is not available use current shim\n// for the Map collection as it has all required methods and because WeakMap\n// can't be fully polyfilled anyway.\n\n\nvar observers = typeof WeakMap !== 'undefined' ? new WeakMap() : new MapShim();\n/**\r\n * ResizeObserver API. Encapsulates the ResizeObserver SPI implementation\r\n * exposing only those methods and properties that are defined in the spec.\r\n */\n\nvar ResizeObserver =\n/** @class */\nfunction () {\n  /**\r\n   * Creates a new instance of ResizeObserver.\r\n   *\r\n   * @param {ResizeObserverCallback} callback - Callback that is invoked when\r\n   *      dimensions of the observed elements change.\r\n   */\n  function ResizeObserver(callback) {\n    if (!(this instanceof ResizeObserver)) {\n      throw new TypeError('Cannot call a class as a function.');\n    }\n\n    if (!arguments.length) {\n      throw new TypeError('1 argument required, but only 0 present.');\n    }\n\n    var controller = ResizeObserverController.getInstance();\n    var observer = new ResizeObserverSPI(callback, controller, this);\n    observers.set(this, observer);\n  }\n\n  return ResizeObserver;\n}(); // Expose public methods of ResizeObserver.\n\n\n['observe', 'unobserve', 'disconnect'].forEach(function (method) {\n  ResizeObserver.prototype[method] = function () {\n    var _a;\n\n    return (_a = observers.get(this))[method].apply(_a, arguments);\n  };\n});\n\nvar index = function () {\n  // Export existing implementation if available.\n  if (typeof global$1.ResizeObserver !== 'undefined') {\n    return global$1.ResizeObserver;\n  }\n\n  return ResizeObserver;\n}();\n\nexport default index;","import { useEffect, useRef, useState } from 'react';\nexport var useOnce = function useOnce(effect) {\n  return useEffect(effect, []);\n};\n/** Return a function that re-renders this component, if still mounted */\n\nexport var useForceUpdate = function useForceUpdate() {\n  var update = useState(0)[1];\n  var unmounted = useRef(false);\n  useOnce(function () {\n    return function () {\n      unmounted.current = true;\n    };\n  });\n  return function () {\n    if (!unmounted.current) {\n      update({});\n    }\n  };\n};\n/** Use a value from the previous render */\n\nexport function usePrev(value) {\n  var prevRef = useRef(undefined);\n  useEffect(function () {\n    prevRef.current = value;\n  });\n  return prevRef.current;\n}","import setPrototypeOf from \"./setPrototypeOf\";\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 \"core-js/modules/es6.array.find-index\";\nimport \"core-js/modules/web.dom.iterable\";\nimport \"core-js/modules/es6.array.iterator\";\nimport \"core-js/modules/es6.object.to-string\";\nimport \"core-js/modules/es6.string.iterator\";\nimport \"core-js/modules/es6.set\";\nimport * as G from './globals'; // The global `requestAnimationFrame` must be dereferenced to avoid \"Illegal invocation\" errors\n\nvar requestAnimationFrame = function requestAnimationFrame(fn) {\n  return (void 0, G.requestAnimationFrame)(fn);\n};\n/**\n * FrameLoop executes its animations in order of lowest priority first.\n * Animations are retained until idle.\n */\n\n\nvar FrameLoop =\n/** @class */\nfunction () {\n  function FrameLoop(raf) {\n    if (raf === void 0) {\n      raf = requestAnimationFrame;\n    }\n\n    var idle = true;\n    var writing = false; // The most recent framestamp\n\n    var lastTime = 0; // The active animations for the current frame, sorted by lowest priority first\n\n    var animations = []; // The priority of the currently advancing animation.\n    // To protect against a race condition whenever a frame is being processed,\n    // where the filtering of `animations` is corrupted with a shifting index,\n    // causing animations to potentially advance 2x faster than intended.\n\n    var priority = 0; // Animations starting on the next frame\n\n    var startQueue = new Set(); // Flushed after all animations are updated.\n    // Used to dispatch events to an \"onFrame\" prop, for example.\n\n    var frameQueue = new Set(); // Flushed at the very end of each frame.\n    // Used to avoid layout thrashing in @react-spring/web, for example.\n\n    var writeQueue = new Set(); // Add an animation to the frameloop\n\n    var start = function start(animation) {\n      var index = animations.indexOf(animation);\n\n      if (index < 0) {\n        index = animations.findIndex(function (other) {\n          return other.priority > animation.priority;\n        });\n        animations.splice(~index ? index : animations.length, 0, animation);\n      }\n    };\n\n    var loop = function loop() {\n      if (idle) return;\n\n      try {\n        advance();\n        raf(loop);\n      } catch (e) {\n        console.error(e);\n      }\n    }; // Start the frameloop\n\n\n    var kickoff = function kickoff() {\n      if (idle) {\n        idle = false; // To minimize frame skips, the frameloop never stops.\n\n        if (lastTime == 0) {\n          lastTime = G.now();\n          raf(loop);\n        }\n      }\n    };\n\n    var timeoutQueue = [];\n\n    this.setTimeout = function (handler, ms) {\n      var time = G.now() + ms;\n\n      var cancel = function cancel() {\n        var index = timeoutQueue.findIndex(function (t) {\n          return t.cancel == cancel;\n        });\n\n        if (index >= 0) {\n          timeoutQueue.splice(index, 1);\n        }\n      };\n\n      var index = findIndex(timeoutQueue, function (t) {\n        return t.time > time;\n      });\n      var timeout = {\n        time: time,\n        handler: handler,\n        cancel: cancel\n      };\n      timeoutQueue.splice(index, 0, timeout);\n      kickoff();\n      return timeout;\n    }; // Process the current frame.\n\n\n    var advance = this.advance = function () {\n      var time = G.now(); // Start animations that were added during last frame.\n\n      if (startQueue.size) {\n        startQueue.forEach(start);\n        startQueue.clear();\n      } // Flush the timeout queue.\n\n\n      if (timeoutQueue.length) {\n        G.batchedUpdates(function () {\n          var count = findIndex(timeoutQueue, function (t) {\n            return t.time > time;\n          });\n          timeoutQueue.splice(0, count).forEach(function (t) {\n            return t.handler();\n          });\n        });\n      }\n\n      if (time > lastTime) {\n        // http://gafferongames.com/game-physics/fix-your-timestep/\n        var dt_1 = Math.min(64, time - lastTime);\n        lastTime = time;\n        G.batchedUpdates(function () {\n          // Animations can be added while the frameloop is updating,\n          // but they need a higher priority to be started on this frame.\n          if (animations.length) {\n            G.willAdvance(animations);\n            animations = animations.filter(function (animation) {\n              priority = animation.priority; // Animations may go idle before the next frame.\n\n              if (!animation.idle) {\n                animation.advance(dt_1);\n              } // Remove idle animations.\n\n\n              return !animation.idle;\n            });\n            priority = 0;\n          }\n\n          if (frameQueue.size) {\n            frameQueue.forEach(function (onFrame) {\n              return onFrame(time);\n            });\n            frameQueue.clear();\n          }\n\n          if (writeQueue.size) {\n            writing = true;\n            writeQueue.forEach(function (write) {\n              return write(time);\n            });\n            writeQueue.clear();\n            writing = false;\n          }\n        });\n      }\n    };\n\n    this.start = function (animation) {\n      if (priority > animation.priority) {\n        startQueue.add(animation);\n      } else {\n        start(animation);\n        kickoff();\n      }\n    };\n\n    this.onFrame = function (cb) {\n      frameQueue.add(cb);\n      kickoff();\n    };\n\n    this.onWrite = function (cb) {\n      if (writing) cb(lastTime);else writeQueue.add(cb);\n    }; // Expose internals for testing.\n\n\n    if (typeof process !== 'undefined' && process.env.NODE_ENV !== 'production') {\n      var dispose_1 = function dispose_1() {\n        idle = true;\n        startQueue.clear();\n        timeoutQueue.length = 0;\n      };\n\n      Object.defineProperties(this, {\n        _animations: {\n          get: function get() {\n            return animations;\n          }\n        },\n        _dispose: {\n          get: function get() {\n            return dispose_1;\n          }\n        }\n      });\n    }\n  }\n\n  return FrameLoop;\n}();\n\nexport { FrameLoop };\n/** Like `Array.prototype.findIndex` but returns `arr.length` instead of `-1` */\n\nfunction findIndex(arr, test) {\n  var index = arr.findIndex(test);\n  return index < 0 ? arr.length : index;\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}","// http://www.w3.org/TR/css3-color/#svg-color\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};\nexport default colors;","// https://github.com/tc39/proposal-object-getownpropertydescriptors\nvar $export = require('./_export');\nvar ownKeys = require('./_own-keys');\nvar toIObject = require('./_to-iobject');\nvar gOPD = require('./_object-gopd');\nvar createProperty = require('./_create-property');\n\n$export($export.S, 'Object', {\n  getOwnPropertyDescriptors: function getOwnPropertyDescriptors(object) {\n    var O = toIObject(object);\n    var getDesc = gOPD.f;\n    var keys = ownKeys(O);\n    var result = {};\n    var i = 0;\n    var key, desc;\n    while (keys.length > i) {\n      desc = getDesc(O, key = keys[i++]);\n      if (desc !== undefined) createProperty(result, key, desc);\n    }\n    return result;\n  }\n});\n","module.exports = __webpack_public_path__ + \"static/play-button-2138735_640-3b62c6ca4fbf30726f22fd05d6e6fde3.png\";","import \"core-js/modules/web.dom.iterable\";\nimport \"core-js/modules/es7.symbol.async-iterator\";\nimport \"core-js/modules/es6.promise\";\nimport \"core-js/modules/es6.object.to-string\";\nimport \"core-js/modules/es6.symbol\";\nimport \"core-js/modules/es6.object.assign\";\n\n/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\n\n/* global Reflect, Promise */\nvar _extendStatics = function extendStatics(d, b) {\n  _extendStatics = Object.setPrototypeOf || {\n    __proto__: []\n  } instanceof Array && function (d, b) {\n    d.__proto__ = b;\n  } || function (d, b) {\n    for (var p in b) {\n      if (b.hasOwnProperty(p)) d[p] = b[p];\n    }\n  };\n\n  return _extendStatics(d, b);\n};\n\nexport function __extends(d, b) {\n  _extendStatics(d, b);\n\n  function __() {\n    this.constructor = d;\n  }\n\n  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n}\n\nvar _assign = function __assign() {\n  _assign = Object.assign || function __assign(t) {\n    for (var s, i = 1, n = arguments.length; i < n; i++) {\n      s = arguments[i];\n\n      for (var p in s) {\n        if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\n      }\n    }\n\n    return t;\n  };\n\n  return _assign.apply(this, arguments);\n};\n\nexport { _assign as __assign };\nexport function __rest(s, e) {\n  var t = {};\n\n  for (var p in s) {\n    if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];\n  }\n\n  if (s != null && typeof Object.getOwnPropertySymbols === \"function\") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];\n  }\n  return t;\n}\nexport function __decorate(decorators, target, key, desc) {\n  var c = arguments.length,\n      r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc,\n      d;\n  if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);else for (var i = decorators.length - 1; i >= 0; i--) {\n    if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n  }\n  return c > 3 && r && Object.defineProperty(target, key, r), r;\n}\nexport function __param(paramIndex, decorator) {\n  return function (target, key) {\n    decorator(target, key, paramIndex);\n  };\n}\nexport function __metadata(metadataKey, metadataValue) {\n  if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\n}\nexport function __awaiter(thisArg, _arguments, P, generator) {\n  function adopt(value) {\n    return value instanceof P ? value : new P(function (resolve) {\n      resolve(value);\n    });\n  }\n\n  return new (P || (P = Promise))(function (resolve, reject) {\n    function fulfilled(value) {\n      try {\n        step(generator.next(value));\n      } catch (e) {\n        reject(e);\n      }\n    }\n\n    function rejected(value) {\n      try {\n        step(generator[\"throw\"](value));\n      } catch (e) {\n        reject(e);\n      }\n    }\n\n    function step(result) {\n      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);\n    }\n\n    step((generator = generator.apply(thisArg, _arguments || [])).next());\n  });\n}\nexport function __generator(thisArg, body) {\n  var _ = {\n    label: 0,\n    sent: function sent() {\n      if (t[0] & 1) throw t[1];\n      return t[1];\n    },\n    trys: [],\n    ops: []\n  },\n      f,\n      y,\n      t,\n      g;\n  return g = {\n    next: verb(0),\n    \"throw\": verb(1),\n    \"return\": verb(2)\n  }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function () {\n    return this;\n  }), g;\n\n  function verb(n) {\n    return function (v) {\n      return step([n, v]);\n    };\n  }\n\n  function step(op) {\n    if (f) throw new TypeError(\"Generator is already executing.\");\n\n    while (_) {\n      try {\n        if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n        if (y = 0, t) op = [op[0] & 2, t.value];\n\n        switch (op[0]) {\n          case 0:\n          case 1:\n            t = op;\n            break;\n\n          case 4:\n            _.label++;\n            return {\n              value: op[1],\n              done: false\n            };\n\n          case 5:\n            _.label++;\n            y = op[1];\n            op = [0];\n            continue;\n\n          case 7:\n            op = _.ops.pop();\n\n            _.trys.pop();\n\n            continue;\n\n          default:\n            if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {\n              _ = 0;\n              continue;\n            }\n\n            if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {\n              _.label = op[1];\n              break;\n            }\n\n            if (op[0] === 6 && _.label < t[1]) {\n              _.label = t[1];\n              t = op;\n              break;\n            }\n\n            if (t && _.label < t[2]) {\n              _.label = t[2];\n\n              _.ops.push(op);\n\n              break;\n            }\n\n            if (t[2]) _.ops.pop();\n\n            _.trys.pop();\n\n            continue;\n        }\n\n        op = body.call(thisArg, _);\n      } catch (e) {\n        op = [6, e];\n        y = 0;\n      } finally {\n        f = t = 0;\n      }\n    }\n\n    if (op[0] & 5) throw op[1];\n    return {\n      value: op[0] ? op[1] : void 0,\n      done: true\n    };\n  }\n}\nexport function __createBinding(o, m, k, k2) {\n  if (k2 === undefined) k2 = k;\n  o[k2] = m[k];\n}\nexport function __exportStar(m, exports) {\n  for (var p in m) {\n    if (p !== \"default\" && !exports.hasOwnProperty(p)) exports[p] = m[p];\n  }\n}\nexport function __values(o) {\n  var s = typeof Symbol === \"function\" && Symbol.iterator,\n      m = s && o[s],\n      i = 0;\n  if (m) return m.call(o);\n  if (o && typeof o.length === \"number\") return {\n    next: function next() {\n      if (o && i >= o.length) o = void 0;\n      return {\n        value: o && o[i++],\n        done: !o\n      };\n    }\n  };\n  throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\n}\nexport function __read(o, n) {\n  var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n  if (!m) return o;\n  var i = m.call(o),\n      r,\n      ar = [],\n      e;\n\n  try {\n    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) {\n      ar.push(r.value);\n    }\n  } catch (error) {\n    e = {\n      error: error\n    };\n  } finally {\n    try {\n      if (r && !r.done && (m = i[\"return\"])) m.call(i);\n    } finally {\n      if (e) throw e.error;\n    }\n  }\n\n  return ar;\n}\nexport function __spread() {\n  for (var ar = [], i = 0; i < arguments.length; i++) {\n    ar = ar.concat(__read(arguments[i]));\n  }\n\n  return ar;\n}\nexport function __spreadArrays() {\n  for (var s = 0, i = 0, il = arguments.length; i < il; i++) {\n    s += arguments[i].length;\n  }\n\n  for (var r = Array(s), k = 0, i = 0; i < il; i++) {\n    for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) {\n      r[k] = a[j];\n    }\n  }\n\n  return r;\n}\n;\nexport function __await(v) {\n  return this instanceof __await ? (this.v = v, this) : new __await(v);\n}\nexport function __asyncGenerator(thisArg, _arguments, generator) {\n  if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\n  var g = generator.apply(thisArg, _arguments || []),\n      i,\n      q = [];\n  return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () {\n    return this;\n  }, i;\n\n  function verb(n) {\n    if (g[n]) i[n] = function (v) {\n      return new Promise(function (a, b) {\n        q.push([n, v, a, b]) > 1 || resume(n, v);\n      });\n    };\n  }\n\n  function resume(n, v) {\n    try {\n      step(g[n](v));\n    } catch (e) {\n      settle(q[0][3], e);\n    }\n  }\n\n  function step(r) {\n    r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);\n  }\n\n  function fulfill(value) {\n    resume(\"next\", value);\n  }\n\n  function reject(value) {\n    resume(\"throw\", value);\n  }\n\n  function settle(f, v) {\n    if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]);\n  }\n}\nexport function __asyncDelegator(o) {\n  var i, p;\n  return i = {}, verb(\"next\"), verb(\"throw\", function (e) {\n    throw e;\n  }), verb(\"return\"), i[Symbol.iterator] = function () {\n    return this;\n  }, i;\n\n  function verb(n, f) {\n    i[n] = o[n] ? function (v) {\n      return (p = !p) ? {\n        value: __await(o[n](v)),\n        done: n === \"return\"\n      } : f ? f(v) : v;\n    } : f;\n  }\n}\nexport function __asyncValues(o) {\n  if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\n  var m = o[Symbol.asyncIterator],\n      i;\n  return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () {\n    return this;\n  }, i);\n\n  function verb(n) {\n    i[n] = o[n] && function (v) {\n      return new Promise(function (resolve, reject) {\n        v = o[n](v), settle(resolve, reject, v.done, v.value);\n      });\n    };\n  }\n\n  function settle(resolve, reject, d, v) {\n    Promise.resolve(v).then(function (v) {\n      resolve({\n        value: v,\n        done: d\n      });\n    }, reject);\n  }\n}\nexport function __makeTemplateObject(cooked, raw) {\n  if (Object.defineProperty) {\n    Object.defineProperty(cooked, \"raw\", {\n      value: raw\n    });\n  } else {\n    cooked.raw = raw;\n  }\n\n  return cooked;\n}\n;\nexport function __importStar(mod) {\n  if (mod && mod.__esModule) return mod;\n  var result = {};\n  if (mod != null) for (var k in mod) {\n    if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\n  }\n  result.default = mod;\n  return result;\n}\nexport function __importDefault(mod) {\n  return mod && mod.__esModule ? mod : {\n    default: mod\n  };\n}\nexport function __classPrivateFieldGet(receiver, privateMap) {\n  if (!privateMap.has(receiver)) {\n    throw new TypeError(\"attempted to get private field on non-instance\");\n  }\n\n  return privateMap.get(receiver);\n}\nexport function __classPrivateFieldSet(receiver, privateMap, value) {\n  if (!privateMap.has(receiver)) {\n    throw new TypeError(\"attempted to set private field on non-instance\");\n  }\n\n  privateMap.set(receiver, value);\n  return value;\n}","import \"core-js/modules/es6.regexp.constructor\";\n// const INTEGER = '[-+]?\\\\d+';\nvar NUMBER = '[-+]?\\\\d*\\\\.?\\\\d+';\nvar PERCENTAGE = NUMBER + '%';\n\nfunction call() {\n  var parts = [];\n\n  for (var _i = 0; _i < arguments.length; _i++) {\n    parts[_i] = arguments[_i];\n  }\n\n  return '\\\\(\\\\s*(' + parts.join(')\\\\s*,\\\\s*(') + ')\\\\s*\\\\)';\n}\n\nexport var rgb = new RegExp('rgb' + call(NUMBER, NUMBER, NUMBER));\nexport var rgba = new RegExp('rgba' + call(NUMBER, NUMBER, NUMBER, NUMBER));\nexport var hsl = new RegExp('hsl' + call(NUMBER, PERCENTAGE, PERCENTAGE));\nexport var hsla = new RegExp('hsla' + call(NUMBER, PERCENTAGE, PERCENTAGE, NUMBER));\nexport var hex3 = /^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/;\nexport var hex4 = /^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/;\nexport var hex6 = /^#([0-9a-fA-F]{6})$/;\nexport var hex8 = /^#([0-9a-fA-F]{8})$/;","/*\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*/\nimport * as matchers from './colorMatchers';\nimport * as G from './globals';\nexport function 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 = matchers.hex6.exec(color)) return parseInt(match[1] + 'ff', 16) >>> 0;\n\n  if (G.colorNames && G.colorNames[color] !== undefined) {\n    return G.colorNames[color];\n  }\n\n  if (match = matchers.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 = matchers.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 = matchers.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 = matchers.hex8.exec(color)) return parseInt(match[1], 16) >>> 0;\n\n  if (match = matchers.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 = matchers.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 = matchers.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(h, c, x) {\n  if (h < 60) return [c, x, 0];\n  if (h < 120) return [x, c, 0];\n  if (h < 180) return [0, c, x];\n  if (h < 240) return [0, x, c];\n  if (h < 300) return [x, 0, c];\n  return [c, 0, x];\n}\n\nfunction hslToRgb(h, s, l) {\n  var C = (1 - Math.abs(2 * l - 1)) * s;\n  var X = C * (1 - Math.abs(h / 60 % 2 - 1));\n  var M = l - C / 2;\n\n  var _a = hue2rgb(h, C, X),\n      R1 = _a[0],\n      G1 = _a[1],\n      B1 = _a[2];\n\n  return Math.round((R1 + M) * 255) << 24 | Math.round((G1 + M) * 255) << 16 | Math.round((B1 + M) * 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}","import { normalizeColor } from './normalizeColor';\nexport function 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(\" + r + \", \" + g + \", \" + b + \", \" + a + \")\";\n}","import \"core-js/modules/es6.number.constructor\";\nimport \"core-js/modules/es6.regexp.match\";\nimport \"core-js/modules/es6.regexp.replace\";\nimport \"core-js/modules/web.dom.iterable\";\nimport \"core-js/modules/es6.array.iterator\";\nimport \"core-js/modules/es6.object.to-string\";\nimport \"core-js/modules/es6.object.keys\";\nimport \"core-js/modules/es6.regexp.constructor\";\nimport { __assign } from \"tslib\";\nimport { getFluidValue } from 'fluids';\nimport { createInterpolator } from './createInterpolator';\nimport { colorToRgba } from './colorToRgba';\nimport * as G from './globals'; // Problem: https://github.com/animatedjs/animated/pull/102\n// Solution: https://stackoverflow.com/questions/638565/parsing-scientific-notation-sensibly/658662\n\nvar numberRegex = /[+\\-]?(?: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; // rgba requires that the r,g,b are integers.... so we want to round them,\n// but we *dont* want to round the opacity (4th column).\n\nvar rgbaRegex = /rgba\\(([0-9\\.-]+), ([0-9\\.-]+), ([0-9\\.-]+), ([0-9\\.-]+)\\)/gi;\n\nvar rgbaRound = function rgbaRound(_, p1, p2, p3, p4) {\n  return \"rgba(\" + Math.round(p1) + \", \" + Math.round(p2) + \", \" + Math.round(p3) + \", \" + p4 + \")\";\n};\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)\" // CSS box-shadows\n *     \"rotate(0deg) translate(2px, 3px)\"  // CSS transforms\n */\n\n\nexport var createStringInterpolator = function createStringInterpolator(config) {\n  if (!colorNamesRegex) colorNamesRegex = G.colorNames ? new RegExp(\"(\" + Object.keys(G.colorNames).join('|') + \")\", 'g') : /^\\b$/; // never match\n  // Convert colors to rgba(...)\n\n  var output = config.output.map(function (value) {\n    return getFluidValue(value).replace(colorRegex, colorToRgba).replace(colorNamesRegex, colorToRgba);\n  }); // Convert [\"1px 2px\", \"0px 0px\"] into [[1, 2], [0, 0]]\n\n  var keyframes = output.map(function (value) {\n    return value.match(numberRegex).map(Number);\n  }); // Convert [\"1px 2px\", \"0px 0px\"] into [[1, 0], [2, 0]]\n\n  var outputRanges = keyframes[0].map(function (_, i) {\n    return keyframes.map(function (values) {\n      if (!(i in values)) {\n        throw Error('The arity of each \"output\" value must be equal');\n      }\n\n      return values[i];\n    });\n  }); // Create an interpolator for each animated number\n\n  var interpolators = outputRanges.map(function (output) {\n    return createInterpolator(__assign(__assign({}, config), {\n      output: output\n    }));\n  }); // Use the first `output` as a template for each call\n\n  return function (input) {\n    var i = 0;\n    return output[0].replace(numberRegex, function () {\n      return String(interpolators[i++](input));\n    }).replace(rgbaRegex, rgbaRound);\n  };\n};","import superPropBase from \"./superPropBase\";\nexport default function _get(target, property, receiver) {\n  if (typeof Reflect !== \"undefined\" && Reflect.get) {\n    _get = Reflect.get;\n  } else {\n    _get = function _get(target, property, receiver) {\n      var base = superPropBase(target, property);\n      if (!base) return;\n      var desc = Object.getOwnPropertyDescriptor(base, property);\n\n      if (desc.get) {\n        return desc.get.call(receiver);\n      }\n\n      return desc.value;\n    };\n  }\n\n  return _get(target, property, receiver || target);\n}","import getPrototypeOf from \"./getPrototypeOf\";\nexport default function _superPropBase(object, property) {\n  while (!Object.prototype.hasOwnProperty.call(object, property)) {\n    object = getPrototypeOf(object);\n    if (object === null) break;\n  }\n\n  return object;\n}","require(\"core-js/modules/web.dom.iterable\");\n\nrequire(\"core-js/modules/es6.array.iterator\");\n\nrequire(\"core-js/modules/es6.regexp.to-string\");\n\nrequire(\"core-js/modules/es6.promise\");\n\nrequire(\"core-js/modules/es6.object.to-string\");\n\nrequire(\"core-js/modules/es6.function.name\");\n\nrequire(\"core-js/modules/es7.symbol.async-iterator\");\n\nrequire(\"core-js/modules/es6.symbol\");\n\n/**\n * Copyright (c) 2014-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\nvar runtime = function (exports) {\n  \"use strict\";\n\n  var Op = Object.prototype;\n  var hasOwn = Op.hasOwnProperty;\n  var undefined; // More compressible than void 0.\n\n  var $Symbol = typeof Symbol === \"function\" ? Symbol : {};\n  var iteratorSymbol = $Symbol.iterator || \"@@iterator\";\n  var asyncIteratorSymbol = $Symbol.asyncIterator || \"@@asyncIterator\";\n  var toStringTagSymbol = $Symbol.toStringTag || \"@@toStringTag\";\n\n  function wrap(innerFn, outerFn, self, tryLocsList) {\n    // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.\n    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;\n    var generator = Object.create(protoGenerator.prototype);\n    var context = new Context(tryLocsList || []); // The ._invoke method unifies the implementations of the .next,\n    // .throw, and .return methods.\n\n    generator._invoke = makeInvokeMethod(innerFn, self, context);\n    return generator;\n  }\n\n  exports.wrap = wrap; // Try/catch helper to minimize deoptimizations. Returns a completion\n  // record like context.tryEntries[i].completion. This interface could\n  // have been (and was previously) designed to take a closure to be\n  // invoked without arguments, but in all the cases we care about we\n  // already have an existing method we want to call, so there's no need\n  // to create a new function object. We can even get away with assuming\n  // the method takes exactly one argument, since that happens to be true\n  // in every case, so we don't have to touch the arguments object. The\n  // only additional allocation required is the completion record, which\n  // has a stable shape and so hopefully should be cheap to allocate.\n\n  function tryCatch(fn, obj, arg) {\n    try {\n      return {\n        type: \"normal\",\n        arg: fn.call(obj, arg)\n      };\n    } catch (err) {\n      return {\n        type: \"throw\",\n        arg: err\n      };\n    }\n  }\n\n  var GenStateSuspendedStart = \"suspendedStart\";\n  var GenStateSuspendedYield = \"suspendedYield\";\n  var GenStateExecuting = \"executing\";\n  var GenStateCompleted = \"completed\"; // Returning this object from the innerFn has the same effect as\n  // breaking out of the dispatch switch statement.\n\n  var ContinueSentinel = {}; // Dummy constructor functions that we use as the .constructor and\n  // .constructor.prototype properties for functions that return Generator\n  // objects. For full spec compliance, you may wish to configure your\n  // minifier not to mangle the names of these two functions.\n\n  function Generator() {}\n\n  function GeneratorFunction() {}\n\n  function GeneratorFunctionPrototype() {} // This is a polyfill for %IteratorPrototype% for environments that\n  // don't natively support it.\n\n\n  var IteratorPrototype = {};\n\n  IteratorPrototype[iteratorSymbol] = function () {\n    return this;\n  };\n\n  var getProto = Object.getPrototypeOf;\n  var NativeIteratorPrototype = getProto && getProto(getProto(values([])));\n\n  if (NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {\n    // This environment has a native %IteratorPrototype%; use it instead\n    // of the polyfill.\n    IteratorPrototype = NativeIteratorPrototype;\n  }\n\n  var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);\n  GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;\n  GeneratorFunctionPrototype.constructor = GeneratorFunction;\n  GeneratorFunctionPrototype[toStringTagSymbol] = GeneratorFunction.displayName = \"GeneratorFunction\"; // Helper for defining the .next, .throw, and .return methods of the\n  // Iterator interface in terms of a single ._invoke method.\n\n  function defineIteratorMethods(prototype) {\n    [\"next\", \"throw\", \"return\"].forEach(function (method) {\n      prototype[method] = function (arg) {\n        return this._invoke(method, arg);\n      };\n    });\n  }\n\n  exports.isGeneratorFunction = function (genFun) {\n    var ctor = typeof genFun === \"function\" && genFun.constructor;\n    return ctor ? ctor === GeneratorFunction || // For the native GeneratorFunction constructor, the best we can\n    // do is to check its .name property.\n    (ctor.displayName || ctor.name) === \"GeneratorFunction\" : false;\n  };\n\n  exports.mark = function (genFun) {\n    if (Object.setPrototypeOf) {\n      Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);\n    } else {\n      genFun.__proto__ = GeneratorFunctionPrototype;\n\n      if (!(toStringTagSymbol in genFun)) {\n        genFun[toStringTagSymbol] = \"GeneratorFunction\";\n      }\n    }\n\n    genFun.prototype = Object.create(Gp);\n    return genFun;\n  }; // Within the body of any async function, `await x` is transformed to\n  // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test\n  // `hasOwn.call(value, \"__await\")` to determine if the yielded value is\n  // meant to be awaited.\n\n\n  exports.awrap = function (arg) {\n    return {\n      __await: arg\n    };\n  };\n\n  function AsyncIterator(generator) {\n    function invoke(method, arg, resolve, reject) {\n      var record = tryCatch(generator[method], generator, arg);\n\n      if (record.type === \"throw\") {\n        reject(record.arg);\n      } else {\n        var result = record.arg;\n        var value = result.value;\n\n        if (value && typeof value === \"object\" && hasOwn.call(value, \"__await\")) {\n          return Promise.resolve(value.__await).then(function (value) {\n            invoke(\"next\", value, resolve, reject);\n          }, function (err) {\n            invoke(\"throw\", err, resolve, reject);\n          });\n        }\n\n        return Promise.resolve(value).then(function (unwrapped) {\n          // When a yielded Promise is resolved, its final value becomes\n          // the .value of the Promise<{value,done}> result for the\n          // current iteration.\n          result.value = unwrapped;\n          resolve(result);\n        }, function (error) {\n          // If a rejected Promise was yielded, throw the rejection back\n          // into the async generator function so it can be handled there.\n          return invoke(\"throw\", error, resolve, reject);\n        });\n      }\n    }\n\n    var previousPromise;\n\n    function enqueue(method, arg) {\n      function callInvokeWithMethodAndArg() {\n        return new Promise(function (resolve, reject) {\n          invoke(method, arg, resolve, reject);\n        });\n      }\n\n      return previousPromise = // If enqueue has been called before, then we want to wait until\n      // all previous Promises have been resolved before calling invoke,\n      // so that results are always delivered in the correct order. If\n      // enqueue has not been called before, then it is important to\n      // call invoke immediately, without waiting on a callback to fire,\n      // so that the async generator function has the opportunity to do\n      // any necessary setup in a predictable way. This predictability\n      // is why the Promise constructor synchronously invokes its\n      // executor callback, and why async functions synchronously\n      // execute code before the first await. Since we implement simple\n      // async functions in terms of async generators, it is especially\n      // important to get this right, even though it requires care.\n      previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, // Avoid propagating failures to Promises returned by later\n      // invocations of the iterator.\n      callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();\n    } // Define the unified helper method that is used to implement .next,\n    // .throw, and .return (see defineIteratorMethods).\n\n\n    this._invoke = enqueue;\n  }\n\n  defineIteratorMethods(AsyncIterator.prototype);\n\n  AsyncIterator.prototype[asyncIteratorSymbol] = function () {\n    return this;\n  };\n\n  exports.AsyncIterator = AsyncIterator; // Note that simple async functions are implemented on top of\n  // AsyncIterator objects; they just return a Promise for the value of\n  // the final result produced by the iterator.\n\n  exports.async = function (innerFn, outerFn, self, tryLocsList) {\n    var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList));\n    return exports.isGeneratorFunction(outerFn) ? iter // If outerFn is a generator, return the full iterator.\n    : iter.next().then(function (result) {\n      return result.done ? result.value : iter.next();\n    });\n  };\n\n  function makeInvokeMethod(innerFn, self, context) {\n    var state = GenStateSuspendedStart;\n    return function invoke(method, arg) {\n      if (state === GenStateExecuting) {\n        throw new Error(\"Generator is already running\");\n      }\n\n      if (state === GenStateCompleted) {\n        if (method === \"throw\") {\n          throw arg;\n        } // Be forgiving, per 25.3.3.3.3 of the spec:\n        // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume\n\n\n        return doneResult();\n      }\n\n      context.method = method;\n      context.arg = arg;\n\n      while (true) {\n        var delegate = context.delegate;\n\n        if (delegate) {\n          var delegateResult = maybeInvokeDelegate(delegate, context);\n\n          if (delegateResult) {\n            if (delegateResult === ContinueSentinel) continue;\n            return delegateResult;\n          }\n        }\n\n        if (context.method === \"next\") {\n          // Setting context._sent for legacy support of Babel's\n          // function.sent implementation.\n          context.sent = context._sent = context.arg;\n        } else if (context.method === \"throw\") {\n          if (state === GenStateSuspendedStart) {\n            state = GenStateCompleted;\n            throw context.arg;\n          }\n\n          context.dispatchException(context.arg);\n        } else if (context.method === \"return\") {\n          context.abrupt(\"return\", context.arg);\n        }\n\n        state = GenStateExecuting;\n        var record = tryCatch(innerFn, self, context);\n\n        if (record.type === \"normal\") {\n          // If an exception is thrown from innerFn, we leave state ===\n          // GenStateExecuting and loop back for another invocation.\n          state = context.done ? GenStateCompleted : GenStateSuspendedYield;\n\n          if (record.arg === ContinueSentinel) {\n            continue;\n          }\n\n          return {\n            value: record.arg,\n            done: context.done\n          };\n        } else if (record.type === \"throw\") {\n          state = GenStateCompleted; // Dispatch the exception by looping back around to the\n          // context.dispatchException(context.arg) call above.\n\n          context.method = \"throw\";\n          context.arg = record.arg;\n        }\n      }\n    };\n  } // Call delegate.iterator[context.method](context.arg) and handle the\n  // result, either by returning a { value, done } result from the\n  // delegate iterator, or by modifying context.method and context.arg,\n  // setting context.delegate to null, and returning the ContinueSentinel.\n\n\n  function maybeInvokeDelegate(delegate, context) {\n    var method = delegate.iterator[context.method];\n\n    if (method === undefined) {\n      // A .throw or .return when the delegate iterator has no .throw\n      // method always terminates the yield* loop.\n      context.delegate = null;\n\n      if (context.method === \"throw\") {\n        // Note: [\"return\"] must be used for ES3 parsing compatibility.\n        if (delegate.iterator[\"return\"]) {\n          // If the delegate iterator has a return method, give it a\n          // chance to clean up.\n          context.method = \"return\";\n          context.arg = undefined;\n          maybeInvokeDelegate(delegate, context);\n\n          if (context.method === \"throw\") {\n            // If maybeInvokeDelegate(context) changed context.method from\n            // \"return\" to \"throw\", let that override the TypeError below.\n            return ContinueSentinel;\n          }\n        }\n\n        context.method = \"throw\";\n        context.arg = new TypeError(\"The iterator does not provide a 'throw' method\");\n      }\n\n      return ContinueSentinel;\n    }\n\n    var record = tryCatch(method, delegate.iterator, context.arg);\n\n    if (record.type === \"throw\") {\n      context.method = \"throw\";\n      context.arg = record.arg;\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    var info = record.arg;\n\n    if (!info) {\n      context.method = \"throw\";\n      context.arg = new TypeError(\"iterator result is not an object\");\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    if (info.done) {\n      // Assign the result of the finished delegate to the temporary\n      // variable specified by delegate.resultName (see delegateYield).\n      context[delegate.resultName] = info.value; // Resume execution at the desired location (see delegateYield).\n\n      context.next = delegate.nextLoc; // If context.method was \"throw\" but the delegate handled the\n      // exception, let the outer generator proceed normally. If\n      // context.method was \"next\", forget context.arg since it has been\n      // \"consumed\" by the delegate iterator. If context.method was\n      // \"return\", allow the original .return call to continue in the\n      // outer generator.\n\n      if (context.method !== \"return\") {\n        context.method = \"next\";\n        context.arg = undefined;\n      }\n    } else {\n      // Re-yield the result returned by the delegate method.\n      return info;\n    } // The delegate iterator is finished, so forget it and continue with\n    // the outer generator.\n\n\n    context.delegate = null;\n    return ContinueSentinel;\n  } // Define Generator.prototype.{next,throw,return} in terms of the\n  // unified ._invoke helper method.\n\n\n  defineIteratorMethods(Gp);\n  Gp[toStringTagSymbol] = \"Generator\"; // A Generator should always return itself as the iterator object when the\n  // @@iterator function is called on it. Some browsers' implementations of the\n  // iterator prototype chain incorrectly implement this, causing the Generator\n  // object to not be returned from this call. This ensures that doesn't happen.\n  // See https://github.com/facebook/regenerator/issues/274 for more details.\n\n  Gp[iteratorSymbol] = function () {\n    return this;\n  };\n\n  Gp.toString = function () {\n    return \"[object Generator]\";\n  };\n\n  function pushTryEntry(locs) {\n    var entry = {\n      tryLoc: locs[0]\n    };\n\n    if (1 in locs) {\n      entry.catchLoc = locs[1];\n    }\n\n    if (2 in locs) {\n      entry.finallyLoc = locs[2];\n      entry.afterLoc = locs[3];\n    }\n\n    this.tryEntries.push(entry);\n  }\n\n  function resetTryEntry(entry) {\n    var record = entry.completion || {};\n    record.type = \"normal\";\n    delete record.arg;\n    entry.completion = record;\n  }\n\n  function Context(tryLocsList) {\n    // The root entry object (effectively a try statement without a catch\n    // or a finally block) gives us a place to store values thrown from\n    // locations where there is no enclosing try statement.\n    this.tryEntries = [{\n      tryLoc: \"root\"\n    }];\n    tryLocsList.forEach(pushTryEntry, this);\n    this.reset(true);\n  }\n\n  exports.keys = function (object) {\n    var keys = [];\n\n    for (var key in object) {\n      keys.push(key);\n    }\n\n    keys.reverse(); // Rather than returning an object with a next method, we keep\n    // things simple and return the next function itself.\n\n    return function next() {\n      while (keys.length) {\n        var key = keys.pop();\n\n        if (key in object) {\n          next.value = key;\n          next.done = false;\n          return next;\n        }\n      } // To avoid creating an additional object, we just hang the .value\n      // and .done properties off the next function object itself. This\n      // also ensures that the minifier will not anonymize the function.\n\n\n      next.done = true;\n      return next;\n    };\n  };\n\n  function values(iterable) {\n    if (iterable) {\n      var iteratorMethod = iterable[iteratorSymbol];\n\n      if (iteratorMethod) {\n        return iteratorMethod.call(iterable);\n      }\n\n      if (typeof iterable.next === \"function\") {\n        return iterable;\n      }\n\n      if (!isNaN(iterable.length)) {\n        var i = -1,\n            next = function next() {\n          while (++i < iterable.length) {\n            if (hasOwn.call(iterable, i)) {\n              next.value = iterable[i];\n              next.done = false;\n              return next;\n            }\n          }\n\n          next.value = undefined;\n          next.done = true;\n          return next;\n        };\n\n        return next.next = next;\n      }\n    } // Return an iterator with no values.\n\n\n    return {\n      next: doneResult\n    };\n  }\n\n  exports.values = values;\n\n  function doneResult() {\n    return {\n      value: undefined,\n      done: true\n    };\n  }\n\n  Context.prototype = {\n    constructor: Context,\n    reset: function reset(skipTempReset) {\n      this.prev = 0;\n      this.next = 0; // Resetting context._sent for legacy support of Babel's\n      // function.sent implementation.\n\n      this.sent = this._sent = undefined;\n      this.done = false;\n      this.delegate = null;\n      this.method = \"next\";\n      this.arg = undefined;\n      this.tryEntries.forEach(resetTryEntry);\n\n      if (!skipTempReset) {\n        for (var name in this) {\n          // Not sure about the optimal order of these conditions:\n          if (name.charAt(0) === \"t\" && hasOwn.call(this, name) && !isNaN(+name.slice(1))) {\n            this[name] = undefined;\n          }\n        }\n      }\n    },\n    stop: function stop() {\n      this.done = true;\n      var rootEntry = this.tryEntries[0];\n      var rootRecord = rootEntry.completion;\n\n      if (rootRecord.type === \"throw\") {\n        throw rootRecord.arg;\n      }\n\n      return this.rval;\n    },\n    dispatchException: function dispatchException(exception) {\n      if (this.done) {\n        throw exception;\n      }\n\n      var context = this;\n\n      function handle(loc, caught) {\n        record.type = \"throw\";\n        record.arg = exception;\n        context.next = loc;\n\n        if (caught) {\n          // If the dispatched exception was caught by a catch block,\n          // then let that catch block handle the exception normally.\n          context.method = \"next\";\n          context.arg = undefined;\n        }\n\n        return !!caught;\n      }\n\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        var record = entry.completion;\n\n        if (entry.tryLoc === \"root\") {\n          // Exception thrown outside of any try block that could handle\n          // it, so set the completion value of the entire function to\n          // throw the exception.\n          return handle(\"end\");\n        }\n\n        if (entry.tryLoc <= this.prev) {\n          var hasCatch = hasOwn.call(entry, \"catchLoc\");\n          var hasFinally = hasOwn.call(entry, \"finallyLoc\");\n\n          if (hasCatch && hasFinally) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            } else if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n          } else if (hasCatch) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            }\n          } else if (hasFinally) {\n            if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n          } else {\n            throw new Error(\"try statement without catch or finally\");\n          }\n        }\n      }\n    },\n    abrupt: function abrupt(type, arg) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n\n        if (entry.tryLoc <= this.prev && hasOwn.call(entry, \"finallyLoc\") && this.prev < entry.finallyLoc) {\n          var finallyEntry = entry;\n          break;\n        }\n      }\n\n      if (finallyEntry && (type === \"break\" || type === \"continue\") && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc) {\n        // Ignore the finally entry if control is not jumping to a\n        // location outside the try/catch block.\n        finallyEntry = null;\n      }\n\n      var record = finallyEntry ? finallyEntry.completion : {};\n      record.type = type;\n      record.arg = arg;\n\n      if (finallyEntry) {\n        this.method = \"next\";\n        this.next = finallyEntry.finallyLoc;\n        return ContinueSentinel;\n      }\n\n      return this.complete(record);\n    },\n    complete: function complete(record, afterLoc) {\n      if (record.type === \"throw\") {\n        throw record.arg;\n      }\n\n      if (record.type === \"break\" || record.type === \"continue\") {\n        this.next = record.arg;\n      } else if (record.type === \"return\") {\n        this.rval = this.arg = record.arg;\n        this.method = \"return\";\n        this.next = \"end\";\n      } else if (record.type === \"normal\" && afterLoc) {\n        this.next = afterLoc;\n      }\n\n      return ContinueSentinel;\n    },\n    finish: function finish(finallyLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n\n        if (entry.finallyLoc === finallyLoc) {\n          this.complete(entry.completion, entry.afterLoc);\n          resetTryEntry(entry);\n          return ContinueSentinel;\n        }\n      }\n    },\n    \"catch\": function _catch(tryLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n\n        if (entry.tryLoc === tryLoc) {\n          var record = entry.completion;\n\n          if (record.type === \"throw\") {\n            var thrown = record.arg;\n            resetTryEntry(entry);\n          }\n\n          return thrown;\n        }\n      } // The context.catch method must only be called with a location\n      // argument that corresponds to a known catch block.\n\n\n      throw new Error(\"illegal catch attempt\");\n    },\n    delegateYield: function delegateYield(iterable, resultName, nextLoc) {\n      this.delegate = {\n        iterator: values(iterable),\n        resultName: resultName,\n        nextLoc: nextLoc\n      };\n\n      if (this.method === \"next\") {\n        // Deliberately forget the last sent value so that we don't\n        // accidentally pass it on to the delegate.\n        this.arg = undefined;\n      }\n\n      return ContinueSentinel;\n    }\n  }; // Regardless of whether this script is executing as a CommonJS module\n  // or not, return the runtime object so that we can declare the variable\n  // regeneratorRuntime in the outer scope, which allows this module to be\n  // injected easily by `bin/regenerator --include-runtime script.js`.\n\n  return exports;\n}( // If this script is executing as a CommonJS module, use module.exports\n// as the regeneratorRuntime namespace. Otherwise create a new empty\n// object. Either way, the resulting object will be used to initialize\n// the regeneratorRuntime variable at the top of this file.\ntypeof module === \"object\" ? module.exports : {});\n\ntry {\n  regeneratorRuntime = runtime;\n} catch (accidentalStrictMode) {\n  // This module should not be running in strict mode, so the above\n  // assignment should always work unless something is misconfigured. Just\n  // in case runtime.js accidentally runs in strict mode, we can escape\n  // strict mode using a global Function call. This could conceivably fail\n  // if a Content Security Policy forbids using Function, but in that case\n  // the proper solution is to fix the accidental strict mode problem. If\n  // you've misconfigured your bundler to force strict mode and applied a\n  // CSP to forbid Function, and you're not willing to fix either of those\n  // problems, please detail your unique predicament in a GitHub issue.\n  Function(\"r\", \"regeneratorRuntime = r\")(runtime);\n}","import { useState, useRef, useEffect } from 'react';\n\nfunction areInputsEqual(newInputs, lastInputs) {\n  if (newInputs.length !== lastInputs.length) {\n    return false;\n  }\n\n  for (var i = 0; i < newInputs.length; i++) {\n    if (newInputs[i] !== lastInputs[i]) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\nfunction useMemoOne(getResult, inputs) {\n  var initial = useState(function () {\n    return {\n      inputs: inputs,\n      result: getResult()\n    };\n  })[0];\n  var committed = useRef(initial);\n  var isInputMatch = Boolean(inputs && committed.current.inputs && areInputsEqual(inputs, committed.current.inputs));\n  var cache = isInputMatch ? committed.current : {\n    inputs: inputs,\n    result: getResult()\n  };\n  useEffect(function () {\n    committed.current = cache;\n  }, [cache]);\n  return cache.result;\n}\n\nfunction useCallbackOne(callback, inputs) {\n  return useMemoOne(function () {\n    return callback;\n  }, inputs);\n}\n\nvar useMemo = useMemoOne;\nvar useCallback = useCallbackOne;\nexport { useCallback, useCallbackOne, useMemo, useMemoOne };","// all object keys, includes non-enumerable and symbols\nvar gOPN = require('./_object-gopn');\nvar gOPS = require('./_object-gops');\nvar anObject = require('./_an-object');\nvar Reflect = require('./_global').Reflect;\nmodule.exports = Reflect && Reflect.ownKeys || function ownKeys(it) {\n  var keys = gOPN.f(anObject(it));\n  var getSymbols = gOPS.f;\n  return getSymbols ? keys.concat(getSymbols(it)) : keys;\n};\n","module.exports = require(\"regenerator-runtime\");\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 _isNativeReflectConstruct() {\n  if (typeof Reflect === \"undefined\" || !Reflect.construct) return false;\n  if (Reflect.construct.sham) return false;\n  if (typeof Proxy === \"function\") return true;\n\n  try {\n    Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));\n    return true;\n  } catch (e) {\n    return false;\n  }\n}","import setPrototypeOf from \"./setPrototypeOf\";\nimport isNativeReflectConstruct from \"./isNativeReflectConstruct\";\nexport default function _construct(Parent, args, Class) {\n  if (isNativeReflectConstruct()) {\n    _construct = Reflect.construct;\n  } else {\n    _construct = function _construct(Parent, args, Class) {\n      var a = [null];\n      a.push.apply(a, args);\n      var Constructor = Function.bind.apply(Parent, a);\n      var instance = new Constructor();\n      if (Class) setPrototypeOf(instance, Class.prototype);\n      return instance;\n    };\n  }\n\n  return _construct.apply(null, arguments);\n}","import getPrototypeOf from \"./getPrototypeOf\";\nimport setPrototypeOf from \"./setPrototypeOf\";\nimport isNativeFunction from \"./isNativeFunction\";\nimport construct from \"./construct\";\nexport default function _wrapNativeSuper(Class) {\n  var _cache = typeof Map === \"function\" ? new Map() : undefined;\n\n  _wrapNativeSuper = function _wrapNativeSuper(Class) {\n    if (Class === null || !isNativeFunction(Class)) return Class;\n\n    if (typeof Class !== \"function\") {\n      throw new TypeError(\"Super expression must either be null or a function\");\n    }\n\n    if (typeof _cache !== \"undefined\") {\n      if (_cache.has(Class)) return _cache.get(Class);\n\n      _cache.set(Class, Wrapper);\n    }\n\n    function Wrapper() {\n      return construct(Class, arguments, getPrototypeOf(this).constructor);\n    }\n\n    Wrapper.prototype = Object.create(Class.prototype, {\n      constructor: {\n        value: Wrapper,\n        enumerable: false,\n        writable: true,\n        configurable: true\n      }\n    });\n    return setPrototypeOf(Wrapper, Class);\n  };\n\n  return _wrapNativeSuper(Class);\n}","export default function _isNativeFunction(fn) {\n  return Function.toString.call(fn).indexOf(\"[native code]\") !== -1;\n}","require(\"core-js/modules/es6.regexp.replace\");\n\nrequire(\"core-js/modules/es6.regexp.split\");\n\n/*!\n * UAParser.js v0.7.21\n * Lightweight JavaScript-based User-Agent string parser\n * https://github.com/faisalman/ua-parser-js\n *\n * Copyright © 2012-2019 Faisal Salman <f@faisalman.com>\n * Licensed under MIT License\n */\n(function (window, undefined) {\n  \"use strict\";\n\n  var LIBVERSION = \"0.7.21\",\n      EMPTY = \"\",\n      UNKNOWN = \"?\",\n      FUNC_TYPE = \"function\",\n      UNDEF_TYPE = \"undefined\",\n      OBJ_TYPE = \"object\",\n      STR_TYPE = \"string\",\n      MAJOR = \"major\",\n      MODEL = \"model\",\n      NAME = \"name\",\n      TYPE = \"type\",\n      VENDOR = \"vendor\",\n      VERSION = \"version\",\n      ARCHITECTURE = \"architecture\",\n      CONSOLE = \"console\",\n      MOBILE = \"mobile\",\n      TABLET = \"tablet\",\n      SMARTTV = \"smarttv\",\n      WEARABLE = \"wearable\",\n      EMBEDDED = \"embedded\";\n  var util = {\n    extend: function extend(regexes, extensions) {\n      var mergedRegexes = {};\n\n      for (var i in regexes) {\n        if (extensions[i] && extensions[i].length % 2 === 0) {\n          mergedRegexes[i] = extensions[i].concat(regexes[i]);\n        } else {\n          mergedRegexes[i] = regexes[i];\n        }\n      }\n\n      return mergedRegexes;\n    },\n    has: function has(str1, str2) {\n      if (typeof str1 === \"string\") {\n        return str2.toLowerCase().indexOf(str1.toLowerCase()) !== -1;\n      } else {\n        return false;\n      }\n    },\n    lowerize: function lowerize(str) {\n      return str.toLowerCase();\n    },\n    major: function major(version) {\n      return typeof version === STR_TYPE ? version.replace(/[^\\d\\.]/g, \"\").split(\".\")[0] : undefined;\n    },\n    trim: function trim(str) {\n      return str.replace(/^[\\s\\uFEFF\\xA0]+|[\\s\\uFEFF\\xA0]+$/g, \"\");\n    }\n  };\n  var mapper = {\n    rgx: function rgx(ua, arrays) {\n      var i = 0,\n          j,\n          k,\n          p,\n          q,\n          matches,\n          match;\n\n      while (i < arrays.length && !matches) {\n        var regex = arrays[i],\n            props = arrays[i + 1];\n        j = k = 0;\n\n        while (j < regex.length && !matches) {\n          matches = regex[j++].exec(ua);\n\n          if (!!matches) {\n            for (p = 0; p < props.length; p++) {\n              match = matches[++k];\n              q = props[p];\n\n              if (typeof q === OBJ_TYPE && q.length > 0) {\n                if (q.length == 2) {\n                  if (typeof q[1] == FUNC_TYPE) {\n                    this[q[0]] = q[1].call(this, match);\n                  } else {\n                    this[q[0]] = q[1];\n                  }\n                } else if (q.length == 3) {\n                  if (typeof q[1] === FUNC_TYPE && !(q[1].exec && q[1].test)) {\n                    this[q[0]] = match ? q[1].call(this, match, q[2]) : undefined;\n                  } else {\n                    this[q[0]] = match ? match.replace(q[1], q[2]) : undefined;\n                  }\n                } else if (q.length == 4) {\n                  this[q[0]] = match ? q[3].call(this, match.replace(q[1], q[2])) : undefined;\n                }\n              } else {\n                this[q] = match ? match : undefined;\n              }\n            }\n          }\n        }\n\n        i += 2;\n      }\n    },\n    str: function str(_str, map) {\n      for (var i in map) {\n        if (typeof map[i] === OBJ_TYPE && map[i].length > 0) {\n          for (var j = 0; j < map[i].length; j++) {\n            if (util.has(map[i][j], _str)) {\n              return i === UNKNOWN ? undefined : i;\n            }\n          }\n        } else if (util.has(map[i], _str)) {\n          return i === UNKNOWN ? undefined : i;\n        }\n      }\n\n      return _str;\n    }\n  };\n  var maps = {\n    browser: {\n      oldsafari: {\n        version: {\n          \"1.0\": \"/8\",\n          1.2: \"/1\",\n          1.3: \"/3\",\n          \"2.0\": \"/412\",\n          \"2.0.2\": \"/416\",\n          \"2.0.3\": \"/417\",\n          \"2.0.4\": \"/419\",\n          \"?\": \"/\"\n        }\n      }\n    },\n    device: {\n      amazon: {\n        model: {\n          \"Fire Phone\": [\"SD\", \"KF\"]\n        }\n      },\n      sprint: {\n        model: {\n          \"Evo Shift 4G\": \"7373KT\"\n        },\n        vendor: {\n          HTC: \"APA\",\n          Sprint: \"Sprint\"\n        }\n      }\n    },\n    os: {\n      windows: {\n        version: {\n          ME: \"4.90\",\n          \"NT 3.11\": \"NT3.51\",\n          \"NT 4.0\": \"NT4.0\",\n          2000: \"NT 5.0\",\n          XP: [\"NT 5.1\", \"NT 5.2\"],\n          Vista: \"NT 6.0\",\n          7: \"NT 6.1\",\n          8: \"NT 6.2\",\n          8.1: \"NT 6.3\",\n          10: [\"NT 6.4\", \"NT 10.0\"],\n          RT: \"ARM\"\n        }\n      }\n    }\n  };\n  var regexes = {\n    browser: [[/(opera\\smini)\\/([\\w\\.-]+)/i, /(opera\\s[mobiletab]+).+version\\/([\\w\\.-]+)/i, /(opera).+version\\/([\\w\\.]+)/i, /(opera)[\\/\\s]+([\\w\\.]+)/i], [NAME, VERSION], [/(opios)[\\/\\s]+([\\w\\.]+)/i], [[NAME, \"Opera Mini\"], VERSION], [/\\s(opr)\\/([\\w\\.]+)/i], [[NAME, \"Opera\"], VERSION], [/(kindle)\\/([\\w\\.]+)/i, /(lunascape|maxthon|netfront|jasmine|blazer)[\\/\\s]?([\\w\\.]*)/i, /(avant\\s|iemobile|slim)(?:browser)?[\\/\\s]?([\\w\\.]*)/i, /(bidubrowser|baidubrowser)[\\/\\s]?([\\w\\.]+)/i, /(?:ms|\\()(ie)\\s([\\w\\.]+)/i, /(rekonq)\\/([\\w\\.]*)/i, /(chromium|flock|rockmelt|midori|epiphany|silk|skyfire|ovibrowser|bolt|iron|vivaldi|iridium|phantomjs|bowser|quark|qupzilla|falkon)\\/([\\w\\.-]+)/i], [NAME, VERSION], [/(konqueror)\\/([\\w\\.]+)/i], [[NAME, \"Konqueror\"], VERSION], [/(trident).+rv[:\\s]([\\w\\.]+).+like\\sgecko/i], [[NAME, \"IE\"], VERSION], [/(edge|edgios|edga|edg)\\/((\\d+)?[\\w\\.]+)/i], [[NAME, \"Edge\"], VERSION], [/(yabrowser)\\/([\\w\\.]+)/i], [[NAME, \"Yandex\"], VERSION], [/(Avast)\\/([\\w\\.]+)/i], [[NAME, \"Avast Secure Browser\"], VERSION], [/(AVG)\\/([\\w\\.]+)/i], [[NAME, \"AVG Secure Browser\"], VERSION], [/(puffin)\\/([\\w\\.]+)/i], [[NAME, \"Puffin\"], VERSION], [/(focus)\\/([\\w\\.]+)/i], [[NAME, \"Firefox Focus\"], VERSION], [/(opt)\\/([\\w\\.]+)/i], [[NAME, \"Opera Touch\"], VERSION], [/((?:[\\s\\/])uc?\\s?browser|(?:juc.+)ucweb)[\\/\\s]?([\\w\\.]+)/i], [[NAME, \"UCBrowser\"], VERSION], [/(comodo_dragon)\\/([\\w\\.]+)/i], [[NAME, /_/g, \" \"], VERSION], [/(windowswechat qbcore)\\/([\\w\\.]+)/i], [[NAME, \"WeChat(Win) Desktop\"], VERSION], [/(micromessenger)\\/([\\w\\.]+)/i], [[NAME, \"WeChat\"], VERSION], [/(brave)\\/([\\w\\.]+)/i], [[NAME, \"Brave\"], VERSION], [/(qqbrowserlite)\\/([\\w\\.]+)/i], [NAME, VERSION], [/(QQ)\\/([\\d\\.]+)/i], [NAME, VERSION], [/m?(qqbrowser)[\\/\\s]?([\\w\\.]+)/i], [NAME, VERSION], [/(baiduboxapp)[\\/\\s]?([\\w\\.]+)/i], [NAME, VERSION], [/(2345Explorer)[\\/\\s]?([\\w\\.]+)/i], [NAME, VERSION], [/(MetaSr)[\\/\\s]?([\\w\\.]+)/i], [NAME], [/(LBBROWSER)/i], [NAME], [/xiaomi\\/miuibrowser\\/([\\w\\.]+)/i], [VERSION, [NAME, \"MIUI Browser\"]], [/;fbav\\/([\\w\\.]+);/i], [VERSION, [NAME, \"Facebook\"]], [/safari\\s(line)\\/([\\w\\.]+)/i, /android.+(line)\\/([\\w\\.]+)\\/iab/i], [NAME, VERSION], [/headlesschrome(?:\\/([\\w\\.]+)|\\s)/i], [VERSION, [NAME, \"Chrome Headless\"]], [/\\swv\\).+(chrome)\\/([\\w\\.]+)/i], [[NAME, /(.+)/, \"$1 WebView\"], VERSION], [/((?:oculus|samsung)browser)\\/([\\w\\.]+)/i], [[NAME, /(.+(?:g|us))(.+)/, \"$1 $2\"], VERSION], [/android.+version\\/([\\w\\.]+)\\s+(?:mobile\\s?safari|safari)*/i], [VERSION, [NAME, \"Android Browser\"]], [/(sailfishbrowser)\\/([\\w\\.]+)/i], [[NAME, \"Sailfish Browser\"], VERSION], [/(chrome|omniweb|arora|[tizenoka]{5}\\s?browser)\\/v?([\\w\\.]+)/i], [NAME, VERSION], [/(dolfin)\\/([\\w\\.]+)/i], [[NAME, \"Dolphin\"], VERSION], [/(qihu|qhbrowser|qihoobrowser|360browser)/i], [[NAME, \"360 Browser\"]], [/((?:android.+)crmo|crios)\\/([\\w\\.]+)/i], [[NAME, \"Chrome\"], VERSION], [/(coast)\\/([\\w\\.]+)/i], [[NAME, \"Opera Coast\"], VERSION], [/fxios\\/([\\w\\.-]+)/i], [VERSION, [NAME, \"Firefox\"]], [/version\\/([\\w\\.]+).+?mobile\\/\\w+\\s(safari)/i], [VERSION, [NAME, \"Mobile Safari\"]], [/version\\/([\\w\\.]+).+?(mobile\\s?safari|safari)/i], [VERSION, NAME], [/webkit.+?(gsa)\\/([\\w\\.]+).+?(mobile\\s?safari|safari)(\\/[\\w\\.]+)/i], [[NAME, \"GSA\"], VERSION], [/webkit.+?(mobile\\s?safari|safari)(\\/[\\w\\.]+)/i], [NAME, [VERSION, mapper.str, maps.browser.oldsafari.version]], [/(webkit|khtml)\\/([\\w\\.]+)/i], [NAME, VERSION], [/(navigator|netscape)\\/([\\w\\.-]+)/i], [[NAME, \"Netscape\"], VERSION], [/(swiftfox)/i, /(icedragon|iceweasel|camino|chimera|fennec|maemo\\sbrowser|minimo|conkeror)[\\/\\s]?([\\w\\.\\+]+)/i, /(firefox|seamonkey|k-meleon|icecat|iceape|firebird|phoenix|palemoon|basilisk|waterfox)\\/([\\w\\.-]+)$/i, /(mozilla)\\/([\\w\\.]+).+rv\\:.+gecko\\/\\d+/i, /(polaris|lynx|dillo|icab|doris|amaya|w3m|netsurf|sleipnir)[\\/\\s]?([\\w\\.]+)/i, /(links)\\s\\(([\\w\\.]+)/i, /(gobrowser)\\/?([\\w\\.]*)/i, /(ice\\s?browser)\\/v?([\\w\\._]+)/i, /(mosaic)[\\/\\s]([\\w\\.]+)/i], [NAME, VERSION]],\n    cpu: [[/(?:(amd|x(?:(?:86|64)[_-])?|wow|win)64)[;\\)]/i], [[ARCHITECTURE, \"amd64\"]], [/(ia32(?=;))/i], [[ARCHITECTURE, util.lowerize]], [/((?:i[346]|x)86)[;\\)]/i], [[ARCHITECTURE, \"ia32\"]], [/windows\\s(ce|mobile);\\sppc;/i], [[ARCHITECTURE, \"arm\"]], [/((?:ppc|powerpc)(?:64)?)(?:\\smac|;|\\))/i], [[ARCHITECTURE, /ower/, \"\", util.lowerize]], [/(sun4\\w)[;\\)]/i], [[ARCHITECTURE, \"sparc\"]], [/((?:avr32|ia64(?=;))|68k(?=\\))|arm(?:64|(?=v\\d+[;l]))|(?=atmel\\s)avr|(?:irix|mips|sparc)(?:64)?(?=;)|pa-risc)/i], [[ARCHITECTURE, util.lowerize]]],\n    device: [[/\\((ipad|playbook);[\\w\\s\\),;-]+(rim|apple)/i], [MODEL, VENDOR, [TYPE, TABLET]], [/applecoremedia\\/[\\w\\.]+ \\((ipad)/], [MODEL, [VENDOR, \"Apple\"], [TYPE, TABLET]], [/(apple\\s{0,1}tv)/i], [[MODEL, \"Apple TV\"], [VENDOR, \"Apple\"], [TYPE, SMARTTV]], [/(archos)\\s(gamepad2?)/i, /(hp).+(touchpad)/i, /(hp).+(tablet)/i, /(kindle)\\/([\\w\\.]+)/i, /\\s(nook)[\\w\\s]+build\\/(\\w+)/i, /(dell)\\s(strea[kpr\\s\\d]*[\\dko])/i], [VENDOR, MODEL, [TYPE, TABLET]], [/(kf[A-z]+)\\sbuild\\/.+silk\\//i], [MODEL, [VENDOR, \"Amazon\"], [TYPE, TABLET]], [/(sd|kf)[0349hijorstuw]+\\sbuild\\/.+silk\\//i], [[MODEL, mapper.str, maps.device.amazon.model], [VENDOR, \"Amazon\"], [TYPE, MOBILE]], [/android.+aft([bms])\\sbuild/i], [MODEL, [VENDOR, \"Amazon\"], [TYPE, SMARTTV]], [/\\((ip[honed|\\s\\w*]+);.+(apple)/i], [MODEL, VENDOR, [TYPE, MOBILE]], [/\\((ip[honed|\\s\\w*]+);/i], [MODEL, [VENDOR, \"Apple\"], [TYPE, MOBILE]], [/(blackberry)[\\s-]?(\\w+)/i, /(blackberry|benq|palm(?=\\-)|sonyericsson|acer|asus|dell|meizu|motorola|polytron)[\\s_-]?([\\w-]*)/i, /(hp)\\s([\\w\\s]+\\w)/i, /(asus)-?(\\w+)/i], [VENDOR, MODEL, [TYPE, MOBILE]], [/\\(bb10;\\s(\\w+)/i], [MODEL, [VENDOR, \"BlackBerry\"], [TYPE, MOBILE]], [/android.+(transfo[prime\\s]{4,10}\\s\\w+|eeepc|slider\\s\\w+|nexus 7|padfone|p00c)/i], [MODEL, [VENDOR, \"Asus\"], [TYPE, TABLET]], [/(sony)\\s(tablet\\s[ps])\\sbuild\\//i, /(sony)?(?:sgp.+)\\sbuild\\//i], [[VENDOR, \"Sony\"], [MODEL, \"Xperia Tablet\"], [TYPE, TABLET]], [/android.+\\s([c-g]\\d{4}|so[-l]\\w+)(?=\\sbuild\\/|\\).+chrome\\/(?![1-6]{0,1}\\d\\.))/i], [MODEL, [VENDOR, \"Sony\"], [TYPE, MOBILE]], [/\\s(ouya)\\s/i, /(nintendo)\\s([wids3u]+)/i], [VENDOR, MODEL, [TYPE, CONSOLE]], [/android.+;\\s(shield)\\sbuild/i], [MODEL, [VENDOR, \"Nvidia\"], [TYPE, CONSOLE]], [/(playstation\\s[34portablevi]+)/i], [MODEL, [VENDOR, \"Sony\"], [TYPE, CONSOLE]], [/(sprint\\s(\\w+))/i], [[VENDOR, mapper.str, maps.device.sprint.vendor], [MODEL, mapper.str, maps.device.sprint.model], [TYPE, MOBILE]], [/(htc)[;_\\s-]+([\\w\\s]+(?=\\)|\\sbuild)|\\w+)/i, /(zte)-(\\w*)/i, /(alcatel|geeksphone|nexian|panasonic|(?=;\\s)sony)[_\\s-]?([\\w-]*)/i], [VENDOR, [MODEL, /_/g, \" \"], [TYPE, MOBILE]], [/(nexus\\s9)/i], [MODEL, [VENDOR, \"HTC\"], [TYPE, TABLET]], [/d\\/huawei([\\w\\s-]+)[;\\)]/i, /(nexus\\s6p|vog-l29|ane-lx1|eml-l29)/i], [MODEL, [VENDOR, \"Huawei\"], [TYPE, MOBILE]], [/android.+(bah2?-a?[lw]\\d{2})/i], [MODEL, [VENDOR, \"Huawei\"], [TYPE, TABLET]], [/(microsoft);\\s(lumia[\\s\\w]+)/i], [VENDOR, MODEL, [TYPE, MOBILE]], [/[\\s\\(;](xbox(?:\\sone)?)[\\s\\);]/i], [MODEL, [VENDOR, \"Microsoft\"], [TYPE, CONSOLE]], [/(kin\\.[onetw]{3})/i], [[MODEL, /\\./g, \" \"], [VENDOR, \"Microsoft\"], [TYPE, MOBILE]], [/\\s(milestone|droid(?:[2-4x]|\\s(?:bionic|x2|pro|razr))?:?(\\s4g)?)[\\w\\s]+build\\//i, /mot[\\s-]?(\\w*)/i, /(XT\\d{3,4}) build\\//i, /(nexus\\s6)/i], [MODEL, [VENDOR, \"Motorola\"], [TYPE, MOBILE]], [/android.+\\s(mz60\\d|xoom[\\s2]{0,2})\\sbuild\\//i], [MODEL, [VENDOR, \"Motorola\"], [TYPE, TABLET]], [/hbbtv\\/\\d+\\.\\d+\\.\\d+\\s+\\([\\w\\s]*;\\s*(\\w[^;]*);([^;]*)/i], [[VENDOR, util.trim], [MODEL, util.trim], [TYPE, SMARTTV]], [/hbbtv.+maple;(\\d+)/i], [[MODEL, /^/, \"SmartTV\"], [VENDOR, \"Samsung\"], [TYPE, SMARTTV]], [/\\(dtv[\\);].+(aquos)/i], [MODEL, [VENDOR, \"Sharp\"], [TYPE, SMARTTV]], [/android.+((sch-i[89]0\\d|shw-m380s|gt-p\\d{4}|gt-n\\d+|sgh-t8[56]9|nexus 10))/i, /((SM-T\\w+))/i], [[VENDOR, \"Samsung\"], MODEL, [TYPE, TABLET]], [/smart-tv.+(samsung)/i], [VENDOR, [TYPE, SMARTTV], MODEL], [/((s[cgp]h-\\w+|gt-\\w+|galaxy\\snexus|sm-\\w[\\w\\d]+))/i, /(sam[sung]*)[\\s-]*(\\w+-?[\\w-]*)/i, /sec-((sgh\\w+))/i], [[VENDOR, \"Samsung\"], MODEL, [TYPE, MOBILE]], [/sie-(\\w*)/i], [MODEL, [VENDOR, \"Siemens\"], [TYPE, MOBILE]], [/(maemo|nokia).*(n900|lumia\\s\\d+)/i, /(nokia)[\\s_-]?([\\w-]*)/i], [[VENDOR, \"Nokia\"], MODEL, [TYPE, MOBILE]], [/android[x\\d\\.\\s;]+\\s([ab][1-7]\\-?[0178a]\\d\\d?)/i], [MODEL, [VENDOR, \"Acer\"], [TYPE, TABLET]], [/android.+([vl]k\\-?\\d{3})\\s+build/i], [MODEL, [VENDOR, \"LG\"], [TYPE, TABLET]], [/android\\s3\\.[\\s\\w;-]{10}(lg?)-([06cv9]{3,4})/i], [[VENDOR, \"LG\"], MODEL, [TYPE, TABLET]], [/(lg) netcast\\.tv/i], [VENDOR, MODEL, [TYPE, SMARTTV]], [/(nexus\\s[45])/i, /lg[e;\\s\\/-]+(\\w*)/i, /android.+lg(\\-?[\\d\\w]+)\\s+build/i], [MODEL, [VENDOR, \"LG\"], [TYPE, MOBILE]], [/(lenovo)\\s?(s(?:5000|6000)(?:[\\w-]+)|tab(?:[\\s\\w]+))/i], [VENDOR, MODEL, [TYPE, TABLET]], [/android.+(ideatab[a-z0-9\\-\\s]+)/i], [MODEL, [VENDOR, \"Lenovo\"], [TYPE, TABLET]], [/(lenovo)[_\\s-]?([\\w-]+)/i], [VENDOR, MODEL, [TYPE, MOBILE]], [/linux;.+((jolla));/i], [VENDOR, MODEL, [TYPE, MOBILE]], [/((pebble))app\\/[\\d\\.]+\\s/i], [VENDOR, MODEL, [TYPE, WEARABLE]], [/android.+;\\s(oppo)\\s?([\\w\\s]+)\\sbuild/i], [VENDOR, MODEL, [TYPE, MOBILE]], [/crkey/i], [[MODEL, \"Chromecast\"], [VENDOR, \"Google\"], [TYPE, SMARTTV]], [/android.+;\\s(glass)\\s\\d/i], [MODEL, [VENDOR, \"Google\"], [TYPE, WEARABLE]], [/android.+;\\s(pixel c)[\\s)]/i], [MODEL, [VENDOR, \"Google\"], [TYPE, TABLET]], [/android.+;\\s(pixel( [23])?( xl)?)[\\s)]/i], [MODEL, [VENDOR, \"Google\"], [TYPE, MOBILE]], [/android.+;\\s(\\w+)\\s+build\\/hm\\1/i, /android.+(hm[\\s\\-_]*note?[\\s_]*(?:\\d\\w)?)\\s+build/i, /android.+(mi[\\s\\-_]*(?:a\\d|one|one[\\s_]plus|note lte)?[\\s_]*(?:\\d?\\w?)[\\s_]*(?:plus)?)\\s+build/i, /android.+(redmi[\\s\\-_]*(?:note)?(?:[\\s_]*[\\w\\s]+))\\s+build/i], [[MODEL, /_/g, \" \"], [VENDOR, \"Xiaomi\"], [TYPE, MOBILE]], [/android.+(mi[\\s\\-_]*(?:pad)(?:[\\s_]*[\\w\\s]+))\\s+build/i], [[MODEL, /_/g, \" \"], [VENDOR, \"Xiaomi\"], [TYPE, TABLET]], [/android.+;\\s(m[1-5]\\snote)\\sbuild/i], [MODEL, [VENDOR, \"Meizu\"], [TYPE, MOBILE]], [/(mz)-([\\w-]{2,})/i], [[VENDOR, \"Meizu\"], MODEL, [TYPE, MOBILE]], [/android.+a000(1)\\s+build/i, /android.+oneplus\\s(a\\d{4})[\\s)]/i], [MODEL, [VENDOR, \"OnePlus\"], [TYPE, MOBILE]], [/android.+[;\\/]\\s*(RCT[\\d\\w]+)\\s+build/i], [MODEL, [VENDOR, \"RCA\"], [TYPE, TABLET]], [/android.+[;\\/\\s]+(Venue[\\d\\s]{2,7})\\s+build/i], [MODEL, [VENDOR, \"Dell\"], [TYPE, TABLET]], [/android.+[;\\/]\\s*(Q[T|M][\\d\\w]+)\\s+build/i], [MODEL, [VENDOR, \"Verizon\"], [TYPE, TABLET]], [/android.+[;\\/]\\s+(Barnes[&\\s]+Noble\\s+|BN[RT])(V?.*)\\s+build/i], [[VENDOR, \"Barnes & Noble\"], MODEL, [TYPE, TABLET]], [/android.+[;\\/]\\s+(TM\\d{3}.*\\b)\\s+build/i], [MODEL, [VENDOR, \"NuVision\"], [TYPE, TABLET]], [/android.+;\\s(k88)\\sbuild/i], [MODEL, [VENDOR, \"ZTE\"], [TYPE, TABLET]], [/android.+[;\\/]\\s*(gen\\d{3})\\s+build.*49h/i], [MODEL, [VENDOR, \"Swiss\"], [TYPE, MOBILE]], [/android.+[;\\/]\\s*(zur\\d{3})\\s+build/i], [MODEL, [VENDOR, \"Swiss\"], [TYPE, TABLET]], [/android.+[;\\/]\\s*((Zeki)?TB.*\\b)\\s+build/i], [MODEL, [VENDOR, \"Zeki\"], [TYPE, TABLET]], [/(android).+[;\\/]\\s+([YR]\\d{2})\\s+build/i, /android.+[;\\/]\\s+(Dragon[\\-\\s]+Touch\\s+|DT)(\\w{5})\\sbuild/i], [[VENDOR, \"Dragon Touch\"], MODEL, [TYPE, TABLET]], [/android.+[;\\/]\\s*(NS-?\\w{0,9})\\sbuild/i], [MODEL, [VENDOR, \"Insignia\"], [TYPE, TABLET]], [/android.+[;\\/]\\s*((NX|Next)-?\\w{0,9})\\s+build/i], [MODEL, [VENDOR, \"NextBook\"], [TYPE, TABLET]], [/android.+[;\\/]\\s*(Xtreme\\_)?(V(1[045]|2[015]|30|40|60|7[05]|90))\\s+build/i], [[VENDOR, \"Voice\"], MODEL, [TYPE, MOBILE]], [/android.+[;\\/]\\s*(LVTEL\\-)?(V1[12])\\s+build/i], [[VENDOR, \"LvTel\"], MODEL, [TYPE, MOBILE]], [/android.+;\\s(PH-1)\\s/i], [MODEL, [VENDOR, \"Essential\"], [TYPE, MOBILE]], [/android.+[;\\/]\\s*(V(100MD|700NA|7011|917G).*\\b)\\s+build/i], [MODEL, [VENDOR, \"Envizen\"], [TYPE, TABLET]], [/android.+[;\\/]\\s*(Le[\\s\\-]+Pan)[\\s\\-]+(\\w{1,9})\\s+build/i], [VENDOR, MODEL, [TYPE, TABLET]], [/android.+[;\\/]\\s*(Trio[\\s\\-]*.*)\\s+build/i], [MODEL, [VENDOR, \"MachSpeed\"], [TYPE, TABLET]], [/android.+[;\\/]\\s*(Trinity)[\\-\\s]*(T\\d{3})\\s+build/i], [VENDOR, MODEL, [TYPE, TABLET]], [/android.+[;\\/]\\s*TU_(1491)\\s+build/i], [MODEL, [VENDOR, \"Rotor\"], [TYPE, TABLET]], [/android.+(KS(.+))\\s+build/i], [MODEL, [VENDOR, \"Amazon\"], [TYPE, TABLET]], [/android.+(Gigaset)[\\s\\-]+(Q\\w{1,9})\\s+build/i], [VENDOR, MODEL, [TYPE, TABLET]], [/\\s(tablet|tab)[;\\/]/i, /\\s(mobile)(?:[;\\/]|\\ssafari)/i], [[TYPE, util.lowerize], VENDOR, MODEL], [/[\\s\\/\\(](smart-?tv)[;\\)]/i], [[TYPE, SMARTTV]], [/(android[\\w\\.\\s\\-]{0,9});.+build/i], [MODEL, [VENDOR, \"Generic\"]]],\n    engine: [[/windows.+\\sedge\\/([\\w\\.]+)/i], [VERSION, [NAME, \"EdgeHTML\"]], [/webkit\\/537\\.36.+chrome\\/(?!27)([\\w\\.]+)/i], [VERSION, [NAME, \"Blink\"]], [/(presto)\\/([\\w\\.]+)/i, /(webkit|trident|netfront|netsurf|amaya|lynx|w3m|goanna)\\/([\\w\\.]+)/i, /(khtml|tasman|links)[\\/\\s]\\(?([\\w\\.]+)/i, /(icab)[\\/\\s]([23]\\.[\\d\\.]+)/i], [NAME, VERSION], [/rv\\:([\\w\\.]{1,9}).+(gecko)/i], [VERSION, NAME]],\n    os: [[/microsoft\\s(windows)\\s(vista|xp)/i], [NAME, VERSION], [/(windows)\\snt\\s6\\.2;\\s(arm)/i, /(windows\\sphone(?:\\sos)*)[\\s\\/]?([\\d\\.\\s\\w]*)/i, /(windows\\smobile|windows)[\\s\\/]?([ntce\\d\\.\\s]+\\w)/i], [NAME, [VERSION, mapper.str, maps.os.windows.version]], [/(win(?=3|9|n)|win\\s9x\\s)([nt\\d\\.]+)/i], [[NAME, \"Windows\"], [VERSION, mapper.str, maps.os.windows.version]], [/\\((bb)(10);/i], [[NAME, \"BlackBerry\"], VERSION], [/(blackberry)\\w*\\/?([\\w\\.]*)/i, /(tizen|kaios)[\\/\\s]([\\w\\.]+)/i, /(android|webos|palm\\sos|qnx|bada|rim\\stablet\\sos|meego|sailfish|contiki)[\\/\\s-]?([\\w\\.]*)/i], [NAME, VERSION], [/(symbian\\s?os|symbos|s60(?=;))[\\/\\s-]?([\\w\\.]*)/i], [[NAME, \"Symbian\"], VERSION], [/\\((series40);/i], [NAME], [/mozilla.+\\(mobile;.+gecko.+firefox/i], [[NAME, \"Firefox OS\"], VERSION], [/(nintendo|playstation)\\s([wids34portablevu]+)/i, /(mint)[\\/\\s\\(]?(\\w*)/i, /(mageia|vectorlinux)[;\\s]/i, /(joli|[kxln]?ubuntu|debian|suse|opensuse|gentoo|(?=\\s)arch|slackware|fedora|mandriva|centos|pclinuxos|redhat|zenwalk|linpus)[\\/\\s-]?(?!chrom)([\\w\\.-]*)/i, /(hurd|linux)\\s?([\\w\\.]*)/i, /(gnu)\\s?([\\w\\.]*)/i], [NAME, VERSION], [/(cros)\\s[\\w]+\\s([\\w\\.]+\\w)/i], [[NAME, \"Chromium OS\"], VERSION], [/(sunos)\\s?([\\w\\.\\d]*)/i], [[NAME, \"Solaris\"], VERSION], [/\\s([frentopc-]{0,4}bsd|dragonfly)\\s?([\\w\\.]*)/i], [NAME, VERSION], [/(haiku)\\s(\\w+)/i], [NAME, VERSION], [/cfnetwork\\/.+darwin/i, /ip[honead]{2,4}(?:.*os\\s([\\w]+)\\slike\\smac|;\\sopera)/i], [[VERSION, /_/g, \".\"], [NAME, \"iOS\"]], [/(mac\\sos\\sx)\\s?([\\w\\s\\.]*)/i, /(macintosh|mac(?=_powerpc)\\s)/i], [[NAME, \"Mac OS\"], [VERSION, /_/g, \".\"]], [/((?:open)?solaris)[\\/\\s-]?([\\w\\.]*)/i, /(aix)\\s((\\d)(?=\\.|\\)|\\s)[\\w\\.])*/i, /(plan\\s9|minix|beos|os\\/2|amigaos|morphos|risc\\sos|openvms|fuchsia)/i, /(unix)\\s?([\\w\\.]*)/i], [NAME, VERSION]]\n  };\n\n  var UAParser = function UAParser(uastring, extensions) {\n    if (typeof uastring === \"object\") {\n      extensions = uastring;\n      uastring = undefined;\n    }\n\n    if (!(this instanceof UAParser)) {\n      return new UAParser(uastring, extensions).getResult();\n    }\n\n    var ua = uastring || (window && window.navigator && window.navigator.userAgent ? window.navigator.userAgent : EMPTY);\n    var rgxmap = extensions ? util.extend(regexes, extensions) : regexes;\n\n    this.getBrowser = function () {\n      var browser = {\n        name: undefined,\n        version: undefined\n      };\n      mapper.rgx.call(browser, ua, rgxmap.browser);\n      browser.major = util.major(browser.version);\n      return browser;\n    };\n\n    this.getCPU = function () {\n      var cpu = {\n        architecture: undefined\n      };\n      mapper.rgx.call(cpu, ua, rgxmap.cpu);\n      return cpu;\n    };\n\n    this.getDevice = function () {\n      var device = {\n        vendor: undefined,\n        model: undefined,\n        type: undefined\n      };\n      mapper.rgx.call(device, ua, rgxmap.device);\n      return device;\n    };\n\n    this.getEngine = function () {\n      var engine = {\n        name: undefined,\n        version: undefined\n      };\n      mapper.rgx.call(engine, ua, rgxmap.engine);\n      return engine;\n    };\n\n    this.getOS = function () {\n      var os = {\n        name: undefined,\n        version: undefined\n      };\n      mapper.rgx.call(os, ua, rgxmap.os);\n      return os;\n    };\n\n    this.getResult = function () {\n      return {\n        ua: this.getUA(),\n        browser: this.getBrowser(),\n        engine: this.getEngine(),\n        os: this.getOS(),\n        device: this.getDevice(),\n        cpu: this.getCPU()\n      };\n    };\n\n    this.getUA = function () {\n      return ua;\n    };\n\n    this.setUA = function (uastring) {\n      ua = uastring;\n      return this;\n    };\n\n    return this;\n  };\n\n  UAParser.VERSION = LIBVERSION;\n  UAParser.BROWSER = {\n    NAME: NAME,\n    MAJOR: MAJOR,\n    VERSION: VERSION\n  };\n  UAParser.CPU = {\n    ARCHITECTURE: ARCHITECTURE\n  };\n  UAParser.DEVICE = {\n    MODEL: MODEL,\n    VENDOR: VENDOR,\n    TYPE: TYPE,\n    CONSOLE: CONSOLE,\n    MOBILE: MOBILE,\n    SMARTTV: SMARTTV,\n    TABLET: TABLET,\n    WEARABLE: WEARABLE,\n    EMBEDDED: EMBEDDED\n  };\n  UAParser.ENGINE = {\n    NAME: NAME,\n    VERSION: VERSION\n  };\n  UAParser.OS = {\n    NAME: NAME,\n    VERSION: VERSION\n  };\n\n  if (typeof exports !== UNDEF_TYPE) {\n    if (typeof module !== UNDEF_TYPE && module.exports) {\n      exports = module.exports = UAParser;\n    }\n\n    exports.UAParser = UAParser;\n  } else {\n    if (typeof define === \"function\" && define.amd) {\n      define(function () {\n        return UAParser;\n      });\n    } else if (window) {\n      window.UAParser = UAParser;\n    }\n  }\n\n  var $ = window && (window.jQuery || window.Zepto);\n\n  if ($ && !$.ua) {\n    var parser = new UAParser();\n    $.ua = parser.getResult();\n\n    $.ua.get = function () {\n      return parser.getUA();\n    };\n\n    $.ua.set = function (uastring) {\n      parser.setUA(uastring);\n      var result = parser.getResult();\n\n      for (var prop in result) {\n        $.ua[prop] = result[prop];\n      }\n    };\n  }\n})(typeof window === \"object\" ? window : this);","import React from \"react\";\nimport { useStaticQuery, graphql } from \"gatsby\";\nimport Img from \"gatsby-image\";\n\nimport ComponentHeader from \"./ComponentHeader\";\n\n//styles\nimport s from \"./Partners.module.scss\";\n\nexport default () => {\n  const {\n    strapiPaCompany: { partners }\n  } = useStaticQuery(graphql`\n    query {\n      strapiPaCompany {\n        partners {\n          alt\n          partners_image {\n            childImageSharp {\n              fluid(maxWidth: 300) {\n                ...GatsbyImageSharpFluid\n              }\n            }\n          }\n          link\n        }\n      }\n    }\n  `);\n  return (\n    <>\n      {/* <ComponentHeader\n        style={{ marginTop: \"1rem\" }}\n        bgColor=\"white\"\n        textColor=\"purple\"\n        text=\"Our Partners\"\n      /> */}\n      <div className={`continer-fluid mb-5`}>\n        <div className={`container`}>\n          <div className={`row`}>\n            {partners.map(\n              ({\n                partners_image: {\n                  childImageSharp: { fluid }\n                },\n                link,\n                alt\n              }) => (\n                <div className={`col-sm-12 col-md-6 col-lg-4 mb-5`}>\n                  <div\n                    className={s.partnerContainer}\n                  >\n                    <a\n                      href={link}\n                      className={`${s.partner}`}\n                      target=\"_blank\"\n                      rel=\"nofollow noopener noreferrer\"\n                      style={{ border: \"2px solid var(--gray-400)\" }}\n                    >\n                      <div style={{ width: \"100%\" }}>\n                        <Img className={s.image} fluid={fluid} alt={alt} />\n                      </div>\n                    </a>\n                  </div>\n                </div>\n              )\n            )}\n          </div>\n        </div>\n      </div>\n    </>\n  );\n};\n","import { useRef, useState, useEffect } from 'react'\r\nimport ResizeObserver from 'resize-observer-polyfill'\r\nimport { useSpring } from 'react-spring'\r\n\r\nexport default function useMeasure() {\r\n  const ref = useRef()\r\n  const [bounds, set] = useState({ left: 0, top: 0, width: 0, height: 0 })\r\n  const [ro] = useState(() => new ResizeObserver(([entry]) => set(entry.contentRect)))\r\n  useEffect(() => {\r\n    ro.observe(ref.current);\r\n\r\n    return () => {\r\n      ro.unobserve(ref.current);\r\n      ro.disconnect()\r\n    }\r\n  }, [])\r\n  return [{ ref }, bounds || {viewHeight: 0, viewWidth: 0}]\r\n}\r\n\r\nexport function usePrevious(value) {\r\n  const ref = useRef()\r\n  useEffect(() => void (ref.current = value), [value])\r\n  return ref.current\r\n}\r\n\r\nexport function useTransitionHeight(initialValue = false) {\r\n  const [active, toggle] = useState(initialValue)\r\n  const previous = usePrevious(active)\r\n  const [bind, { height: viewHeight }] = useMeasure()\r\n  const { height } = useSpring({\r\n    from: { height: 0 },\r\n    to: { height: active ? viewHeight : 0 }\r\n  })\r\n  return [{ height: active && previous === active ? 'auto' : height, overflow: 'hidden' }, bind, () => toggle(!active), (bool) => { toggle(bool)}]\r\n}\r\n","import { useLayoutEffect, useContext } from \"react\";\r\nimport { layoutContext } from \"../components/layouts/original/layout\";\r\n\r\nexport default function useSetPageData(location) {\r\n  const setPageData = useContext(layoutContext);\r\n\r\n  useLayoutEffect(() => {\r\n    setPageData(location);\r\n  }, [setPageData, location]);\r\n}\r\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}","export * from '@react-spring/web';","import React from \"react\";\nimport { Link } from \"gatsby\";\nimport Image from \"gatsby-image\";\nimport { StaticQuery, graphql } from \"gatsby\";\n\n//styles\nimport s from \"./card.module.scss\";\n\nexport default ({ itemClassName }) => (\n  <StaticQuery\n    query={graphql`\n      query {\n        strapiPsRpa {\n          hero {\n            main_heading\n            service_icon {\n              childImageSharp {\n                fixed(width: 100, height: 100) {\n                  ...GatsbyImageSharpFixed\n                }\n              }\n            }\n          }\n        }\n      }\n    `}\n    render={data => {\n      const { hero } = data.strapiPsRpa;\n\n      return (\n        <div className={`${itemClassName} ${s.industry}`}>\n          <Link to=\"/solutions/rpa/\">\n            <div>\n              <div className={`hero-circle m-auto`}>\n                <Image\n                  fixed={\n                    hero[0].service_icon.childImageSharp.fixed\n                  }\n                  className={s.icon}\n                />\n                {/* <img src={icon} className={s.icon} /> */}\n              </div>\n              <h3 className={`text-center`}>{hero[0].main_heading}</h3>\n            </div>\n            <span className={`btn btn-secondary btn-lg ${s.button}`}>\n              Learn More\n            </span>\n          </Link>\n        </div>\n      );\n    }}\n  />\n);\n","export default function _setPrototypeOf(o, p) {\n  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {\n    o.__proto__ = p;\n    return o;\n  };\n\n  return _setPrototypeOf(o, p);\n}","// extracted by mini-css-extract-plugin\nmodule.exports = {\"partnerContainer\":\"Partners-module--partnerContainer--1jGBH\",\"image\":\"Partners-module--image--29SsO\",\"partner\":\"Partners-module--partner--2AKB3\"};","// extracted by mini-css-extract-plugin\nmodule.exports = {\"content\":\"TabToAccordion-module--content--CSeSo\",\"benefits\":\"TabToAccordion-module--benefits--36f1Y\",\"benefitsOverlay\":\"TabToAccordion-module--benefits-overlay--2R6cq\",\"btn\":\"TabToAccordion-module--btn--Ids9O\",\"active\":\"TabToAccordion-module--active--Iprx7\",\"paraDesk\":\"TabToAccordion-module--para-desk--22QLH\",\"visibleMdDown\":\"TabToAccordion-module--visible-md-down--16-p8\",\"visibleLg\":\"TabToAccordion-module--visible-lg--3zgBw\",\"bg\":\"TabToAccordion-module--bg--1nSBH\",\"tabletCenter\":\"TabToAccordion-module--tablet-center--1Ns4X\"};","import arrayWithHoles from \"./arrayWithHoles\";\nimport iterableToArrayLimit from \"./iterableToArrayLimit\";\nimport unsupportedIterableToArray from \"./unsupportedIterableToArray\";\nimport nonIterableRest from \"./nonIterableRest\";\nexport default function _slicedToArray(arr, i) {\n  return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();\n}","export default function _arrayWithHoles(arr) {\n  if (Array.isArray(arr)) return arr;\n}","export default function _iterableToArrayLimit(arr, i) {\n  if (typeof Symbol === \"undefined\" || !(Symbol.iterator in Object(arr))) return;\n  var _arr = [];\n  var _n = true;\n  var _d = false;\n  var _e = undefined;\n\n  try {\n    for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {\n      _arr.push(_s.value);\n\n      if (i && _arr.length === i) break;\n    }\n  } catch (err) {\n    _d = true;\n    _e = err;\n  } finally {\n    try {\n      if (!_n && _i[\"return\"] != null) _i[\"return\"]();\n    } finally {\n      if (_d) throw _e;\n    }\n  }\n\n  return _arr;\n}","export default function _nonIterableRest() {\n  throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}"],"sourceRoot":""}