{"version":3,"sources":["webpack:///./src/components/ScrollIndicator.tsx","webpack:///./src/components/VideoModal.tsx","webpack:///./src/pages/index.tsx","webpack:///./node_modules/tslib/tslib.es6.js","webpack:///./node_modules/core-js/modules/es6.array.find.js","webpack:///./node_modules/core-js/modules/es6.string.starts-with.js","webpack:///./node_modules/core-js/modules/_typed.js","webpack:///./node_modules/core-js/modules/_to-index.js","webpack:///./node_modules/core-js/modules/_array-fill.js","webpack:///./node_modules/gatsby/node_modules/@babel/runtime/helpers/esm/getPrototypeOf.js","webpack:///./node_modules/gatsby/node_modules/@babel/runtime/helpers/esm/setPrototypeOf.js","webpack:///./node_modules/gatsby/node_modules/@babel/runtime/helpers/esm/construct.js","webpack:///./node_modules/gatsby/node_modules/@babel/runtime/helpers/esm/wrapNativeSuper.js","webpack:///./node_modules/gatsby/node_modules/@babel/runtime/helpers/esm/isNativeFunction.js","webpack:///./node_modules/polished/dist/polished.es.js","webpack:///./node_modules/gatsby/node_modules/@babel/runtime/helpers/esm/inheritsLoose.js","webpack:///./node_modules/gatsby/node_modules/@babel/runtime/helpers/esm/assertThisInitialized.js","webpack:///./node_modules/hey-listen/dist/hey-listen.es.js","webpack:///./node_modules/framesync/dist/framesync.es.js","webpack:///./node_modules/style-value-types/dist/style-value-types.es.js","webpack:///./node_modules/@popmotion/easing/dist/easing.es.js","webpack:///./node_modules/@popmotion/popcorn/dist/popcorn.es.js","webpack:///./node_modules/stylefire/dist/stylefire.es.js","webpack:///./node_modules/popmotion/dist/popmotion.es.js","webpack:///./node_modules/framer-motion/dist/framer-motion.es.js","webpack:///./src/images/facebook-f-brands.inline.svg","webpack:///./src/images/twitter-brands.inline.svg","webpack:///./src/images/instagram-brands.inline.svg","webpack:///./node_modules/core-js/modules/es6.array.find-index.js","webpack:///./node_modules/core-js/modules/es7.object.values.js","webpack:///./node_modules/core-js/modules/_object-to-array.js","webpack:///./node_modules/core-js/modules/es6.typed.float32-array.js","webpack:///./node_modules/core-js/modules/_typed-array.js","webpack:///./node_modules/core-js/modules/_typed-buffer.js","webpack:///./node_modules/core-js/modules/_array-copy-within.js","webpack:///./src/images/chevron-left-solid.inline.svg","webpack:///./node_modules/core-js/modules/es6.string.sup.js","webpack:///./node_modules/core-js/modules/es6.string.sub.js","webpack:///./node_modules/core-js/modules/es6.string.small.js","webpack:///./node_modules/core-js/modules/es6.array.of.js","webpack:///./node_modules/use-sidecar/dist/es2015/exports.js","webpack:///./node_modules/react-style-singleton/dist/es2015/singleton.js","webpack:///./node_modules/react-style-singleton/dist/es2015/component.js","webpack:///./node_modules/react-style-singleton/dist/es2015/hook.js","webpack:///./node_modules/react-remove-scroll-bar/dist/es2015/utils.js","webpack:///./node_modules/react-remove-scroll-bar/dist/es2015/component.js","webpack:///./node_modules/react-remove-scroll/dist/es2015/handleScroll.js","webpack:///./node_modules/react-remove-scroll/dist/es2015/aggresiveCapture.js","webpack:///./node_modules/react-remove-scroll/dist/es2015/SideEffect.js","webpack:///./node_modules/use-sidecar/dist/es2015/medium.js","webpack:///./node_modules/react-remove-scroll/dist/es2015/medium.js","webpack:///./node_modules/react-remove-scroll/dist/es2015/sidecar.js","webpack:///./node_modules/react-remove-scroll/dist/es2015/UI.js","webpack:///./node_modules/react-remove-scroll-bar/dist/es2015/constants.js","webpack:///./src/data/Photos.ts","webpack:///./src/components/ImageModalPhoto.tsx","webpack:///./src/components/ImageModal.tsx","webpack:///./src/components/ShareLinks.tsx","webpack:///./src/config.ts","webpack:///./src/images/play-circle-light.inline.svg"],"names":["ScrollIndicator","props","progressBarRef","useRef","handleScroll","el","document","getElementById","scrolled","scrollTop","scrollHeight","clientHeight","current","style","width","useLayoutEffect","addEventListener","removeEventListener","ScrollIndicatorContainer","ProgressBar","ref","styled","div","COLOURS","blue","STYLES","easeOutQuint","VideoModal","visible","setIsVisible","useEffect","window","body","VideoModalWrapper","onClick","initial","opacity","animate","exit","VideoFrame","src","allow","allowFullScreen","frameBorder","motion","headerSize","rgba","charcoal","white","desktopSize","iframe","StyledImg","Img","HomeStyles","createGlobalStyle","ParallaxContainer","HomePageContainer","Hero","Content","background","Titles","PlayVideo","PlayText","span","ImageContainer","GatsbyImg","mobileHeight","desktopHeight","img","ImageCaption","maxWidth","Images","pageQuery","IndexPage","useState","isVideoModalVisible","setIsVideoModalVisible","useMediaQuery","query","data","heroImage","Pocock_Tassie_266","Pocock_Tassie_247","Pocock_Tassie_205","Pocock_Tassie_94","Pocock_Tassie_136","Pocock_Tassie_201","Pocock_Tassie_318","Pocock_Tassie_311","Pocock_Tassie_284","Pocock_Tassie_397","Pocock_Tassie_406","Pocock_Tassie_304","Layout","inverseColor","footer","header","Helmet","name","content","property","id","Header","inverseHeader","fluid","childImageSharp","imgStyle","objectPosition","HERO_SUBTITLE_TEXT","height","ShareLinks","padding","margin","alt","ProductLink","product","Footer","_extendStatics","d","b","Object","setPrototypeOf","__proto__","Array","p","hasOwnProperty","__extends","__","this","constructor","prototype","create","_assign","assign","t","s","i","n","arguments","length","call","apply","__rest","e","indexOf","getOwnPropertySymbols","propertyIsEnumerable","$export","$find","forced","P","F","find","callbackfn","undefined","toLength","context","$startsWith","startsWith","searchString","that","index","Math","min","search","String","slice","Typed","global","hide","uid","TYPED","VIEW","ABV","ArrayBuffer","DataView","CONSTR","TypedArrayConstructors","split","module","exports","toInteger","it","number","RangeError","toObject","toAbsoluteIndex","value","O","aLen","end","endPos","_getPrototypeOf","o","getPrototypeOf","_setPrototypeOf","Parent","args","Class","Reflect","construct","sham","Proxy","Date","toString","isNativeReflectConstruct","a","push","instance","Function","bind","_cache","Map","fn","TypeError","has","get","set","Wrapper","enumerable","writable","configurable","_Error","subClass","superClass","PolishedError","code","self","ReferenceError","_assertThisInitialized","Error","colorToInt","color","round","convertToInt","red","green","hslToRgb","hue","saturation","lightness","convert","huePrime","chroma","abs","secondComponent","lightnessModification","namedColorMap","aliceblue","antiquewhite","aqua","aquamarine","azure","beige","bisque","black","blanchedalmond","blueviolet","brown","burlywood","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","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","rosybrown","royalblue","saddlebrown","salmon","sandybrown","seagreen","seashell","sienna","silver","skyblue","slateblue","slategray","slategrey","snow","springgreen","steelblue","tan","teal","thistle","tomato","turquoise","violet","wheat","whitesmoke","yellow","yellowgreen","hexRegex","hexRgbaRegex","reducedHexRegex","reducedRgbaHexRegex","rgbRegex","rgbaRegex","hslRegex","hslaRegex","parseToRgb","normalizedColor","normalizedColorName","toLowerCase","nameToHex","match","parseInt","alpha","parseFloat","toFixed","_alpha","rgbMatched","exec","rgbaMatched","hslMatched","rgbColorString","hslRgbMatched","hslaMatched","_rgbColorString","_hslRgbMatched","reduceHexValue","numberToHex","hex","rgb","firstValue","secondValue","thirdValue","fourthValue","rgbValue","warning","invariant","StepId","prevTime","onNextFrame","requestAnimationFrame","callback","timestamp","now","timeToCall","max","setTimeout","defaultElapsed","useDefaultElapsed","willRunNextFrame","delta","stepsOrder","Read","Update","Render","PostRender","setWillRunNextFrame","willRun","reduce","acc","key","setRunNextFrame","processToRun","processToRunNextFrame","numThisFrame","isProcessing","cancelled","toKeepAlive","renderStep","step","WeakSet","cancel","process","indexOfCallback","add","splice","frame","_a","process_1","schedule","keepAlive","immediate","addToCurrentBuffer","buffer","sync","startLoop","cancelSync","steps","processStep","stepId","processFrame","forEach","getFrameData","v","sanitize","Number","floatRegex","colorRegex","singleColorRegex","test","parse","transform","createUnitType","unit","endsWith","degrees","percent","px","vh","vw","progressPercentage","clampRgbUnit","isRgba","isHsla","splitColorValues","terms","values","valuesArray","substring","lastIndexOf","rgbUnit","isColorString","colorType","_b","alpha$$1","rgbaTemplate","hsla","hslaTemplate","r","g","substr","convertNumbersToZero","complex","isNaN","numValues","foundNumbers","foundColors","input","parsed","replace","map","createTransformer","prop","template","token","numColors","numNumbers","output","getAnimatableNone","target","parsedTarget","targetTransformer","reversed","easing","mirrored","createReversedEasing","createMirroredEasing","createExpoIn","power","pow","createBackIn","createAnticipateEasing","backEasing","linear","easeIn","easeOut","easeInOut","circIn","sin","acos","circOut","circInOut","backIn","backOut","backInOut","anticipate","bounceOut","p2","bounceIn","bounceInOut","NEWTON_ITERATIONS","NEWTON_MIN_SLOPE","SUBDIVISION_PRECISION","SUBDIVISION_MAX_ITERATIONS","K_SPLINE_TABLE_SIZE","K_SAMPLE_STEP_SIZE","FLOAT_32_SUPPORTED","Float32Array","a1","a2","c","getSlope","calcBezier","cubicBezier","mX1","mY1","mX2","mY2","sampleValues","getTForX","aX","dist","guessForT","initialSlope","intervalStart","currentSample","lastSample","aGuessT","currentSlope","newtonRaphsonIterate","aA","aB","currentX","currentT","binarySubdivide","calcSampleValues","zeroPoint","x","y","z","isNum","curryRange","func","cv","clamp$1","isPoint","point","isPoint3D","distance1D","distance","xDelta","yDelta","zDelta","sqrt","from","to","toFromDifference","mix","progress","mixLinearColor","fromExpo","toExpo","colorTypes","getColorType","type","notAnimatable","color$$1","fromColorType","toColorType","fromColor","toColor","blended","mixFunc","combineFunctions","pipe","transformers","_i","getMixer","origin","mixArray","blendValue","fromThis","analyse","numRGB","numHSL","originStats","targetStats","identity","springForce","alterDisplacement","constant","displacement","springModifiedDisplacement","velocityPerSecond","velocity","frameDuration","rangeSize","testElement","onRead","onRender","uncachedValues","Set","_c","useCache","state","changedValues","hasChanged","setValue","hasCSSVariable","currentValue","render","styler","forceRead","forceRender","CAMEL_CASE_PATTERN","camelToDash","str","camelCache","dashCache","prefixes","numPrefixes","isBrowser","setDashPrefix","prefixed","prefixer","asDashCase","cache","createElement","prefix","noPrefix","prefixedPropertyName","charAt","toUpperCase","testPrefix","setServerProperty","axes","transformProps","axesAcc","axesKey","transformPropDictionary","dict","isTransformProp","sortTransformProps","transformOriginProps","isTransformOriginProp","_int","valueTypes","backgroundColor","outlineColor","fill","stroke","borderColor","borderTopColor","borderRightColor","borderBottomColor","borderLeftColor","borderWidth","borderTopWidth","borderRightWidth","borderBottomWidth","borderLeftWidth","borderRadius","radius","borderTopLeftRadius","borderTopRightRadius","borderBottomRightRadius","borderBottomLeftRadius","maxHeight","size","top","right","bottom","left","paddingTop","paddingRight","paddingBottom","paddingLeft","marginTop","marginRight","marginBottom","marginLeft","rotate","rotateX","rotateY","rotateZ","scale","scaleX","scaleY","scaleZ","skew","skewX","skewY","translateX","translateY","translateZ","perspective","originX","originY","originZ","zIndex","fillOpacity","strokeOpacity","numOctaves","getValueType","getValueAsType","SCROLL_LEFT","SCROLL_TOP","scrollKeys","blacklist","translateAlias","isCustomTemplate","buildStyleProperty","enableHardwareAcceleration","styles","transformOrigin","transformKeys","isDashCase","transformIsDefault","hasTransform","hasTransformOrigin","valueType","valueAsType","transformString","transformHasZ","sort","numTransformKeys","trim","buildTransform","createStyleBuilder","cssStyler","options","element","preparseOutput","defaultValueType","domValue","getComputedStyle","getPropertyValue","buildStyles","numChangedValues","setProperty","camelCaseAttributes","defaultOrigin","svgAttrsTemplate","unmeasured","calcOrigin","offset","buildSVGAttrs","dimensions","totalPathLength","cssBuilder","attrs","pathLength","pathSpacing","pathOffset","calculateSVGTransformOrigin","createAttrBuilder","svgStyler","getAttribute","buildAttrs","setAttribute","viewport","pageYOffset","pageXOffset","scrollLeft","scrollTo","WeakMap","node","HTMLElement","createCssStyler","SVGElement","getBBox","getBoundingClientRect","getDimensions","getSVGElementDimensions","tagName","isPath","getTotalLength","getStyler","nodeOrSelector","querySelector","Observer","observer","_this","middleware","onComplete","isActive","update","updateObserver","complete","error","err","m","createObserver","observerCandidate","Action","start","isComplete","subscription","stop","init","observerProps","api","applyMiddleware","concat","funcs","pipedUpdate","unitTypes","findUnitType","createAction","action","unitType","mixer","createColorAction","createComplexAction","createVectorAction","typeTests","testNames","keys","isVectorProp","getVectorKeys","vectorKeys","testVectorProps","some","createVectorTests","testProp","Boolean","isUnitProp","vectorDecay","_d","_e","timeConstant","_f","restDelta","modifyTarget","elapsed","amplitude","idealTarget","frameDelta","exp","isMoving","vectorSpring","stiffness","damping","_g","mass","_h","restSpeed","_j","initialVelocity","position","prevPosition","timeDelta","dampingRatio","angularFreq","envelope","expoDecay","cos","isBelowVelocityThreshold","isBelowDisplacementThreshold","bounceStiffness","bounceDamping","activeAnimation","_complete","prev","isSpring","isLessThanMin","isMoreThanMax","isOutOfBounds","onUpdate","currentVelocity","isTravellingAwayFromBounds","startSpring","startAnimation","animation","next","vectorScrubber","ease","reverseEase","seek","duration","flip","loop","yoyo","repeatDelay","_k","_l","flipCount","_m","yoyoCount","_o","loopCount","playhead","currentProgress","_isActive","reverseAnimation","updateTween","startTimer","stopTimer","getElapsed","getProgress","pause","resume","newProgress","reverse","clampProgress$1","easings","times","tweenProps","isArray","defaultTimings","scrubbers","rangeLength","finalInputIndex","finalScrubberIndex","subs","scrub","progressInRange","listen","events","eventNames","eventName","defaultPointerPos","clientX","clientY","pageX","pageY","eventToPoint","points","passive","capture","touches","numTouches","thisTouch","timeToDelay","timeout","clearTimeout","isFloat","MotionValue","transformer","parent","lastUpdated","canTrackVelocity","updateAndNotify","updateSubscribers","notifySubscriber","children","setChild","renderSubscribers","postRender","scheduleVelocityCheck","subscriber","velocityCheck","child","addChild","config","removeChild","subscribeTo","subscriptions","updateSubscriber","onChange","onRenderRequest","attach","passiveEffect","getVelocity","Promise","resolve","stopAnimation","then","clearAnimation","isAnimating","destroy","clear","motionValue","opts","useConstant","resolver","isMotionValue","syncRenderSession","isOpen","open","flush","updateStyler","MotionValuesMap","hasMounted","unsubscribers","bindValueToOutput","defaultValue","unsubscribeOnRender","unsubscribeOnChange","setOnUpdate","setTransformTemplate","transformTemplate","updateTransformTemplate","getTransformTemplate","mount","unmount","_value","unsubscribe","specialMotionValueProps","useMotionValues","motionValues","MountMotionValues","isStatic","Element","domStyler","resolveCurrent","resolvedValues","styleProp","motionValueStyles","transformValues","prevMotionStyles","thisStyle","isKeyframesTarget","resolveFinalValueInKeyframes","dimensionTypes","testValueType","getDimensionValueType","underDampedSpring","overDampedSpring","linearTween","defaultTransitions","definition","isEasingArray","secondsToMilliseconds","seconds","transitions","tween","spring","keyframes","inertia","just","transitionOptionParser","transitionDefinition","delay","when","delayChildren","staggerChildren","staggerDirection","transition","valueKey","transitionFactory","valueTransitionDefinition","isOriginAnimatable","isTargetAnimatable","actionFactory","preprocessOptions","delay$1","animationFactory","valueDelay","ValueAnimationControls","readValueFromSource","makeTargetAnimatable","variants","baseTarget","overrides","resolvedOverrides","activeOverrides","hasValue","setProps","setVariants","setDefaultTransition","defaultTransition","setValues","priority","transitionEnd","targetValue","checkForNewValues","newValueKeys","filter","numNewValues","resolveVariant","variant","custom","getHighestPriority","setOverride","overrideIndex","startOverride","override","clearOverride","highest","resetIsAnimating","overrideTarget","remainingValues","onStart","applyVariantLabels","variantLabelList","animateVariantLabels","animateVariant","animationDefinition","transitionOverride","animatable","animations","valueTarget","allAnimations","all","variantLabels","label","variantLabel","getAnimations","getChildrenAnimations","animateChildren","last","first","maxStaggerDuration","generateStaggerDuration","childControls","onAnimationStart","onAnimationComplete","checkOverrideIsAnimating","numOverrides","resolvedOverride","controls","resetChildren","AnimationControls","pendingAnimations","componentControls","subscribe","animations_1","MotionContext","isVariantLabel","isAnimationControls","parentContext","initialState","whileTap","whileHover","shouldPropagateControls","targetInitial","targetAnimate","initialDependency","animateDependency","initialToApply","Infinity","useValueAnimationControls","subscribeToParentControls","parentControls","unmountProps","Point","checkShouldInheritVariant","inherit","getValueControlsConfig","loadFunctionalityComponents","renderComponent","externalRef","external","useExternalRef","exitProps","isExiting","onExitComplete","applyExitProps","shouldInheritVariant","functionality","renderedComponent","Provider","svgElements","subtract","relativeTo","idOrElem","elem","localElem","rect","scrollX","scrollY","MotionPluginContext","transformPagePoint","isViewportScrollBlocked","event","preventDefault","blockViewportScroll","unblockViewportScroll","isMouseEvent","PointerEvent","pointerType","MouseEvent","isTouchEvent","useUnmountEffect","addDomEvent","handler","defaultPagePoint","pointFromMouse","wrapHandler","shouldFilterPrimaryPointer","listener","changedTouches","extractEventInfo","eventHandler","button","filterPrimaryPointer","isBrowser$1","supportsPointerEvents","onpointerdown","supportsTouchEvents","ontouchstart","supportsMouseEvents","onmousedown","mouseEventNames","pointerdown","pointermove","pointerup","pointercancel","pointerover","pointerout","pointerenter","pointerleave","touchEventNames","getPointerEventName","addPointerEvent","usePointerEvent","useDomEvent","startDevicePoint","session","pointHistory","lastDevicePoint","getVelocity$1","timestampedPoint","lastPoint","time","usePanGesture","onPan","onPanStart","onPanEnd","onPanSessionStart","hasPanEvents","lastMoveEvent","lastMoveEventInfo","pointerEventSubscription","handlers","removePointerEvents","getPanInfo","currentPoint","transformPoint","info","cancelPan","updatePoint","panStarted","startEvent","distancePastThreshold","onPointerMove","buttons","onPointerUp","initialInfo","removeOnPointerMove","removeOnPointerUp","isNodeOrChild","parentElement","getGesturePriority","gesture","createLock","lock","globalHorizontalLock","globalVerticalLock","getGlobalLock","drag","openHorizontal_1","openVertical_1","tapGesturePriority","hoverPriority","filterTouch","useGestures","onTap","onTapStart","onTapCancel","hasTapListeners","isTapping","cancelPointerEventListener","removePointerUp","openGestureLock","useTapGesture","onHoverStart","onHoverEnd","useHoverGesture","makeHookComponent","hook","gestureProps","Gestures","shouldRender","Component","innerRef","isRefObject","useMotionValue","allowDefaultPointerDown","getBoundingBox","getCurrentOffset","constraintsRef","draggableRef","parentBoundingBox","draggableBoundingBox","shouldDrag","direction","currentDirection","getConstraints","axis","applyConstraints","constraints","dragElastic","constrainedValue","applyOverdrag","bothAxis","useDrag","dragDirectionLock","dragPropagation","dragConstraints","dragMomentum","_dragValueX","_dragValueY","_dragTransitionControls","dragOriginX","dragOriginY","dragTransition","onDirectionLock","onDragStart","onDrag","onDragEnd","onDragTransitionEnd","constraintsNeedResolution","dragStatus","isDragging","onResize","defaultOriginX","defaultOriginY","openGlobalLock","prevConstraintsBox","scalePoint","constraintsBox","draggableBox","scaleAxisPoint","dimension","pointToScale","recordBoxInfo","top_1","applyConstraintsToPoint","axisPoint","convertPanToDrag","cancelDrag","lockThreshold","getCurrentDirection","onDirectionLock_1","momentumAnimations","animateDragEnd","activeElement","blur","Drag","isCSSVariable","cssVariableRegex","maxDepth","getVariableValue","depth","parseCSSVariable","fallback","resolved","BoundingBoxDimension","positionalKeys","isPositionalKey","hasPositionalKey","setAndResetVelocity","getPosFromMatrix","matrix","pos","getTranslateFromMatrix","pos2","pos3","_bbox","matrix3d","nonTranslationalTransformKeys","positionalValues","elementStyler","targetPositionalKeys","removedTransformValues","hasAttemptedToRemoveTransformValues","changedValueTypeKeys","toType","fromType","numKeyframes","removedTransforms","removeNonTranslationalTransform","convertedTarget","changedKeys","originBbox","elementComputedStyle","display","originComputedStyle","targetBbox","convertChangedValueTypes","parseDomVariant","resolveCSSVariables","unitConversion","useForceUpdate","forcedRenderCount","setForcedRenderCount","StepName","SyncLayoutContext","jobs","Prepare","jobsNeedProcessing","flushCallbackList","list","numJobs","flushAllJobs","prepare","read","createUseSyncEffect","stepName","layoutSync","defaultLayoutTransition","defaultPositionTransition","centerOf","getLayout","measure","offsetLeft","offsetTop","offsetWidth","offsetHeight","boundingBox","readPositionStyle","isSizeKey","useLayoutAnimation","layoutTransition","positionOnly","isHTMLElement","compare","nextPosition","getLayoutType","prevCenter","nextCenter","calcDelta","isResolver","makeTransition","layoutKey","transformKey","visualOrigin","deltaKey","baseTransition","getDefaultLayoutTransition","offsetToApply","AnimatePropType","positionTransition","validMotionProps","isValidMotionProp","hasUpdated","prevLength","shallowCompare","targetWithoutTransition","mergeTransitionEnd","_a$1","resolveVariantLabels","unresolvedVariant","asDependencyList","join","hasVariantChanged","oldVariant","newVariant","AnimatePropComponents","Target","targetAndTransition","isInitialRender","prevValues","targetToAnimate","animatingTarget","finalTarget","shouldAnimateOnMount","isValidValue","valueHasUpdated","useAnimateProp","VariantLabel","targetVariants","parentAlreadyMounted","shouldAnimate","useVariants","AnimationSubscription","useAnimationGroupSubscription","isAnimationSubscription","animationProps","animatePropTypeTests","getAnimationComponent","animatePropType","isPropValid","emotionIsPropValid_1","functionalityComponents","numFunctionalityComponents","createDomMotionConfig","isDOM","isSVG","forwardedProps","domProps","filterValidProps","staticVisualStyles","activeComponents","Animation","Component_1","htmlMotionComponents","svgMotionComponents","getChildKey","exitBeforeEnter","localForceUpdate","forceUpdate","filteredChildren","filtered","onlyElements","presentChildren","allChildren","exiting","updateChildLookup","childrenToRender","presentKeys","targetKeys","numPresent","insertionIndex","removeIndex","findIndex","React","FacebookFBrandsInline","defaultProps","default","TwitterBrandsInline","InstagramBrandsInline","KEY","$values","S","DESCRIPTORS","getKeys","toIObject","isEnum","f","isEntries","result","byteOffset","LIBRARY","fails","$typed","$buffer","ctx","anInstance","propertyDesc","redefineAll","toIndex","toPrimitive","classof","isObject","isArrayIter","gOPN","getIterFn","wks","createArrayMethod","createArrayIncludes","speciesConstructor","ArrayIterators","Iterators","$iterDetect","setSpecies","arrayFill","arrayCopyWithin","$DP","$GOPD","dP","gOPD","Uint8Array","ArrayProto","$ArrayBuffer","$DataView","arrayForEach","arrayFilter","arraySome","arrayEvery","arrayFind","arrayFindIndex","arrayIncludes","arrayIndexOf","arrayValues","arrayKeys","arrayEntries","entries","arrayLastIndexOf","arrayReduce","arrayReduceRight","reduceRight","arrayJoin","arraySort","arraySlice","arrayToString","arrayToLocaleString","toLocaleString","ITERATOR","TAG","TYPED_CONSTRUCTOR","DEF_CONSTRUCTOR","ALL_CONSTRUCTORS","TYPED_ARRAY","$map","allocate","LITTLE_ENDIAN","Uint16Array","FORCED_SET","toOffset","BYTES","validate","C","speciesFromList","fromList","addGetter","internal","$from","source","iterator","mapfn","mapping","iterFn","done","$of","TO_LOCALE_BUG","$toLocaleString","proto","copyWithin","every","predicate","searchElement","includes","separator","middle","floor","comparefn","subarray","begin","$begin","BYTES_PER_ELEMENT","$slice","$set","arrayLike","len","$iterators","isTAIndex","$getDesc","$setDesc","desc","getOwnPropertyDescriptor","defineProperty","$TypedArrayPrototype$","wrapper","CLAMPED","NAME","GETTER","SETTER","TypedArray","Base","TAC","FORCED","TypedArrayPrototype","addElement","getter","setter","$offset","$length","byteLength","klass","$len","l","iter","$nativeIterator","CORRECT_ITER_NAME","$iterator","G","W","of","setToStringTag","PROTOTYPE","WRONG_INDEX","BaseBuffer","log","LN2","$BUFFER","$LENGTH","$OFFSET","packIEEE754","mLen","nBytes","eLen","eMax","eBias","rt","unpackIEEE754","nBits","NaN","unpackI32","bytes","packI8","packI16","packI32","packF64","packF32","view","isLittleEndian","intIndex","store","pack","conversion","ArrayBufferProto","j","$setInt8","setInt8","getInt8","setUint8","bufferLength","getUint8","getInt16","getUint16","getInt32","getUint32","getFloat32","getFloat64","setInt16","setUint16","setInt32","setUint32","setFloat32","setFloat64","count","inc","ChevronLeftSolidInline","createHTML","createProperty","sideCar","rest","isSideCarExport","stylesheetSingleton","counter","stylesheet","tag","css","makeStyleTag","styleSheet","cssText","appendChild","createTextNode","head","getElementsByTagName","insertStyleTag","remove","parentNode","sheet","useStyle","zeroGap","gap","getGapWidth","gapMode","offsets","cs","getOffset","documentWidth","documentElement","clientWidth","windowWidth","innerWidth","allowRelative","important","setGap","noRelative","noImportant","locationCouldBeScrolled","elementCouldBeScrolled","getScrollVariables","overflowY","overflowX","elementCouldBeVScrolled","elementCouldBeHScrolled","scrollWidth","getHScrollVariables","endTarget","sourceDelta","targetInLock","contains","shouldCancelScroll","isDeltaPositive","availableScroll","availableScrollTop","elementScroll","passiveSupported","nonPassive","getTouchXY","getDeltaXY","deltaX","deltaY","extractRef","deltaCompare","generateStyle","idCounter","lockStack","ItoI","innerCreateMedium","defaults","assigned","useMedium","item","assignSyncMedium","cb","cbs","assignMedium","pendingQueue","executeQueue","cycle","_filter","exported","effectCar","medium","async","ssr","createSidecarMedium","shouldPreventQueue","touchStartRef","activeAxis","Style","lastProps","inert","classList","allow_1","lockRef","shards","shouldCancelEvent","currentAxis","touch","touchStart","moveDirection","canBeScrolledInMainDirection","cancelingAxis","shouldPrevent","sourceEvent","should","shardNodes","noIsolation","shouldCancel","scrollTouchStart","scrollWheel","scrollTouchMove","setCallbacks","onScrollCapture","onWheelCapture","onTouchMoveCapture","inst","removeScrollBar","nothing","callbacks","forwardProps","className","enabled","SideCar","containerProps","only","classNames","fullWidth","zeroRight","PHOTOS","ModalImg","console","images","edges","file","image","objectFit","enter","center","ImageModal","memo","setIsImageModalVisible","handleChangePhoto","selectedImage","setSelectedImage","caption","model","lens","settings","photoDetails","setPhotoDetails","setImageSrc","downHandler","keyCode","imageSrc","sidecar","ImageModalWrapper","ModalContent","Close","PhotoContainer","SwitchControl","PhotoWrapper","MotionContainer","random","swipe","swipePower","ImageInfo","ProductInfo","Model","Details","textSize2","displayStyle","linkTo","hasLinkBeenCopied","setHasLinkBeenCopied","ShareLinksContainer","IconLink","href","rel","aria-label","ShareLabel","ShareLink","textArea","select","execCommand","textSize3","PlayCircleLightInline"],"mappings":"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","file":"component---src-pages-index-tsx-0e553a9d19ac70476b2a.js","sourcesContent":["import React, { useState, useEffect, useRef, useLayoutEffect } from \"react\";\r\nimport styled from 'styled-components';\r\nimport { STYLES } from \"../styles/Styles\";\r\nimport { COLOURS } from \"../styles/Colours\";\r\n\r\ninterface Props {\r\n\r\n}\r\n\r\nexport const ScrollIndicator = (props: Props) => {\r\n\r\n  const progressBarRef = useRef<HTMLDivElement>();\r\n\r\n  const handleScroll = () => {\r\n    const el = document.getElementById(\"scrollingContent\");\r\n    const winScroll = el.scrollTop;\r\n    const height = el.scrollHeight - el.clientHeight;\r\n    const scrolled = (winScroll / height) * 100;\r\n    progressBarRef.current.style.width = `${scrolled}%`;\r\n  }\r\n\r\n  useLayoutEffect(() => {\r\n\r\n    const el = document.getElementById(\"scrollingContent\");\r\n    el.addEventListener('scroll', handleScroll);\r\n    return () => {\r\n      el.removeEventListener('scroll', handleScroll);\r\n    }\r\n  })\r\n\r\n  return (\r\n    <ScrollIndicatorContainer>\r\n      <ProgressBar ref={progressBarRef}/>\r\n    </ScrollIndicatorContainer>\r\n  )\r\n}\r\n\r\nconst ScrollIndicatorContainer = styled.div`\r\n  position: fixed;\r\n  z-index: 1;\r\n  top: 0;\r\n  width: 100vw;\r\n  height: 4px;\r\n`;\r\n\r\nconst ProgressBar = styled.div`\r\n  height: 100%;\r\n  width: 0;\r\n  background-color: ${COLOURS.blue};\r\n  transition: width 0ms ${STYLES.easeOutQuint};\r\n`;","import React, { useEffect } from \"react\";\r\nimport ReactDOM from 'react-dom';\r\nimport styled from 'styled-components';\r\nimport { COLOURS } from './../styles/Colours';\r\nimport { rgba } from 'polished';\r\nimport { STYLES } from \"../styles/Styles\";\r\nimport CloseIcon from '../images/times-light.inline.svg';\r\nimport { Close } from \"./ImageModal\";\r\nimport { AnimatePresence, motion } from \"framer-motion\";\r\n\r\ninterface Props {\r\n  visible: boolean;\r\n  setIsVisible: any;\r\n}\r\n\r\nexport const VideoModal = (props: Props) => {\r\n  const {\r\n    visible,\r\n    setIsVisible\r\n  } = props;\r\n\r\n\r\n  let el;\r\n  useEffect(() => {\r\n    const el = window.document.body;\r\n  }, []);\r\n\r\n  return (\r\n    <AnimatePresence>\r\n      {visible &&\r\n\r\n        <VideoModalWrapper\r\n          onClick={() => setIsVisible(false)}\r\n          initial={{ opacity: 0 }}\r\n          animate={{ opacity: 1 }}\r\n          exit={{ opacity: 0 }}\r\n        >\r\n          <Close onClick={() => setIsVisible(false)}><CloseIcon /> Close</Close>\r\n          <VideoFrame\r\n            src=\"https://www.youtube.com/embed/2vvPRoevwHw?&autoplay=1\"\r\n            allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\"\r\n            allowFullScreen\r\n            frameBorder='none'\r\n          />\r\n\r\n        </VideoModalWrapper>\r\n\r\n      }\r\n    </AnimatePresence>\r\n  )\r\n\r\n}\r\n\r\nconst VideoModalWrapper = styled(motion.div)`\r\n  position: fixed;\r\n  height: 100%;\r\n  width: 100%;\r\n  display: flex;\r\n  flex-direction: column;\r\n  align-items: center;\r\n  justify-content: center;\r\n  top: ${STYLES.headerSize};\r\n  top: 0;\r\n  left: 0;\r\n  background-color: ${rgba(COLOURS.charcoal, 0.9)};\r\n  color: ${COLOURS.white};\r\n  z-index: 99;\r\n  @media(min-width: ${STYLES.desktopSize}) {\r\n    padding: 2rem 8rem;\r\n  }\r\n`;\r\n\r\nconst VideoFrame = styled.iframe`\r\n  width: 100%;\r\n  @media(max-width: ${STYLES.desktopSize}) {\r\n    height: 67.1%;\r\n  }\r\n  @media(min-width: ${STYLES.desktopSize}) {\r\n    height: 100%;\r\n    max-height: 800px;\r\n  }\r\n`;\r\n\r\n","import { graphql } from 'gatsby';\r\nimport Img from 'gatsby-image';\r\nimport React, { useState, useEffect } from \"react\";\r\nimport { Helmet } from \"react-helmet\";\r\nimport { useMediaQuery } from 'react-responsive';\r\nimport styled, { createGlobalStyle, css } from 'styled-components';\r\nimport { Footer } from \"../components/Footer\";\r\nimport Header from \"../components/Header\";\r\nimport { Layout } from \"../components/Layout\";\r\nimport { ProductLink } from \"../components/ProductLink\";\r\nimport { ScrollIndicator } from \"../components/ScrollIndicator\";\r\nimport { ShareLinks } from \"../components/ShareLinks\";\r\nimport { VideoModal } from '../components/VideoModal';\r\nimport PlayIcon from '../images/play-circle-light.inline.svg';\r\nimport { COLOURS } from \"../styles/Colours\";\r\nimport { BigQuote, Block, MediumQuote, Subtitle, Title } from \"../styles/Components\";\r\nimport { STYLES } from \"../styles/Styles\";\r\nimport {\r\n  HomeParagraph1,\r\n  HomeParagraph2,\r\n  HomeParagraph3,\r\n  HomeParagraph4,\r\n  HomeParagraph5,\r\n  HomeParagraph6,\r\n  HomeParagraph7,\r\n  HomeParagraph8,\r\n  HomeParagraph9,\r\n  HomeQuote1,\r\n  HomeQuote2,\r\n  HERO_SUBTITLE_TEXT\r\n} from './../components/Copy';\r\n\r\nconst IndexPage = (props: any) => {\r\n\r\n  const [isVideoModalVisible, setIsVideoModalVisible] = useState<boolean>(false);\r\n  const isTabletOrMobile = useMediaQuery({ query: '(max-width: 1224px)' });\r\n\r\n  useEffect(() => {\r\n  }, []);\r\n\r\n  const {\r\n    heroImage,\r\n    Pocock_Tassie_266,\r\n    Pocock_Tassie_247,\r\n    Pocock_Tassie_205,\r\n    Pocock_Tassie_94,\r\n    Pocock_Tassie_136,\r\n    Pocock_Tassie_201,\r\n    Pocock_Tassie_318,\r\n    Pocock_Tassie_311,\r\n    Pocock_Tassie_284,\r\n    Pocock_Tassie_397,\r\n    Pocock_Tassie_406,\r\n    Pocock_Tassie_304\r\n  } = props.data;\r\n\r\n  return (\r\n    <Layout inverseColor footer={false} header={false}>\r\n      <Helmet>\r\n        <meta name=\"robots\" content=\"index,follow\" />\r\n        <title>David Pocock's Passion for Photography & Conservation Collide</title>\r\n        <meta name=\"description\" content=\"Join Australia Wallabies' forward David Pocock on his journey through the Tarkine region in Tasmania where he let two of his passions collide; wildlife photography and conservation\" />\r\n        <meta name=\"site-section\" content=\"Explore\" />\r\n        <meta name=\"page-template\" content=\"Story Page\" />\r\n        <meta name=\"page-category\" content=\"Get Inspired\" />\r\n        <meta name=\"og:title\" property=\"og:title\" content=\"David Pocock's Passion for Photography & Conservation Collide\" />\r\n        <meta name=\"og:description\" property=\"og:description\" content=\"Join Australia Wallabies' forward David Pocock on his journey through the Tarkine region in Tasmania where he let two of his passions collide; wildlife photography and conservation\" />\r\n      </Helmet>\r\n      <HomeStyles />\r\n      <VideoModal\r\n        visible={isVideoModalVisible}\r\n        setIsVisible={setIsVideoModalVisible}\r\n      />\r\n      <ScrollIndicator />\r\n      <HomePageContainer id='scrollingContent'>\r\n        <ParallaxContainer>\r\n          <Header inverseHeader />\r\n\r\n          <Hero>\r\n            <StyledImg fluid={heroImage.childImageSharp.fluid} imgStyle={{objectPosition: 'right 0%'}}/>\r\n            <Titles>\r\n              <Title>An Unlikely Union</Title>\r\n              <Subtitle>{HERO_SUBTITLE_TEXT}</Subtitle>\r\n            </Titles>\r\n            <PlayVideo onClick={() => setIsVideoModalVisible(true)}>\r\n              <PlayText>Watch the video</PlayText><PlayIcon height='50px' />\r\n            </PlayVideo>\r\n          </Hero>\r\n          <Content>\r\n            <Block>\r\n              <HomeQuote1 />\r\n              <ShareLinks style={{padding: '3rem 0'}}/>\r\n              <HomeParagraph1 />\r\n            </Block>\r\n            <ImageContainer style={{margin: '0 auto', maxWidth: STYLES.desktopSize, width: '100%'}}>\r\n                <GatsbyImg fluid={Pocock_Tassie_266.childImageSharp.fluid} alt='' mobileHeight={300} desktopHeight={700}/>\r\n              <ImageCaption>Taken with <ProductLink product='EOS 5D Mark IV'/>. <ProductLink product='EF 24-105mm f/4L IS USM' />. ISO 1000, f/5.0, 1/200s</ImageCaption>\r\n            </ImageContainer>\r\n            <Block>\r\n              <HomeParagraph2 />\r\n            </Block>\r\n            <ImageContainer>\r\n                <GatsbyImg fluid={Pocock_Tassie_247.childImageSharp.fluid} alt='' mobileHeight={300} desktopHeight={700}/>\r\n              <ImageCaption>Taken with <ProductLink product='EOS-1D X Mark II' />. <ProductLink product='EF 200-400mm f/4L IS USM Extender 1.4X' />. ISO 3200, f/7.1, 1/1250s</ImageCaption>\r\n            </ImageContainer>\r\n            <Block>\r\n              <HomeParagraph3 />\r\n            </Block>\r\n            <Images>\r\n              <ImageContainer>\r\n                  <GatsbyImg fluid={Pocock_Tassie_205.childImageSharp.fluid} mobileHeight={400} desktopHeight={600}/>\r\n                <ImageCaption>Taken with <ProductLink product='EOS R' />. <ProductLink product='RF 24-105mm f/4L IS USM' />. ISO 2000, f/4.0, 1/160s</ImageCaption>\r\n              </ImageContainer>\r\n              <ImageContainer>\r\n                  <GatsbyImg fluid={Pocock_Tassie_94.childImageSharp.fluid} mobileHeight={400} desktopHeight={600}/>\r\n                <ImageCaption>Taken with <ProductLink product='EOS 5D Mark IV' />. <ProductLink product='EF 50mm f/1.2L USM' />. ISO 640, f/3.5, 1/80s</ImageCaption>\r\n              </ImageContainer>\r\n            </Images>\r\n            <Block>\r\n              <HomeParagraph4 />\r\n            </Block>\r\n            <ImageContainer>\r\n                <GatsbyImg fluid={Pocock_Tassie_136.childImageSharp.fluid} alt='' mobileHeight={300} desktopHeight={700}/>\r\n              <ImageCaption>Taken with <ProductLink product='EOS 5D Mark IV' />. <ProductLink product='EF 24-105mm f/4L IS USM' />. ISO 800, f/4.0, 1/125s</ImageCaption>\r\n            </ImageContainer>\r\n            <Block>\r\n              <HomeParagraph5 />\r\n            </Block>\r\n            <Block>\r\n              <HomeQuote2 />\r\n            </Block>\r\n            <Images>\r\n              <ImageContainer>\r\n                  <GatsbyImg fluid={Pocock_Tassie_201.childImageSharp.fluid} mobileHeight={400} desktopHeight={600} />\r\n                <ImageCaption>Taken with <ProductLink product='EOS-1D X Mark II' />. <ProductLink product='EF 200-400mm f/4L IS USM Extender 1.4X' />. ISO 800, f/5.6, 1/500s</ImageCaption>\r\n              </ImageContainer>\r\n              <ImageContainer>\r\n                  <GatsbyImg fluid={Pocock_Tassie_318.childImageSharp.fluid} mobileHeight={400} desktopHeight={600}/>\r\n                <ImageCaption>Taken with <ProductLink product='EOS-1D X Mark II' />. <ProductLink product='EF 16-35mm f/2.8L II USM' />. ISO 1250, f/3.2, 1/40s</ImageCaption>\r\n              </ImageContainer>\r\n            </Images>\r\n            <Block>\r\n              <HomeParagraph6 />\r\n            </Block>\r\n            <ImageContainer style={{margin: '0 auto', maxWidth: STYLES.desktopSize, width: '100%'}}>\r\n                <GatsbyImg fluid={Pocock_Tassie_311.childImageSharp.fluid} alt='' mobileHeight={300} desktopHeight={700}/>\r\n              <ImageCaption>Taken with <ProductLink product='EOS 5D Mark IV' />. <ProductLink product='EF 50mm f/1.2L USM' />. ISO 6400, f/3.5, 1/120s</ImageCaption>\r\n            </ImageContainer>\r\n            <Block>\r\n              <HomeParagraph7 />\r\n            </Block>\r\n            <ImageContainer style={{ width: '100%' }}>\r\n                <GatsbyImg fluid={Pocock_Tassie_284.childImageSharp.fluid} alt='' mobileHeight={300} desktopHeight={600}/>\r\n              <ImageCaption>Taken with <ProductLink product='EOS-1D X Mark II' />. <ProductLink product='EF 200-400mm f/4L IS USM Extender 1.4X' />. ISO 12800, f/7.1, 1/1600s</ImageCaption>\r\n            </ImageContainer>\r\n            <Block>\r\n              <HomeParagraph8 />\r\n            </Block>\r\n            <Images>\r\n              <ImageContainer>\r\n                  <GatsbyImg fluid={Pocock_Tassie_397.childImageSharp.fluid} mobileHeight={400} desktopHeight={600} />\r\n                <ImageCaption>Taken with <ProductLink product='EOS 5D Mark IV' />. <ProductLink product='EF 24-105mm f/4L IS USM' />. ISO 1000, f/2.8, 1/640s</ImageCaption>\r\n              </ImageContainer>\r\n              <ImageContainer>\r\n                  <GatsbyImg fluid={Pocock_Tassie_406.childImageSharp.fluid} mobileHeight={400} desktopHeight={600}/>\r\n                <ImageCaption>Taken with <ProductLink product='EOS 5D Mark IV' />. <ProductLink product='EF 24-105mm f/4L IS USM' />. ISO 1000, f/2.8, 1/1000s</ImageCaption>\r\n              </ImageContainer>\r\n            </Images>\r\n            <Block>\r\n              <HomeParagraph9 />\r\n            </Block>\r\n            <ImageContainer style={{margin: '0 auto', maxWidth: STYLES.desktopSize, width: '100%'}}>\r\n                <GatsbyImg fluid={Pocock_Tassie_304.childImageSharp.fluid} alt='' mobileHeight={300} desktopHeight={700}/>\r\n              <ImageCaption>Taken with <ProductLink product='EOS 5D Mark IV' />. <ProductLink product='EF 50mm f/1.2L USM' />. ISO 1000, f/5.0, 1/500s</ImageCaption>\r\n            </ImageContainer>\r\n            <Footer />\r\n          </Content>\r\n        </ParallaxContainer>\r\n      </HomePageContainer>\r\n    </Layout>\r\n  )\r\n};\r\n\r\nconst StyledImg = styled(Img)`\r\n  height: 100vh;\r\n  width: 100vw;\r\n  opacity: 0.4;\r\n`;\r\n\r\nconst HomeStyles = createGlobalStyle`\r\n  main {\r\n  }\r\n  body {\r\n    height: 100%;\r\n  }\r\n  #layout {\r\n    height: 100% !important;\r\n  }\r\n`;\r\n\r\nconst ParallaxContainer = styled.div`\r\n  perspective: 1px;\r\n  perspective-origin: 0 0;\r\n  transform-style: preserve-3d;\r\n  width: 100%;\r\n  height: 100%;\r\n  min-height: min-content;\r\n  display: flex;\r\n  position: relative;\r\n  flex-direction: column;\r\n`;\r\n\r\nconst HomePageContainer = styled.div`\r\n  display: flex;\r\n  position: relative;\r\n  flex-direction: column;\r\n  width: 100%;\r\n  height: 100%;\r\n  overflow-x: hidden;\r\n  overflow-y: auto;\r\n  -webkit-overflow-scrolling: touch;\r\n  transform-style: preserve-3d;\r\n`;\r\n\r\nconst Hero = styled.div`\r\n  display: flex;\r\n  flex-direction: column;\r\n  align-items: center;\r\n  justify-content: center;\r\n  width: 100%;\r\n  background-color: ${COLOURS.charcoal};\r\n  color: ${COLOURS.white};\r\n  background-position: center top;\r\n  background-size: cover;\r\n  position: relative;\r\n\r\n  position: sticky;\r\n  top: 0px;\r\n\r\n  transform-origin: 0 0;\r\n  transform: translateZ(-2px) scale(3);\r\n  transform-style: preserve-3d;\r\n\r\n  z-index: -1;\r\n  flex-shrink: 0;\r\n`;\r\n\r\nconst Content = styled.div`\r\n  background-color: ${COLOURS.background};\r\n  width: 100%;\r\n  display: flex;\r\n  flex-direction: column;\r\n  min-height: min-content;\r\n`;\r\n\r\nconst Titles = styled.div`\r\n  margin-top:  ${STYLES.headerSize};\r\n  display: flex;\r\n  flex-direction: column;\r\n  justify-content: center;\r\n  margin-top: auto;\r\n  text-align: center;\r\n  width: 100%;\r\n  padding: 0 2rem;\r\n  position: absolute;\r\n  top: 30%;\r\n  >*:not(:first-child) {\r\n    margin-top: 0.5rem;\r\n  }\r\n`;\r\n\r\nconst PlayVideo = styled.div`\r\n  margin: auto 0;\r\n  display: flex;\r\n  align-items: center;\r\n  height: 40px;\r\n  position: absolute;\r\n  top: 60%;\r\n  :hover {\r\n    cursor: pointer;\r\n    opacity: 0.8;\r\n  }\r\n`;\r\n\r\nconst PlayText = styled.span`\r\n  font-size: 22px;\r\n  margin-right: 1rem;\r\n`;\r\n\r\nconst ImageContainer = styled.div`\r\n  display: flex;\r\n  flex-direction: column;\r\n  overflow: hidden;\r\n  align-items: center;\r\n\r\n  @media(min-width: ${STYLES.desktopSize}) {\r\n    padding: 2rem 0;\r\n  }\r\n`;\r\n\r\ninterface ImageWrapperProps {\r\n  mobileHeight?: number;\r\n  desktopHeight?: number;\r\n}\r\n\r\nconst ImageWrapper = styled.div<ImageWrapperProps>`\r\n  display: flex;\r\n\r\n  @media(max-width: ${STYLES.desktopSize}) {\r\n    height: ${props => `${props.mobileHeight}px`};\r\n  }\r\n  @media(min-width: ${STYLES.desktopSize}) {\r\n    height: ${props => `${props.desktopHeight}px`};\r\n  }\r\n\r\n`;\r\n\r\nconst Image = styled.img`\r\n  width: 100%;\r\n`;\r\n\r\nconst GatsbyImg = styled(Img)<any>`\r\n  width: 100%;\r\n  @media(max-width: ${STYLES.desktopSize}) {\r\n    height: ${props => `${props.mobileHeight}px`};\r\n  }\r\n  @media(min-width: ${STYLES.desktopSize}) {\r\n    height: ${props => `${props.desktopHeight}px`};\r\n  }\r\n`;\r\n\r\n\r\nconst ImageCaption = styled.span`\r\n  max-width: ${STYLES.maxWidth};\r\n  width: 100%;\r\n  padding: 0.5rem 0;\r\n  @media(max-width: ${STYLES.desktopSize}) {\r\n    padding: 0.5rem 1.5rem;\r\n  }\r\n`;\r\n\r\nconst Images = styled.div`\r\n  display: flex;\r\n  @media(min-width: ${STYLES.desktopSize}) {\r\n    padding: 0 4rem;\r\n    >* {\r\n      margin: 0 1rem;\r\n      flex: 1;\r\n    }\r\n  }\r\n  @media(max-width: ${STYLES.desktopSize}) {\r\n    flex-direction: column;\r\n  }\r\n`;\r\n\r\nexport default IndexPage;\r\n\r\nexport const pageQuery = graphql`\r\n  query {\r\n    heroImage: file(relativePath: { eq: \"photos/5. Pocock_Tassie-98.jpg\" }) {\r\n      childImageSharp {\r\n        fluid(maxWidth: 3000) {\r\n          ...GatsbyImageSharpFluid\r\n        }\r\n      }\r\n    },\r\n    Pocock_Tassie_266: file(relativePath: { eq: \"highres/Pocock_Tassie-266.jpg\" }) {\r\n      childImageSharp {\r\n        fluid(maxWidth: 1440) {\r\n          ...GatsbyImageSharpFluid\r\n        }\r\n      }\r\n    },\r\n    Pocock_Tassie_247: file(relativePath: { eq: \"photos/31. Pocock_Tassie-247.jpg\" }) {\r\n      childImageSharp {\r\n        fluid(maxWidth: 1680) {\r\n          ...GatsbyImageSharpFluid\r\n        }\r\n      }\r\n    },\r\n    Pocock_Tassie_205: file(relativePath: { eq: \"photos/11. Pocock_Tassie-205.jpg\" }) {\r\n      childImageSharp {\r\n        fluid(maxWidth: 1440) {\r\n          ...GatsbyImageSharpFluid\r\n        }\r\n      }\r\n    },\r\n    Pocock_Tassie_94: file(relativePath: { eq: \"photos/8. Pocock_Tassie-94.jpg\" }) {\r\n      childImageSharp {\r\n        fluid(maxWidth: 1440) {\r\n          ...GatsbyImageSharpFluid\r\n        }\r\n      }\r\n    },\r\n    Pocock_Tassie_136: file(relativePath: { eq: \"photos/4. Pocock_Tassie-136.jpg\" }) {\r\n      childImageSharp {\r\n        fluid(maxWidth: 1680) {\r\n          ...GatsbyImageSharpFluid\r\n        }\r\n      }\r\n    },\r\n    Pocock_Tassie_201: file(relativePath: { eq: \"photos/17. Pocock_Tassie-201.jpg\" }) {\r\n      childImageSharp {\r\n        fluid(maxWidth: 2000) {\r\n          ...GatsbyImageSharpFluid\r\n        }\r\n      }\r\n    },\r\n    Pocock_Tassie_318: file(relativePath: { eq: \"photos/12. Pocock_Tassie-318.jpg\" }) {\r\n      childImageSharp {\r\n        fluid(maxWidth: 2000) {\r\n          ...GatsbyImageSharpFluid\r\n        }\r\n      }\r\n    },\r\n    Pocock_Tassie_311: file(relativePath: { eq: \"highres/Pocock_Tassie-311.jpg\" }) {\r\n      childImageSharp {\r\n        fluid(maxWidth: 2000) {\r\n          ...GatsbyImageSharpFluid\r\n        }\r\n      }\r\n    },\r\n    Pocock_Tassie_284: file(relativePath: { eq: \"photos/20. Pocock_Tassie-284.jpg\" }) {\r\n      childImageSharp {\r\n        fluid(maxWidth: 2000) {\r\n          ...GatsbyImageSharpFluid\r\n        }\r\n      }\r\n    },\r\n    Pocock_Tassie_397: file(relativePath: { eq: \"photos/24. Pocock_Tassie-397.jpg\" }) {\r\n      childImageSharp {\r\n        fluid(maxWidth: 2000) {\r\n          ...GatsbyImageSharpFluid\r\n        }\r\n      }\r\n    },\r\n    Pocock_Tassie_406: file(relativePath: { eq: \"photos/26. Pocock_Tassie-406.jpg\" }) {\r\n      childImageSharp {\r\n        fluid(maxWidth: 2000) {\r\n          ...GatsbyImageSharpFluid\r\n        }\r\n      }\r\n    },\r\n    Pocock_Tassie_304: file(relativePath: { eq: \"photos/1. Pocock_Tassie-304.jpg\" }) {\r\n      childImageSharp {\r\n        fluid(maxWidth: 2000) {\r\n          ...GatsbyImageSharpFluid\r\n        }\r\n      }\r\n    },\r\n  }\r\n`;\r\n","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.object.define-property\";\nimport \"core-js/modules/es6.symbol\";\nimport \"core-js/modules/es6.array.index-of\";\nimport \"core-js/modules/es6.object.assign\";\nimport \"core-js/modules/es6.object.create\";\nimport \"core-js/modules/es6.object.set-prototype-of\";\n\n/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation. All rights reserved.\r\nLicensed under the Apache License, Version 2.0 (the \"License\"); you may not use\r\nthis file except in compliance with the License. You may obtain a copy of the\r\nLicense at http://www.apache.org/licenses/LICENSE-2.0\r\n\r\nTHIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\r\nKIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED\r\nWARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,\r\nMERCHANTABLITY OR NON-INFRINGEMENT.\r\n\r\nSee the Apache Version 2.0 License for specific language governing permissions\r\nand limitations under the License.\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  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) : new P(function (resolve) {\n        resolve(result.value);\n      }).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 __exportStar(m, exports) {\n  for (var p in m) {\n    if (!exports.hasOwnProperty(p)) exports[p] = m[p];\n  }\n}\nexport function __values(o) {\n  var m = typeof Symbol === \"function\" && o[Symbol.iterator],\n      i = 0;\n  if (m) return m.call(o);\n  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}\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}","'use strict';\n// 22.1.3.8 Array.prototype.find(predicate, thisArg = undefined)\nvar $export = require('./_export');\nvar $find = require('./_array-methods')(5);\nvar KEY = 'find';\nvar forced = true;\n// Shouldn't skip holes\nif (KEY in []) Array(1)[KEY](function () { forced = false; });\n$export($export.P + $export.F * forced, 'Array', {\n  find: function find(callbackfn /* , that = undefined */) {\n    return $find(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);\n  }\n});\nrequire('./_add-to-unscopables')(KEY);\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","var global = require('./_global');\nvar hide = require('./_hide');\nvar uid = require('./_uid');\nvar TYPED = uid('typed_array');\nvar VIEW = uid('view');\nvar ABV = !!(global.ArrayBuffer && global.DataView);\nvar CONSTR = ABV;\nvar i = 0;\nvar l = 9;\nvar Typed;\n\nvar TypedArrayConstructors = (\n  'Int8Array,Uint8Array,Uint8ClampedArray,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array'\n).split(',');\n\nwhile (i < l) {\n  if (Typed = global[TypedArrayConstructors[i++]]) {\n    hide(Typed.prototype, TYPED, true);\n    hide(Typed.prototype, VIEW, true);\n  } else CONSTR = false;\n}\n\nmodule.exports = {\n  ABV: ABV,\n  CONSTR: CONSTR,\n  TYPED: TYPED,\n  VIEW: VIEW\n};\n","// https://tc39.github.io/ecma262/#sec-toindex\nvar toInteger = require('./_to-integer');\nvar toLength = require('./_to-length');\nmodule.exports = function (it) {\n  if (it === undefined) return 0;\n  var number = toInteger(it);\n  var length = toLength(number);\n  if (number !== length) throw RangeError('Wrong length!');\n  return length;\n};\n","// 22.1.3.6 Array.prototype.fill(value, start = 0, end = this.length)\n'use strict';\nvar toObject = require('./_to-object');\nvar toAbsoluteIndex = require('./_to-absolute-index');\nvar toLength = require('./_to-length');\nmodule.exports = function fill(value /* , start = 0, end = @length */) {\n  var O = toObject(this);\n  var length = toLength(O.length);\n  var aLen = arguments.length;\n  var index = toAbsoluteIndex(aLen > 1 ? arguments[1] : undefined, length);\n  var end = aLen > 2 ? arguments[2] : undefined;\n  var endPos = end === undefined ? length : toAbsoluteIndex(end, length);\n  while (endPos > index) O[index++] = value;\n  return O;\n};\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 _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}","import setPrototypeOf from \"./setPrototypeOf\";\n\nfunction 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}\n\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}","import \"core-js/modules/es6.array.index-of\";\nimport \"core-js/modules/es6.regexp.to-string\";\nimport \"core-js/modules/es6.date.to-string\";\nimport \"core-js/modules/es6.string.sup\";\nimport \"core-js/modules/es6.string.sub\";\nimport \"core-js/modules/es6.string.small\";\nimport \"core-js/modules/es6.string.trim\";\nimport \"core-js/modules/es6.array.filter\";\nimport \"core-js/modules/es7.symbol.async-iterator\";\nimport \"core-js/modules/es6.symbol\";\nimport \"core-js/modules/es6.array.reduce\";\nimport \"core-js/modules/es6.array.is-array\";\nimport \"core-js/modules/es6.regexp.match\";\nimport \"core-js/modules/es6.regexp.split\";\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.array.sort\";\nimport \"core-js/modules/es6.array.map\";\nimport \"core-js/modules/es6.regexp.constructor\";\nimport \"core-js/modules/es6.regexp.replace\";\nimport \"core-js/modules/es6.array.for-each\";\nimport \"core-js/modules/es6.array.of\";\nimport _extends from '@babel/runtime/helpers/esm/extends';\nimport _assertThisInitialized from '@babel/runtime/helpers/esm/assertThisInitialized';\nimport _inheritsLoose from '@babel/runtime/helpers/esm/inheritsLoose';\nimport _wrapNativeSuper from '@babel/runtime/helpers/esm/wrapNativeSuper';\nimport _taggedTemplateLiteralLoose from '@babel/runtime/helpers/esm/taggedTemplateLiteralLoose';\n\nfunction last() {\n  var _ref;\n\n  return _ref = arguments.length - 1, _ref < 0 || arguments.length <= _ref ? undefined : arguments[_ref];\n}\n\nfunction negation(a) {\n  return -a;\n}\n\nfunction addition(a, b) {\n  return a + b;\n}\n\nfunction subtraction(a, b) {\n  return a - b;\n}\n\nfunction multiplication(a, b) {\n  return a * b;\n}\n\nfunction division(a, b) {\n  return a / b;\n}\n\nfunction factorial(a) {\n  if (a % 1 || !(+a >= 0)) return NaN;\n  if (a > 170) return Infinity;else if (a === 0) return 1;else {\n    return a * factorial(a - 1);\n  }\n}\n\nfunction power(a, b) {\n  return Math.pow(a, b);\n}\n\nfunction sqrt(a) {\n  return Math.sqrt(a);\n}\n\nfunction max() {\n  return Math.max.apply(Math, arguments);\n}\n\nfunction min() {\n  return Math.min.apply(Math, arguments);\n}\n\nfunction comma() {\n  return Array.of.apply(Array, arguments);\n}\n\nvar defaultMathSymbols = {\n  symbols: {\n    '!': {\n      postfix: {\n        symbol: '!',\n        f: factorial,\n        notation: 'postfix',\n        precedence: 6,\n        rightToLeft: 0,\n        argCount: 1\n      },\n      symbol: '!',\n      regSymbol: '!'\n    },\n    '^': {\n      infix: {\n        symbol: '^',\n        f: power,\n        notation: 'infix',\n        precedence: 5,\n        rightToLeft: 1,\n        argCount: 2\n      },\n      symbol: '^',\n      regSymbol: '\\\\^'\n    },\n    '*': {\n      infix: {\n        symbol: '*',\n        f: multiplication,\n        notation: 'infix',\n        precedence: 4,\n        rightToLeft: 0,\n        argCount: 2\n      },\n      symbol: '*',\n      regSymbol: '\\\\*'\n    },\n    '/': {\n      infix: {\n        symbol: '/',\n        f: division,\n        notation: 'infix',\n        precedence: 4,\n        rightToLeft: 0,\n        argCount: 2\n      },\n      symbol: '/',\n      regSymbol: '/'\n    },\n    '+': {\n      infix: {\n        symbol: '+',\n        f: addition,\n        notation: 'infix',\n        precedence: 2,\n        rightToLeft: 0,\n        argCount: 2\n      },\n      prefix: {\n        symbol: '+',\n        f: last,\n        notation: 'prefix',\n        precedence: 3,\n        rightToLeft: 0,\n        argCount: 1\n      },\n      symbol: '+',\n      regSymbol: '\\\\+'\n    },\n    '-': {\n      infix: {\n        symbol: '-',\n        f: subtraction,\n        notation: 'infix',\n        precedence: 2,\n        rightToLeft: 0,\n        argCount: 2\n      },\n      prefix: {\n        symbol: '-',\n        f: negation,\n        notation: 'prefix',\n        precedence: 3,\n        rightToLeft: 0,\n        argCount: 1\n      },\n      symbol: '-',\n      regSymbol: '-'\n    },\n    ',': {\n      infix: {\n        symbol: ',',\n        f: comma,\n        notation: 'infix',\n        precedence: 1,\n        rightToLeft: 0,\n        argCount: 2\n      },\n      symbol: ',',\n      regSymbol: ','\n    },\n    '(': {\n      prefix: {\n        symbol: '(',\n        f: last,\n        notation: 'prefix',\n        precedence: 0,\n        rightToLeft: 0,\n        argCount: 1\n      },\n      symbol: '(',\n      regSymbol: '\\\\('\n    },\n    ')': {\n      postfix: {\n        symbol: ')',\n        f: undefined,\n        notation: 'postfix',\n        precedence: 0,\n        rightToLeft: 0,\n        argCount: 1\n      },\n      symbol: ')',\n      regSymbol: '\\\\)'\n    },\n    min: {\n      func: {\n        symbol: 'min',\n        f: min,\n        notation: 'func',\n        precedence: 0,\n        rightToLeft: 0,\n        argCount: 1\n      },\n      symbol: 'min',\n      regSymbol: 'min\\\\b'\n    },\n    max: {\n      func: {\n        symbol: 'max',\n        f: max,\n        notation: 'func',\n        precedence: 0,\n        rightToLeft: 0,\n        argCount: 1\n      },\n      symbol: 'max',\n      regSymbol: 'max\\\\b'\n    },\n    sqrt: {\n      func: {\n        symbol: 'sqrt',\n        f: sqrt,\n        notation: 'func',\n        precedence: 0,\n        rightToLeft: 0,\n        argCount: 1\n      },\n      symbol: 'sqrt',\n      regSymbol: 'sqrt\\\\b'\n    }\n  }\n}; // based on https://github.com/styled-components/styled-components/blob/fcf6f3804c57a14dd7984dfab7bc06ee2edca044/src/utils/error.js\n\n/**\n * Parse errors.md and turn it into a simple hash of code: message\n * @private\n */\n\nvar ERRORS = {\n  \"1\": \"Passed invalid arguments to hsl, please pass multiple numbers e.g. hsl(360, 0.75, 0.4) or an object e.g. rgb({ hue: 255, saturation: 0.4, lightness: 0.75 }).\\n\\n\",\n  \"2\": \"Passed invalid arguments to hsla, please pass multiple numbers e.g. hsla(360, 0.75, 0.4, 0.7) or an object e.g. rgb({ hue: 255, saturation: 0.4, lightness: 0.75, alpha: 0.7 }).\\n\\n\",\n  \"3\": \"Passed an incorrect argument to a color function, please pass a string representation of a color.\\n\\n\",\n  \"4\": \"Couldn't generate valid rgb string from %s, it returned %s.\\n\\n\",\n  \"5\": \"Couldn't parse the color string. Please provide the color as a string in hex, rgb, rgba, hsl or hsla notation.\\n\\n\",\n  \"6\": \"Passed invalid arguments to rgb, please pass multiple numbers e.g. rgb(255, 205, 100) or an object e.g. rgb({ red: 255, green: 205, blue: 100 }).\\n\\n\",\n  \"7\": \"Passed invalid arguments to rgba, please pass multiple numbers e.g. rgb(255, 205, 100, 0.75) or an object e.g. rgb({ red: 255, green: 205, blue: 100, alpha: 0.75 }).\\n\\n\",\n  \"8\": \"Passed invalid argument to toColorString, please pass a RgbColor, RgbaColor, HslColor or HslaColor object.\\n\\n\",\n  \"9\": \"Please provide a number of steps to the modularScale helper.\\n\\n\",\n  \"10\": \"Please pass a number or one of the predefined scales to the modularScale helper as the ratio.\\n\\n\",\n  \"11\": \"Invalid value passed as base to modularScale, expected number or em string but got \\\"%s\\\"\\n\\n\",\n  \"12\": \"Expected a string ending in \\\"px\\\" or a number passed as the first argument to %s(), got \\\"%s\\\" instead.\\n\\n\",\n  \"13\": \"Expected a string ending in \\\"px\\\" or a number passed as the second argument to %s(), got \\\"%s\\\" instead.\\n\\n\",\n  \"14\": \"Passed invalid pixel value (\\\"%s\\\") to %s(), please pass a value like \\\"12px\\\" or 12.\\n\\n\",\n  \"15\": \"Passed invalid base value (\\\"%s\\\") to %s(), please pass a value like \\\"12px\\\" or 12.\\n\\n\",\n  \"16\": \"You must provide a template to this method.\\n\\n\",\n  \"17\": \"You passed an unsupported selector state to this method.\\n\\n\",\n  \"18\": \"minScreen and maxScreen must be provided as stringified numbers with the same units.\\n\\n\",\n  \"19\": \"fromSize and toSize must be provided as stringified numbers with the same units.\\n\\n\",\n  \"20\": \"expects either an array of objects or a single object with the properties prop, fromSize, and toSize.\\n\\n\",\n  \"21\": \"expects the objects in the first argument array to have the properties `prop`, `fromSize`, and `toSize`.\\n\\n\",\n  \"22\": \"expects the first argument object to have the properties `prop`, `fromSize`, and `toSize`.\\n\\n\",\n  \"23\": \"fontFace expects a name of a font-family.\\n\\n\",\n  \"24\": \"fontFace expects either the path to the font file(s) or a name of a local copy.\\n\\n\",\n  \"25\": \"fontFace expects localFonts to be an array.\\n\\n\",\n  \"26\": \"fontFace expects fileFormats to be an array.\\n\\n\",\n  \"27\": \"radialGradient requries at least 2 color-stops to properly render.\\n\\n\",\n  \"28\": \"Please supply a filename to retinaImage() as the first argument.\\n\\n\",\n  \"29\": \"Passed invalid argument to triangle, please pass correct pointingDirection e.g. 'right'.\\n\\n\",\n  \"30\": \"Passed an invalid value to `height` or `width`. Please provide a pixel based unit.\\n\\n\",\n  \"31\": \"The animation shorthand only takes 8 arguments. See the specification for more information: http://mdn.io/animation\\n\\n\",\n  \"32\": \"To pass multiple animations please supply them in arrays, e.g. animation(['rotate', '2s'], ['move', '1s'])\\nTo pass a single animation please supply them in simple values, e.g. animation('rotate', '2s')\\n\\n\",\n  \"33\": \"The animation shorthand arrays can only have 8 elements. See the specification for more information: http://mdn.io/animation\\n\\n\",\n  \"34\": \"borderRadius expects a radius value as a string or number as the second argument.\\n\\n\",\n  \"35\": \"borderRadius expects one of \\\"top\\\", \\\"bottom\\\", \\\"left\\\" or \\\"right\\\" as the first argument.\\n\\n\",\n  \"36\": \"Property must be a string value.\\n\\n\",\n  \"37\": \"Syntax Error at %s.\\n\\n\",\n  \"38\": \"Formula contains a function that needs parentheses at %s.\\n\\n\",\n  \"39\": \"Formula is missing closing parenthesis at %s.\\n\\n\",\n  \"40\": \"Formula has too many closing parentheses at %s.\\n\\n\",\n  \"41\": \"All values in a formula must have the same unit or be unitless.\\n\\n\",\n  \"42\": \"Please provide a number of steps to the modularScale helper.\\n\\n\",\n  \"43\": \"Please pass a number or one of the predefined scales to the modularScale helper as the ratio.\\n\\n\",\n  \"44\": \"Invalid value passed as base to modularScale, expected number or em/rem string but got %s.\\n\\n\",\n  \"45\": \"Passed invalid argument to hslToColorString, please pass a HslColor or HslaColor object.\\n\\n\",\n  \"46\": \"Passed invalid argument to rgbToColorString, please pass a RgbColor or RgbaColor object.\\n\\n\",\n  \"47\": \"minScreen and maxScreen must be provided as stringified numbers with the same units.\\n\\n\",\n  \"48\": \"fromSize and toSize must be provided as stringified numbers with the same units.\\n\\n\",\n  \"49\": \"Expects either an array of objects or a single object with the properties prop, fromSize, and toSize.\\n\\n\",\n  \"50\": \"Expects the objects in the first argument array to have the properties prop, fromSize, and toSize.\\n\\n\",\n  \"51\": \"Expects the first argument object to have the properties prop, fromSize, and toSize.\\n\\n\",\n  \"52\": \"fontFace expects either the path to the font file(s) or a name of a local copy.\\n\\n\",\n  \"53\": \"fontFace expects localFonts to be an array.\\n\\n\",\n  \"54\": \"fontFace expects fileFormats to be an array.\\n\\n\",\n  \"55\": \"fontFace expects a name of a font-family.\\n\\n\",\n  \"56\": \"linearGradient requries at least 2 color-stops to properly render.\\n\\n\",\n  \"57\": \"radialGradient requries at least 2 color-stops to properly render.\\n\\n\",\n  \"58\": \"Please supply a filename to retinaImage() as the first argument.\\n\\n\",\n  \"59\": \"Passed invalid argument to triangle, please pass correct pointingDirection e.g. 'right'.\\n\\n\",\n  \"60\": \"Passed an invalid value to `height` or `width`. Please provide a pixel based unit.\\n\\n\",\n  \"61\": \"Property must be a string value.\\n\\n\",\n  \"62\": \"borderRadius expects a radius value as a string or number as the second argument.\\n\\n\",\n  \"63\": \"borderRadius expects one of \\\"top\\\", \\\"bottom\\\", \\\"left\\\" or \\\"right\\\" as the first argument.\\n\\n\",\n  \"64\": \"The animation shorthand only takes 8 arguments. See the specification for more information: http://mdn.io/animation.\\n\\n\",\n  \"65\": \"To pass multiple animations please supply them in arrays, e.g. animation(['rotate', '2s'], ['move', '1s'])\\\\nTo pass a single animation please supply them in simple values, e.g. animation('rotate', '2s').\\n\\n\",\n  \"66\": \"The animation shorthand arrays can only have 8 elements. See the specification for more information: http://mdn.io/animation.\\n\\n\",\n  \"67\": \"You must provide a template to this method.\\n\\n\",\n  \"68\": \"You passed an unsupported selector state to this method.\\n\\n\",\n  \"69\": \"Expected a string ending in \\\"px\\\" or a number passed as the first argument to %s(), got %s instead.\\n\\n\",\n  \"70\": \"Expected a string ending in \\\"px\\\" or a number passed as the second argument to %s(), got %s instead.\\n\\n\",\n  \"71\": \"Passed invalid pixel value %s to %s(), please pass a value like \\\"12px\\\" or 12.\\n\\n\",\n  \"72\": \"Passed invalid base value %s to %s(), please pass a value like \\\"12px\\\" or 12.\\n\"\n};\n/**\n * super basic version of sprintf\n * @private\n */\n\nfunction format() {\n  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n    args[_key] = arguments[_key];\n  }\n\n  var a = args[0];\n  var b = [];\n  var c;\n\n  for (c = 1; c < args.length; c += 1) {\n    b.push(args[c]);\n  }\n\n  b.forEach(function (d) {\n    a = a.replace(/%[a-z]/, d);\n  });\n  return a;\n}\n/**\n * Create an error file out of errors.md for development and a simple web link to the full errors\n * in production mode.\n * @private\n */\n\n\nvar PolishedError =\n/*#__PURE__*/\nfunction (_Error) {\n  _inheritsLoose(PolishedError, _Error);\n\n  function PolishedError(code) {\n    var _this;\n\n    if (process.env.NODE_ENV === 'production') {\n      _this = _Error.call(this, \"An error occurred. See https://github.com/styled-components/polished/blob/master/src/internalHelpers/errors.md#\" + code + \" for more information.\") || this;\n    } else {\n      for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {\n        args[_key2 - 1] = arguments[_key2];\n      }\n\n      _this = _Error.call(this, format.apply(void 0, [ERRORS[code]].concat(args))) || this;\n    }\n\n    return _assertThisInitialized(_this);\n  }\n\n  return PolishedError;\n}(\n/*#__PURE__*/\n_wrapNativeSuper(Error));\n\nvar unitRegExp = /((?!\\w)a|na|hc|mc|dg|me[r]?|xe|ni(?![a-zA-Z])|mm|cp|tp|xp|q(?!s)|hv|xamv|nimv|wv|sm|s(?!\\D|$)|ged|darg?|nrut)/g; // Merges additional math functionality into the defaults.\n\nfunction mergeSymbolMaps(additionalSymbols) {\n  var symbolMap = {};\n  symbolMap.symbols = additionalSymbols ? _extends({}, defaultMathSymbols.symbols, additionalSymbols.symbols) : _extends({}, defaultMathSymbols.symbols);\n  return symbolMap;\n}\n\nfunction exec(operators, values) {\n  var _ref;\n\n  var op = operators.pop();\n  values.push(op.f.apply(op, (_ref = []).concat.apply(_ref, values.splice(-op.argCount))));\n  return op.precedence;\n}\n\nfunction calculate(expression, additionalSymbols) {\n  var symbolMap = mergeSymbolMaps(additionalSymbols);\n  var match;\n  var operators = [symbolMap.symbols['('].prefix];\n  var values = [];\n  var pattern = new RegExp( // Pattern for numbers\n  \"\\\\d+(?:\\\\.\\\\d+)?|\" + // ...and patterns for individual operators/function names\n  Object.keys(symbolMap.symbols).map(function (key) {\n    return symbolMap.symbols[key];\n  }) // longer symbols should be listed first\n  // $FlowFixMe\n  .sort(function (a, b) {\n    return b.symbol.length - a.symbol.length;\n  }) // $FlowFixMe\n  .map(function (val) {\n    return val.regSymbol;\n  }).join('|') + \"|(\\\\S)\", 'g');\n  pattern.lastIndex = 0; // Reset regular expression object\n\n  var afterValue = false;\n\n  do {\n    match = pattern.exec(expression);\n\n    var _ref2 = match || [')', undefined],\n        token = _ref2[0],\n        bad = _ref2[1];\n\n    var notNumber = symbolMap.symbols[token];\n    var notNewValue = notNumber && !notNumber.prefix && !notNumber.func;\n    var notAfterValue = !notNumber || !notNumber.postfix && !notNumber.infix; // Check for syntax errors:\n\n    if (bad || (afterValue ? notAfterValue : notNewValue)) {\n      throw new PolishedError(37, match ? match.index : expression.length, expression);\n    }\n\n    if (afterValue) {\n      // We either have an infix or postfix operator (they should be mutually exclusive)\n      var curr = notNumber.postfix || notNumber.infix;\n\n      do {\n        var prev = operators[operators.length - 1];\n        if ((curr.precedence - prev.precedence || prev.rightToLeft) > 0) break; // Apply previous operator, since it has precedence over current one\n      } while (exec(operators, values)); // Exit loop after executing an opening parenthesis or function\n\n\n      afterValue = curr.notation === 'postfix';\n\n      if (curr.symbol !== ')') {\n        operators.push(curr); // Postfix always has precedence over any operator that follows after it\n\n        if (afterValue) exec(operators, values);\n      }\n    } else if (notNumber) {\n      // prefix operator or function\n      operators.push(notNumber.prefix || notNumber.func);\n\n      if (notNumber.func) {\n        // Require an opening parenthesis\n        match = pattern.exec(expression);\n\n        if (!match || match[0] !== '(') {\n          throw new PolishedError(38, match ? match.index : expression.length, expression);\n        }\n      }\n    } else {\n      // number\n      values.push(+token);\n      afterValue = true;\n    }\n  } while (match && operators.length);\n\n  if (operators.length) {\n    throw new PolishedError(39, match ? match.index : expression.length, expression);\n  } else if (match) {\n    throw new PolishedError(40, match ? match.index : expression.length, expression);\n  } else {\n    return values.pop();\n  }\n}\n\nfunction reverseString(str) {\n  return str.split('').reverse().join('');\n}\n/**\n * Helper for doing math with CSS Units. Accepts a formula as a string. All values in the formula must have the same unit (or be unitless). Supports complex formulas utliziing addition, subtraction, multiplication, division, square root, powers, factorial, min, max, as well as parentheses for order of operation.\n *\n *In cases where you need to do calculations with mixed units where one unit is a [relative length unit](https://developer.mozilla.org/en-US/docs/Web/CSS/length#Relative_length_units), you will want to use [CSS Calc](https://developer.mozilla.org/en-US/docs/Web/CSS/calc).\n *\n * *warning* While we've done everything possible to ensure math safely evalutes formulas expressed as strings, you should always use extreme caution when passing `math` user provided values.\n * @example\n * // Styles as object usage\n * const styles = {\n *   fontSize: math('12rem + 8rem'),\n *   fontSize: math('(12px + 2px) * 3'),\n *   fontSize: math('3px^2 + sqrt(4)'),\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   fontSize: ${math('12rem + 8rem')};\n *   fontSize: ${math('(12px + 2px) * 3')};\n *   fontSize: ${math('3px^2 + sqrt(4)')};\n * `\n *\n * // CSS as JS Output\n *\n * div: {\n *   fontSize: '20rem',\n *   fontSize: '42px',\n *   fontSize: '11px',\n * }\n */\n\n\nfunction math(formula, additionalSymbols) {\n  var reversedFormula = reverseString(formula);\n  var formulaMatch = reversedFormula.match(unitRegExp); // Check that all units are the same\n\n  if (formulaMatch && !formulaMatch.every(function (unit) {\n    return unit === formulaMatch[0];\n  })) {\n    throw new PolishedError(41);\n  }\n\n  var cleanFormula = reverseString(reversedFormula.replace(unitRegExp, ''));\n  return \"\" + calculate(cleanFormula, additionalSymbols) + (formulaMatch ? reverseString(formulaMatch[0]) : '');\n} // @private\n\n\nfunction capitalizeString(string) {\n  return string.charAt(0).toUpperCase() + string.slice(1);\n}\n\nvar positionMap = ['Top', 'Right', 'Bottom', 'Left'];\n\nfunction generateProperty(property, position) {\n  if (!property) return position.toLowerCase();\n  var splitProperty = property.split('-');\n\n  if (splitProperty.length > 1) {\n    splitProperty.splice(1, 0, position);\n    return splitProperty.reduce(function (acc, val) {\n      return \"\" + acc + capitalizeString(val);\n    });\n  }\n\n  var joinedProperty = property.replace(/([a-z])([A-Z])/g, \"$1\" + position + \"$2\");\n  return property === joinedProperty ? \"\" + property + position : joinedProperty;\n}\n\nfunction generateStyles(property, valuesWithDefaults) {\n  var styles = {};\n\n  for (var i = 0; i < valuesWithDefaults.length; i += 1) {\n    if (valuesWithDefaults[i] || valuesWithDefaults[i] === 0) {\n      styles[generateProperty(property, positionMap[i])] = valuesWithDefaults[i];\n    }\n  }\n\n  return styles;\n}\n/**\n * Enables shorthand for direction-based properties. It accepts a property (hyphenated or camelCased) and up to four values that map to top, right, bottom, and left, respectively. You can optionally pass an empty string to get only the directional values as properties. You can also optionally pass a null argument for a directional value to ignore it.\n * @example\n * // Styles as object usage\n * const styles = {\n *   ...directionalProperty('padding', '12px', '24px', '36px', '48px')\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   ${directionalProperty('padding', '12px', '24px', '36px', '48px')}\n * `\n *\n * // CSS as JS Output\n *\n * div {\n *   'paddingTop': '12px',\n *   'paddingRight': '24px',\n *   'paddingBottom': '36px',\n *   'paddingLeft': '48px'\n * }\n */\n\n\nfunction directionalProperty(property) {\n  for (var _len = arguments.length, values = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n    values[_key - 1] = arguments[_key];\n  } //  prettier-ignore\n\n\n  var firstValue = values[0],\n      _values$ = values[1],\n      secondValue = _values$ === void 0 ? firstValue : _values$,\n      _values$2 = values[2],\n      thirdValue = _values$2 === void 0 ? firstValue : _values$2,\n      _values$3 = values[3],\n      fourthValue = _values$3 === void 0 ? secondValue : _values$3;\n  var valuesWithDefaults = [firstValue, secondValue, thirdValue, fourthValue];\n  return generateStyles(property, valuesWithDefaults);\n}\n/**\n * Check if a string ends with something\n * @private\n */\n\n\nfunction endsWith(string, suffix) {\n  return string.substr(-suffix.length) === suffix;\n}\n\nvar cssRegex = /^([+-]?(?:\\d+|\\d*\\.\\d+))([a-z]*|%)$/;\n/**\n * Returns a given CSS value minus its unit (or the original value if an invalid string is passed). Optionally returns an array containing the stripped value and the original unit of measure.\n *\n * @example\n * // Styles as object usage\n * const styles = {\n *   '--dimension': stripUnit('100px'),\n *   '--unit': stripUnit('100px')[1],\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   --dimension: ${stripUnit('100px')};\n *   --unit: ${stripUnit('100px')[1]};\n * `\n *\n * // CSS in JS Output\n *\n * element {\n *   '--dimension': 100,\n *   '--unit': 'px',\n * }\n */\n\nfunction stripUnit(value, unitReturn) {\n  if (typeof value !== 'string') return unitReturn ? [value, undefined] : value;\n  var matchedValue = value.match(cssRegex);\n\n  if (unitReturn) {\n    if (matchedValue) return [parseFloat(value), matchedValue[2]];\n    return [value, undefined];\n  }\n\n  if (matchedValue) return parseFloat(value);\n  return value;\n}\n/**\n * Factory function that creates pixel-to-x converters\n * @private\n */\n\n\nvar pxtoFactory = function pxtoFactory(to) {\n  return function (pxval, base) {\n    if (base === void 0) {\n      base = '16px';\n    }\n\n    var newPxval = pxval;\n    var newBase = base;\n\n    if (typeof pxval === 'string') {\n      if (!endsWith(pxval, 'px')) {\n        throw new PolishedError(69, to, pxval);\n      }\n\n      newPxval = stripUnit(pxval);\n    }\n\n    if (typeof base === 'string') {\n      if (!endsWith(base, 'px')) {\n        throw new PolishedError(70, to, base);\n      }\n\n      newBase = stripUnit(base);\n    }\n\n    if (typeof newPxval === 'string') {\n      throw new PolishedError(71, pxval, to);\n    }\n\n    if (typeof newBase === 'string') {\n      throw new PolishedError(72, base, to);\n    }\n\n    return \"\" + newPxval / newBase + to;\n  };\n};\n/**\n * Convert pixel value to ems. The default base value is 16px, but can be changed by passing a\n * second argument to the function.\n * @function\n * @param {string|number} pxval\n * @param {string|number} [base='16px']\n * @example\n * // Styles as object usage\n * const styles = {\n *   'height': em('16px')\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   height: ${em('16px')}\n * `\n *\n * // CSS in JS Output\n *\n * element {\n *   'height': '1em'\n * }\n */\n\n\nvar em =\n/*#__PURE__*/\npxtoFactory('em');\nvar cssRegex$1 = /^([+-]?(?:\\d+|\\d*\\.\\d+))([a-z]*|%)$/;\n/**\n * Returns a given CSS value and its unit as elements of an array.\n *\n * @deprecated - getValueAndUnit has been marked for deprecation in polished 3.0 and will be fully deprecated in 4.0. It's functionality has been been moved to stripUnit as an optional return.\n *\n * @example\n * // Styles as object usage\n * const styles = {\n *   '--dimension': getValueAndUnit('100px')[0],\n *   '--unit': getValueAndUnit('100px')[1],\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   --dimension: ${getValueAndUnit('100px')[0]};\n *   --unit: ${getValueAndUnit('100px')[1]};\n * `\n *\n * // CSS in JS Output\n *\n * element {\n *   '--dimension': 100,\n *   '--unit': 'px',\n * }\n */\n\nfunction getValueAndUnit(value) {\n  // eslint-disable-next-line no-console\n  console.warn(\"getValueAndUnit has been marked for deprecation in polished 3.0 and will be fully deprecated in 4.0. It's functionality has been been moved to stripUnit as an optional return.\");\n  if (typeof value !== 'string') return [value, ''];\n  var matchedValue = value.match(cssRegex$1);\n  if (matchedValue) return [parseFloat(value), matchedValue[2]];\n  return [value, undefined];\n}\n\nvar ratioNames = {\n  minorSecond: 1.067,\n  majorSecond: 1.125,\n  minorThird: 1.2,\n  majorThird: 1.25,\n  perfectFourth: 1.333,\n  augFourth: 1.414,\n  perfectFifth: 1.5,\n  minorSixth: 1.6,\n  goldenSection: 1.618,\n  majorSixth: 1.667,\n  minorSeventh: 1.778,\n  majorSeventh: 1.875,\n  octave: 2,\n  majorTenth: 2.5,\n  majorEleventh: 2.667,\n  majorTwelfth: 3,\n  doubleOctave: 4\n};\n\nfunction getRatio(ratioName) {\n  return ratioNames[ratioName];\n}\n/**\n * Establish consistent measurements and spacial relationships throughout your projects by incrementing an em or rem value up or down a defined scale. We provide a list of commonly used scales as pre-defined variables.\n * @example\n * // Styles as object usage\n * const styles = {\n *    // Increment two steps up the default scale\n *   'fontSize': modularScale(2)\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *    // Increment two steps up the default scale\n *   fontSize: ${modularScale(2)}\n * `\n *\n * // CSS in JS Output\n *\n * element {\n *   'fontSize': '1.77689em'\n * }\n */\n\n\nfunction modularScale(steps, base, ratio) {\n  if (base === void 0) {\n    base = '1em';\n  }\n\n  if (ratio === void 0) {\n    ratio = 1.333;\n  }\n\n  if (typeof steps !== 'number') {\n    throw new PolishedError(42);\n  }\n\n  if (typeof ratio === 'string' && !ratioNames[ratio]) {\n    throw new PolishedError(43);\n  }\n\n  var _ref = typeof base === 'string' ? stripUnit(base, true) : [base, ''],\n      realBase = _ref[0],\n      unit = _ref[1];\n\n  var realRatio = typeof ratio === 'string' ? getRatio(ratio) : ratio;\n\n  if (typeof realBase === 'string') {\n    throw new PolishedError(44, base);\n  }\n\n  return \"\" + realBase * Math.pow(realRatio, steps) + unit;\n}\n/**\n * Convert pixel value to rems. The default base value is 16px, but can be changed by passing a\n * second argument to the function.\n * @function\n * @param {string|number} pxval\n * @param {string|number} [base='16px']\n * @example\n * // Styles as object usage\n * const styles = {\n *   'height': rem('16px')\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   height: ${rem('16px')}\n * `\n *\n * // CSS in JS Output\n *\n * element {\n *   'height': '1rem'\n * }\n */\n\n\nvar rem =\n/*#__PURE__*/\npxtoFactory('rem');\n/**\n * Returns a CSS calc formula for linear interpolation of a property between two values. Accepts optional minScreen (defaults to '320px') and maxScreen (defaults to '1200px').\n *\n * @example\n * // Styles as object usage\n * const styles = {\n *   fontSize: between('20px', '100px', '400px', '1000px'),\n *   fontSize: between('20px', '100px')\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   fontSize: ${between('20px', '100px', '400px', '1000px')};\n *   fontSize: ${between('20px', '100px')}\n * `\n *\n * // CSS as JS Output\n *\n * h1: {\n *   'fontSize': 'calc(-33.33333333333334px + 13.333333333333334vw)',\n *   'fontSize': 'calc(-9.090909090909093px + 9.090909090909092vw)'\n * }\n */\n\nfunction between(fromSize, toSize, minScreen, maxScreen) {\n  if (minScreen === void 0) {\n    minScreen = '320px';\n  }\n\n  if (maxScreen === void 0) {\n    maxScreen = '1200px';\n  }\n\n  var _stripUnit = stripUnit(fromSize, true),\n      unitlessFromSize = _stripUnit[0],\n      fromSizeUnit = _stripUnit[1];\n\n  var _stripUnit2 = stripUnit(toSize, true),\n      unitlessToSize = _stripUnit2[0],\n      toSizeUnit = _stripUnit2[1];\n\n  var _stripUnit3 = stripUnit(minScreen, true),\n      unitlessMinScreen = _stripUnit3[0],\n      minScreenUnit = _stripUnit3[1];\n\n  var _stripUnit4 = stripUnit(maxScreen, true),\n      unitlessMaxScreen = _stripUnit4[0],\n      maxScreenUnit = _stripUnit4[1];\n\n  if (typeof unitlessMinScreen !== 'number' || typeof unitlessMaxScreen !== 'number' || !minScreenUnit || !maxScreenUnit || minScreenUnit !== maxScreenUnit) {\n    throw new PolishedError(47);\n  }\n\n  if (typeof unitlessFromSize !== 'number' || typeof unitlessToSize !== 'number' || fromSizeUnit !== toSizeUnit) {\n    throw new PolishedError(48);\n  }\n\n  var slope = (unitlessFromSize - unitlessToSize) / (unitlessMinScreen - unitlessMaxScreen);\n  var base = unitlessToSize - slope * unitlessMaxScreen;\n  return \"calc(\" + base.toFixed(2) + (fromSizeUnit || '') + \" + \" + (100 * slope).toFixed(2) + \"vw)\";\n}\n/**\n * CSS to contain a float (credit to CSSMojo).\n *\n * @example\n * // Styles as object usage\n * const styles = {\n *    ...clearFix(),\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   ${clearFix()}\n * `\n *\n * // CSS as JS Output\n *\n * '&::after': {\n *   'clear': 'both',\n *   'content': '\"\"',\n *   'display': 'table'\n * }\n */\n\n\nfunction clearFix(parent) {\n  var _ref;\n\n  if (parent === void 0) {\n    parent = '&';\n  }\n\n  var pseudoSelector = parent + \"::after\";\n  return _ref = {}, _ref[pseudoSelector] = {\n    clear: 'both',\n    content: '\"\"',\n    display: 'table'\n  }, _ref;\n}\n/**\n * CSS to fully cover an area. Can optionally be passed an offset to act as a \"padding\".\n *\n * @example\n * // Styles as object usage\n * const styles = {\n *   ...cover()\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   ${cover()}\n * `\n *\n * // CSS as JS Output\n *\n * div: {\n *   'position': 'absolute',\n *   'top': '0',\n *   'right: '0',\n *   'bottom': '0',\n *   'left: '0'\n * }\n */\n\n\nfunction cover(offset) {\n  if (offset === void 0) {\n    offset = 0;\n  }\n\n  return {\n    position: 'absolute',\n    top: offset,\n    right: offset,\n    bottom: offset,\n    left: offset\n  };\n}\n/**\n * CSS to represent truncated text with an ellipsis.\n *\n * @example\n * // Styles as object usage\n * const styles = {\n *   ...ellipsis('250px')\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   ${ellipsis('250px')}\n * `\n *\n * // CSS as JS Output\n *\n * div: {\n *   'display': 'inline-block',\n *   'maxWidth': '250px',\n *   'overflow': 'hidden',\n *   'textOverflow': 'ellipsis',\n *   'whiteSpace': 'nowrap',\n *   'wordWrap': 'normal'\n * }\n */\n\n\nfunction ellipsis(width) {\n  if (width === void 0) {\n    width = '100%';\n  }\n\n  return {\n    display: 'inline-block',\n    maxWidth: width,\n    overflow: 'hidden',\n    textOverflow: 'ellipsis',\n    whiteSpace: 'nowrap',\n    wordWrap: 'normal'\n  };\n}\n/**\n * Returns a set of media queries that resizes a property (or set of properties) between a provided fromSize and toSize. Accepts optional minScreen (defaults to '320px') and maxScreen (defaults to '1200px') to constrain the interpolation.\n *\n * @example\n * // Styles as object usage\n * const styles = {\n *   ...fluidRange(\n *    {\n *        prop: 'padding',\n *        fromSize: '20px',\n *        toSize: '100px',\n *      },\n *      '400px',\n *      '1000px',\n *    )\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   ${fluidRange(\n *      {\n *        prop: 'padding',\n *        fromSize: '20px',\n *        toSize: '100px',\n *      },\n *      '400px',\n *      '1000px',\n *    )}\n * `\n *\n * // CSS as JS Output\n *\n * div: {\n *   \"@media (min-width: 1000px)\": Object {\n *     \"padding\": \"100px\",\n *   },\n *   \"@media (min-width: 400px)\": Object {\n *     \"padding\": \"calc(-33.33333333333334px + 13.333333333333334vw)\",\n *   },\n *   \"padding\": \"20px\",\n * }\n */\n\n\nfunction fluidRange(cssProp, minScreen, maxScreen) {\n  if (minScreen === void 0) {\n    minScreen = '320px';\n  }\n\n  if (maxScreen === void 0) {\n    maxScreen = '1200px';\n  }\n\n  if (!Array.isArray(cssProp) && typeof cssProp !== 'object' || cssProp === null) {\n    throw new PolishedError(49);\n  }\n\n  if (Array.isArray(cssProp)) {\n    var mediaQueries = {};\n    var fallbacks = {};\n\n    for (var _iterator = cssProp, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {\n      var _extends2, _extends3;\n\n      var _ref;\n\n      if (_isArray) {\n        if (_i >= _iterator.length) break;\n        _ref = _iterator[_i++];\n      } else {\n        _i = _iterator.next();\n        if (_i.done) break;\n        _ref = _i.value;\n      }\n\n      var obj = _ref;\n\n      if (!obj.prop || !obj.fromSize || !obj.toSize) {\n        throw new PolishedError(50);\n      }\n\n      fallbacks[obj.prop] = obj.fromSize;\n      mediaQueries[\"@media (min-width: \" + minScreen + \")\"] = _extends({}, mediaQueries[\"@media (min-width: \" + minScreen + \")\"], (_extends2 = {}, _extends2[obj.prop] = between(obj.fromSize, obj.toSize, minScreen, maxScreen), _extends2));\n      mediaQueries[\"@media (min-width: \" + maxScreen + \")\"] = _extends({}, mediaQueries[\"@media (min-width: \" + maxScreen + \")\"], (_extends3 = {}, _extends3[obj.prop] = obj.toSize, _extends3));\n    }\n\n    return _extends({}, fallbacks, mediaQueries);\n  } else {\n    var _ref2, _ref3, _ref4;\n\n    if (!cssProp.prop || !cssProp.fromSize || !cssProp.toSize) {\n      throw new PolishedError(51);\n    }\n\n    return _ref4 = {}, _ref4[cssProp.prop] = cssProp.fromSize, _ref4[\"@media (min-width: \" + minScreen + \")\"] = (_ref2 = {}, _ref2[cssProp.prop] = between(cssProp.fromSize, cssProp.toSize, minScreen, maxScreen), _ref2), _ref4[\"@media (min-width: \" + maxScreen + \")\"] = (_ref3 = {}, _ref3[cssProp.prop] = cssProp.toSize, _ref3), _ref4;\n  }\n}\n\nvar dataURIRegex = /^\\s*data:([a-z]+\\/[a-z-]+(;[a-z-]+=[a-z-]+)?)?(;charset=[a-z0-9-]+)?(;base64)?,[a-z0-9!$&',()*+,;=\\-._~:@/?%\\s]*\\s*$/i;\nvar formatHintMap = {\n  woff: 'woff',\n  woff2: 'woff2',\n  ttf: 'truetype',\n  otf: 'opentype',\n  eot: 'embedded-opentype',\n  svg: 'svg',\n  svgz: 'svg'\n};\n\nfunction generateFormatHint(format, formatHint) {\n  if (!formatHint) return '';\n  return \" format(\\\"\" + formatHintMap[format] + \"\\\")\";\n}\n\nfunction isDataURI(fontFilePath) {\n  return !!fontFilePath.match(dataURIRegex);\n}\n\nfunction generateFileReferences(fontFilePath, fileFormats, formatHint) {\n  if (isDataURI(fontFilePath)) {\n    return \"url(\\\"\" + fontFilePath + \"\\\")\" + generateFormatHint(fileFormats[0], formatHint);\n  }\n\n  var fileFontReferences = fileFormats.map(function (format) {\n    return \"url(\\\"\" + fontFilePath + \".\" + format + \"\\\")\" + generateFormatHint(format, formatHint);\n  });\n  return fileFontReferences.join(', ');\n}\n\nfunction generateLocalReferences(localFonts) {\n  var localFontReferences = localFonts.map(function (font) {\n    return \"local(\\\"\" + font + \"\\\")\";\n  });\n  return localFontReferences.join(', ');\n}\n\nfunction generateSources(fontFilePath, localFonts, fileFormats, formatHint) {\n  var fontReferences = [];\n  if (localFonts) fontReferences.push(generateLocalReferences(localFonts));\n\n  if (fontFilePath) {\n    fontReferences.push(generateFileReferences(fontFilePath, fileFormats, formatHint));\n  }\n\n  return fontReferences.join(', ');\n}\n/**\n * CSS for a @font-face declaration.\n *\n * @example\n * // Styles as object basic usage\n * const styles = {\n *    ...fontFace({\n *      'fontFamily': 'Sans-Pro',\n *      'fontFilePath': 'path/to/file'\n *    })\n * }\n *\n * // styled-components basic usage\n * const GlobalStyle = createGlobalStyle`${\n *   fontFace({\n *     'fontFamily': 'Sans-Pro',\n *     'fontFilePath': 'path/to/file'\n *   }\n * )}`\n *\n * // CSS as JS Output\n *\n * '@font-face': {\n *   'fontFamily': 'Sans-Pro',\n *   'src': 'url(\"path/to/file.eot\"), url(\"path/to/file.woff2\"), url(\"path/to/file.woff\"), url(\"path/to/file.ttf\"), url(\"path/to/file.svg\")',\n * }\n */\n\n\nfunction fontFace(_ref) {\n  var fontFamily = _ref.fontFamily,\n      fontFilePath = _ref.fontFilePath,\n      fontStretch = _ref.fontStretch,\n      fontStyle = _ref.fontStyle,\n      fontVariant = _ref.fontVariant,\n      fontWeight = _ref.fontWeight,\n      _ref$fileFormats = _ref.fileFormats,\n      fileFormats = _ref$fileFormats === void 0 ? ['eot', 'woff2', 'woff', 'ttf', 'svg'] : _ref$fileFormats,\n      _ref$formatHint = _ref.formatHint,\n      formatHint = _ref$formatHint === void 0 ? false : _ref$formatHint,\n      localFonts = _ref.localFonts,\n      unicodeRange = _ref.unicodeRange,\n      fontDisplay = _ref.fontDisplay,\n      fontVariationSettings = _ref.fontVariationSettings,\n      fontFeatureSettings = _ref.fontFeatureSettings; // Error Handling\n\n  if (!fontFamily) throw new PolishedError(55);\n\n  if (!fontFilePath && !localFonts) {\n    throw new PolishedError(52);\n  }\n\n  if (localFonts && !Array.isArray(localFonts)) {\n    throw new PolishedError(53);\n  }\n\n  if (!Array.isArray(fileFormats)) {\n    throw new PolishedError(54);\n  }\n\n  var fontFaceDeclaration = {\n    '@font-face': {\n      fontFamily: fontFamily,\n      src: generateSources(fontFilePath, localFonts, fileFormats, formatHint),\n      unicodeRange: unicodeRange,\n      fontStretch: fontStretch,\n      fontStyle: fontStyle,\n      fontVariant: fontVariant,\n      fontWeight: fontWeight,\n      fontDisplay: fontDisplay,\n      fontVariationSettings: fontVariationSettings,\n      fontFeatureSettings: fontFeatureSettings\n    } // Removes undefined fields for cleaner css object.\n\n  };\n  return JSON.parse(JSON.stringify(fontFaceDeclaration));\n}\n/**\n * CSS to hide text to show a background image in a SEO-friendly way.\n *\n * @example\n * // Styles as object usage\n * const styles = {\n *   'backgroundImage': 'url(logo.png)',\n *   ...hideText(),\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   backgroundImage: url(logo.png);\n *   ${hideText()};\n * `\n *\n * // CSS as JS Output\n *\n * 'div': {\n *   'backgroundImage': 'url(logo.png)',\n *   'textIndent': '101%',\n *   'overflow': 'hidden',\n *   'whiteSpace': 'nowrap',\n * }\n */\n\n\nfunction hideText() {\n  return {\n    textIndent: '101%',\n    overflow: 'hidden',\n    whiteSpace: 'nowrap'\n  };\n}\n/**\n * CSS to hide content visually but remain accessible to screen readers.\n * from [HTML5 Boilerplate](https://github.com/h5bp/html5-boilerplate/blob/9a176f57af1cfe8ec70300da4621fb9b07e5fa31/src/css/main.css#L121)\n *\n * @example\n * // Styles as object usage\n * const styles = {\n *   ...hideVisually(),\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   ${hideVisually()};\n * `\n *\n * // CSS as JS Output\n *\n * 'div': {\n *   'border': '0',\n *   'clip': 'rect(0 0 0 0)',\n *   'clipPath': 'inset(50%)',\n *   'height': '1px',\n *   'margin': '-1px',\n *   'overflow': 'hidden',\n *   'padding': '0',\n *   'position': 'absolute',\n *   'whiteSpace': 'nowrap',\n *   'width': '1px',\n * }\n */\n\n\nfunction hideVisually() {\n  return {\n    border: '0',\n    clip: 'rect(0 0 0 0)',\n    clipPath: 'inset(50%)',\n    height: '1px',\n    margin: '-1px',\n    overflow: 'hidden',\n    padding: '0',\n    position: 'absolute',\n    whiteSpace: 'nowrap',\n    width: '1px'\n  };\n}\n/**\n * Generates a media query to target HiDPI devices.\n *\n * @example\n * // Styles as object usage\n * const styles = {\n *  [hiDPI(1.5)]: {\n *    width: 200px;\n *  }\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   ${hiDPI(1.5)} {\n *     width: 200px;\n *   }\n * `\n *\n * // CSS as JS Output\n *\n * '@media only screen and (-webkit-min-device-pixel-ratio: 1.5),\n *  only screen and (min--moz-device-pixel-ratio: 1.5),\n *  only screen and (-o-min-device-pixel-ratio: 1.5/1),\n *  only screen and (min-resolution: 144dpi),\n *  only screen and (min-resolution: 1.5dppx)': {\n *   'width': '200px',\n * }\n */\n\n\nfunction hiDPI(ratio) {\n  if (ratio === void 0) {\n    ratio = 1.3;\n  }\n\n  return \"\\n    @media only screen and (-webkit-min-device-pixel-ratio: \" + ratio + \"),\\n    only screen and (min--moz-device-pixel-ratio: \" + ratio + \"),\\n    only screen and (-o-min-device-pixel-ratio: \" + ratio + \"/1),\\n    only screen and (min-resolution: \" + Math.round(ratio * 96) + \"dpi),\\n    only screen and (min-resolution: \" + ratio + \"dppx)\\n  \";\n}\n\nfunction constructGradientValue(literals) {\n  var template = '';\n\n  for (var _len = arguments.length, substitutions = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n    substitutions[_key - 1] = arguments[_key];\n  }\n\n  for (var i = 0; i < literals.length; i += 1) {\n    template += literals[i];\n\n    if (i === substitutions.length - 1 && substitutions[i]) {\n      var definedValues = substitutions.filter(function (substitute) {\n        return !!substitute;\n      }); // Adds leading coma if properties preceed color-stops\n\n      if (definedValues.length > 1) {\n        template = template.slice(0, -1);\n        template += \", \" + substitutions[i]; // No trailing space if color-stops is the only param provided\n      } else if (definedValues.length === 1) {\n        template += \"\" + substitutions[i];\n      }\n    } else if (substitutions[i]) {\n      template += substitutions[i] + \" \";\n    }\n  }\n\n  return template.trim();\n}\n\nfunction _templateObject() {\n  var data = _taggedTemplateLiteralLoose([\"linear-gradient(\", \"\", \")\"]);\n\n  _templateObject = function _templateObject() {\n    return data;\n  };\n\n  return data;\n}\n/**\n * CSS for declaring a linear gradient, including a fallback background-color. The fallback is either the first color-stop or an explicitly passed fallback color.\n *\n * @example\n * // Styles as object usage\n * const styles = {\n *   ...linearGradient({\n        colorStops: ['#00FFFF 0%', 'rgba(0, 0, 255, 0) 50%', '#0000FF 95%'],\n        toDirection: 'to top right',\n        fallback: '#FFF',\n      })\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   ${linearGradient({\n        colorStops: ['#00FFFF 0%', 'rgba(0, 0, 255, 0) 50%', '#0000FF 95%'],\n        toDirection: 'to top right',\n        fallback: '#FFF',\n      })}\n *`\n *\n * // CSS as JS Output\n *\n * div: {\n *   'backgroundColor': '#FFF',\n *   'backgroundImage': 'linear-gradient(to top right, #00FFFF 0%, rgba(0, 0, 255, 0) 50%, #0000FF 95%)',\n * }\n */\n\n\nfunction linearGradient(_ref) {\n  var colorStops = _ref.colorStops,\n      fallback = _ref.fallback,\n      _ref$toDirection = _ref.toDirection,\n      toDirection = _ref$toDirection === void 0 ? '' : _ref$toDirection;\n\n  if (!colorStops || colorStops.length < 2) {\n    throw new PolishedError(56);\n  }\n\n  return {\n    backgroundColor: fallback || colorStops[0].split(' ')[0],\n    backgroundImage: constructGradientValue(_templateObject(), toDirection, colorStops.join(', '))\n  };\n}\n/**\n * CSS to normalize abnormalities across browsers (normalize.css v8.0.0 | MIT License | github.com/necolas/normalize.css)\n *\n * @example\n * // Styles as object usage\n * const styles = {\n *    ...normalize(),\n * }\n *\n * // styled-components usage\n * const GlobalStyle = createGlobalStyle`${normalize()}`\n *\n * // CSS as JS Output\n *\n * html {\n *   lineHeight: 1.15,\n *   textSizeAdjust: 100%,\n * } ...\n */\n\n\nfunction normalize() {\n  var _ref;\n\n  return [(_ref = {\n    html: {\n      lineHeight: '1.15',\n      textSizeAdjust: '100%'\n    },\n    body: {\n      margin: '0'\n    },\n    h1: {\n      fontSize: '2em',\n      margin: '0.67em 0'\n    },\n    hr: {\n      boxSizing: 'content-box',\n      height: '0',\n      overflow: 'visible'\n    },\n    pre: {\n      fontFamily: 'monospace, monospace',\n      fontSize: '1em'\n    },\n    a: {\n      backgroundColor: 'transparent'\n    },\n    'abbr[title]': {\n      borderBottom: 'none',\n      textDecoration: 'underline'\n    }\n  }, _ref[\"b,\\n    strong\"] = {\n    fontWeight: 'bolder'\n  }, _ref[\"code,\\n    kbd,\\n    samp\"] = {\n    fontFamily: 'monospace, monospace',\n    fontSize: '1em'\n  }, _ref.small = {\n    fontSize: '80%'\n  }, _ref[\"sub,\\n    sup\"] = {\n    fontSize: '75%',\n    lineHeight: '0',\n    position: 'relative',\n    verticalAlign: 'baseline'\n  }, _ref.sub = {\n    bottom: '-0.25em'\n  }, _ref.sup = {\n    top: '-0.5em'\n  }, _ref.img = {\n    borderStyle: 'none'\n  }, _ref[\"button,\\n    input,\\n    optgroup,\\n    select,\\n    textarea\"] = {\n    fontFamily: 'inherit',\n    fontSize: '100%',\n    lineHeight: '1.15',\n    margin: '0'\n  }, _ref[\"button,\\n    input\"] = {\n    overflow: 'visible'\n  }, _ref[\"button,\\n    select\"] = {\n    textTransform: 'none'\n  }, _ref[\"button,\\n    html [type=\\\"button\\\"],\\n    [type=\\\"reset\\\"],\\n    [type=\\\"submit\\\"]\"] = {\n    WebkitAppearance: 'button'\n  }, _ref[\"button::-moz-focus-inner,\\n    [type=\\\"button\\\"]::-moz-focus-inner,\\n    [type=\\\"reset\\\"]::-moz-focus-inner,\\n    [type=\\\"submit\\\"]::-moz-focus-inner\"] = {\n    borderStyle: 'none',\n    padding: '0'\n  }, _ref[\"button:-moz-focusring,\\n    [type=\\\"button\\\"]:-moz-focusring,\\n    [type=\\\"reset\\\"]:-moz-focusring,\\n    [type=\\\"submit\\\"]:-moz-focusring\"] = {\n    outline: '1px dotted ButtonText'\n  }, _ref.fieldset = {\n    padding: '0.35em 0.625em 0.75em'\n  }, _ref.legend = {\n    boxSizing: 'border-box',\n    color: 'inherit',\n    display: 'table',\n    maxWidth: '100%',\n    padding: '0',\n    whiteSpace: 'normal'\n  }, _ref.progress = {\n    verticalAlign: 'baseline'\n  }, _ref.textarea = {\n    overflow: 'auto'\n  }, _ref[\"[type=\\\"checkbox\\\"],\\n    [type=\\\"radio\\\"]\"] = {\n    boxSizing: 'border-box',\n    padding: '0'\n  }, _ref[\"[type=\\\"number\\\"]::-webkit-inner-spin-button,\\n    [type=\\\"number\\\"]::-webkit-outer-spin-button\"] = {\n    height: 'auto'\n  }, _ref['[type=\"search\"]'] = {\n    WebkitAppearance: 'textfield',\n    outlineOffset: '-2px'\n  }, _ref['[type=\"search\"]::-webkit-search-decoration'] = {\n    WebkitAppearance: 'none'\n  }, _ref['::-webkit-file-upload-button'] = {\n    WebkitAppearance: 'button',\n    font: 'inherit'\n  }, _ref.details = {\n    display: 'block'\n  }, _ref.summary = {\n    display: 'list-item'\n  }, _ref.template = {\n    display: 'none'\n  }, _ref['[hidden]'] = {\n    display: 'none'\n  }, _ref), {\n    'abbr[title]': {\n      textDecoration: 'underline dotted'\n    }\n  }];\n}\n\nfunction _templateObject$1() {\n  var data = _taggedTemplateLiteralLoose([\"radial-gradient(\", \"\", \"\", \"\", \")\"]);\n\n  _templateObject$1 = function _templateObject() {\n    return data;\n  };\n\n  return data;\n}\n/**\n * CSS for declaring a radial gradient, including a fallback background-color. The fallback is either the first color-stop or an explicitly passed fallback color.\n *\n * @example\n * // Styles as object usage\n * const styles = {\n *   ...radialGradient({\n *     colorStops: ['#00FFFF 0%', 'rgba(0, 0, 255, 0) 50%', '#0000FF 95%'],\n *     extent: 'farthest-corner at 45px 45px',\n *     position: 'center',\n *     shape: 'ellipse',\n *   })\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   ${radialGradient({\n *     colorStops: ['#00FFFF 0%', 'rgba(0, 0, 255, 0) 50%', '#0000FF 95%'],\n *     extent: 'farthest-corner at 45px 45px',\n *     position: 'center',\n *     shape: 'ellipse',\n *   })}\n *`\n *\n * // CSS as JS Output\n *\n * div: {\n *   'backgroundColor': '#00FFFF',\n *   'backgroundImage': 'radial-gradient(center ellipse farthest-corner at 45px 45px, #00FFFF 0%, rgba(0, 0, 255, 0) 50%, #0000FF 95%)',\n * }\n */\n\n\nfunction radialGradient(_ref) {\n  var colorStops = _ref.colorStops,\n      _ref$extent = _ref.extent,\n      extent = _ref$extent === void 0 ? '' : _ref$extent,\n      fallback = _ref.fallback,\n      _ref$position = _ref.position,\n      position = _ref$position === void 0 ? '' : _ref$position,\n      _ref$shape = _ref.shape,\n      shape = _ref$shape === void 0 ? '' : _ref$shape;\n\n  if (!colorStops || colorStops.length < 2) {\n    throw new PolishedError(57);\n  }\n\n  return {\n    backgroundColor: fallback || colorStops[0].split(' ')[0],\n    backgroundImage: constructGradientValue(_templateObject$1(), position, shape, extent, colorStops.join(', '))\n  };\n}\n/**\n * A helper to generate a retina background image and non-retina\n * background image. The retina background image will output to a HiDPI media query. The mixin uses\n * a _2x.png filename suffix by default.\n *\n * @example\n * // Styles as object usage\n * const styles = {\n *  ...retinaImage('my-img')\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   ${retinaImage('my-img')}\n * `\n *\n * // CSS as JS Output\n * div {\n *   backgroundImage: 'url(my-img.png)',\n *   '@media only screen and (-webkit-min-device-pixel-ratio: 1.3),\n *    only screen and (min--moz-device-pixel-ratio: 1.3),\n *    only screen and (-o-min-device-pixel-ratio: 1.3/1),\n *    only screen and (min-resolution: 144dpi),\n *    only screen and (min-resolution: 1.5dppx)': {\n *     backgroundImage: 'url(my-img_2x.png)',\n *   }\n * }\n */\n\n\nfunction retinaImage(filename, backgroundSize, extension, retinaFilename, retinaSuffix) {\n  var _ref;\n\n  if (extension === void 0) {\n    extension = 'png';\n  }\n\n  if (retinaSuffix === void 0) {\n    retinaSuffix = '_2x';\n  }\n\n  if (!filename) {\n    throw new PolishedError(58);\n  } // Replace the dot at the beginning of the passed extension if one exists\n\n\n  var ext = extension.replace(/^\\./, '');\n  var rFilename = retinaFilename ? retinaFilename + \".\" + ext : \"\" + filename + retinaSuffix + \".\" + ext;\n  return _ref = {\n    backgroundImage: \"url(\" + filename + \".\" + ext + \")\"\n  }, _ref[hiDPI()] = _extends({\n    backgroundImage: \"url(\" + rFilename + \")\"\n  }, backgroundSize ? {\n    backgroundSize: backgroundSize\n  } : {}), _ref;\n}\n/* eslint-disable key-spacing */\n\n\nvar functionsMap = {\n  easeInBack: 'cubic-bezier(0.600, -0.280, 0.735, 0.045)',\n  easeInCirc: 'cubic-bezier(0.600,  0.040, 0.980, 0.335)',\n  easeInCubic: 'cubic-bezier(0.550,  0.055, 0.675, 0.190)',\n  easeInExpo: 'cubic-bezier(0.950,  0.050, 0.795, 0.035)',\n  easeInQuad: 'cubic-bezier(0.550,  0.085, 0.680, 0.530)',\n  easeInQuart: 'cubic-bezier(0.895,  0.030, 0.685, 0.220)',\n  easeInQuint: 'cubic-bezier(0.755,  0.050, 0.855, 0.060)',\n  easeInSine: 'cubic-bezier(0.470,  0.000, 0.745, 0.715)',\n  easeOutBack: 'cubic-bezier(0.175,  0.885, 0.320, 1.275)',\n  easeOutCubic: 'cubic-bezier(0.215,  0.610, 0.355, 1.000)',\n  easeOutCirc: 'cubic-bezier(0.075,  0.820, 0.165, 1.000)',\n  easeOutExpo: 'cubic-bezier(0.190,  1.000, 0.220, 1.000)',\n  easeOutQuad: 'cubic-bezier(0.250,  0.460, 0.450, 0.940)',\n  easeOutQuart: 'cubic-bezier(0.165,  0.840, 0.440, 1.000)',\n  easeOutQuint: 'cubic-bezier(0.230,  1.000, 0.320, 1.000)',\n  easeOutSine: 'cubic-bezier(0.390,  0.575, 0.565, 1.000)',\n  easeInOutBack: 'cubic-bezier(0.680, -0.550, 0.265, 1.550)',\n  easeInOutCirc: 'cubic-bezier(0.785,  0.135, 0.150, 0.860)',\n  easeInOutCubic: 'cubic-bezier(0.645,  0.045, 0.355, 1.000)',\n  easeInOutExpo: 'cubic-bezier(1.000,  0.000, 0.000, 1.000)',\n  easeInOutQuad: 'cubic-bezier(0.455,  0.030, 0.515, 0.955)',\n  easeInOutQuart: 'cubic-bezier(0.770,  0.000, 0.175, 1.000)',\n  easeInOutQuint: 'cubic-bezier(0.860,  0.000, 0.070, 1.000)',\n  easeInOutSine: 'cubic-bezier(0.445,  0.050, 0.550, 0.950)'\n  /* eslint-enable key-spacing */\n\n};\n\nfunction getTimingFunction(functionName) {\n  return functionsMap[functionName];\n}\n/**\n * String to represent common easing functions as demonstrated here: (github.com/jaukia/easie).\n *\n * @example\n * // Styles as object usage\n * const styles = {\n *   'transitionTimingFunction': timingFunctions('easeInQuad')\n * }\n *\n * // styled-components usage\n *  const div = styled.div`\n *   transitionTimingFunction: ${timingFunctions('easeInQuad')};\n * `\n *\n * // CSS as JS Output\n *\n * 'div': {\n *   'transitionTimingFunction': 'cubic-bezier(0.550,  0.085, 0.680, 0.530)',\n * }\n */\n\n\nfunction timingFunctions(timingFunction) {\n  return getTimingFunction(timingFunction);\n}\n\nvar getBorderWidth = function getBorderWidth(pointingDirection, height, width) {\n  var fullWidth = \"\" + width[0] + (width[1] || '');\n  var halfWidth = \"\" + width[0] / 2 + (width[1] || '');\n  var fullHeight = \"\" + height[0] + (height[1] || '');\n  var halfHeight = \"\" + height[0] / 2 + (height[1] || '');\n\n  switch (pointingDirection) {\n    case 'top':\n      return \"0 \" + halfWidth + \" \" + fullHeight + \" \" + halfWidth;\n\n    case 'topLeft':\n      return fullWidth + \" \" + fullHeight + \" 0 0\";\n\n    case 'left':\n      return halfHeight + \" \" + fullWidth + \" \" + halfHeight + \" 0\";\n\n    case 'bottomLeft':\n      return fullWidth + \" 0 0 \" + fullHeight;\n\n    case 'bottom':\n      return fullHeight + \" \" + halfWidth + \" 0 \" + halfWidth;\n\n    case 'bottomRight':\n      return \"0 0 \" + fullWidth + \" \" + fullHeight;\n\n    case 'right':\n      return halfHeight + \" 0 \" + halfHeight + \" \" + fullWidth;\n\n    case 'topRight':\n    default:\n      return \"0 \" + fullWidth + \" \" + fullHeight + \" 0\";\n  }\n};\n\nvar getBorderColor = function getBorderColor(pointingDirection, foregroundColor, backgroundColor) {\n  switch (pointingDirection) {\n    case 'top':\n    case 'bottomRight':\n      return backgroundColor + \" \" + backgroundColor + \" \" + foregroundColor + \" \" + backgroundColor;\n\n    case 'right':\n    case 'bottomLeft':\n      return backgroundColor + \" \" + backgroundColor + \" \" + backgroundColor + \" \" + foregroundColor;\n\n    case 'bottom':\n    case 'topLeft':\n      return foregroundColor + \" \" + backgroundColor + \" \" + backgroundColor + \" \" + backgroundColor;\n\n    case 'left':\n    case 'topRight':\n      return backgroundColor + \" \" + foregroundColor + \" \" + backgroundColor + \" \" + backgroundColor;\n\n    default:\n      throw new PolishedError(59);\n  }\n};\n/**\n * CSS to represent triangle with any pointing direction with an optional background color.\n *\n * @example\n * // Styles as object usage\n *\n * const styles = {\n *   ...triangle({ pointingDirection: 'right', width: '100px', height: '100px', foregroundColor: 'red' })\n * }\n *\n *\n * // styled-components usage\n * const div = styled.div`\n *   ${triangle({ pointingDirection: 'right', width: '100px', height: '100px', foregroundColor: 'red' })}\n *\n *\n * // CSS as JS Output\n *\n * div: {\n *  'borderColor': 'transparent transparent transparent red',\n *  'borderStyle': 'solid',\n *  'borderWidth': '50px 0 50px 100px',\n *  'height': '0',\n *  'width': '0',\n * }\n */\n\n\nfunction triangle(_ref) {\n  var pointingDirection = _ref.pointingDirection,\n      height = _ref.height,\n      width = _ref.width,\n      foregroundColor = _ref.foregroundColor,\n      _ref$backgroundColor = _ref.backgroundColor,\n      backgroundColor = _ref$backgroundColor === void 0 ? 'transparent' : _ref$backgroundColor;\n  var widthAndUnit = stripUnit(width, true);\n  var heightAndUnit = stripUnit(height, true);\n\n  if (isNaN(heightAndUnit[0]) || isNaN(widthAndUnit[0])) {\n    throw new PolishedError(60);\n  }\n\n  return {\n    width: '0',\n    height: '0',\n    borderColor: getBorderColor(pointingDirection, foregroundColor, backgroundColor),\n    borderStyle: 'solid',\n    borderWidth: getBorderWidth(pointingDirection, heightAndUnit, widthAndUnit)\n  };\n}\n/**\n * Provides an easy way to change the `wordWrap` property.\n *\n * @example\n * // Styles as object usage\n * const styles = {\n *   ...wordWrap('break-word')\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   ${wordWrap('break-word')}\n * `\n *\n * // CSS as JS Output\n *\n * const styles = {\n *   overflowWrap: 'break-word',\n *   wordWrap: 'break-word',\n *   wordBreak: 'break-all',\n * }\n */\n\n\nfunction wordWrap(wrap) {\n  if (wrap === void 0) {\n    wrap = 'break-word';\n  }\n\n  var wordBreak = wrap === 'break-word' ? 'break-all' : wrap;\n  return {\n    overflowWrap: wrap,\n    wordWrap: wrap,\n    wordBreak: wordBreak\n  };\n}\n\nfunction colorToInt(color) {\n  return Math.round(color * 255);\n}\n\nfunction convertToInt(red, green, blue) {\n  return colorToInt(red) + \",\" + colorToInt(green) + \",\" + colorToInt(blue);\n}\n\nfunction hslToRgb(hue, saturation, lightness, convert) {\n  if (convert === void 0) {\n    convert = convertToInt;\n  }\n\n  if (saturation === 0) {\n    // achromatic\n    return convert(lightness, lightness, lightness);\n  } // formulae from https://en.wikipedia.org/wiki/HSL_and_HSV\n\n\n  var huePrime = (hue % 360 + 360) % 360 / 60;\n  var chroma = (1 - Math.abs(2 * lightness - 1)) * saturation;\n  var secondComponent = chroma * (1 - Math.abs(huePrime % 2 - 1));\n  var red = 0;\n  var green = 0;\n  var blue = 0;\n\n  if (huePrime >= 0 && huePrime < 1) {\n    red = chroma;\n    green = secondComponent;\n  } else if (huePrime >= 1 && huePrime < 2) {\n    red = secondComponent;\n    green = chroma;\n  } else if (huePrime >= 2 && huePrime < 3) {\n    green = chroma;\n    blue = secondComponent;\n  } else if (huePrime >= 3 && huePrime < 4) {\n    green = secondComponent;\n    blue = chroma;\n  } else if (huePrime >= 4 && huePrime < 5) {\n    red = secondComponent;\n    blue = chroma;\n  } else if (huePrime >= 5 && huePrime < 6) {\n    red = chroma;\n    blue = secondComponent;\n  }\n\n  var lightnessModification = lightness - chroma / 2;\n  var finalRed = red + lightnessModification;\n  var finalGreen = green + lightnessModification;\n  var finalBlue = blue + lightnessModification;\n  return convert(finalRed, finalGreen, finalBlue);\n}\n\nvar namedColorMap = {\n  aliceblue: 'f0f8ff',\n  antiquewhite: 'faebd7',\n  aqua: '00ffff',\n  aquamarine: '7fffd4',\n  azure: 'f0ffff',\n  beige: 'f5f5dc',\n  bisque: 'ffe4c4',\n  black: '000',\n  blanchedalmond: 'ffebcd',\n  blue: '0000ff',\n  blueviolet: '8a2be2',\n  brown: 'a52a2a',\n  burlywood: 'deb887',\n  cadetblue: '5f9ea0',\n  chartreuse: '7fff00',\n  chocolate: 'd2691e',\n  coral: 'ff7f50',\n  cornflowerblue: '6495ed',\n  cornsilk: 'fff8dc',\n  crimson: 'dc143c',\n  cyan: '00ffff',\n  darkblue: '00008b',\n  darkcyan: '008b8b',\n  darkgoldenrod: 'b8860b',\n  darkgray: 'a9a9a9',\n  darkgreen: '006400',\n  darkgrey: 'a9a9a9',\n  darkkhaki: 'bdb76b',\n  darkmagenta: '8b008b',\n  darkolivegreen: '556b2f',\n  darkorange: 'ff8c00',\n  darkorchid: '9932cc',\n  darkred: '8b0000',\n  darksalmon: 'e9967a',\n  darkseagreen: '8fbc8f',\n  darkslateblue: '483d8b',\n  darkslategray: '2f4f4f',\n  darkslategrey: '2f4f4f',\n  darkturquoise: '00ced1',\n  darkviolet: '9400d3',\n  deeppink: 'ff1493',\n  deepskyblue: '00bfff',\n  dimgray: '696969',\n  dimgrey: '696969',\n  dodgerblue: '1e90ff',\n  firebrick: 'b22222',\n  floralwhite: 'fffaf0',\n  forestgreen: '228b22',\n  fuchsia: 'ff00ff',\n  gainsboro: 'dcdcdc',\n  ghostwhite: 'f8f8ff',\n  gold: 'ffd700',\n  goldenrod: 'daa520',\n  gray: '808080',\n  green: '008000',\n  greenyellow: 'adff2f',\n  grey: '808080',\n  honeydew: 'f0fff0',\n  hotpink: 'ff69b4',\n  indianred: 'cd5c5c',\n  indigo: '4b0082',\n  ivory: 'fffff0',\n  khaki: 'f0e68c',\n  lavender: 'e6e6fa',\n  lavenderblush: 'fff0f5',\n  lawngreen: '7cfc00',\n  lemonchiffon: 'fffacd',\n  lightblue: 'add8e6',\n  lightcoral: 'f08080',\n  lightcyan: 'e0ffff',\n  lightgoldenrodyellow: 'fafad2',\n  lightgray: 'd3d3d3',\n  lightgreen: '90ee90',\n  lightgrey: 'd3d3d3',\n  lightpink: 'ffb6c1',\n  lightsalmon: 'ffa07a',\n  lightseagreen: '20b2aa',\n  lightskyblue: '87cefa',\n  lightslategray: '789',\n  lightslategrey: '789',\n  lightsteelblue: 'b0c4de',\n  lightyellow: 'ffffe0',\n  lime: '0f0',\n  limegreen: '32cd32',\n  linen: 'faf0e6',\n  magenta: 'f0f',\n  maroon: '800000',\n  mediumaquamarine: '66cdaa',\n  mediumblue: '0000cd',\n  mediumorchid: 'ba55d3',\n  mediumpurple: '9370db',\n  mediumseagreen: '3cb371',\n  mediumslateblue: '7b68ee',\n  mediumspringgreen: '00fa9a',\n  mediumturquoise: '48d1cc',\n  mediumvioletred: 'c71585',\n  midnightblue: '191970',\n  mintcream: 'f5fffa',\n  mistyrose: 'ffe4e1',\n  moccasin: 'ffe4b5',\n  navajowhite: 'ffdead',\n  navy: '000080',\n  oldlace: 'fdf5e6',\n  olive: '808000',\n  olivedrab: '6b8e23',\n  orange: 'ffa500',\n  orangered: 'ff4500',\n  orchid: 'da70d6',\n  palegoldenrod: 'eee8aa',\n  palegreen: '98fb98',\n  paleturquoise: 'afeeee',\n  palevioletred: 'db7093',\n  papayawhip: 'ffefd5',\n  peachpuff: 'ffdab9',\n  peru: 'cd853f',\n  pink: 'ffc0cb',\n  plum: 'dda0dd',\n  powderblue: 'b0e0e6',\n  purple: '800080',\n  rebeccapurple: '639',\n  red: 'f00',\n  rosybrown: 'bc8f8f',\n  royalblue: '4169e1',\n  saddlebrown: '8b4513',\n  salmon: 'fa8072',\n  sandybrown: 'f4a460',\n  seagreen: '2e8b57',\n  seashell: 'fff5ee',\n  sienna: 'a0522d',\n  silver: 'c0c0c0',\n  skyblue: '87ceeb',\n  slateblue: '6a5acd',\n  slategray: '708090',\n  slategrey: '708090',\n  snow: 'fffafa',\n  springgreen: '00ff7f',\n  steelblue: '4682b4',\n  tan: 'd2b48c',\n  teal: '008080',\n  thistle: 'd8bfd8',\n  tomato: 'ff6347',\n  turquoise: '40e0d0',\n  violet: 'ee82ee',\n  wheat: 'f5deb3',\n  white: 'fff',\n  whitesmoke: 'f5f5f5',\n  yellow: 'ff0',\n  yellowgreen: '9acd32'\n  /**\n   * Checks if a string is a CSS named color and returns its equivalent hex value, otherwise returns the original color.\n   * @private\n   */\n\n};\n\nfunction nameToHex(color) {\n  if (typeof color !== 'string') return color;\n  var normalizedColorName = color.toLowerCase();\n  return namedColorMap[normalizedColorName] ? \"#\" + namedColorMap[normalizedColorName] : color;\n}\n\nvar hexRegex = /^#[a-fA-F0-9]{6}$/;\nvar hexRgbaRegex = /^#[a-fA-F0-9]{8}$/;\nvar reducedHexRegex = /^#[a-fA-F0-9]{3}$/;\nvar reducedRgbaHexRegex = /^#[a-fA-F0-9]{4}$/;\nvar rgbRegex = /^rgb\\(\\s*(\\d{1,3})\\s*,\\s*(\\d{1,3})\\s*,\\s*(\\d{1,3})\\s*\\)$/i;\nvar rgbaRegex = /^rgba\\(\\s*(\\d{1,3})\\s*,\\s*(\\d{1,3})\\s*,\\s*(\\d{1,3})\\s*,\\s*([-+]?[0-9]*[.]?[0-9]+)\\s*\\)$/i;\nvar hslRegex = /^hsl\\(\\s*(\\d{0,3}[.]?[0-9]+)\\s*,\\s*(\\d{1,3})%\\s*,\\s*(\\d{1,3})%\\s*\\)$/i;\nvar hslaRegex = /^hsla\\(\\s*(\\d{0,3}[.]?[0-9]+)\\s*,\\s*(\\d{1,3})%\\s*,\\s*(\\d{1,3})%\\s*,\\s*([-+]?[0-9]*[.]?[0-9]+)\\s*\\)$/i;\n/**\n * Returns an RgbColor or RgbaColor object. This utility function is only useful\n * if want to extract a color component. With the color util `toColorString` you\n * can convert a RgbColor or RgbaColor object back to a string.\n *\n * @example\n * // Assigns `{ red: 255, green: 0, blue: 0 }` to color1\n * const color1 = parseToRgb('rgb(255, 0, 0)');\n * // Assigns `{ red: 92, green: 102, blue: 112, alpha: 0.75 }` to color2\n * const color2 = parseToRgb('hsla(210, 10%, 40%, 0.75)');\n */\n\nfunction parseToRgb(color) {\n  if (typeof color !== 'string') {\n    throw new PolishedError(3);\n  }\n\n  var normalizedColor = nameToHex(color);\n\n  if (normalizedColor.match(hexRegex)) {\n    return {\n      red: parseInt(\"\" + normalizedColor[1] + normalizedColor[2], 16),\n      green: parseInt(\"\" + normalizedColor[3] + normalizedColor[4], 16),\n      blue: parseInt(\"\" + normalizedColor[5] + normalizedColor[6], 16)\n    };\n  }\n\n  if (normalizedColor.match(hexRgbaRegex)) {\n    var alpha = parseFloat((parseInt(\"\" + normalizedColor[7] + normalizedColor[8], 16) / 255).toFixed(2));\n    return {\n      red: parseInt(\"\" + normalizedColor[1] + normalizedColor[2], 16),\n      green: parseInt(\"\" + normalizedColor[3] + normalizedColor[4], 16),\n      blue: parseInt(\"\" + normalizedColor[5] + normalizedColor[6], 16),\n      alpha: alpha\n    };\n  }\n\n  if (normalizedColor.match(reducedHexRegex)) {\n    return {\n      red: parseInt(\"\" + normalizedColor[1] + normalizedColor[1], 16),\n      green: parseInt(\"\" + normalizedColor[2] + normalizedColor[2], 16),\n      blue: parseInt(\"\" + normalizedColor[3] + normalizedColor[3], 16)\n    };\n  }\n\n  if (normalizedColor.match(reducedRgbaHexRegex)) {\n    var _alpha = parseFloat((parseInt(\"\" + normalizedColor[4] + normalizedColor[4], 16) / 255).toFixed(2));\n\n    return {\n      red: parseInt(\"\" + normalizedColor[1] + normalizedColor[1], 16),\n      green: parseInt(\"\" + normalizedColor[2] + normalizedColor[2], 16),\n      blue: parseInt(\"\" + normalizedColor[3] + normalizedColor[3], 16),\n      alpha: _alpha\n    };\n  }\n\n  var rgbMatched = rgbRegex.exec(normalizedColor);\n\n  if (rgbMatched) {\n    return {\n      red: parseInt(\"\" + rgbMatched[1], 10),\n      green: parseInt(\"\" + rgbMatched[2], 10),\n      blue: parseInt(\"\" + rgbMatched[3], 10)\n    };\n  }\n\n  var rgbaMatched = rgbaRegex.exec(normalizedColor);\n\n  if (rgbaMatched) {\n    return {\n      red: parseInt(\"\" + rgbaMatched[1], 10),\n      green: parseInt(\"\" + rgbaMatched[2], 10),\n      blue: parseInt(\"\" + rgbaMatched[3], 10),\n      alpha: parseFloat(\"\" + rgbaMatched[4])\n    };\n  }\n\n  var hslMatched = hslRegex.exec(normalizedColor);\n\n  if (hslMatched) {\n    var hue = parseInt(\"\" + hslMatched[1], 10);\n    var saturation = parseInt(\"\" + hslMatched[2], 10) / 100;\n    var lightness = parseInt(\"\" + hslMatched[3], 10) / 100;\n    var rgbColorString = \"rgb(\" + hslToRgb(hue, saturation, lightness) + \")\";\n    var hslRgbMatched = rgbRegex.exec(rgbColorString);\n\n    if (!hslRgbMatched) {\n      throw new PolishedError(4, normalizedColor, rgbColorString);\n    }\n\n    return {\n      red: parseInt(\"\" + hslRgbMatched[1], 10),\n      green: parseInt(\"\" + hslRgbMatched[2], 10),\n      blue: parseInt(\"\" + hslRgbMatched[3], 10)\n    };\n  }\n\n  var hslaMatched = hslaRegex.exec(normalizedColor);\n\n  if (hslaMatched) {\n    var _hue = parseInt(\"\" + hslaMatched[1], 10);\n\n    var _saturation = parseInt(\"\" + hslaMatched[2], 10) / 100;\n\n    var _lightness = parseInt(\"\" + hslaMatched[3], 10) / 100;\n\n    var _rgbColorString = \"rgb(\" + hslToRgb(_hue, _saturation, _lightness) + \")\";\n\n    var _hslRgbMatched = rgbRegex.exec(_rgbColorString);\n\n    if (!_hslRgbMatched) {\n      throw new PolishedError(4, normalizedColor, _rgbColorString);\n    }\n\n    return {\n      red: parseInt(\"\" + _hslRgbMatched[1], 10),\n      green: parseInt(\"\" + _hslRgbMatched[2], 10),\n      blue: parseInt(\"\" + _hslRgbMatched[3], 10),\n      alpha: parseFloat(\"\" + hslaMatched[4])\n    };\n  }\n\n  throw new PolishedError(5);\n}\n\nfunction rgbToHsl(color) {\n  // make sure rgb are contained in a set of [0, 255]\n  var red = color.red / 255;\n  var green = color.green / 255;\n  var blue = color.blue / 255;\n  var max = Math.max(red, green, blue);\n  var min = Math.min(red, green, blue);\n  var lightness = (max + min) / 2;\n\n  if (max === min) {\n    // achromatic\n    if (color.alpha !== undefined) {\n      return {\n        hue: 0,\n        saturation: 0,\n        lightness: lightness,\n        alpha: color.alpha\n      };\n    } else {\n      return {\n        hue: 0,\n        saturation: 0,\n        lightness: lightness\n      };\n    }\n  }\n\n  var hue;\n  var delta = max - min;\n  var saturation = lightness > 0.5 ? delta / (2 - max - min) : delta / (max + min);\n\n  switch (max) {\n    case red:\n      hue = (green - blue) / delta + (green < blue ? 6 : 0);\n      break;\n\n    case green:\n      hue = (blue - red) / delta + 2;\n      break;\n\n    default:\n      // blue case\n      hue = (red - green) / delta + 4;\n      break;\n  }\n\n  hue *= 60;\n\n  if (color.alpha !== undefined) {\n    return {\n      hue: hue,\n      saturation: saturation,\n      lightness: lightness,\n      alpha: color.alpha\n    };\n  }\n\n  return {\n    hue: hue,\n    saturation: saturation,\n    lightness: lightness\n  };\n}\n/**\n * Returns an HslColor or HslaColor object. This utility function is only useful\n * if want to extract a color component. With the color util `toColorString` you\n * can convert a HslColor or HslaColor object back to a string.\n *\n * @example\n * // Assigns `{ hue: 0, saturation: 1, lightness: 0.5 }` to color1\n * const color1 = parseToHsl('rgb(255, 0, 0)');\n * // Assigns `{ hue: 128, saturation: 1, lightness: 0.5, alpha: 0.75 }` to color2\n * const color2 = parseToHsl('hsla(128, 100%, 50%, 0.75)');\n */\n\n\nfunction parseToHsl(color) {\n  // Note: At a later stage we can optimize this function as right now a hsl\n  // color would be parsed converted to rgb values and converted back to hsl.\n  return rgbToHsl(parseToRgb(color));\n}\n/**\n * Reduces hex values if possible e.g. #ff8866 to #f86\n * @private\n */\n\n\nvar reduceHexValue = function reduceHexValue(value) {\n  if (value.length === 7 && value[1] === value[2] && value[3] === value[4] && value[5] === value[6]) {\n    return \"#\" + value[1] + value[3] + value[5];\n  }\n\n  return value;\n};\n\nfunction numberToHex(value) {\n  var hex = value.toString(16);\n  return hex.length === 1 ? \"0\" + hex : hex;\n}\n\nfunction colorToHex(color) {\n  return numberToHex(Math.round(color * 255));\n}\n\nfunction convertToHex(red, green, blue) {\n  return reduceHexValue(\"#\" + colorToHex(red) + colorToHex(green) + colorToHex(blue));\n}\n\nfunction hslToHex(hue, saturation, lightness) {\n  return hslToRgb(hue, saturation, lightness, convertToHex);\n}\n/**\n * Returns a string value for the color. The returned result is the smallest possible hex notation.\n *\n * @example\n * // Styles as object usage\n * const styles = {\n *   background: hsl(359, 0.75, 0.4),\n *   background: hsl({ hue: 360, saturation: 0.75, lightness: 0.4 }),\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   background: ${hsl(359, 0.75, 0.4)};\n *   background: ${hsl({ hue: 360, saturation: 0.75, lightness: 0.4 })};\n * `\n *\n * // CSS in JS Output\n *\n * element {\n *   background: \"#b3191c\";\n *   background: \"#b3191c\";\n * }\n */\n\n\nfunction hsl(value, saturation, lightness) {\n  if (typeof value === 'number' && typeof saturation === 'number' && typeof lightness === 'number') {\n    return hslToHex(value, saturation, lightness);\n  } else if (typeof value === 'object' && saturation === undefined && lightness === undefined) {\n    return hslToHex(value.hue, value.saturation, value.lightness);\n  }\n\n  throw new PolishedError(1);\n}\n/**\n * Returns a string value for the color. The returned result is the smallest possible rgba or hex notation.\n *\n * @example\n * // Styles as object usage\n * const styles = {\n *   background: hsla(359, 0.75, 0.4, 0.7),\n *   background: hsla({ hue: 360, saturation: 0.75, lightness: 0.4, alpha: 0,7 }),\n *   background: hsla(359, 0.75, 0.4, 1),\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   background: ${hsla(359, 0.75, 0.4, 0.7)};\n *   background: ${hsla({ hue: 360, saturation: 0.75, lightness: 0.4, alpha: 0,7 })};\n *   background: ${hsla(359, 0.75, 0.4, 1)};\n * `\n *\n * // CSS in JS Output\n *\n * element {\n *   background: \"rgba(179,25,28,0.7)\";\n *   background: \"rgba(179,25,28,0.7)\";\n *   background: \"#b3191c\";\n * }\n */\n\n\nfunction hsla(value, saturation, lightness, alpha) {\n  if (typeof value === 'number' && typeof saturation === 'number' && typeof lightness === 'number' && typeof alpha === 'number') {\n    return alpha >= 1 ? hslToHex(value, saturation, lightness) : \"rgba(\" + hslToRgb(value, saturation, lightness) + \",\" + alpha + \")\";\n  } else if (typeof value === 'object' && saturation === undefined && lightness === undefined && alpha === undefined) {\n    return value.alpha >= 1 ? hslToHex(value.hue, value.saturation, value.lightness) : \"rgba(\" + hslToRgb(value.hue, value.saturation, value.lightness) + \",\" + value.alpha + \")\";\n  }\n\n  throw new PolishedError(2);\n}\n/**\n * Returns a string value for the color. The returned result is the smallest possible hex notation.\n *\n * @example\n * // Styles as object usage\n * const styles = {\n *   background: rgb(255, 205, 100),\n *   background: rgb({ red: 255, green: 205, blue: 100 }),\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   background: ${rgb(255, 205, 100)};\n *   background: ${rgb({ red: 255, green: 205, blue: 100 })};\n * `\n *\n * // CSS in JS Output\n *\n * element {\n *   background: \"#ffcd64\";\n *   background: \"#ffcd64\";\n * }\n */\n\n\nfunction rgb(value, green, blue) {\n  if (typeof value === 'number' && typeof green === 'number' && typeof blue === 'number') {\n    return reduceHexValue(\"#\" + numberToHex(value) + numberToHex(green) + numberToHex(blue));\n  } else if (typeof value === 'object' && green === undefined && blue === undefined) {\n    return reduceHexValue(\"#\" + numberToHex(value.red) + numberToHex(value.green) + numberToHex(value.blue));\n  }\n\n  throw new PolishedError(6);\n}\n/**\n * Returns a string value for the color. The returned result is the smallest possible rgba or hex notation.\n *\n * Can also be used to fade a color by passing a hex value or named CSS color along with an alpha value.\n *\n * @example\n * // Styles as object usage\n * const styles = {\n *   background: rgba(255, 205, 100, 0.7),\n *   background: rgba({ red: 255, green: 205, blue: 100, alpha: 0.7 }),\n *   background: rgba(255, 205, 100, 1),\n *   background: rgba('#ffffff', 0.4),\n *   background: rgba('black', 0.7),\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   background: ${rgba(255, 205, 100, 0.7)};\n *   background: ${rgba({ red: 255, green: 205, blue: 100, alpha: 0.7 })};\n *   background: ${rgba(255, 205, 100, 1)};\n *   background: ${rgba('#ffffff', 0.4)};\n *   background: ${rgba('black', 0.7)};\n * `\n *\n * // CSS in JS Output\n *\n * element {\n *   background: \"rgba(255,205,100,0.7)\";\n *   background: \"rgba(255,205,100,0.7)\";\n *   background: \"#ffcd64\";\n *   background: \"rgba(255,255,255,0.4)\";\n *   background: \"rgba(0,0,0,0.7)\";\n * }\n */\n\n\nfunction rgba(firstValue, secondValue, thirdValue, fourthValue) {\n  if (typeof firstValue === 'string' && typeof secondValue === 'number') {\n    var rgbValue = parseToRgb(firstValue);\n    return \"rgba(\" + rgbValue.red + \",\" + rgbValue.green + \",\" + rgbValue.blue + \",\" + secondValue + \")\";\n  } else if (typeof firstValue === 'number' && typeof secondValue === 'number' && typeof thirdValue === 'number' && typeof fourthValue === 'number') {\n    return fourthValue >= 1 ? rgb(firstValue, secondValue, thirdValue) : \"rgba(\" + firstValue + \",\" + secondValue + \",\" + thirdValue + \",\" + fourthValue + \")\";\n  } else if (typeof firstValue === 'object' && secondValue === undefined && thirdValue === undefined && fourthValue === undefined) {\n    return firstValue.alpha >= 1 ? rgb(firstValue.red, firstValue.green, firstValue.blue) : \"rgba(\" + firstValue.red + \",\" + firstValue.green + \",\" + firstValue.blue + \",\" + firstValue.alpha + \")\";\n  }\n\n  throw new PolishedError(7);\n}\n\nvar isRgb = function isRgb(color) {\n  return typeof color.red === 'number' && typeof color.green === 'number' && typeof color.blue === 'number' && (typeof color.alpha !== 'number' || typeof color.alpha === 'undefined');\n};\n\nvar isRgba = function isRgba(color) {\n  return typeof color.red === 'number' && typeof color.green === 'number' && typeof color.blue === 'number' && typeof color.alpha === 'number';\n};\n\nvar isHsl = function isHsl(color) {\n  return typeof color.hue === 'number' && typeof color.saturation === 'number' && typeof color.lightness === 'number' && (typeof color.alpha !== 'number' || typeof color.alpha === 'undefined');\n};\n\nvar isHsla = function isHsla(color) {\n  return typeof color.hue === 'number' && typeof color.saturation === 'number' && typeof color.lightness === 'number' && typeof color.alpha === 'number';\n};\n/**\n * Converts a RgbColor, RgbaColor, HslColor or HslaColor object to a color string.\n * This util is useful in case you only know on runtime which color object is\n * used. Otherwise we recommend to rely on `rgb`, `rgba`, `hsl` or `hsla`.\n *\n * @example\n * // Styles as object usage\n * const styles = {\n *   background: toColorString({ red: 255, green: 205, blue: 100 }),\n *   background: toColorString({ red: 255, green: 205, blue: 100, alpha: 0.72 }),\n *   background: toColorString({ hue: 240, saturation: 1, lightness: 0.5 }),\n *   background: toColorString({ hue: 360, saturation: 0.75, lightness: 0.4, alpha: 0.72 }),\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   background: ${toColorString({ red: 255, green: 205, blue: 100 })};\n *   background: ${toColorString({ red: 255, green: 205, blue: 100, alpha: 0.72 })};\n *   background: ${toColorString({ hue: 240, saturation: 1, lightness: 0.5 })};\n *   background: ${toColorString({ hue: 360, saturation: 0.75, lightness: 0.4, alpha: 0.72 })};\n * `\n *\n * // CSS in JS Output\n * element {\n *   background: \"#ffcd64\";\n *   background: \"rgba(255,205,100,0.72)\";\n *   background: \"#00f\";\n *   background: \"rgba(179,25,25,0.72)\";\n * }\n */\n\n\nfunction toColorString(color) {\n  if (typeof color !== 'object') throw new PolishedError(8);\n  if (isRgba(color)) return rgba(color);\n  if (isRgb(color)) return rgb(color);\n  if (isHsla(color)) return hsla(color);\n  if (isHsl(color)) return hsl(color);\n  throw new PolishedError(8);\n} // Type definitions taken from https://github.com/gcanti/flow-static-land/blob/master/src/Fun.js\n// eslint-disable-next-line no-unused-vars\n// eslint-disable-next-line no-unused-vars\n// eslint-disable-next-line no-redeclare\n\n\nfunction curried(f, length, acc) {\n  return function fn() {\n    // eslint-disable-next-line prefer-rest-params\n    var combined = acc.concat(Array.prototype.slice.call(arguments));\n    return combined.length >= length ? f.apply(this, combined) : curried(f, length, combined);\n  };\n} // eslint-disable-next-line no-redeclare\n\n\nfunction curry(f) {\n  // eslint-disable-line no-redeclare\n  return curried(f, f.length, []);\n}\n/**\n * Changes the hue of the color. Hue is a number between 0 to 360. The first\n * argument for adjustHue is the amount of degrees the color is rotated around\n * the color wheel, always producing a positive hue value.\n *\n * @example\n * // Styles as object usage\n * const styles = {\n *   background: adjustHue(180, '#448'),\n *   background: adjustHue('180', 'rgba(101,100,205,0.7)'),\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   background: ${adjustHue(180, '#448')};\n *   background: ${adjustHue('180', 'rgba(101,100,205,0.7)')};\n * `\n *\n * // CSS in JS Output\n * element {\n *   background: \"#888844\";\n *   background: \"rgba(136,136,68,0.7)\";\n * }\n */\n\n\nfunction adjustHue(degree, color) {\n  if (color === 'transparent') return color;\n  var hslColor = parseToHsl(color);\n  return toColorString(_extends({}, hslColor, {\n    hue: hslColor.hue + parseFloat(degree)\n  }));\n} // prettier-ignore\n\n\nvar curriedAdjustHue =\n/*#__PURE__*/\ncurry\n/* ::<number | string, string, string> */\n(adjustHue);\n/**\n * Returns the complement of the provided color. This is identical to adjustHue(180, <color>).\n *\n * @example\n * // Styles as object usage\n * const styles = {\n *   background: complement('#448'),\n *   background: complement('rgba(204,205,100,0.7)'),\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   background: ${complement('#448')};\n *   background: ${complement('rgba(204,205,100,0.7)')};\n * `\n *\n * // CSS in JS Output\n * element {\n *   background: \"#884\";\n *   background: \"rgba(153,153,153,0.7)\";\n * }\n */\n\nfunction complement(color) {\n  if (color === 'transparent') return color;\n  var hslColor = parseToHsl(color);\n  return toColorString(_extends({}, hslColor, {\n    hue: (hslColor.hue + 180) % 360\n  }));\n}\n\nfunction guard(lowerBoundary, upperBoundary, value) {\n  return Math.max(lowerBoundary, Math.min(upperBoundary, value));\n}\n/**\n * Returns a string value for the darkened color.\n *\n * @example\n * // Styles as object usage\n * const styles = {\n *   background: darken(0.2, '#FFCD64'),\n *   background: darken('0.2', 'rgba(255,205,100,0.7)'),\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   background: ${darken(0.2, '#FFCD64')};\n *   background: ${darken('0.2', 'rgba(255,205,100,0.7)')};\n * `\n *\n * // CSS in JS Output\n *\n * element {\n *   background: \"#ffbd31\";\n *   background: \"rgba(255,189,49,0.7)\";\n * }\n */\n\n\nfunction darken(amount, color) {\n  if (color === 'transparent') return color;\n  var hslColor = parseToHsl(color);\n  return toColorString(_extends({}, hslColor, {\n    lightness: guard(0, 1, hslColor.lightness - parseFloat(amount))\n  }));\n} // prettier-ignore\n\n\nvar curriedDarken =\n/*#__PURE__*/\ncurry\n/* ::<number | string, string, string> */\n(darken);\n/**\n * Decreases the intensity of a color. Its range is between 0 to 1. The first\n * argument of the desaturate function is the amount by how much the color\n * intensity should be decreased.\n *\n * @example\n * // Styles as object usage\n * const styles = {\n *   background: desaturate(0.2, '#CCCD64'),\n *   background: desaturate('0.2', 'rgba(204,205,100,0.7)'),\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   background: ${desaturate(0.2, '#CCCD64')};\n *   background: ${desaturate('0.2', 'rgba(204,205,100,0.7)')};\n * `\n *\n * // CSS in JS Output\n * element {\n *   background: \"#b8b979\";\n *   background: \"rgba(184,185,121,0.7)\";\n * }\n */\n\nfunction desaturate(amount, color) {\n  if (color === 'transparent') return color;\n  var hslColor = parseToHsl(color);\n  return toColorString(_extends({}, hslColor, {\n    saturation: guard(0, 1, hslColor.saturation - parseFloat(amount))\n  }));\n} // prettier-ignore\n\n\nvar curriedDesaturate =\n/*#__PURE__*/\ncurry\n/* ::<number | string, string, string> */\n(desaturate);\n/**\n * Returns a number (float) representing the luminance of a color.\n *\n * @example\n * // Styles as object usage\n * const styles = {\n *   background: getLuminance('#CCCD64') >= getLuminance('#0000ff') ? '#CCCD64' : '#0000ff',\n *   background: getLuminance('rgba(58, 133, 255, 1)') >= getLuminance('rgba(255, 57, 149, 1)') ?\n *                             'rgba(58, 133, 255, 1)' :\n *                             'rgba(255, 57, 149, 1)',\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   background: ${getLuminance('#CCCD64') >= getLuminance('#0000ff') ? '#CCCD64' : '#0000ff'};\n *   background: ${getLuminance('rgba(58, 133, 255, 1)') >= getLuminance('rgba(255, 57, 149, 1)') ?\n *                             'rgba(58, 133, 255, 1)' :\n *                             'rgba(255, 57, 149, 1)'};\n *\n * // CSS in JS Output\n *\n * div {\n *   background: \"#CCCD64\";\n *   background: \"rgba(58, 133, 255, 1)\";\n * }\n */\n\nfunction getLuminance(color) {\n  if (color === 'transparent') return 0;\n  var rgbColor = parseToRgb(color);\n\n  var _Object$keys$map = Object.keys(rgbColor).map(function (key) {\n    var channel = rgbColor[key] / 255;\n    return channel <= 0.03928 ? channel / 12.92 : Math.pow((channel + 0.055) / 1.055, 2.4);\n  }),\n      r = _Object$keys$map[0],\n      g = _Object$keys$map[1],\n      b = _Object$keys$map[2];\n\n  return parseFloat((0.2126 * r + 0.7152 * g + 0.0722 * b).toFixed(3));\n}\n/**\n * Returns the contrast ratio between two colors based on\n * [W3's recommended equation for calculating contrast](http://www.w3.org/TR/WCAG20/#contrast-ratiodef).\n *\n * @example\n * const contrastRatio = getContrast('#444', '#fff');\n */\n\n\nfunction getContrast(color1, color2) {\n  var luminance1 = getLuminance(color1);\n  var luminance2 = getLuminance(color2);\n  return parseFloat((luminance1 > luminance2 ? (luminance1 + 0.05) / (luminance2 + 0.05) : (luminance2 + 0.05) / (luminance1 + 0.05)).toFixed(2));\n}\n/**\n * Converts the color to a grayscale, by reducing its saturation to 0.\n *\n * @example\n * // Styles as object usage\n * const styles = {\n *   background: grayscale('#CCCD64'),\n *   background: grayscale('rgba(204,205,100,0.7)'),\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   background: ${grayscale('#CCCD64')};\n *   background: ${grayscale('rgba(204,205,100,0.7)')};\n * `\n *\n * // CSS in JS Output\n * element {\n *   background: \"#999\";\n *   background: \"rgba(153,153,153,0.7)\";\n * }\n */\n\n\nfunction grayscale(color) {\n  if (color === 'transparent') return color;\n  return toColorString(_extends({}, parseToHsl(color), {\n    saturation: 0\n  }));\n}\n/**\n * Converts a HslColor or HslaColor object to a color string.\n * This util is useful in case you only know on runtime which color object is\n * used. Otherwise we recommend to rely on `hsl` or `hsla`.\n *\n * @example\n * // Styles as object usage\n * const styles = {\n *   background: hslToColorString({ hue: 240, saturation: 1, lightness: 0.5 }),\n *   background: hslToColorString({ hue: 360, saturation: 0.75, lightness: 0.4, alpha: 0.72 }),\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   background: ${hslToColorString({ hue: 240, saturation: 1, lightness: 0.5 })};\n *   background: ${hslToColorString({ hue: 360, saturation: 0.75, lightness: 0.4, alpha: 0.72 })};\n * `\n *\n * // CSS in JS Output\n * element {\n *   background: \"#00f\";\n *   background: \"rgba(179,25,25,0.72)\";\n * }\n */\n\n\nfunction hslToColorString(color) {\n  if (typeof color === 'object' && typeof color.hue === 'number' && typeof color.saturation === 'number' && typeof color.lightness === 'number') {\n    if (color.alpha && typeof color.alpha === 'number') {\n      return hsla({\n        hue: color.hue,\n        saturation: color.saturation,\n        lightness: color.lightness,\n        alpha: color.alpha\n      });\n    }\n\n    return hsl({\n      hue: color.hue,\n      saturation: color.saturation,\n      lightness: color.lightness\n    });\n  }\n\n  throw new PolishedError(45);\n}\n/**\n * Inverts the red, green and blue values of a color.\n *\n * @example\n * // Styles as object usage\n * const styles = {\n *   background: invert('#CCCD64'),\n *   background: invert('rgba(101,100,205,0.7)'),\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   background: ${invert('#CCCD64')};\n *   background: ${invert('rgba(101,100,205,0.7)')};\n * `\n *\n * // CSS in JS Output\n *\n * element {\n *   background: \"#33329b\";\n *   background: \"rgba(154,155,50,0.7)\";\n * }\n */\n\n\nfunction invert(color) {\n  if (color === 'transparent') return color; // parse color string to rgb\n\n  var value = parseToRgb(color);\n  return toColorString(_extends({}, value, {\n    red: 255 - value.red,\n    green: 255 - value.green,\n    blue: 255 - value.blue\n  }));\n}\n/**\n * Returns a string value for the lightened color.\n *\n * @example\n * // Styles as object usage\n * const styles = {\n *   background: lighten(0.2, '#CCCD64'),\n *   background: lighten('0.2', 'rgba(204,205,100,0.7)'),\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   background: ${lighten(0.2, '#FFCD64')};\n *   background: ${lighten('0.2', 'rgba(204,205,100,0.7)')};\n * `\n *\n * // CSS in JS Output\n *\n * element {\n *   background: \"#e5e6b1\";\n *   background: \"rgba(229,230,177,0.7)\";\n * }\n */\n\n\nfunction lighten(amount, color) {\n  if (color === 'transparent') return color;\n  var hslColor = parseToHsl(color);\n  return toColorString(_extends({}, hslColor, {\n    lightness: guard(0, 1, hslColor.lightness + parseFloat(amount))\n  }));\n} // prettier-ignore\n\n\nvar curriedLighten =\n/*#__PURE__*/\ncurry\n/* ::<number | string, string, string> */\n(lighten);\n/**\n * Determines which contrast guidelines have been met for two colors.\n * Based on the [contrast calculations recommended by W3](https://www.w3.org/WAI/WCAG21/Understanding/contrast-enhanced.html).\n *\n * @example\n * const scores = meetsContrastGuidelines('#444', '#fff');\n */\n\nfunction meetsContrastGuidelines(color1, color2) {\n  var contrastRatio = getContrast(color1, color2);\n  return {\n    AA: contrastRatio >= 4.5,\n    AALarge: contrastRatio >= 3,\n    AAA: contrastRatio >= 7,\n    AAALarge: contrastRatio >= 4.5\n  };\n}\n/**\n * Mixes the two provided colors together by calculating the average of each of the RGB components weighted to the first color by the provided weight.\n *\n * @example\n * // Styles as object usage\n * const styles = {\n *   background: mix(0.5, '#f00', '#00f')\n *   background: mix(0.25, '#f00', '#00f')\n *   background: mix('0.5', 'rgba(255, 0, 0, 0.5)', '#00f')\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   background: ${mix(0.5, '#f00', '#00f')};\n *   background: ${mix(0.25, '#f00', '#00f')};\n *   background: ${mix('0.5', 'rgba(255, 0, 0, 0.5)', '#00f')};\n * `\n *\n * // CSS in JS Output\n *\n * element {\n *   background: \"#7f007f\";\n *   background: \"#3f00bf\";\n *   background: \"rgba(63, 0, 191, 0.75)\";\n * }\n */\n\n\nfunction mix(weight, color, otherColor) {\n  if (color === 'transparent') return otherColor;\n  if (otherColor === 'transparent') return color;\n  var parsedColor1 = parseToRgb(color);\n\n  var color1 = _extends({}, parsedColor1, {\n    alpha: typeof parsedColor1.alpha === 'number' ? parsedColor1.alpha : 1\n  });\n\n  var parsedColor2 = parseToRgb(otherColor);\n\n  var color2 = _extends({}, parsedColor2, {\n    alpha: typeof parsedColor2.alpha === 'number' ? parsedColor2.alpha : 1 // The formular is copied from the original Sass implementation:\n    // http://sass-lang.com/documentation/Sass/Script/Functions.html#mix-instance_method\n\n  });\n\n  var alphaDelta = color1.alpha - color2.alpha;\n  var x = parseFloat(weight) * 2 - 1;\n  var y = x * alphaDelta === -1 ? x : x + alphaDelta;\n  var z = 1 + x * alphaDelta;\n  var weight1 = (y / z + 1) / 2.0;\n  var weight2 = 1 - weight1;\n  var mixedColor = {\n    red: Math.floor(color1.red * weight1 + color2.red * weight2),\n    green: Math.floor(color1.green * weight1 + color2.green * weight2),\n    blue: Math.floor(color1.blue * weight1 + color2.blue * weight2),\n    alpha: color1.alpha + (color2.alpha - color1.alpha) * (parseFloat(weight) / 1.0)\n  };\n  return rgba(mixedColor);\n} // prettier-ignore\n\n\nvar curriedMix =\n/*#__PURE__*/\ncurry\n/* ::<number | string, string, string, string> */\n(mix);\n/**\n * Increases the opacity of a color. Its range for the amount is between 0 to 1.\n *\n *\n * @example\n * // Styles as object usage\n * const styles = {\n *   background: opacify(0.1, 'rgba(255, 255, 255, 0.9)');\n *   background: opacify(0.2, 'hsla(0, 0%, 100%, 0.5)'),\n *   background: opacify('0.5', 'rgba(255, 0, 0, 0.2)'),\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   background: ${opacify(0.1, 'rgba(255, 255, 255, 0.9)')};\n *   background: ${opacify(0.2, 'hsla(0, 0%, 100%, 0.5)')},\n *   background: ${opacify('0.5', 'rgba(255, 0, 0, 0.2)')},\n * `\n *\n * // CSS in JS Output\n *\n * element {\n *   background: \"#fff\";\n *   background: \"rgba(255,255,255,0.7)\";\n *   background: \"rgba(255,0,0,0.7)\";\n * }\n */\n\nfunction opacify(amount, color) {\n  if (color === 'transparent') return color;\n  var parsedColor = parseToRgb(color);\n  var alpha = typeof parsedColor.alpha === 'number' ? parsedColor.alpha : 1;\n\n  var colorWithAlpha = _extends({}, parsedColor, {\n    alpha: guard(0, 1, (alpha * 100 + parseFloat(amount) * 100) / 100)\n  });\n\n  return rgba(colorWithAlpha);\n} // prettier-ignore\n\n\nvar curriedOpacify =\n/*#__PURE__*/\ncurry\n/* ::<number | string, string, string> */\n(opacify);\n/**\n * Returns black or white (or optional light and dark return colors) for best contrast depending on the luminosity of the given color.\n * Follows [W3C specs for readability](https://www.w3.org/TR/WCAG20-TECHS/G18.html).\n *\n * @example\n * // Styles as object usage\n * const styles = {\n *   color: readableColor('#000'),\n *   color: readableColor('black', '#001', '#ff8'),\n *   color: readableColor('white', '#001', '#ff8'),\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   color: ${readableColor('#000')};\n *   color: ${readableColor('black', '#001', '#ff8')};\n *   color: ${readableColor('white', '#001', '#ff8')};\n * `\n *\n * // CSS in JS Output\n *\n * element {\n *   color: \"#fff\";\n *   color: \"#ff8\";\n *   color: \"#001\";\n * }\n */\n\nfunction readableColor(color, lightReturnColor, darkReturnColor) {\n  if (lightReturnColor === void 0) {\n    lightReturnColor = '#000';\n  }\n\n  if (darkReturnColor === void 0) {\n    darkReturnColor = '#fff';\n  }\n\n  return getLuminance(color) > 0.179 ? lightReturnColor : darkReturnColor;\n}\n/**\n * Converts a RgbColor or RgbaColor object to a color string.\n * This util is useful in case you only know on runtime which color object is\n * used. Otherwise we recommend to rely on `rgb` or `rgba`.\n *\n * @example\n * // Styles as object usage\n * const styles = {\n *   background: rgbToColorString({ red: 255, green: 205, blue: 100 }),\n *   background: rgbToColorString({ red: 255, green: 205, blue: 100, alpha: 0.72 }),\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   background: ${rgbToColorString({ red: 255, green: 205, blue: 100 })};\n *   background: ${rgbToColorString({ red: 255, green: 205, blue: 100, alpha: 0.72 })};\n * `\n *\n * // CSS in JS Output\n * element {\n *   background: \"#ffcd64\";\n *   background: \"rgba(255,205,100,0.72)\";\n * }\n */\n\n\nfunction rgbToColorString(color) {\n  if (typeof color === 'object' && typeof color.red === 'number' && typeof color.green === 'number' && typeof color.blue === 'number') {\n    if (color.alpha && typeof color.alpha === 'number') {\n      return rgba({\n        red: color.red,\n        green: color.green,\n        blue: color.blue,\n        alpha: color.alpha\n      });\n    }\n\n    return rgb({\n      red: color.red,\n      green: color.green,\n      blue: color.blue\n    });\n  }\n\n  throw new PolishedError(46);\n}\n/**\n * Increases the intensity of a color. Its range is between 0 to 1. The first\n * argument of the saturate function is the amount by how much the color\n * intensity should be increased.\n *\n * @example\n * // Styles as object usage\n * const styles = {\n *   background: saturate(0.2, '#CCCD64'),\n *   background: saturate('0.2', 'rgba(204,205,100,0.7)'),\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   background: ${saturate(0.2, '#FFCD64')};\n *   background: ${saturate('0.2', 'rgba(204,205,100,0.7)')};\n * `\n *\n * // CSS in JS Output\n *\n * element {\n *   background: \"#e0e250\";\n *   background: \"rgba(224,226,80,0.7)\";\n * }\n */\n\n\nfunction saturate(amount, color) {\n  if (color === 'transparent') return color;\n  var hslColor = parseToHsl(color);\n  return toColorString(_extends({}, hslColor, {\n    saturation: guard(0, 1, hslColor.saturation + parseFloat(amount))\n  }));\n} // prettier-ignore\n\n\nvar curriedSaturate =\n/*#__PURE__*/\ncurry\n/* ::<number | string, string, string> */\n(saturate);\n/**\n * Sets the hue of a color to the provided value. The hue range can be\n * from 0 and 359.\n *\n * @example\n * // Styles as object usage\n * const styles = {\n *   background: setHue(42, '#CCCD64'),\n *   background: setHue('244', 'rgba(204,205,100,0.7)'),\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   background: ${setHue(42, '#CCCD64')};\n *   background: ${setHue('244', 'rgba(204,205,100,0.7)')};\n * `\n *\n * // CSS in JS Output\n * element {\n *   background: \"#cdae64\";\n *   background: \"rgba(107,100,205,0.7)\";\n * }\n */\n\nfunction setHue(hue, color) {\n  if (color === 'transparent') return color;\n  return toColorString(_extends({}, parseToHsl(color), {\n    hue: parseFloat(hue)\n  }));\n} // prettier-ignore\n\n\nvar curriedSetHue =\n/*#__PURE__*/\ncurry\n/* ::<number | string, string, string> */\n(setHue);\n/**\n * Sets the lightness of a color to the provided value. The lightness range can be\n * from 0 and 1.\n *\n * @example\n * // Styles as object usage\n * const styles = {\n *   background: setLightness(0.2, '#CCCD64'),\n *   background: setLightness('0.75', 'rgba(204,205,100,0.7)'),\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   background: ${setLightness(0.2, '#CCCD64')};\n *   background: ${setLightness('0.75', 'rgba(204,205,100,0.7)')};\n * `\n *\n * // CSS in JS Output\n * element {\n *   background: \"#4d4d19\";\n *   background: \"rgba(223,224,159,0.7)\";\n * }\n */\n\nfunction setLightness(lightness, color) {\n  if (color === 'transparent') return color;\n  return toColorString(_extends({}, parseToHsl(color), {\n    lightness: parseFloat(lightness)\n  }));\n} // prettier-ignore\n\n\nvar curriedSetLightness =\n/*#__PURE__*/\ncurry\n/* ::<number | string, string, string> */\n(setLightness);\n/**\n * Sets the saturation of a color to the provided value. The saturation range can be\n * from 0 and 1.\n *\n * @example\n * // Styles as object usage\n * const styles = {\n *   background: setSaturation(0.2, '#CCCD64'),\n *   background: setSaturation('0.75', 'rgba(204,205,100,0.7)'),\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   background: ${setSaturation(0.2, '#CCCD64')};\n *   background: ${setSaturation('0.75', 'rgba(204,205,100,0.7)')};\n * `\n *\n * // CSS in JS Output\n * element {\n *   background: \"#adad84\";\n *   background: \"rgba(228,229,76,0.7)\";\n * }\n */\n\nfunction setSaturation(saturation, color) {\n  if (color === 'transparent') return color;\n  return toColorString(_extends({}, parseToHsl(color), {\n    saturation: parseFloat(saturation)\n  }));\n} // prettier-ignore\n\n\nvar curriedSetSaturation =\n/*#__PURE__*/\ncurry\n/* ::<number | string, string, string> */\n(setSaturation);\n/**\n * Shades a color by mixing it with black. `shade` can produce\n * hue shifts, where as `darken` manipulates the luminance channel and therefore\n * doesn't produce hue shifts.\n *\n * @example\n * // Styles as object usage\n * const styles = {\n *   background: shade(0.25, '#00f')\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   background: ${shade(0.25, '#00f')};\n * `\n *\n * // CSS in JS Output\n *\n * element {\n *   background: \"#00003f\";\n * }\n */\n\nfunction shade(percentage, color) {\n  if (color === 'transparent') return color;\n  return curriedMix(parseFloat(percentage), 'rgb(0, 0, 0)', color);\n} // prettier-ignore\n\n\nvar curriedShade =\n/*#__PURE__*/\ncurry\n/* ::<number | string, string, string> */\n(shade);\n/**\n * Tints a color by mixing it with white. `tint` can produce\n * hue shifts, where as `lighten` manipulates the luminance channel and therefore\n * doesn't produce hue shifts.\n *\n * @example\n * // Styles as object usage\n * const styles = {\n *   background: tint(0.25, '#00f')\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   background: ${tint(0.25, '#00f')};\n * `\n *\n * // CSS in JS Output\n *\n * element {\n *   background: \"#bfbfff\";\n * }\n */\n\nfunction tint(percentage, color) {\n  if (color === 'transparent') return color;\n  return curriedMix(parseFloat(percentage), 'rgb(255, 255, 255)', color);\n} // prettier-ignore\n\n\nvar curriedTint =\n/*#__PURE__*/\ncurry\n/* ::<number | string, string, string> */\n(tint);\n/**\n * Decreases the opacity of a color. Its range for the amount is between 0 to 1.\n *\n *\n * @example\n * // Styles as object usage\n * const styles = {\n *   background: transparentize(0.1, '#fff');\n *   background: transparentize(0.2, 'hsl(0, 0%, 100%)'),\n *   background: transparentize('0.5', 'rgba(255, 0, 0, 0.8)'),\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   background: ${transparentize(0.1, '#fff')};\n *   background: ${transparentize(0.2, 'hsl(0, 0%, 100%)')},\n *   background: ${transparentize('0.5', 'rgba(255, 0, 0, 0.8)')},\n * `\n *\n * // CSS in JS Output\n *\n * element {\n *   background: \"rgba(255,255,255,0.9)\";\n *   background: \"rgba(255,255,255,0.8)\";\n *   background: \"rgba(255,0,0,0.3)\";\n * }\n */\n\nfunction transparentize(amount, color) {\n  if (color === 'transparent') return color;\n  var parsedColor = parseToRgb(color);\n  var alpha = typeof parsedColor.alpha === 'number' ? parsedColor.alpha : 1;\n\n  var colorWithAlpha = _extends({}, parsedColor, {\n    alpha: guard(0, 1, (alpha * 100 - parseFloat(amount) * 100) / 100)\n  });\n\n  return rgba(colorWithAlpha);\n} // prettier-ignore\n\n\nvar curriedTransparentize =\n/*#__PURE__*/\ncurry\n/* ::<number | string, string, string> */\n(transparentize);\n/**\n * Shorthand for easily setting the animation property. Allows either multiple arrays with animations\n * or a single animation spread over the arguments.\n * @example\n * // Styles as object usage\n * const styles = {\n *   ...animation(['rotate', '1s', 'ease-in-out'], ['colorchange', '2s'])\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   ${animation(['rotate', '1s', 'ease-in-out'], ['colorchange', '2s'])}\n * `\n *\n * // CSS as JS Output\n *\n * div {\n *   'animation': 'rotate 1s ease-in-out, colorchange 2s'\n * }\n * @example\n * // Styles as object usage\n * const styles = {\n *   ...animation('rotate', '1s', 'ease-in-out')\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   ${animation('rotate', '1s', 'ease-in-out')}\n * `\n *\n * // CSS as JS Output\n *\n * div {\n *   'animation': 'rotate 1s ease-in-out'\n * }\n */\n\nfunction animation() {\n  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n    args[_key] = arguments[_key];\n  } // Allow single or multiple animations passed\n\n\n  var multiMode = Array.isArray(args[0]);\n\n  if (!multiMode && args.length > 8) {\n    throw new PolishedError(64);\n  }\n\n  var code = args.map(function (arg) {\n    if (multiMode && !Array.isArray(arg) || !multiMode && Array.isArray(arg)) {\n      throw new PolishedError(65);\n    }\n\n    if (Array.isArray(arg) && arg.length > 8) {\n      throw new PolishedError(66);\n    }\n\n    return Array.isArray(arg) ? arg.join(' ') : arg;\n  }).join(', ');\n  return {\n    animation: code\n  };\n}\n/**\n * Shorthand that accepts any number of backgroundImage values as parameters for creating a single background statement.\n * @example\n * // Styles as object usage\n * const styles = {\n *   ...backgroundImages('url(\"/image/background.jpg\")', 'linear-gradient(red, green)')\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   ${backgroundImages('url(\"/image/background.jpg\")', 'linear-gradient(red, green)')}\n * `\n *\n * // CSS as JS Output\n *\n * div {\n *   'backgroundImage': 'url(\"/image/background.jpg\"), linear-gradient(red, green)'\n * }\n */\n\n\nfunction backgroundImages() {\n  for (var _len = arguments.length, properties = new Array(_len), _key = 0; _key < _len; _key++) {\n    properties[_key] = arguments[_key];\n  }\n\n  return {\n    backgroundImage: properties.join(', ')\n  };\n}\n/**\n * Shorthand that accepts any number of background values as parameters for creating a single background statement.\n * @example\n * // Styles as object usage\n * const styles = {\n *   ...backgrounds('url(\"/image/background.jpg\")', 'linear-gradient(red, green)', 'center no-repeat')\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   ${backgrounds('url(\"/image/background.jpg\")', 'linear-gradient(red, green)', 'center no-repeat')}\n * `\n *\n * // CSS as JS Output\n *\n * div {\n *   'background': 'url(\"/image/background.jpg\"), linear-gradient(red, green), center no-repeat'\n * }\n */\n\n\nfunction backgrounds() {\n  for (var _len = arguments.length, properties = new Array(_len), _key = 0; _key < _len; _key++) {\n    properties[_key] = arguments[_key];\n  }\n\n  return {\n    background: properties.join(', ')\n  };\n}\n\nvar sideMap = ['top', 'right', 'bottom', 'left'];\n/**\n * Shorthand for the border property that splits out individual properties for use with tools like Fela and Styletron. A side keyword can optionally be passed to target only one side's border properties.\n *\n * @example\n * // Styles as object usage\n * const styles = {\n *   ...border('1px', 'solid', 'red')\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   ${border('1px', 'solid', 'red')}\n * `\n *\n * // CSS as JS Output\n *\n * div {\n *   'borderColor': 'red',\n *   'borderStyle': 'solid',\n *   'borderWidth': `1px`,\n * }\n *\n * // Styles as object usage\n * const styles = {\n *   ...border('top', '1px', 'solid', 'red')\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   ${border('top', '1px', 'solid', 'red')}\n * `\n *\n * // CSS as JS Output\n *\n * div {\n *   'borderTopColor': 'red',\n *   'borderTopStyle': 'solid',\n *   'borderTopWidth': `1px`,\n * }\n */\n\nfunction border(sideKeyword) {\n  for (var _len = arguments.length, values = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n    values[_key - 1] = arguments[_key];\n  }\n\n  if (typeof sideKeyword === 'string' && sideMap.indexOf(sideKeyword) >= 0) {\n    var _ref;\n\n    return _ref = {}, _ref[\"border\" + capitalizeString(sideKeyword) + \"Width\"] = values[0], _ref[\"border\" + capitalizeString(sideKeyword) + \"Style\"] = values[1], _ref[\"border\" + capitalizeString(sideKeyword) + \"Color\"] = values[2], _ref;\n  } else {\n    values.unshift(sideKeyword);\n    return {\n      borderWidth: values[0],\n      borderStyle: values[1],\n      borderColor: values[2]\n    };\n  }\n}\n/**\n * Shorthand that accepts up to four values, including null to skip a value, and maps them to their respective directions.\n * @example\n * // Styles as object usage\n * const styles = {\n *   ...borderColor('red', 'green', 'blue', 'yellow')\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   ${borderColor('red', 'green', 'blue', 'yellow')}\n * `\n *\n * // CSS as JS Output\n *\n * div {\n *   'borderTopColor': 'red',\n *   'borderRightColor': 'green',\n *   'borderBottomColor': 'blue',\n *   'borderLeftColor': 'yellow'\n * }\n */\n\n\nfunction borderColor() {\n  for (var _len = arguments.length, values = new Array(_len), _key = 0; _key < _len; _key++) {\n    values[_key] = arguments[_key];\n  }\n\n  return directionalProperty.apply(void 0, ['borderColor'].concat(values));\n}\n/**\n * Shorthand that accepts a value for side and a value for radius and applies the radius value to both corners of the side.\n * @example\n * // Styles as object usage\n * const styles = {\n *   ...borderRadius('top', '5px')\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   ${borderRadius('top', '5px')}\n * `\n *\n * // CSS as JS Output\n *\n * div {\n *   'borderTopRightRadius': '5px',\n *   'borderTopLeftRadius': '5px',\n * }\n */\n\n\nfunction borderRadius(side, radius) {\n  var uppercaseSide = capitalizeString(side);\n\n  if (!radius && radius !== 0) {\n    throw new PolishedError(62);\n  }\n\n  if (uppercaseSide === 'Top' || uppercaseSide === 'Bottom') {\n    var _ref;\n\n    return _ref = {}, _ref[\"border\" + uppercaseSide + \"RightRadius\"] = radius, _ref[\"border\" + uppercaseSide + \"LeftRadius\"] = radius, _ref;\n  }\n\n  if (uppercaseSide === 'Left' || uppercaseSide === 'Right') {\n    var _ref2;\n\n    return _ref2 = {}, _ref2[\"borderTop\" + uppercaseSide + \"Radius\"] = radius, _ref2[\"borderBottom\" + uppercaseSide + \"Radius\"] = radius, _ref2;\n  }\n\n  throw new PolishedError(63);\n}\n/**\n * Shorthand that accepts up to four values, including null to skip a value, and maps them to their respective directions.\n * @example\n * // Styles as object usage\n * const styles = {\n *   ...borderStyle('solid', 'dashed', 'dotted', 'double')\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   ${borderStyle('solid', 'dashed', 'dotted', 'double')}\n * `\n *\n * // CSS as JS Output\n *\n * div {\n *   'borderTopStyle': 'solid',\n *   'borderRightStyle': 'dashed',\n *   'borderBottomStyle': 'dotted',\n *   'borderLeftStyle': 'double'\n * }\n */\n\n\nfunction borderStyle() {\n  for (var _len = arguments.length, values = new Array(_len), _key = 0; _key < _len; _key++) {\n    values[_key] = arguments[_key];\n  }\n\n  return directionalProperty.apply(void 0, ['borderStyle'].concat(values));\n}\n/**\n * Shorthand that accepts up to four values, including null to skip a value, and maps them to their respective directions.\n * @example\n * // Styles as object usage\n * const styles = {\n *   ...borderWidth('12px', '24px', '36px', '48px')\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   ${borderWidth('12px', '24px', '36px', '48px')}\n * `\n *\n * // CSS as JS Output\n *\n * div {\n *   'borderTopWidth': '12px',\n *   'borderRightWidth': '24px',\n *   'borderBottomWidth': '36px',\n *   'borderLeftWidth': '48px'\n * }\n */\n\n\nfunction borderWidth() {\n  for (var _len = arguments.length, values = new Array(_len), _key = 0; _key < _len; _key++) {\n    values[_key] = arguments[_key];\n  }\n\n  return directionalProperty.apply(void 0, ['borderWidth'].concat(values));\n}\n\nfunction generateSelectors(template, state) {\n  var stateSuffix = state ? \":\" + state : '';\n  return template(stateSuffix);\n}\n/**\n * Function helper that adds an array of states to a template of selectors. Used in textInputs and buttons.\n * @private\n */\n\n\nfunction statefulSelectors(states, template, stateMap) {\n  if (!template) throw new PolishedError(67);\n  if (states.length === 0) return generateSelectors(template, null);\n  var selectors = [];\n\n  for (var i = 0; i < states.length; i += 1) {\n    if (stateMap && stateMap.indexOf(states[i]) < 0) {\n      throw new PolishedError(68);\n    }\n\n    selectors.push(generateSelectors(template, states[i]));\n  }\n\n  selectors = selectors.join(',');\n  return selectors;\n}\n\nvar stateMap = [undefined, null, 'active', 'focus', 'hover'];\n\nfunction template(state) {\n  return \"button\" + state + \",\\n  input[type=\\\"button\\\"]\" + state + \",\\n  input[type=\\\"reset\\\"]\" + state + \",\\n  input[type=\\\"submit\\\"]\" + state;\n}\n/**\n * Populates selectors that target all buttons. You can pass optional states to append to the selectors.\n * @example\n * // Styles as object usage\n * const styles = {\n *   [buttons('active')]: {\n *     'border': 'none'\n *   }\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   > ${buttons('active')} {\n *     border: none;\n *   }\n * `\n *\n * // CSS in JS Output\n *\n *  'button:active,\n *  'input[type=\"button\"]:active,\n *  'input[type=\\\"reset\\\"]:active,\n *  'input[type=\\\"submit\\\"]:active: {\n *   'border': 'none'\n * }\n */\n\n\nfunction buttons() {\n  for (var _len = arguments.length, states = new Array(_len), _key = 0; _key < _len; _key++) {\n    states[_key] = arguments[_key];\n  }\n\n  return statefulSelectors(states, template, stateMap);\n}\n/**\n * Shorthand that accepts up to four values, including null to skip a value, and maps them to their respective directions.\n * @example\n * // Styles as object usage\n * const styles = {\n *   ...margin('12px', '24px', '36px', '48px')\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   ${margin('12px', '24px', '36px', '48px')}\n * `\n *\n * // CSS as JS Output\n *\n * div {\n *   'marginTop': '12px',\n *   'marginRight': '24px',\n *   'marginBottom': '36px',\n *   'marginLeft': '48px'\n * }\n */\n\n\nfunction margin() {\n  for (var _len = arguments.length, values = new Array(_len), _key = 0; _key < _len; _key++) {\n    values[_key] = arguments[_key];\n  }\n\n  return directionalProperty.apply(void 0, ['margin'].concat(values));\n}\n/**\n * Shorthand that accepts up to four values, including null to skip a value, and maps them to their respective directions.\n * @example\n * // Styles as object usage\n * const styles = {\n *   ...padding('12px', '24px', '36px', '48px')\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   ${padding('12px', '24px', '36px', '48px')}\n * `\n *\n * // CSS as JS Output\n *\n * div {\n *   'paddingTop': '12px',\n *   'paddingRight': '24px',\n *   'paddingBottom': '36px',\n *   'paddingLeft': '48px'\n * }\n */\n\n\nfunction padding() {\n  for (var _len = arguments.length, values = new Array(_len), _key = 0; _key < _len; _key++) {\n    values[_key] = arguments[_key];\n  }\n\n  return directionalProperty.apply(void 0, ['padding'].concat(values));\n}\n\nvar positionMap$1 = ['absolute', 'fixed', 'relative', 'static', 'sticky'];\n/**\n * Shorthand accepts up to five values, including null to skip a value, and maps them to their respective directions. The first value can optionally be a position keyword.\n * @example\n * // Styles as object usage\n * const styles = {\n *   ...position('12px', '24px', '36px', '48px')\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   ${position('12px', '24px', '36px', '48px')}\n * `\n *\n * // CSS as JS Output\n *\n * div {\n *   'top': '12px',\n *   'right': '24px',\n *   'bottom': '36px',\n *   'left': '48px'\n * }\n *\n * // Styles as object usage\n * const styles = {\n *   ...position('absolute', '12px', '24px', '36px', '48px')\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   ${position('absolute', '12px', '24px', '36px', '48px')}\n * `\n *\n * // CSS as JS Output\n *\n * div {\n *   'position': 'absolute',\n *   'top': '12px',\n *   'right': '24px',\n *   'bottom': '36px',\n *   'left': '48px'\n * }\n */\n\nfunction position(positionKeyword) {\n  for (var _len = arguments.length, values = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n    values[_key - 1] = arguments[_key];\n  }\n\n  if (positionMap$1.indexOf(positionKeyword) >= 0) {\n    return _extends({\n      position: positionKeyword\n    }, directionalProperty.apply(void 0, [''].concat(values)));\n  } else {\n    var firstValue = positionKeyword; // in this case position is actually the first value\n\n    return directionalProperty.apply(void 0, ['', firstValue].concat(values));\n  }\n}\n/**\n * Shorthand to set the height and width properties in a single statement.\n * @example\n * // Styles as object usage\n * const styles = {\n *   ...size('300px', '250px')\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   ${size('300px', '250px')}\n * `\n *\n * // CSS as JS Output\n *\n * div {\n *   'height': '300px',\n *   'width': '250px',\n * }\n */\n\n\nfunction size(height, width) {\n  if (width === void 0) {\n    width = height;\n  }\n\n  return {\n    height: height,\n    width: width\n  };\n}\n\nvar stateMap$1 = [undefined, null, 'active', 'focus', 'hover'];\n\nfunction template$1(state) {\n  return \"input[type=\\\"color\\\"]\" + state + \",\\n    input[type=\\\"date\\\"]\" + state + \",\\n    input[type=\\\"datetime\\\"]\" + state + \",\\n    input[type=\\\"datetime-local\\\"]\" + state + \",\\n    input[type=\\\"email\\\"]\" + state + \",\\n    input[type=\\\"month\\\"]\" + state + \",\\n    input[type=\\\"number\\\"]\" + state + \",\\n    input[type=\\\"password\\\"]\" + state + \",\\n    input[type=\\\"search\\\"]\" + state + \",\\n    input[type=\\\"tel\\\"]\" + state + \",\\n    input[type=\\\"text\\\"]\" + state + \",\\n    input[type=\\\"time\\\"]\" + state + \",\\n    input[type=\\\"url\\\"]\" + state + \",\\n    input[type=\\\"week\\\"]\" + state + \",\\n    input:not([type])\" + state + \",\\n    textarea\" + state;\n}\n/**\n * Populates selectors that target all text inputs. You can pass optional states to append to the selectors.\n * @example\n * // Styles as object usage\n * const styles = {\n *   [textInputs('active')]: {\n *     'border': 'none'\n *   }\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   > ${textInputs('active')} {\n *     border: none;\n *   }\n * `\n *\n * // CSS in JS Output\n *\n *  'input[type=\"color\"]:active,\n *  input[type=\"date\"]:active,\n *  input[type=\"datetime\"]:active,\n *  input[type=\"datetime-local\"]:active,\n *  input[type=\"email\"]:active,\n *  input[type=\"month\"]:active,\n *  input[type=\"number\"]:active,\n *  input[type=\"password\"]:active,\n *  input[type=\"search\"]:active,\n *  input[type=\"tel\"]:active,\n *  input[type=\"text\"]:active,\n *  input[type=\"time\"]:active,\n *  input[type=\"url\"]:active,\n *  input[type=\"week\"]:active,\n *  input:not([type]):active,\n *  textarea:active': {\n *   'border': 'none'\n * }\n */\n\n\nfunction textInputs() {\n  for (var _len = arguments.length, states = new Array(_len), _key = 0; _key < _len; _key++) {\n    states[_key] = arguments[_key];\n  }\n\n  return statefulSelectors(states, template$1, stateMap$1);\n}\n/**\n * Accepts any number of transition values as parameters for creating a single transition statement. You may also pass an array of properties as the first parameter that you would like to apply the same transition values to (second parameter).\n * @example\n * // Styles as object usage\n * const styles = {\n *   ...transitions('opacity 1.0s ease-in 0s', 'width 2.0s ease-in 2s'),\n *   ...transitions(['color', 'background-color'], '2.0s ease-in 2s')\n * }\n *\n * // styled-components usage\n * const div = styled.div`\n *   ${transitions('opacity 1.0s ease-in 0s', 'width 2.0s ease-in 2s')};\n *   ${transitions(['color', 'background-color'], '2.0s ease-in 2s'),};\n * `\n *\n * // CSS as JS Output\n *\n * div {\n *   'transition': 'opacity 1.0s ease-in 0s, width 2.0s ease-in 2s'\n *   'transition': 'color 2.0s ease-in 2s, background-color 2.0s ease-in 2s',\n * }\n */\n\n\nfunction transitions() {\n  for (var _len = arguments.length, properties = new Array(_len), _key = 0; _key < _len; _key++) {\n    properties[_key] = arguments[_key];\n  }\n\n  if (Array.isArray(properties[0]) && properties.length === 2) {\n    var value = properties[1];\n\n    if (typeof value !== 'string') {\n      throw new PolishedError(61);\n    }\n\n    var transitionsString = properties[0].map(function (property) {\n      return property + \" \" + value;\n    }).join(', ');\n    return {\n      transition: transitionsString\n    };\n  } else {\n    return {\n      transition: properties.join(', ')\n    };\n  }\n}\n\nexport { curriedAdjustHue as adjustHue, animation, backgroundImages, backgrounds, between, border, borderColor, borderRadius, borderStyle, borderWidth, buttons, clearFix, complement, cover, curriedDarken as darken, curriedDesaturate as desaturate, directionalProperty, ellipsis, em, fluidRange, fontFace, getContrast, getLuminance, getValueAndUnit, grayscale, hiDPI, hideText, hideVisually, hsl, hslToColorString, hsla, invert, curriedLighten as lighten, linearGradient, margin, math, meetsContrastGuidelines, curriedMix as mix, modularScale, normalize, curriedOpacify as opacify, padding, parseToHsl, parseToRgb, position, radialGradient, readableColor, rem, retinaImage, rgb, rgbToColorString, rgba, curriedSaturate as saturate, curriedSetHue as setHue, curriedSetLightness as setLightness, curriedSetSaturation as setSaturation, curriedShade as shade, size, stripUnit, textInputs, timingFunctions, curriedTint as tint, toColorString, transitions, curriedTransparentize as transparentize, triangle, wordWrap };","export default function _inheritsLoose(subClass, superClass) {\n  subClass.prototype = Object.create(superClass.prototype);\n  subClass.prototype.constructor = subClass;\n  subClass.__proto__ = superClass;\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}","var warning = function warning() {};\n\nvar invariant = function invariant() {};\n\nif (process.env.NODE_ENV !== 'production') {\n  warning = function warning(check, message) {\n    if (!check && typeof console !== 'undefined') {\n      console.warn(message);\n    }\n  };\n\n  invariant = function invariant(check, message) {\n    if (!check) {\n      throw new Error(message);\n    }\n  };\n}\n\nexport { invariant, warning };","import \"core-js/modules/es6.array.for-each\";\nimport \"core-js/modules/es6.array.reduce\";\nimport \"core-js/modules/es6.array.index-of\";\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.weak-set\";\nimport \"core-js/modules/es6.date.now\";\nimport { invariant } from 'hey-listen';\nvar prevTime = 0;\nvar onNextFrame = typeof window !== 'undefined' && window.requestAnimationFrame !== undefined ? function (callback) {\n  return window.requestAnimationFrame(callback);\n} : function (callback) {\n  var timestamp = Date.now();\n  var timeToCall = Math.max(0, 16.7 - (timestamp - prevTime));\n  prevTime = timestamp + timeToCall;\n  setTimeout(function () {\n    return callback(prevTime);\n  }, timeToCall);\n};\n\nvar createStep = function createStep(setRunNextFrame) {\n  var processToRun = [];\n  var processToRunNextFrame = [];\n  var numThisFrame = 0;\n  var isProcessing = false;\n  var i = 0;\n  var cancelled = new WeakSet();\n  var toKeepAlive = new WeakSet();\n  var renderStep = {\n    cancel: function cancel(process) {\n      var indexOfCallback = processToRunNextFrame.indexOf(process);\n      cancelled.add(process);\n\n      if (indexOfCallback !== -1) {\n        processToRunNextFrame.splice(indexOfCallback, 1);\n      }\n    },\n    process: function process(frame) {\n      var _a;\n\n      isProcessing = true;\n      _a = [processToRunNextFrame, processToRun], processToRun = _a[0], processToRunNextFrame = _a[1];\n      processToRunNextFrame.length = 0;\n      numThisFrame = processToRun.length;\n\n      if (numThisFrame) {\n        var process_1;\n\n        for (i = 0; i < numThisFrame; i++) {\n          process_1 = processToRun[i];\n          process_1(frame);\n\n          if (toKeepAlive.has(process_1) === true && !cancelled.has(process_1)) {\n            renderStep.schedule(process_1);\n            setRunNextFrame(true);\n          }\n        }\n      }\n\n      isProcessing = false;\n    },\n    schedule: function schedule(process, keepAlive, immediate) {\n      if (keepAlive === void 0) {\n        keepAlive = false;\n      }\n\n      if (immediate === void 0) {\n        immediate = false;\n      }\n\n      invariant(typeof process === 'function', 'Argument must be a function');\n      var addToCurrentBuffer = immediate && isProcessing;\n      var buffer = addToCurrentBuffer ? processToRun : processToRunNextFrame;\n      cancelled[\"delete\"](process);\n      if (keepAlive) toKeepAlive.add(process);\n\n      if (buffer.indexOf(process) === -1) {\n        buffer.push(process);\n        if (addToCurrentBuffer) numThisFrame = processToRun.length;\n      }\n    }\n  };\n  return renderStep;\n};\n\nvar StepId;\n\n(function (StepId) {\n  StepId[\"Read\"] = \"read\";\n  StepId[\"Update\"] = \"update\";\n  StepId[\"Render\"] = \"render\";\n  StepId[\"PostRender\"] = \"postRender\";\n  StepId[\"FixedUpdate\"] = \"fixedUpdate\";\n})(StepId || (StepId = {}));\n\nvar maxElapsed = 40;\nvar defaultElapsed = 1 / 60 * 1000;\nvar useDefaultElapsed = true;\nvar willRunNextFrame = false;\nvar isProcessing = false;\nvar frame = {\n  delta: 0,\n  timestamp: 0\n};\nvar stepsOrder = [StepId.Read, StepId.Update, StepId.Render, StepId.PostRender];\n\nvar setWillRunNextFrame = function setWillRunNextFrame(willRun) {\n  return willRunNextFrame = willRun;\n};\n\nvar _a = stepsOrder.reduce(function (acc, key) {\n  var step = createStep(setWillRunNextFrame);\n\n  acc.sync[key] = function (process, keepAlive, immediate) {\n    if (keepAlive === void 0) {\n      keepAlive = false;\n    }\n\n    if (immediate === void 0) {\n      immediate = false;\n    }\n\n    if (!willRunNextFrame) startLoop();\n    step.schedule(process, keepAlive, immediate);\n    return process;\n  };\n\n  acc.cancelSync[key] = function (process) {\n    return step.cancel(process);\n  };\n\n  acc.steps[key] = step;\n  return acc;\n}, {\n  steps: {},\n  sync: {},\n  cancelSync: {}\n}),\n    steps = _a.steps,\n    sync = _a.sync,\n    cancelSync = _a.cancelSync;\n\nvar processStep = function processStep(stepId) {\n  return steps[stepId].process(frame);\n};\n\nvar processFrame = function processFrame(timestamp) {\n  willRunNextFrame = false;\n  frame.delta = useDefaultElapsed ? defaultElapsed : Math.max(Math.min(timestamp - frame.timestamp, maxElapsed), 1);\n  if (!useDefaultElapsed) defaultElapsed = frame.delta;\n  frame.timestamp = timestamp;\n  isProcessing = true;\n  stepsOrder.forEach(processStep);\n  isProcessing = false;\n\n  if (willRunNextFrame) {\n    useDefaultElapsed = false;\n    onNextFrame(processFrame);\n  }\n};\n\nvar startLoop = function startLoop() {\n  willRunNextFrame = true;\n  useDefaultElapsed = true;\n  if (!isProcessing) onNextFrame(processFrame);\n};\n\nvar getFrameData = function getFrameData() {\n  return frame;\n};\n\nexport default sync;\nexport { cancelSync, getFrameData };","import \"core-js/modules/es6.array.map\";\nimport \"core-js/modules/es6.regexp.replace\";\nimport \"core-js/modules/es6.regexp.match\";\nimport \"core-js/modules/es6.string.starts-with\";\nimport \"core-js/modules/es6.array.last-index-of\";\nimport \"core-js/modules/es6.array.index-of\";\nimport \"core-js/modules/es6.regexp.split\";\nimport \"core-js/modules/es6.string.ends-with\";\nimport \"core-js/modules/es6.number.constructor\";\nimport \"core-js/modules/es6.object.assign\";\n\n/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation. All rights reserved.\r\nLicensed under the Apache License, Version 2.0 (the \"License\"); you may not use\r\nthis file except in compliance with the License. You may obtain a copy of the\r\nLicense at http://www.apache.org/licenses/LICENSE-2.0\r\n\r\nTHIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\r\nKIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED\r\nWARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,\r\nMERCHANTABLITY OR NON-INFRINGEMENT.\r\n\r\nSee the Apache Version 2.0 License for specific language governing permissions\r\nand limitations under the License.\r\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\nvar clamp = function clamp(min, max) {\n  return function (v) {\n    return Math.max(Math.min(v, max), min);\n  };\n};\n\nvar sanitize = function sanitize(v) {\n  return v % 1 ? Number(v.toFixed(5)) : v;\n};\n\nvar floatRegex = /(-)?(\\d[\\d\\.]*)/g;\nvar colorRegex = /(#[0-9a-f]{6}|#[0-9a-f]{3}|#(?:[0-9a-f]{2}){2,4}|(rgb|hsl)a?\\((-?\\d+%?[,\\s]+){2,3}\\s*[\\d\\.]+%?\\))/gi;\nvar singleColorRegex = /^(#[0-9a-f]{3}|#(?:[0-9a-f]{2}){2,4}|(rgb|hsl)a?\\((-?\\d+%?[,\\s]+){2,3}\\s*[\\d\\.]+%?\\))$/i;\nvar number = {\n  test: function test(v) {\n    return typeof v === 'number';\n  },\n  parse: parseFloat,\n  transform: function transform(v) {\n    return v;\n  }\n};\n\nvar alpha = _assign({}, number, {\n  transform: clamp(0, 1)\n});\n\nvar scale = _assign({}, number, {\n  \"default\": 1\n});\n\nvar createUnitType = function createUnitType(unit) {\n  return {\n    test: function test(v) {\n      return typeof v === 'string' && v.endsWith(unit) && v.split(' ').length === 1;\n    },\n    parse: parseFloat,\n    transform: function transform(v) {\n      return \"\" + v + unit;\n    }\n  };\n};\n\nvar degrees = createUnitType('deg');\nvar percent = createUnitType('%');\nvar px = createUnitType('px');\nvar vh = createUnitType('vh');\nvar vw = createUnitType('vw');\n\nvar progressPercentage = _assign({}, percent, {\n  parse: function parse(v) {\n    return percent.parse(v) / 100;\n  },\n  transform: function transform(v) {\n    return percent.transform(v * 100);\n  }\n});\n\nvar getValueFromFunctionString = function getValueFromFunctionString(value) {\n  return value.substring(value.indexOf('(') + 1, value.lastIndexOf(')'));\n};\n\nvar clampRgbUnit = clamp(0, 255);\n\nvar isRgba = function isRgba(v) {\n  return v.red !== undefined;\n};\n\nvar isHsla = function isHsla(v) {\n  return v.hue !== undefined;\n};\n\nvar splitColorValues = function splitColorValues(terms) {\n  return function (v) {\n    if (typeof v !== 'string') return v;\n    var values = {};\n    var valuesArray = getValueFromFunctionString(v).split(/,\\s*/);\n\n    for (var i = 0; i < 4; i++) {\n      values[terms[i]] = valuesArray[i] !== undefined ? parseFloat(valuesArray[i]) : 1;\n    }\n\n    return values;\n  };\n};\n\nvar rgbaTemplate = function rgbaTemplate(_a) {\n  var red = _a.red,\n      green = _a.green,\n      blue = _a.blue,\n      _b = _a.alpha,\n      alpha$$1 = _b === void 0 ? 1 : _b;\n  return \"rgba(\" + red + \", \" + green + \", \" + blue + \", \" + alpha$$1 + \")\";\n};\n\nvar hslaTemplate = function hslaTemplate(_a) {\n  var hue = _a.hue,\n      saturation = _a.saturation,\n      lightness = _a.lightness,\n      _b = _a.alpha,\n      alpha$$1 = _b === void 0 ? 1 : _b;\n  return \"hsla(\" + hue + \", \" + saturation + \", \" + lightness + \", \" + alpha$$1 + \")\";\n};\n\nvar rgbUnit = _assign({}, number, {\n  transform: function transform(v) {\n    return Math.round(clampRgbUnit(v));\n  }\n});\n\nfunction isColorString(color, colorType) {\n  return color.startsWith(colorType) && singleColorRegex.test(color);\n}\n\nvar rgba = {\n  test: function test(v) {\n    return typeof v === 'string' ? isColorString(v, 'rgb') : isRgba(v);\n  },\n  parse: splitColorValues(['red', 'green', 'blue', 'alpha']),\n  transform: function transform(_a) {\n    var red = _a.red,\n        green = _a.green,\n        blue = _a.blue,\n        _b = _a.alpha,\n        alpha$$1 = _b === void 0 ? 1 : _b;\n    return rgbaTemplate({\n      red: rgbUnit.transform(red),\n      green: rgbUnit.transform(green),\n      blue: rgbUnit.transform(blue),\n      alpha: sanitize(alpha.transform(alpha$$1))\n    });\n  }\n};\nvar hsla = {\n  test: function test(v) {\n    return typeof v === 'string' ? isColorString(v, 'hsl') : isHsla(v);\n  },\n  parse: splitColorValues(['hue', 'saturation', 'lightness', 'alpha']),\n  transform: function transform(_a) {\n    var hue = _a.hue,\n        saturation = _a.saturation,\n        lightness = _a.lightness,\n        _b = _a.alpha,\n        alpha$$1 = _b === void 0 ? 1 : _b;\n    return hslaTemplate({\n      hue: Math.round(hue),\n      saturation: percent.transform(sanitize(saturation)),\n      lightness: percent.transform(sanitize(lightness)),\n      alpha: sanitize(alpha.transform(alpha$$1))\n    });\n  }\n};\n\nvar hex = _assign({}, rgba, {\n  test: function test(v) {\n    return typeof v === 'string' && isColorString(v, '#');\n  },\n  parse: function parse(v) {\n    var r = '';\n    var g = '';\n    var b = '';\n\n    if (v.length > 4) {\n      r = v.substr(1, 2);\n      g = v.substr(3, 2);\n      b = v.substr(5, 2);\n    } else {\n      r = v.substr(1, 1);\n      g = v.substr(2, 1);\n      b = v.substr(3, 1);\n      r += r;\n      g += g;\n      b += b;\n    }\n\n    return {\n      red: parseInt(r, 16),\n      green: parseInt(g, 16),\n      blue: parseInt(b, 16),\n      alpha: 1\n    };\n  }\n});\n\nvar color = {\n  test: function test(v) {\n    return typeof v === 'string' && singleColorRegex.test(v) || isRgba(v) || isHsla(v);\n  },\n  parse: function parse(v) {\n    if (rgba.test(v)) {\n      return rgba.parse(v);\n    } else if (hsla.test(v)) {\n      return hsla.parse(v);\n    } else if (hex.test(v)) {\n      return hex.parse(v);\n    }\n\n    return v;\n  },\n  transform: function transform(v) {\n    if (isRgba(v)) {\n      return rgba.transform(v);\n    } else if (isHsla(v)) {\n      return hsla.transform(v);\n    }\n\n    return v;\n  }\n};\nvar COLOR_TOKEN = '${c}';\nvar NUMBER_TOKEN = '${n}';\n\nvar convertNumbersToZero = function convertNumbersToZero(v) {\n  return typeof v === 'number' ? 0 : v;\n};\n\nvar complex = {\n  test: function test(v) {\n    if (typeof v !== 'string' || !isNaN(v)) return false;\n    var numValues = 0;\n    var foundNumbers = v.match(floatRegex);\n    var foundColors = v.match(colorRegex);\n    if (foundNumbers) numValues += foundNumbers.length;\n    if (foundColors) numValues += foundColors.length;\n    return numValues > 0;\n  },\n  parse: function parse(v) {\n    var input = v;\n    var parsed = [];\n    var foundColors = input.match(colorRegex);\n\n    if (foundColors) {\n      input = input.replace(colorRegex, COLOR_TOKEN);\n      parsed.push.apply(parsed, foundColors.map(color.parse));\n    }\n\n    var foundNumbers = input.match(floatRegex);\n\n    if (foundNumbers) {\n      parsed.push.apply(parsed, foundNumbers.map(number.parse));\n    }\n\n    return parsed;\n  },\n  createTransformer: function createTransformer(prop) {\n    var template = prop;\n    var token = 0;\n    var foundColors = prop.match(colorRegex);\n    var numColors = foundColors ? foundColors.length : 0;\n\n    if (foundColors) {\n      for (var i = 0; i < numColors; i++) {\n        template = template.replace(foundColors[i], COLOR_TOKEN);\n        token++;\n      }\n    }\n\n    var foundNumbers = template.match(floatRegex);\n    var numNumbers = foundNumbers ? foundNumbers.length : 0;\n\n    if (foundNumbers) {\n      for (var i = 0; i < numNumbers; i++) {\n        template = template.replace(foundNumbers[i], NUMBER_TOKEN);\n        token++;\n      }\n    }\n\n    return function (v) {\n      var output = template;\n\n      for (var i = 0; i < token; i++) {\n        output = output.replace(i < numColors ? COLOR_TOKEN : NUMBER_TOKEN, i < numColors ? color.transform(v[i]) : sanitize(v[i]));\n      }\n\n      return output;\n    };\n  },\n  getAnimatableNone: function getAnimatableNone(target) {\n    var parsedTarget = complex.parse(target);\n    var targetTransformer = complex.createTransformer(target);\n    return targetTransformer(parsedTarget.map(convertNumbersToZero));\n  }\n};\nexport { number, scale, alpha, degrees, percent, progressPercentage, px, vw, vh, rgba, rgbUnit, hsla, hex, color, complex };","import \"core-js/modules/es6.typed.float32-array\";\nvar DEFAULT_OVERSHOOT_STRENGTH = 1.525;\n\nvar reversed = function reversed(easing) {\n  return function (p) {\n    return 1 - easing(1 - p);\n  };\n};\n\nvar mirrored = function mirrored(easing) {\n  return function (p) {\n    return p <= 0.5 ? easing(2 * p) / 2 : (2 - easing(2 * (1 - p))) / 2;\n  };\n};\n\nvar createReversedEasing = reversed;\nvar createMirroredEasing = mirrored;\n\nvar createExpoIn = function createExpoIn(power) {\n  return function (p) {\n    return Math.pow(p, power);\n  };\n};\n\nvar createBackIn = function createBackIn(power) {\n  return function (p) {\n    return p * p * ((power + 1) * p - power);\n  };\n};\n\nvar createAnticipateEasing = function createAnticipateEasing(power) {\n  var backEasing = createBackIn(power);\n  return function (p) {\n    return (p *= 2) < 1 ? 0.5 * backEasing(p) : 0.5 * (2 - Math.pow(2, -10 * (p - 1)));\n  };\n};\n\nvar linear = function linear(p) {\n  return p;\n};\n\nvar easeIn =\n/*#__PURE__*/\ncreateExpoIn(2);\nvar easeOut =\n/*#__PURE__*/\nreversed(easeIn);\nvar easeInOut =\n/*#__PURE__*/\nmirrored(easeIn);\n\nvar circIn = function circIn(p) {\n  return 1 - Math.sin(Math.acos(p));\n};\n\nvar circOut =\n/*#__PURE__*/\nreversed(circIn);\nvar circInOut =\n/*#__PURE__*/\nmirrored(circOut);\nvar backIn =\n/*#__PURE__*/\ncreateBackIn(DEFAULT_OVERSHOOT_STRENGTH);\nvar backOut =\n/*#__PURE__*/\nreversed(backIn);\nvar backInOut =\n/*#__PURE__*/\nmirrored(backIn);\nvar anticipate =\n/*#__PURE__*/\ncreateAnticipateEasing(DEFAULT_OVERSHOOT_STRENGTH);\nvar BOUNCE_FIRST_THRESHOLD = 4.0 / 11.0;\nvar BOUNCE_SECOND_THRESHOLD = 8.0 / 11.0;\nvar BOUNCE_THIRD_THRESHOLD = 9.0 / 10.0;\nvar ca = 4356.0 / 361.0;\nvar cb = 35442.0 / 1805.0;\nvar cc = 16061.0 / 1805.0;\n\nvar bounceOut = function bounceOut(p) {\n  var p2 = p * p;\n  return p < BOUNCE_FIRST_THRESHOLD ? 7.5625 * p2 : p < BOUNCE_SECOND_THRESHOLD ? 9.075 * p2 - 9.9 * p + 3.4 : p < BOUNCE_THIRD_THRESHOLD ? ca * p2 - cb * p + cc : 10.8 * p * p - 20.52 * p + 10.72;\n};\n\nvar bounceIn = function bounceIn(p) {\n  return 1.0 - bounceOut(1.0 - p);\n};\n\nvar bounceInOut = function bounceInOut(p) {\n  return p < 0.5 ? 0.5 * (1.0 - bounceOut(1.0 - p * 2.0)) : 0.5 * bounceOut(p * 2.0 - 1.0) + 0.5;\n};\n\nvar NEWTON_ITERATIONS = 8;\nvar NEWTON_MIN_SLOPE = 0.001;\nvar SUBDIVISION_PRECISION = 0.0000001;\nvar SUBDIVISION_MAX_ITERATIONS = 10;\nvar K_SPLINE_TABLE_SIZE = 11;\nvar K_SAMPLE_STEP_SIZE = 1.0 / (K_SPLINE_TABLE_SIZE - 1.0);\nvar FLOAT_32_SUPPORTED = typeof Float32Array !== 'undefined';\n\nvar a = function a(a1, a2) {\n  return 1.0 - 3.0 * a2 + 3.0 * a1;\n};\n\nvar b = function b(a1, a2) {\n  return 3.0 * a2 - 6.0 * a1;\n};\n\nvar c = function c(a1) {\n  return 3.0 * a1;\n};\n\nvar getSlope = function getSlope(t, a1, a2) {\n  return 3.0 * a(a1, a2) * t * t + 2.0 * b(a1, a2) * t + c(a1);\n};\n\nvar calcBezier = function calcBezier(t, a1, a2) {\n  return ((a(a1, a2) * t + b(a1, a2)) * t + c(a1)) * t;\n};\n\nfunction cubicBezier(mX1, mY1, mX2, mY2) {\n  var sampleValues = FLOAT_32_SUPPORTED ? new Float32Array(K_SPLINE_TABLE_SIZE) : new Array(K_SPLINE_TABLE_SIZE);\n\n  var binarySubdivide = function binarySubdivide(aX, aA, aB) {\n    var i = 0;\n    var currentX;\n    var currentT;\n\n    do {\n      currentT = aA + (aB - aA) / 2.0;\n      currentX = calcBezier(currentT, mX1, mX2) - aX;\n\n      if (currentX > 0.0) {\n        aB = currentT;\n      } else {\n        aA = currentT;\n      }\n    } while (Math.abs(currentX) > SUBDIVISION_PRECISION && ++i < SUBDIVISION_MAX_ITERATIONS);\n\n    return currentT;\n  };\n\n  var newtonRaphsonIterate = function newtonRaphsonIterate(aX, aGuessT) {\n    var i = 0;\n    var currentSlope = 0;\n    var currentX;\n\n    for (; i < NEWTON_ITERATIONS; ++i) {\n      currentSlope = getSlope(aGuessT, mX1, mX2);\n\n      if (currentSlope === 0.0) {\n        return aGuessT;\n      }\n\n      currentX = calcBezier(aGuessT, mX1, mX2) - aX;\n      aGuessT -= currentX / currentSlope;\n    }\n\n    return aGuessT;\n  };\n\n  var calcSampleValues = function calcSampleValues() {\n    for (var i = 0; i < K_SPLINE_TABLE_SIZE; ++i) {\n      sampleValues[i] = calcBezier(i * K_SAMPLE_STEP_SIZE, mX1, mX2);\n    }\n  };\n\n  var getTForX = function getTForX(aX) {\n    var intervalStart = 0.0;\n    var currentSample = 1;\n    var lastSample = K_SPLINE_TABLE_SIZE - 1;\n    var dist = 0.0;\n    var guessForT = 0.0;\n    var initialSlope = 0.0;\n\n    for (; currentSample !== lastSample && sampleValues[currentSample] <= aX; ++currentSample) {\n      intervalStart += K_SAMPLE_STEP_SIZE;\n    }\n\n    --currentSample;\n    dist = (aX - sampleValues[currentSample]) / (sampleValues[currentSample + 1] - sampleValues[currentSample]);\n    guessForT = intervalStart + dist * K_SAMPLE_STEP_SIZE;\n    initialSlope = getSlope(guessForT, mX1, mX2);\n\n    if (initialSlope >= NEWTON_MIN_SLOPE) {\n      return newtonRaphsonIterate(aX, guessForT);\n    } else if (initialSlope === 0.0) {\n      return guessForT;\n    } else {\n      return binarySubdivide(aX, intervalStart, intervalStart + K_SAMPLE_STEP_SIZE);\n    }\n  };\n\n  calcSampleValues();\n\n  var resolver = function resolver(aX) {\n    var returnValue;\n\n    if (mX1 === mY1 && mX2 === mY2) {\n      returnValue = aX;\n    } else if (aX === 0) {\n      returnValue = 0;\n    } else if (aX === 1) {\n      returnValue = 1;\n    } else {\n      returnValue = calcBezier(getTForX(aX), mY1, mY2);\n    }\n\n    return returnValue;\n  };\n\n  return resolver;\n}\n\nexport { reversed, mirrored, createReversedEasing, createMirroredEasing, createExpoIn, createBackIn, createAnticipateEasing, linear, easeIn, easeOut, easeInOut, circIn, circOut, circInOut, backIn, backOut, backInOut, anticipate, bounceOut, bounceIn, bounceInOut, cubicBezier };","import \"core-js/modules/es6.array.is-array\";\nimport \"core-js/modules/es6.array.map\";\nimport \"core-js/modules/es6.array.reduce\";\nimport \"core-js/modules/es6.array.find\";\nimport \"core-js/modules/es6.object.assign\";\nimport { hsla, rgba, hex, color, complex } from 'style-value-types';\nimport { invariant } from 'hey-listen';\nimport { getFrameData } from 'framesync';\nimport { createAnticipateEasing, createBackIn, createExpoIn, cubicBezier, linear, easeIn, easeOut, easeInOut, circIn, circOut, circInOut, backIn, backOut, backInOut, anticipate, reversed, mirrored } from '@popmotion/easing';\nexport { createAnticipateEasing, createBackIn, createExpoIn, cubicBezier, linear, easeIn, easeOut, easeInOut, circIn, circOut, circInOut, backIn, backOut, backInOut, anticipate, reversed, mirrored } from '@popmotion/easing';\nvar zeroPoint = {\n  x: 0,\n  y: 0,\n  z: 0\n};\n\nvar isNum = function isNum(v) {\n  return typeof v === 'number';\n};\n\nvar radiansToDegrees = function radiansToDegrees(radians) {\n  return radians * 180 / Math.PI;\n};\n\nvar angle = function angle(a, b) {\n  if (b === void 0) {\n    b = zeroPoint;\n  }\n\n  return radiansToDegrees(Math.atan2(b.y - a.y, b.x - a.x));\n};\n\nvar applyOffset = function applyOffset(from, to) {\n  var hasReceivedFrom = true;\n\n  if (to === undefined) {\n    to = from;\n    hasReceivedFrom = false;\n  }\n\n  return function (v) {\n    if (hasReceivedFrom) {\n      return v - from + to;\n    } else {\n      from = v;\n      hasReceivedFrom = true;\n      return to;\n    }\n  };\n};\n\nvar curryRange = function curryRange(func) {\n  return function (min, max, v) {\n    return v !== undefined ? func(min, max, v) : function (cv) {\n      return func(min, max, cv);\n    };\n  };\n};\n\nvar clamp = function clamp(min, max, v) {\n  return Math.min(Math.max(v, min), max);\n};\n\nvar clamp$1 = curryRange(clamp);\n\nvar conditional = function conditional(check, apply) {\n  return function (v) {\n    return check(v) ? apply(v) : v;\n  };\n};\n\nvar degreesToRadians = function degreesToRadians(degrees) {\n  return degrees * Math.PI / 180;\n};\n\nvar isPoint = function isPoint(point) {\n  return point.hasOwnProperty('x') && point.hasOwnProperty('y');\n};\n\nvar isPoint3D = function isPoint3D(point) {\n  return isPoint(point) && point.hasOwnProperty('z');\n};\n\nvar distance1D = function distance1D(a, b) {\n  return Math.abs(a - b);\n};\n\nvar distance = function distance(a, b) {\n  if (b === void 0) {\n    b = zeroPoint;\n  }\n\n  if (isNum(a) && isNum(b)) {\n    return distance1D(a, b);\n  } else if (isPoint(a) && isPoint(b)) {\n    var xDelta = distance1D(a.x, b.x);\n    var yDelta = distance1D(a.y, b.y);\n    var zDelta = isPoint3D(a) && isPoint3D(b) ? distance1D(a.z, b.z) : 0;\n    return Math.sqrt(Math.pow(xDelta, 2) + Math.pow(yDelta, 2) + Math.pow(zDelta, 2));\n  }\n\n  return 0;\n};\n\nvar progress = function progress(from, to, value) {\n  var toFromDifference = to - from;\n  return toFromDifference === 0 ? 1 : (value - from) / toFromDifference;\n};\n\nvar mix = function mix(from, to, progress) {\n  return -progress * from + progress * to + from;\n};\n/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation. All rights reserved.\r\nLicensed under the Apache License, Version 2.0 (the \"License\"); you may not use\r\nthis file except in compliance with the License. You may obtain a copy of the\r\nLicense at http://www.apache.org/licenses/LICENSE-2.0\r\n\r\nTHIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\r\nKIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED\r\nWARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,\r\nMERCHANTABLITY OR NON-INFRINGEMENT.\r\n\r\nSee the Apache Version 2.0 License for specific language governing permissions\r\nand limitations under the License.\r\n***************************************************************************** */\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\nvar mixLinearColor = function mixLinearColor(from, to, v) {\n  var fromExpo = from * from;\n  var toExpo = to * to;\n  return Math.sqrt(Math.max(0, v * (toExpo - fromExpo) + fromExpo));\n};\n\nvar colorTypes = [hex, rgba, hsla];\n\nvar getColorType = function getColorType(v) {\n  return colorTypes.find(function (type) {\n    return type.test(v);\n  });\n};\n\nvar notAnimatable = function notAnimatable(color$$1) {\n  return \"'\" + color$$1 + \"' is not an animatable color. Use the equivalent color code instead.\";\n};\n\nvar mixColor = function mixColor(from, to) {\n  var fromColorType = getColorType(from);\n  var toColorType = getColorType(to);\n  invariant(!!fromColorType, notAnimatable(from));\n  invariant(!!toColorType, notAnimatable(to));\n  invariant(fromColorType.transform === toColorType.transform, 'Both colors must be hex/RGBA, OR both must be HSLA.');\n  var fromColor = fromColorType.parse(from);\n  var toColor = toColorType.parse(to);\n\n  var blended = _assign({}, fromColor);\n\n  var mixFunc = fromColorType === hsla ? mix : mixLinearColor;\n  return function (v) {\n    for (var key in blended) {\n      if (key !== 'alpha') {\n        blended[key] = mixFunc(fromColor[key], toColor[key], v);\n      }\n    }\n\n    blended.alpha = mix(fromColor.alpha, toColor.alpha, v);\n    return fromColorType.transform(blended);\n  };\n};\n\nvar combineFunctions = function combineFunctions(a, b) {\n  return function (v) {\n    return b(a(v));\n  };\n};\n\nvar pipe = function pipe() {\n  var transformers = [];\n\n  for (var _i = 0; _i < arguments.length; _i++) {\n    transformers[_i] = arguments[_i];\n  }\n\n  return transformers.reduce(combineFunctions);\n};\n\nfunction getMixer(origin, target) {\n  if (isNum(origin)) {\n    return function (v) {\n      return mix(origin, target, v);\n    };\n  } else if (color.test(origin)) {\n    return mixColor(origin, target);\n  } else {\n    return mixComplex(origin, target);\n  }\n}\n\nvar mixArray = function mixArray(from, to) {\n  var output = from.slice();\n  var numValues = output.length;\n  var blendValue = from.map(function (fromThis, i) {\n    return getMixer(fromThis, to[i]);\n  });\n  return function (v) {\n    for (var i = 0; i < numValues; i++) {\n      output[i] = blendValue[i](v);\n    }\n\n    return output;\n  };\n};\n\nvar mixObject = function mixObject(origin, target) {\n  var output = _assign({}, origin, target);\n\n  var blendValue = {};\n\n  for (var key in output) {\n    if (origin[key] !== undefined && target[key] !== undefined) {\n      blendValue[key] = getMixer(origin[key], target[key]);\n    }\n  }\n\n  return function (v) {\n    for (var key in blendValue) {\n      output[key] = blendValue[key](v);\n    }\n\n    return output;\n  };\n};\n\nfunction analyse(value) {\n  var parsed = complex.parse(value);\n  var numValues = parsed.length;\n  var numNumbers = 0;\n  var numRGB = 0;\n  var numHSL = 0;\n\n  for (var i = 0; i < numValues; i++) {\n    if (numNumbers || typeof parsed[i] === 'number') {\n      numNumbers++;\n    } else {\n      if (parsed[i].hue !== undefined) {\n        numHSL++;\n      } else {\n        numRGB++;\n      }\n    }\n  }\n\n  return {\n    parsed: parsed,\n    numNumbers: numNumbers,\n    numRGB: numRGB,\n    numHSL: numHSL\n  };\n}\n\nvar mixComplex = function mixComplex(origin, target) {\n  var template = complex.createTransformer(target);\n  var originStats = analyse(origin);\n  var targetStats = analyse(target);\n  invariant(originStats.numHSL === targetStats.numHSL && originStats.numRGB === targetStats.numRGB && originStats.numNumbers >= targetStats.numNumbers, \"Complex values '\" + origin + \"' and '\" + target + \"' too different to mix. Ensure all colors are of the same type.\");\n  return pipe(mixArray(originStats.parsed, targetStats.parsed), template);\n};\n\nvar mixNumber = function mixNumber(from, to) {\n  return function (p) {\n    return mix(from, to, p);\n  };\n};\n\nfunction detectMixerFactory(v) {\n  if (typeof v === 'number') {\n    return mixNumber;\n  } else if (typeof v === 'string') {\n    if (color.test(v)) {\n      return mixColor;\n    } else {\n      return mixComplex;\n    }\n  } else if (Array.isArray(v)) {\n    return mixArray;\n  } else if (typeof v === 'object') {\n    return mixObject;\n  }\n}\n\nfunction createMixers(output, ease, customMixer) {\n  var mixers = [];\n  var mixerFactory = customMixer || detectMixerFactory(output[0]);\n  var numMixers = output.length - 1;\n\n  for (var i = 0; i < numMixers; i++) {\n    var mixer = mixerFactory(output[i], output[i + 1]);\n\n    if (ease) {\n      var easingFunction = Array.isArray(ease) ? ease[i] : ease;\n      mixer = pipe(easingFunction, mixer);\n    }\n\n    mixers.push(mixer);\n  }\n\n  return mixers;\n}\n\nfunction fastInterpolate(_a, _b) {\n  var from = _a[0],\n      to = _a[1];\n  var mixer = _b[0];\n  return function (v) {\n    return mixer(progress(from, to, v));\n  };\n}\n\nfunction slowInterpolate(input, mixers) {\n  var inputLength = input.length;\n  var lastInputIndex = inputLength - 1;\n  return function (v) {\n    var mixerIndex = 0;\n    var foundMixerIndex = false;\n\n    if (v <= input[0]) {\n      foundMixerIndex = true;\n    } else if (v >= input[lastInputIndex]) {\n      mixerIndex = lastInputIndex - 1;\n      foundMixerIndex = true;\n    }\n\n    if (!foundMixerIndex) {\n      var i = 1;\n\n      for (; i < inputLength; i++) {\n        if (input[i] > v || i === lastInputIndex) {\n          break;\n        }\n      }\n\n      mixerIndex = i - 1;\n    }\n\n    var progressInRange = progress(input[mixerIndex], input[mixerIndex + 1], v);\n    return mixers[mixerIndex](progressInRange);\n  };\n}\n\nfunction interpolate(input, output, _a) {\n  var _b = _a === void 0 ? {} : _a,\n      _c = _b.clamp,\n      clamp = _c === void 0 ? true : _c,\n      ease = _b.ease,\n      mixer = _b.mixer;\n\n  var inputLength = input.length;\n  invariant(inputLength === output.length, 'Both input and output ranges must be the same length');\n  invariant(!ease || !Array.isArray(ease) || ease.length === inputLength - 1, 'Array of easing functions must be of length `input.length - 1`, as it applies to the transitions **between** the defined values.');\n\n  if (input[0] > input[inputLength - 1]) {\n    input = [].concat(input);\n    output = [].concat(output);\n    input.reverse();\n    output.reverse();\n  }\n\n  var mixers = createMixers(output, ease, mixer);\n  var interpolator = inputLength === 2 ? fastInterpolate(input, mixers) : slowInterpolate(input, mixers);\n  return clamp ? pipe(clamp$1(input[0], input[inputLength - 1]), interpolator) : interpolator;\n}\n\nvar pointFromVector = function pointFromVector(origin, angle, distance) {\n  angle = degreesToRadians(angle);\n  return {\n    x: distance * Math.cos(angle) + origin.x,\n    y: distance * Math.sin(angle) + origin.y\n  };\n};\n\nvar toDecimal = function toDecimal(num, precision) {\n  if (precision === void 0) {\n    precision = 2;\n  }\n\n  precision = Math.pow(10, precision);\n  return Math.round(num * precision) / precision;\n};\n\nvar smoothFrame = function smoothFrame(prevValue, nextValue, duration, smoothing) {\n  if (smoothing === void 0) {\n    smoothing = 0;\n  }\n\n  return toDecimal(prevValue + duration * (nextValue - prevValue) / Math.max(smoothing, duration));\n};\n\nvar smooth = function smooth(strength) {\n  if (strength === void 0) {\n    strength = 50;\n  }\n\n  var previousValue = 0;\n  var lastUpdated = 0;\n  return function (v) {\n    var currentFramestamp = getFrameData().timestamp;\n    var timeDelta = currentFramestamp !== lastUpdated ? currentFramestamp - lastUpdated : 0;\n    var newValue = timeDelta ? smoothFrame(previousValue, v, timeDelta, strength) : previousValue;\n    lastUpdated = currentFramestamp;\n    previousValue = newValue;\n    return newValue;\n  };\n};\n\nvar snap = function snap(points) {\n  if (typeof points === 'number') {\n    return function (v) {\n      return Math.round(v / points) * points;\n    };\n  } else {\n    var i_1 = 0;\n    var numPoints_1 = points.length;\n    return function (v) {\n      var lastDistance = Math.abs(points[0] - v);\n\n      for (i_1 = 1; i_1 < numPoints_1; i_1++) {\n        var point = points[i_1];\n        var distance = Math.abs(point - v);\n        if (distance === 0) return point;\n        if (distance > lastDistance) return points[i_1 - 1];\n        if (i_1 === numPoints_1 - 1) return point;\n        lastDistance = distance;\n      }\n    };\n  }\n};\n\nvar identity = function identity(v) {\n  return v;\n};\n\nvar springForce = function springForce(alterDisplacement) {\n  if (alterDisplacement === void 0) {\n    alterDisplacement = identity;\n  }\n\n  return curryRange(function (constant, origin, v) {\n    var displacement = origin - v;\n    var springModifiedDisplacement = -(0 - constant + 1) * (0 - alterDisplacement(Math.abs(displacement)));\n    return displacement <= 0 ? origin + springModifiedDisplacement : origin - springModifiedDisplacement;\n  });\n};\n\nvar springForceLinear = springForce();\nvar springForceExpo = springForce(Math.sqrt);\n\nvar velocityPerFrame = function velocityPerFrame(xps, frameDuration) {\n  return isNum(xps) ? xps / (1000 / frameDuration) : 0;\n};\n\nvar velocityPerSecond = function velocityPerSecond(velocity, frameDuration) {\n  return frameDuration ? velocity * (1000 / frameDuration) : 0;\n};\n\nvar wrap = function wrap(min, max, v) {\n  var rangeSize = max - min;\n  return ((v - min) % rangeSize + rangeSize) % rangeSize + min;\n};\n\nvar wrap$1 = curryRange(wrap);\nvar clampProgress = clamp$1(0, 1);\n\nvar steps = function steps(_steps, direction) {\n  if (direction === void 0) {\n    direction = 'end';\n  }\n\n  return function (progress) {\n    progress = direction === 'end' ? Math.min(progress, 0.999) : Math.max(progress, 0.001);\n    var expanded = progress * _steps;\n    var rounded = direction === 'end' ? Math.floor(expanded) : Math.ceil(expanded);\n    return clampProgress(rounded / _steps);\n  };\n};\n\nexport { angle, applyOffset, clamp$1 as clamp, conditional, degreesToRadians, distance, interpolate, isPoint, isPoint3D, mix, mixArray, mixColor, mixComplex, mixObject, pipe, pointFromVector, progress, radiansToDegrees, smooth, smoothFrame, snap, springForce, springForceExpo, springForceLinear, steps, toDecimal, velocityPerFrame, velocityPerSecond, wrap$1 as wrap };","import \"core-js/modules/es6.weak-map\";\nimport \"core-js/modules/es6.string.trim\";\nimport \"core-js/modules/es6.array.sort\";\nimport \"core-js/modules/es6.array.reduce\";\nimport \"core-js/modules/es6.map\";\nimport \"core-js/modules/es6.regexp.replace\";\nimport \"core-js/modules/es6.string.starts-with\";\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 \"core-js/modules/es6.symbol\";\nimport \"core-js/modules/es6.array.index-of\";\nimport \"core-js/modules/es6.object.assign\";\nimport sync from 'framesync';\nimport { alpha, color, degrees, scale, px, progressPercentage, number } from 'style-value-types';\nimport { invariant } from 'hey-listen';\n/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation. All rights reserved.\r\nLicensed under the Apache License, Version 2.0 (the \"License\"); you may not use\r\nthis file except in compliance with the License. You may obtain a copy of the\r\nLicense at http://www.apache.org/licenses/LICENSE-2.0\r\n\r\nTHIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\r\nKIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED\r\nWARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,\r\nMERCHANTABLITY OR NON-INFRINGEMENT.\r\n\r\nSee the Apache Version 2.0 License for specific language governing permissions\r\nand limitations under the License.\r\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\nfunction __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) t[p[i]] = s[p[i]];\n  }\n  return t;\n}\n\nvar createStyler = function createStyler(_a) {\n  var onRead = _a.onRead,\n      onRender = _a.onRender,\n      _b = _a.uncachedValues,\n      uncachedValues = _b === void 0 ? new Set() : _b,\n      _c = _a.useCache,\n      useCache = _c === void 0 ? true : _c;\n  return function (_a) {\n    if (_a === void 0) {\n      _a = {};\n    }\n\n    var props = __rest(_a, []);\n\n    var state = {};\n    var changedValues = [];\n    var hasChanged = false;\n\n    function setValue(key, value) {\n      if (key.startsWith('--')) {\n        props.hasCSSVariable = true;\n      }\n\n      var currentValue = state[key];\n      state[key] = value;\n      if (state[key] === currentValue) return;\n\n      if (changedValues.indexOf(key) === -1) {\n        changedValues.push(key);\n      }\n\n      if (!hasChanged) {\n        hasChanged = true;\n        sync.render(styler.render);\n      }\n    }\n\n    var styler = {\n      get: function get(key, forceRead) {\n        if (forceRead === void 0) {\n          forceRead = false;\n        }\n\n        var useCached = !forceRead && useCache && !uncachedValues.has(key) && state[key] !== undefined;\n        return useCached ? state[key] : onRead(key, props);\n      },\n      set: function set(values, value) {\n        if (typeof values === 'string') {\n          setValue(values, value);\n        } else {\n          for (var key in values) {\n            setValue(key, values[key]);\n          }\n        }\n\n        return this;\n      },\n      render: function render(forceRender) {\n        if (forceRender === void 0) {\n          forceRender = false;\n        }\n\n        if (hasChanged || forceRender === true) {\n          onRender(state, props, changedValues);\n          hasChanged = false;\n          changedValues.length = 0;\n        }\n\n        return this;\n      }\n    };\n    return styler;\n  };\n};\n\nvar CAMEL_CASE_PATTERN = /([a-z])([A-Z])/g;\nvar REPLACE_TEMPLATE = '$1-$2';\n\nvar camelToDash = function camelToDash(str) {\n  return str.replace(CAMEL_CASE_PATTERN, REPLACE_TEMPLATE).toLowerCase();\n};\n\nvar camelCache =\n/*#__PURE__*/\nnew Map();\nvar dashCache =\n/*#__PURE__*/\nnew Map();\nvar prefixes = ['Webkit', 'Moz', 'O', 'ms', ''];\nvar numPrefixes = prefixes.length;\nvar isBrowser = typeof document !== 'undefined';\nvar testElement;\n\nvar setDashPrefix = function setDashPrefix(key, prefixed) {\n  return dashCache.set(key, camelToDash(prefixed));\n};\n\nvar testPrefix = function testPrefix(key) {\n  testElement = testElement || document.createElement('div');\n\n  for (var i = 0; i < numPrefixes; i++) {\n    var prefix = prefixes[i];\n    var noPrefix = prefix === '';\n    var prefixedPropertyName = noPrefix ? key : prefix + key.charAt(0).toUpperCase() + key.slice(1);\n\n    if (prefixedPropertyName in testElement.style || noPrefix) {\n      if (noPrefix && key === 'clipPath' && dashCache.has(key)) {\n        return;\n      }\n\n      camelCache.set(key, prefixedPropertyName);\n      setDashPrefix(key, \"\" + (noPrefix ? '' : '-') + camelToDash(prefixedPropertyName));\n    }\n  }\n};\n\nvar setServerProperty = function setServerProperty(key) {\n  return setDashPrefix(key, key);\n};\n\nvar prefixer = function prefixer(key, asDashCase) {\n  if (asDashCase === void 0) {\n    asDashCase = false;\n  }\n\n  var cache = asDashCase ? dashCache : camelCache;\n\n  if (!cache.has(key)) {\n    isBrowser ? testPrefix(key) : setServerProperty(key);\n  }\n\n  return cache.get(key) || key;\n};\n\nvar axes = ['', 'X', 'Y', 'Z'];\nvar order = ['translate', 'scale', 'rotate', 'skew', 'transformPerspective'];\nvar transformProps =\n/*#__PURE__*/\norder.reduce(function (acc, key) {\n  return axes.reduce(function (axesAcc, axesKey) {\n    axesAcc.push(key + axesKey);\n    return axesAcc;\n  }, acc);\n}, ['x', 'y', 'z']);\nvar transformPropDictionary =\n/*#__PURE__*/\ntransformProps.reduce(function (dict, key) {\n  dict[key] = true;\n  return dict;\n}, {});\n\nfunction isTransformProp(key) {\n  return transformPropDictionary[key] === true;\n}\n\nfunction sortTransformProps(a, b) {\n  return transformProps.indexOf(a) - transformProps.indexOf(b);\n}\n\nvar transformOriginProps =\n/*#__PURE__*/\nnew Set(['originX', 'originY', 'originZ']);\n\nfunction isTransformOriginProp(key) {\n  return transformOriginProps.has(key);\n}\n\nvar _int =\n/*#__PURE__*/\n_assign({}, number, {\n  transform: Math.round\n});\n\nvar valueTypes = {\n  color: color,\n  backgroundColor: color,\n  outlineColor: color,\n  fill: color,\n  stroke: color,\n  borderColor: color,\n  borderTopColor: color,\n  borderRightColor: color,\n  borderBottomColor: color,\n  borderLeftColor: color,\n  borderWidth: px,\n  borderTopWidth: px,\n  borderRightWidth: px,\n  borderBottomWidth: px,\n  borderLeftWidth: px,\n  borderRadius: px,\n  radius: px,\n  borderTopLeftRadius: px,\n  borderTopRightRadius: px,\n  borderBottomRightRadius: px,\n  borderBottomLeftRadius: px,\n  width: px,\n  maxWidth: px,\n  height: px,\n  maxHeight: px,\n  size: px,\n  top: px,\n  right: px,\n  bottom: px,\n  left: px,\n  padding: px,\n  paddingTop: px,\n  paddingRight: px,\n  paddingBottom: px,\n  paddingLeft: px,\n  margin: px,\n  marginTop: px,\n  marginRight: px,\n  marginBottom: px,\n  marginLeft: px,\n  rotate: degrees,\n  rotateX: degrees,\n  rotateY: degrees,\n  rotateZ: degrees,\n  scale: scale,\n  scaleX: scale,\n  scaleY: scale,\n  scaleZ: scale,\n  skew: degrees,\n  skewX: degrees,\n  skewY: degrees,\n  distance: px,\n  translateX: px,\n  translateY: px,\n  translateZ: px,\n  x: px,\n  y: px,\n  z: px,\n  perspective: px,\n  opacity: alpha,\n  originX: progressPercentage,\n  originY: progressPercentage,\n  originZ: px,\n  zIndex: _int,\n  fillOpacity: alpha,\n  strokeOpacity: alpha,\n  numOctaves: _int\n};\n\nvar getValueType = function getValueType(key) {\n  return valueTypes[key];\n};\n\nvar getValueAsType = function getValueAsType(value, type) {\n  return type && typeof value === 'number' ? type.transform(value) : value;\n};\n\nvar SCROLL_LEFT = 'scrollLeft';\nvar SCROLL_TOP = 'scrollTop';\nvar scrollKeys =\n/*#__PURE__*/\nnew Set([SCROLL_LEFT, SCROLL_TOP]);\nvar blacklist =\n/*#__PURE__*/\nnew Set([SCROLL_LEFT, SCROLL_TOP, 'transform']);\nvar translateAlias = {\n  x: 'translateX',\n  y: 'translateY',\n  z: 'translateZ'\n};\n\nfunction isCustomTemplate(v) {\n  return typeof v === 'function';\n}\n\nfunction buildTransform(state, transform, transformKeys, transformIsDefault, enableHardwareAcceleration) {\n  var transformString = '';\n  var transformHasZ = false;\n  transformKeys.sort(sortTransformProps);\n  var numTransformKeys = transformKeys.length;\n\n  for (var i = 0; i < numTransformKeys; i++) {\n    var key = transformKeys[i];\n    transformString += (translateAlias[key] || key) + \"(\" + transform[key] + \") \";\n    transformHasZ = key === 'z' ? true : transformHasZ;\n  }\n\n  if (!transformHasZ && enableHardwareAcceleration) {\n    transformString += 'translateZ(0)';\n  } else {\n    transformString = transformString.trim();\n  }\n\n  if (isCustomTemplate(state.transform)) {\n    transformString = state.transform(transform, transformString);\n  } else if (transformIsDefault) {\n    transformString = 'none';\n  }\n\n  return transformString;\n}\n\nfunction buildStyleProperty(state, enableHardwareAcceleration, styles, transform, transformOrigin, transformKeys, isDashCase) {\n  if (enableHardwareAcceleration === void 0) {\n    enableHardwareAcceleration = true;\n  }\n\n  if (styles === void 0) {\n    styles = {};\n  }\n\n  if (transform === void 0) {\n    transform = {};\n  }\n\n  if (transformOrigin === void 0) {\n    transformOrigin = {};\n  }\n\n  if (transformKeys === void 0) {\n    transformKeys = [];\n  }\n\n  if (isDashCase === void 0) {\n    isDashCase = false;\n  }\n\n  var transformIsDefault = true;\n  var hasTransform = false;\n  var hasTransformOrigin = false;\n\n  for (var key in state) {\n    var value = state[key];\n    var valueType = getValueType(key);\n    var valueAsType = getValueAsType(value, valueType);\n\n    if (isTransformProp(key)) {\n      hasTransform = true;\n      transform[key] = valueAsType;\n      transformKeys.push(key);\n\n      if (transformIsDefault) {\n        if (valueType[\"default\"] && value !== valueType[\"default\"] || !valueType[\"default\"] && value !== 0) {\n          transformIsDefault = false;\n        }\n      }\n    } else if (isTransformOriginProp(key)) {\n      transformOrigin[key] = valueAsType;\n      hasTransformOrigin = true;\n    } else if (!blacklist.has(key) || !isCustomTemplate(valueAsType)) {\n      styles[prefixer(key, isDashCase)] = valueAsType;\n    }\n  }\n\n  if (hasTransform || typeof state.transform === 'function') {\n    styles.transform = buildTransform(state, transform, transformKeys, transformIsDefault, enableHardwareAcceleration);\n  }\n\n  if (hasTransformOrigin) {\n    styles.transformOrigin = (transformOrigin.originX || '50%') + \" \" + (transformOrigin.originY || '50%') + \" \" + (transformOrigin.originZ || 0);\n  }\n\n  return styles;\n}\n\nfunction createStyleBuilder(enableHardwareAcceleration, isDashCase) {\n  if (enableHardwareAcceleration === void 0) {\n    enableHardwareAcceleration = true;\n  }\n\n  if (isDashCase === void 0) {\n    isDashCase = true;\n  }\n\n  var styles = {};\n  var transform = {};\n  var transformOrigin = {};\n  var transformKeys = [];\n  return function (state) {\n    transformKeys.length = 0;\n    buildStyleProperty(state, enableHardwareAcceleration, styles, transform, transformOrigin, transformKeys, isDashCase);\n    return styles;\n  };\n}\n\nfunction onRead(key, options) {\n  var element = options.element,\n      preparseOutput = options.preparseOutput;\n  var defaultValueType = getValueType(key);\n\n  if (isTransformProp(key)) {\n    return defaultValueType ? defaultValueType[\"default\"] || 0 : 0;\n  } else if (scrollKeys.has(key)) {\n    return element[key];\n  } else {\n    var domValue = window.getComputedStyle(element, null).getPropertyValue(prefixer(key, true)) || 0;\n    return preparseOutput && defaultValueType && defaultValueType.test(domValue) && defaultValueType.parse ? defaultValueType.parse(domValue) : domValue;\n  }\n}\n\nfunction onRender(state, _a, changedValues) {\n  var element = _a.element,\n      buildStyles = _a.buildStyles,\n      hasCSSVariable = _a.hasCSSVariable;\n  Object.assign(element.style, buildStyles(state));\n\n  if (hasCSSVariable) {\n    var numChangedValues = changedValues.length;\n\n    for (var i = 0; i < numChangedValues; i++) {\n      var key = changedValues[i];\n\n      if (key.startsWith('--')) {\n        element.style.setProperty(key, state[key]);\n      }\n    }\n  }\n\n  if (changedValues.indexOf(SCROLL_LEFT) !== -1) {\n    element[SCROLL_LEFT] = state[SCROLL_LEFT];\n  }\n\n  if (changedValues.indexOf(SCROLL_TOP) !== -1) {\n    element[SCROLL_TOP] = state[SCROLL_TOP];\n  }\n}\n\nvar cssStyler =\n/*#__PURE__*/\ncreateStyler({\n  onRead: onRead,\n  onRender: onRender,\n  uncachedValues: scrollKeys\n});\n\nfunction createCssStyler(element, _a) {\n  if (_a === void 0) {\n    _a = {};\n  }\n\n  var enableHardwareAcceleration = _a.enableHardwareAcceleration,\n      props = __rest(_a, [\"enableHardwareAcceleration\"]);\n\n  return cssStyler(_assign({\n    element: element,\n    buildStyles: createStyleBuilder(enableHardwareAcceleration),\n    preparseOutput: true\n  }, props));\n}\n\nvar camelCaseAttributes =\n/*#__PURE__*/\nnew Set(['baseFrequency', 'diffuseConstant', 'kernelMatrix', 'kernelUnitLength', 'keySplines', 'keyTimes', 'limitingConeAngle', 'markerHeight', 'markerWidth', 'numOctaves', 'targetX', 'targetY', 'surfaceScale', 'specularConstant', 'specularExponent', 'stdDeviation', 'tableValues']);\nvar defaultOrigin = 0.5;\n\nvar svgAttrsTemplate = function svgAttrsTemplate() {\n  return {\n    style: {}\n  };\n};\n\nvar progressToPixels = function progressToPixels(progress, length) {\n  return px.transform(progress * length);\n};\n\nvar unmeasured = {\n  x: 0,\n  y: 0,\n  width: 0,\n  height: 0\n};\n\nfunction calcOrigin(origin, offset, size) {\n  return typeof origin === 'string' ? origin : px.transform(offset + size * origin);\n}\n\nfunction calculateSVGTransformOrigin(dimensions, originX, originY) {\n  return calcOrigin(originX, dimensions.x, dimensions.width) + \" \" + calcOrigin(originY, dimensions.y, dimensions.height);\n}\n\nfunction buildSVGAttrs(_a, dimensions, totalPathLength, cssBuilder, attrs, isDashCase) {\n  if (dimensions === void 0) {\n    dimensions = unmeasured;\n  }\n\n  if (cssBuilder === void 0) {\n    cssBuilder = createStyleBuilder(false, false);\n  }\n\n  if (attrs === void 0) {\n    attrs = svgAttrsTemplate();\n  }\n\n  if (isDashCase === void 0) {\n    isDashCase = true;\n  }\n\n  var x = _a.x,\n      y = _a.y,\n      z = _a.z,\n      originX = _a.originX,\n      originY = _a.originY,\n      pathLength = _a.pathLength,\n      _b = _a.pathSpacing,\n      pathSpacing = _b === void 0 ? 1 : _b,\n      _c = _a.pathOffset,\n      pathOffset = _c === void 0 ? 0 : _c,\n      state = __rest(_a, [\"x\", \"y\", \"z\", \"originX\", \"originY\", \"pathLength\", \"pathSpacing\", \"pathOffset\"]);\n\n  var style = cssBuilder(state);\n\n  for (var key in style) {\n    if (key === 'transform') {\n      attrs.style.transform = style[key];\n    } else {\n      var attrKey = isDashCase && !camelCaseAttributes.has(key) ? camelToDash(key) : key;\n      attrs[attrKey] = style[key];\n    }\n  }\n\n  if (originX !== undefined || originY !== undefined || style.transform) {\n    attrs.style.transformOrigin = calculateSVGTransformOrigin(dimensions, originX !== undefined ? originX : defaultOrigin, originY !== undefined ? originY : defaultOrigin);\n  }\n\n  if (x !== undefined) attrs.x = x;\n  if (y !== undefined) attrs.y = y;\n\n  if (totalPathLength !== undefined && pathLength !== undefined) {\n    attrs[isDashCase ? 'stroke-dashoffset' : 'strokeDashoffset'] = progressToPixels(-pathOffset, totalPathLength);\n    attrs[isDashCase ? 'stroke-dasharray' : 'strokeDasharray'] = progressToPixels(pathLength, totalPathLength) + \" \" + progressToPixels(pathSpacing, totalPathLength);\n  }\n\n  return attrs;\n}\n\nfunction createAttrBuilder(dimensions, totalPathLength, isDashCase) {\n  if (isDashCase === void 0) {\n    isDashCase = true;\n  }\n\n  var attrs = svgAttrsTemplate();\n  var cssBuilder = createStyleBuilder(false, false);\n  return function (state) {\n    return buildSVGAttrs(state, dimensions, totalPathLength, cssBuilder, attrs, isDashCase);\n  };\n}\n\nvar getDimensions = function getDimensions(element) {\n  return typeof element.getBBox === 'function' ? element.getBBox() : element.getBoundingClientRect();\n};\n\nvar getSVGElementDimensions = function getSVGElementDimensions(element) {\n  try {\n    return getDimensions(element);\n  } catch (e) {\n    return {\n      x: 0,\n      y: 0,\n      width: 0,\n      height: 0\n    };\n  }\n};\n\nvar isPath = function isPath(element) {\n  return element.tagName === 'path';\n};\n\nvar svgStyler =\n/*#__PURE__*/\ncreateStyler({\n  onRead: function onRead(key, _a) {\n    var element = _a.element;\n    key = !camelCaseAttributes.has(key) ? camelToDash(key) : key;\n\n    if (!isTransformProp(key)) {\n      return element.getAttribute(key);\n    } else {\n      var valueType = getValueType(key);\n      return valueType ? valueType[\"default\"] || 0 : 0;\n    }\n  },\n  onRender: function onRender(state, _a) {\n    var element = _a.element,\n        buildAttrs = _a.buildAttrs;\n    var attrs = buildAttrs(state);\n\n    for (var key in attrs) {\n      if (key === 'style') {\n        Object.assign(element.style, attrs.style);\n      } else {\n        element.setAttribute(key, attrs[key]);\n      }\n    }\n  }\n});\n\nvar svg = function svg(element) {\n  var dimensions = getSVGElementDimensions(element);\n  var pathLength = isPath(element) && element.getTotalLength ? element.getTotalLength() : undefined;\n  return svgStyler({\n    element: element,\n    buildAttrs: createAttrBuilder(dimensions, pathLength)\n  });\n};\n\nvar viewport =\n/*#__PURE__*/\ncreateStyler({\n  useCache: false,\n  onRead: function onRead(key) {\n    return key === 'scrollTop' ? window.pageYOffset : window.pageXOffset;\n  },\n  onRender: function onRender(_a) {\n    var _b = _a.scrollTop,\n        scrollTop = _b === void 0 ? 0 : _b,\n        _c = _a.scrollLeft,\n        scrollLeft = _c === void 0 ? 0 : _c;\n    return window.scrollTo(scrollLeft, scrollTop);\n  }\n});\nvar cache =\n/*#__PURE__*/\nnew WeakMap();\n\nvar createDOMStyler = function createDOMStyler(node, props) {\n  var styler;\n\n  if (node instanceof HTMLElement) {\n    styler = createCssStyler(node, props);\n  } else if (node instanceof SVGElement) {\n    styler = svg(node);\n  } else if (node === window) {\n    styler = viewport(node);\n  }\n\n  invariant(styler !== undefined, 'No valid node provided. Node must be HTMLElement, SVGElement or window.');\n  cache.set(node, styler);\n  return styler;\n};\n\nvar getStyler = function getStyler(node, props) {\n  return cache.has(node) ? cache.get(node) : createDOMStyler(node, props);\n};\n\nfunction index(nodeOrSelector, props) {\n  var node = typeof nodeOrSelector === 'string' ? document.querySelector(nodeOrSelector) : nodeOrSelector;\n  return getStyler(node, props);\n}\n\nexport default index;\nexport { createStyler as createStylerFactory, buildStyleProperty, buildSVGAttrs, transformProps, isTransformProp };","import \"core-js/modules/es6.regexp.split\";\nimport \"core-js/modules/es6.array.is-array\";\nimport \"core-js/modules/es6.array.map\";\nimport \"core-js/modules/es6.array.find\";\nimport \"core-js/modules/es6.array.some\";\nimport \"core-js/modules/es6.array.reduce\";\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.array.index-of\";\nimport \"core-js/modules/es6.array.filter\";\nimport \"core-js/modules/es6.array.for-each\";\nimport { __rest, __assign, __extends } from 'tslib';\nimport { pipe, velocityPerSecond, mixComplex, mixColor, mix, clamp, progress, velocityPerFrame, distance, angle, applyOffset } from '@popmotion/popcorn';\nimport sync, { getFrameData, cancelSync } from 'framesync';\nimport { color, complex, px, percent, degrees, vh, vw, number } from 'style-value-types';\nimport { createReversedEasing, linear, easeOut, easeInOut } from '@popmotion/easing';\nimport { invariant } from 'hey-listen';\n\nvar Observer =\n/*#__PURE__*/\nfunction () {\n  function Observer(_a, observer) {\n    var _this = this;\n\n    var middleware = _a.middleware,\n        onComplete = _a.onComplete;\n    this.isActive = true;\n\n    this.update = function (v) {\n      if (_this.observer.update) _this.updateObserver(v);\n    };\n\n    this.complete = function () {\n      if (_this.observer.complete && _this.isActive) _this.observer.complete();\n      if (_this.onComplete) _this.onComplete();\n      _this.isActive = false;\n    };\n\n    this.error = function (err) {\n      if (_this.observer.error && _this.isActive) _this.observer.error(err);\n      _this.isActive = false;\n    };\n\n    this.observer = observer;\n\n    this.updateObserver = function (v) {\n      return observer.update(v);\n    };\n\n    this.onComplete = onComplete;\n\n    if (observer.update && middleware && middleware.length) {\n      middleware.forEach(function (m) {\n        return _this.updateObserver = m(_this.updateObserver, _this.complete);\n      });\n    }\n  }\n\n  return Observer;\n}();\n\nvar createObserver = function createObserver(observerCandidate, _a, onComplete) {\n  var middleware = _a.middleware;\n\n  if (typeof observerCandidate === 'function') {\n    return new Observer({\n      middleware: middleware,\n      onComplete: onComplete\n    }, {\n      update: observerCandidate\n    });\n  } else {\n    return new Observer({\n      middleware: middleware,\n      onComplete: onComplete\n    }, observerCandidate);\n  }\n};\n\nvar Action =\n/*#__PURE__*/\nfunction () {\n  function Action(props) {\n    if (props === void 0) {\n      props = {};\n    }\n\n    this.props = props;\n  }\n\n  Action.prototype.create = function (props) {\n    return new Action(props);\n  };\n\n  Action.prototype.start = function (observerCandidate) {\n    if (observerCandidate === void 0) {\n      observerCandidate = {};\n    }\n\n    var isComplete = false;\n    var subscription = {\n      stop: function stop() {\n        return undefined;\n      }\n    };\n\n    var _a = this.props,\n        init = _a.init,\n        observerProps = __rest(_a, [\"init\"]);\n\n    var observer = createObserver(observerCandidate, observerProps, function () {\n      isComplete = true;\n      subscription.stop();\n    });\n    var api = init(observer);\n    subscription = api ? __assign({}, subscription, api) : subscription;\n    if (isComplete) subscription.stop();\n    return subscription;\n  };\n\n  Action.prototype.applyMiddleware = function (middleware) {\n    return this.create(__assign({}, this.props, {\n      middleware: this.props.middleware ? [middleware].concat(this.props.middleware) : [middleware]\n    }));\n  };\n\n  Action.prototype.pipe = function () {\n    var funcs = [];\n\n    for (var _i = 0; _i < arguments.length; _i++) {\n      funcs[_i] = arguments[_i];\n    }\n\n    var pipedUpdate = funcs.length === 1 ? funcs[0] : pipe.apply(void 0, funcs);\n    return this.applyMiddleware(function (update) {\n      return function (v) {\n        return update(pipedUpdate(v));\n      };\n    });\n  };\n\n  return Action;\n}();\n\nvar action = function action(init) {\n  return new Action({\n    init: init\n  });\n};\n\nvar Chainable =\n/*#__PURE__*/\nfunction () {\n  function Chainable(props) {\n    if (props === void 0) {\n      props = {};\n    }\n\n    this.props = props;\n  }\n\n  Chainable.prototype.applyMiddleware = function (middleware) {\n    return this.create(__assign({}, this.props, {\n      middleware: this.props.middleware ? [middleware].concat(this.props.middleware) : [middleware]\n    }));\n  };\n\n  Chainable.prototype.pipe = function () {\n    var funcs = [];\n\n    for (var _i = 0; _i < arguments.length; _i++) {\n      funcs[_i] = arguments[_i];\n    }\n\n    var pipedUpdate = funcs.length === 1 ? funcs[0] : pipe.apply(void 0, funcs);\n    return this.applyMiddleware(function (update) {\n      return function (v) {\n        return update(pipedUpdate(v));\n      };\n    });\n  };\n\n  Chainable.prototype[\"while\"] = function (predicate) {\n    return this.applyMiddleware(function (update, complete) {\n      return function (v) {\n        return predicate(v) ? update(v) : complete();\n      };\n    });\n  };\n\n  Chainable.prototype.filter = function (predicate) {\n    return this.applyMiddleware(function (update) {\n      return function (v) {\n        return predicate(v) && update(v);\n      };\n    });\n  };\n\n  return Chainable;\n}();\n\nvar BaseMulticast =\n/*#__PURE__*/\nfunction (_super) {\n  __extends(BaseMulticast, _super);\n\n  function BaseMulticast() {\n    var _this = _super !== null && _super.apply(this, arguments) || this;\n\n    _this.subscribers = [];\n    return _this;\n  }\n\n  BaseMulticast.prototype.complete = function () {\n    this.subscribers.forEach(function (subscriber) {\n      return subscriber.complete();\n    });\n  };\n\n  BaseMulticast.prototype.error = function (err) {\n    this.subscribers.forEach(function (subscriber) {\n      return subscriber.error(err);\n    });\n  };\n\n  BaseMulticast.prototype.update = function (v) {\n    for (var i = 0; i < this.subscribers.length; i++) {\n      this.subscribers[i].update(v);\n    }\n  };\n\n  BaseMulticast.prototype.subscribe = function (observerCandidate) {\n    var _this = this;\n\n    var observer = createObserver(observerCandidate, this.props);\n    this.subscribers.push(observer);\n    var subscription = {\n      unsubscribe: function unsubscribe() {\n        var index = _this.subscribers.indexOf(observer);\n\n        if (index !== -1) _this.subscribers.splice(index, 1);\n      }\n    };\n    return subscription;\n  };\n\n  BaseMulticast.prototype.stop = function () {\n    if (this.parent) this.parent.stop();\n  };\n\n  return BaseMulticast;\n}(Chainable);\n\nvar Multicast =\n/*#__PURE__*/\nfunction (_super) {\n  __extends(Multicast, _super);\n\n  function Multicast() {\n    return _super !== null && _super.apply(this, arguments) || this;\n  }\n\n  Multicast.prototype.create = function (props) {\n    return new Multicast(props);\n  };\n\n  return Multicast;\n}(BaseMulticast);\n\nvar multicast = function multicast() {\n  return new Multicast();\n};\n\nvar ValueReaction =\n/*#__PURE__*/\nfunction (_super) {\n  __extends(ValueReaction, _super);\n\n  function ValueReaction(props) {\n    var _this = _super.call(this, props) || this;\n\n    _this.scheduleVelocityCheck = function () {\n      return sync.postRender(_this.velocityCheck);\n    };\n\n    _this.velocityCheck = function (_a) {\n      var timestamp = _a.timestamp;\n\n      if (timestamp !== _this.lastUpdated) {\n        _this.prev = _this.current;\n      }\n    };\n\n    _this.prev = _this.current = props.value || 0;\n\n    _this.updateCurrent = function (v) {\n      return _this.current = v;\n    };\n\n    _this.getVelocityOfCurrent = function () {\n      return _this.getSingleVelocity(_this.current, _this.prev);\n    };\n\n    if (props.initialSubscription) _this.subscribe(props.initialSubscription);\n    return _this;\n  }\n\n  ValueReaction.prototype.create = function (props) {\n    return new ValueReaction(props);\n  };\n\n  ValueReaction.prototype.get = function () {\n    return this.current;\n  };\n\n  ValueReaction.prototype.getVelocity = function () {\n    return this.getVelocityOfCurrent();\n  };\n\n  ValueReaction.prototype.update = function (v) {\n    _super.prototype.update.call(this, v);\n\n    this.prev = this.current;\n    this.updateCurrent(v);\n\n    var _a = getFrameData(),\n        delta = _a.delta,\n        timestamp = _a.timestamp;\n\n    this.timeDelta = delta;\n    this.lastUpdated = timestamp;\n    sync.postRender(this.scheduleVelocityCheck);\n  };\n\n  ValueReaction.prototype.subscribe = function (observerCandidate) {\n    var sub = _super.prototype.subscribe.call(this, observerCandidate);\n\n    this.subscribers[this.subscribers.length - 1].update(this.current);\n    return sub;\n  };\n\n  ValueReaction.prototype.getSingleVelocity = function (current, prev) {\n    return typeof current === 'number' && typeof prev === 'number' ? velocityPerSecond(current - prev, this.timeDelta) : velocityPerSecond(parseFloat(current) - parseFloat(prev), this.timeDelta) || 0;\n  };\n\n  return ValueReaction;\n}(BaseMulticast);\n\nvar value = function value(_value, initialSubscription) {\n  return new ValueReaction({\n    value: _value,\n    initialSubscription: initialSubscription\n  });\n};\n\nvar createVectorTests = function createVectorTests(typeTests) {\n  var testNames = Object.keys(typeTests);\n\n  var isVectorProp = function isVectorProp(prop, key) {\n    return prop !== undefined && !typeTests[key](prop);\n  };\n\n  var getVectorKeys = function getVectorKeys(props) {\n    return testNames.reduce(function (vectorKeys, key) {\n      if (isVectorProp(props[key], key)) vectorKeys.push(key);\n      return vectorKeys;\n    }, []);\n  };\n\n  var testVectorProps = function testVectorProps(props) {\n    return props && testNames.some(function (key) {\n      return isVectorProp(props[key], key);\n    });\n  };\n\n  return {\n    getVectorKeys: getVectorKeys,\n    testVectorProps: testVectorProps\n  };\n};\n\nvar unitTypes = [px, percent, degrees, vh, vw];\n\nvar findUnitType = function findUnitType(prop) {\n  return unitTypes.find(function (type) {\n    return type.test(prop);\n  });\n};\n\nvar isUnitProp = function isUnitProp(prop) {\n  return Boolean(findUnitType(prop));\n};\n\nvar createAction = function createAction(action, props) {\n  return action(props);\n};\n\nvar createUnitAction = function createUnitAction(action, _a) {\n  var from = _a.from,\n      to = _a.to,\n      props = __rest(_a, [\"from\", \"to\"]);\n\n  var unitType = findUnitType(from) || findUnitType(to);\n  var transform = unitType.transform,\n      parse = unitType.parse;\n  return action(__assign({}, props, {\n    from: typeof from === 'string' ? parse(from) : from,\n    to: typeof to === 'string' ? parse(to) : to\n  })).pipe(transform);\n};\n\nvar createMixerAction = function createMixerAction(mixer) {\n  return function (action, _a) {\n    var from = _a.from,\n        to = _a.to,\n        props = __rest(_a, [\"from\", \"to\"]);\n\n    return action(__assign({}, props, {\n      from: 0,\n      to: 1\n    })).pipe(mixer(from, to));\n  };\n};\n\nvar createColorAction =\n/*#__PURE__*/\ncreateMixerAction(mixColor);\nvar createComplexAction =\n/*#__PURE__*/\ncreateMixerAction(mixComplex);\n\nvar createVectorAction = function createVectorAction(action, typeTests) {\n  var _a = createVectorTests(typeTests),\n      testVectorProps = _a.testVectorProps,\n      getVectorKeys = _a.getVectorKeys;\n\n  var vectorAction = function vectorAction(props) {\n    var isVector = testVectorProps(props);\n    if (!isVector) return action(props);\n    var vectorKeys = getVectorKeys(props);\n    var testKey = vectorKeys[0];\n    var testProp = props[testKey];\n    return getActionCreator(testProp)(action, props, vectorKeys);\n  };\n\n  return vectorAction;\n};\n\nvar getActionCreator = function getActionCreator(prop) {\n  if (typeof prop === 'number') {\n    return createAction;\n  } else if (isUnitProp(prop)) {\n    return createUnitAction;\n  } else if (color.test(prop)) {\n    return createColorAction;\n  } else if (complex.test(prop)) {\n    return createComplexAction;\n  } else {\n    return createAction;\n  }\n};\n\nvar decay = function decay(props) {\n  if (props === void 0) {\n    props = {};\n  }\n\n  return action(function (_a) {\n    var complete = _a.complete,\n        update = _a.update;\n    var _b = props.velocity,\n        velocity = _b === void 0 ? 0 : _b,\n        _c = props.from,\n        from = _c === void 0 ? 0 : _c,\n        _d = props.power,\n        power = _d === void 0 ? 0.8 : _d,\n        _e = props.timeConstant,\n        timeConstant = _e === void 0 ? 350 : _e,\n        _f = props.restDelta,\n        restDelta = _f === void 0 ? 0.5 : _f,\n        modifyTarget = props.modifyTarget;\n    var elapsed = 0;\n    var amplitude = power * velocity;\n    var idealTarget = Math.round(from + amplitude);\n    var target = typeof modifyTarget === 'undefined' ? idealTarget : modifyTarget(idealTarget);\n    var process = sync.update(function (_a) {\n      var frameDelta = _a.delta;\n      elapsed += frameDelta;\n      var delta = -amplitude * Math.exp(-elapsed / timeConstant);\n      var isMoving = delta > restDelta || delta < -restDelta;\n      var current = isMoving ? target + delta : target;\n      update(current);\n\n      if (!isMoving) {\n        cancelSync.update(process);\n        complete();\n      }\n    }, true);\n    return {\n      stop: function stop() {\n        return cancelSync.update(process);\n      }\n    };\n  });\n};\n\nvar vectorDecay =\n/*#__PURE__*/\ncreateVectorAction(decay, {\n  from: number.test,\n  modifyTarget: function modifyTarget(func) {\n    return typeof func === 'function';\n  },\n  velocity: number.test\n});\n\nvar spring = function spring(props) {\n  if (props === void 0) {\n    props = {};\n  }\n\n  return action(function (_a) {\n    var update = _a.update,\n        complete = _a.complete;\n    var _b = props.velocity,\n        velocity = _b === void 0 ? 0.0 : _b;\n    var _c = props.from,\n        from = _c === void 0 ? 0.0 : _c,\n        _d = props.to,\n        to = _d === void 0 ? 0.0 : _d,\n        _e = props.stiffness,\n        stiffness = _e === void 0 ? 100 : _e,\n        _f = props.damping,\n        damping = _f === void 0 ? 10 : _f,\n        _g = props.mass,\n        mass = _g === void 0 ? 1.0 : _g,\n        _h = props.restSpeed,\n        restSpeed = _h === void 0 ? 0.01 : _h,\n        _j = props.restDelta,\n        restDelta = _j === void 0 ? 0.01 : _j;\n    var initialVelocity = velocity ? -(velocity / 1000) : 0.0;\n    var t = 0;\n    var delta = to - from;\n    var position = from;\n    var prevPosition = position;\n    var process = sync.update(function (_a) {\n      var timeDelta = _a.delta;\n      t += timeDelta;\n      var dampingRatio = damping / (2 * Math.sqrt(stiffness * mass));\n      var angularFreq = Math.sqrt(stiffness / mass) / 1000;\n      prevPosition = position;\n\n      if (dampingRatio < 1) {\n        var envelope = Math.exp(-dampingRatio * angularFreq * t);\n        var expoDecay = angularFreq * Math.sqrt(1.0 - dampingRatio * dampingRatio);\n        position = to - envelope * ((initialVelocity + dampingRatio * angularFreq * delta) / expoDecay * Math.sin(expoDecay * t) + delta * Math.cos(expoDecay * t));\n      } else {\n        var envelope = Math.exp(-angularFreq * t);\n        position = to - envelope * (delta + (initialVelocity + angularFreq * delta) * t);\n      }\n\n      velocity = velocityPerSecond(position - prevPosition, timeDelta);\n      var isBelowVelocityThreshold = Math.abs(velocity) <= restSpeed;\n      var isBelowDisplacementThreshold = Math.abs(to - position) <= restDelta;\n\n      if (isBelowVelocityThreshold && isBelowDisplacementThreshold) {\n        position = to;\n        update(position);\n        cancelSync.update(process);\n        complete();\n      } else {\n        update(position);\n      }\n    }, true);\n    return {\n      stop: function stop() {\n        return cancelSync.update(process);\n      }\n    };\n  });\n};\n\nvar vectorSpring =\n/*#__PURE__*/\ncreateVectorAction(spring, {\n  from: number.test,\n  to: number.test,\n  stiffness: number.test,\n  damping: number.test,\n  mass: number.test,\n  velocity: number.test\n});\n\nvar inertia = function inertia(_a) {\n  var _b = _a.from,\n      from = _b === void 0 ? 0 : _b,\n      _c = _a.velocity,\n      velocity = _c === void 0 ? 0 : _c,\n      min = _a.min,\n      max = _a.max,\n      _d = _a.power,\n      power = _d === void 0 ? 0.8 : _d,\n      _e = _a.timeConstant,\n      timeConstant = _e === void 0 ? 700 : _e,\n      _f = _a.bounceStiffness,\n      bounceStiffness = _f === void 0 ? 500 : _f,\n      _g = _a.bounceDamping,\n      bounceDamping = _g === void 0 ? 10 : _g,\n      _h = _a.restDelta,\n      restDelta = _h === void 0 ? 1 : _h,\n      modifyTarget = _a.modifyTarget;\n  return action(function (_a) {\n    var update = _a.update,\n        _complete = _a.complete;\n    var prev = from;\n    var current = from;\n    var activeAnimation;\n    var isSpring = false;\n\n    var isLessThanMin = function isLessThanMin(v) {\n      return min !== undefined && v <= min;\n    };\n\n    var isMoreThanMax = function isMoreThanMax(v) {\n      return max !== undefined && v >= max;\n    };\n\n    var isOutOfBounds = function isOutOfBounds(v) {\n      return isLessThanMin(v) || isMoreThanMax(v);\n    };\n\n    var isTravellingAwayFromBounds = function isTravellingAwayFromBounds(v, currentVelocity) {\n      return isLessThanMin(v) && currentVelocity < 0 || isMoreThanMax(v) && currentVelocity > 0;\n    };\n\n    var onUpdate = function onUpdate(v) {\n      update(v);\n      prev = current;\n      current = v;\n      velocity = velocityPerSecond(current - prev, getFrameData().delta);\n\n      if (activeAnimation && !isSpring && isTravellingAwayFromBounds(v, velocity)) {\n        startSpring({\n          from: v,\n          velocity: velocity\n        });\n      }\n    };\n\n    var startAnimation = function startAnimation(animation, next) {\n      activeAnimation && activeAnimation.stop();\n      activeAnimation = animation.start({\n        update: onUpdate,\n        complete: function complete() {\n          if (next) {\n            next();\n            return;\n          }\n\n          _complete();\n        }\n      });\n    };\n\n    var startSpring = function startSpring(props) {\n      isSpring = true;\n      startAnimation(vectorSpring(__assign({}, props, {\n        to: isLessThanMin(props.from) ? min : max,\n        stiffness: bounceStiffness,\n        damping: bounceDamping,\n        restDelta: restDelta\n      })));\n    };\n\n    if (isOutOfBounds(from)) {\n      startSpring({\n        from: from,\n        velocity: velocity\n      });\n    } else if (velocity !== 0) {\n      var animation = vectorDecay({\n        from: from,\n        velocity: velocity,\n        timeConstant: timeConstant,\n        power: power,\n        restDelta: isOutOfBounds(from) ? 20 : restDelta,\n        modifyTarget: modifyTarget\n      });\n      startAnimation(animation, function () {\n        if (isOutOfBounds(current)) {\n          startSpring({\n            from: current,\n            velocity: velocity\n          });\n        } else {\n          _complete();\n        }\n      });\n    } else {\n      _complete();\n    }\n\n    return {\n      stop: function stop() {\n        return activeAnimation && activeAnimation.stop();\n      }\n    };\n  });\n};\n\nvar index =\n/*#__PURE__*/\ncreateVectorAction(inertia, {\n  from: number.test,\n  velocity: number.test,\n  min: number.test,\n  max: number.test,\n  damping: number.test,\n  stiffness: number.test,\n  modifyTarget: function modifyTarget(func) {\n    return typeof func === 'function';\n  }\n});\n\nvar frame = function frame() {\n  return action(function (_a) {\n    var update = _a.update;\n    var initialTime = 0;\n    var process = sync.update(function (_a) {\n      var timestamp = _a.timestamp;\n      if (!initialTime) initialTime = timestamp;\n      update(timestamp - initialTime);\n    }, true, true);\n    return {\n      stop: function stop() {\n        return cancelSync.update(process);\n      }\n    };\n  });\n};\n\nvar scrubber = function scrubber(_a) {\n  var _b = _a.from,\n      from = _b === void 0 ? 0 : _b,\n      _c = _a.to,\n      to = _c === void 0 ? 1 : _c,\n      _d = _a.ease,\n      ease = _d === void 0 ? linear : _d,\n      _e = _a.reverseEase,\n      reverseEase = _e === void 0 ? false : _e;\n\n  if (reverseEase) {\n    ease = createReversedEasing(ease);\n  }\n\n  return action(function (_a) {\n    var update = _a.update;\n    return {\n      seek: function seek(progress) {\n        return update(progress);\n      }\n    };\n  }).pipe(ease, function (v) {\n    return mix(from, to, v);\n  });\n};\n\nvar vectorScrubber =\n/*#__PURE__*/\ncreateVectorAction(scrubber, {\n  ease: function ease(func) {\n    return typeof func === 'function';\n  },\n  from: number.test,\n  to: number.test\n});\nvar clampProgress =\n/*#__PURE__*/\nclamp(0, 1);\n\nvar tween = function tween(props) {\n  if (props === void 0) {\n    props = {};\n  }\n\n  return action(function (_a) {\n    var update = _a.update,\n        complete = _a.complete;\n    var _b = props.duration,\n        duration = _b === void 0 ? 300 : _b,\n        _c = props.ease,\n        ease = _c === void 0 ? easeOut : _c,\n        _d = props.flip,\n        flip = _d === void 0 ? 0 : _d,\n        _e = props.loop,\n        loop = _e === void 0 ? 0 : _e,\n        _f = props.yoyo,\n        yoyo = _f === void 0 ? 0 : _f,\n        _g = props.repeatDelay,\n        repeatDelay = _g === void 0 ? 0 : _g;\n    var _h = props.from,\n        from = _h === void 0 ? 0 : _h,\n        _j = props.to,\n        to = _j === void 0 ? 1 : _j,\n        _k = props.elapsed,\n        elapsed = _k === void 0 ? 0 : _k,\n        _l = props.flipCount,\n        flipCount = _l === void 0 ? 0 : _l,\n        _m = props.yoyoCount,\n        yoyoCount = _m === void 0 ? 0 : _m,\n        _o = props.loopCount,\n        loopCount = _o === void 0 ? 0 : _o;\n    var playhead = vectorScrubber({\n      from: from,\n      to: to,\n      ease: ease\n    }).start(update);\n    var currentProgress = 0;\n    var process;\n    var _isActive = false;\n\n    var reverseAnimation = function reverseAnimation(reverseEase) {\n      var _a;\n\n      if (reverseEase === void 0) {\n        reverseEase = false;\n      }\n\n      _a = [to, from], from = _a[0], to = _a[1];\n      playhead = vectorScrubber({\n        from: from,\n        to: to,\n        ease: ease,\n        reverseEase: reverseEase\n      }).start(update);\n    };\n\n    var isTweenComplete = function isTweenComplete() {\n      var isComplete = _isActive && elapsed > duration + repeatDelay;\n      if (!isComplete) return false;\n      if (isComplete && !loop && !flip && !yoyo) return true;\n      var overtime = elapsed - duration;\n      elapsed = overtime - repeatDelay;\n\n      if (loop && loopCount < loop) {\n        loopCount++;\n        return false;\n      } else if (flip && flipCount < flip) {\n        flipCount++;\n        reverseAnimation();\n        return false;\n      } else if (yoyo && yoyoCount < yoyo) {\n        yoyoCount++;\n        reverseAnimation(yoyoCount % 2 !== 0);\n        return false;\n      }\n\n      return true;\n    };\n\n    var updateTween = function updateTween() {\n      currentProgress = clampProgress(progress(0, duration, elapsed));\n      playhead.seek(currentProgress);\n    };\n\n    var startTimer = function startTimer() {\n      _isActive = true;\n      process = sync.update(function (_a) {\n        var delta = _a.delta;\n        elapsed += delta;\n        updateTween();\n\n        if (isTweenComplete()) {\n          cancelSync.update(process);\n          complete && sync.update(complete, false, true);\n        }\n      }, true);\n    };\n\n    var stopTimer = function stopTimer() {\n      _isActive = false;\n      if (process) cancelSync.update(process);\n    };\n\n    startTimer();\n    return {\n      isActive: function isActive() {\n        return _isActive;\n      },\n      getElapsed: function getElapsed() {\n        return clamp(0, duration, elapsed);\n      },\n      getProgress: function getProgress() {\n        return currentProgress;\n      },\n      stop: function stop() {\n        stopTimer();\n      },\n      pause: function pause() {\n        stopTimer();\n        return this;\n      },\n      resume: function resume() {\n        if (!_isActive) startTimer();\n        return this;\n      },\n      seek: function seek(newProgress) {\n        elapsed = mix(0, duration, newProgress);\n        sync.update(updateTween, false, true);\n        return this;\n      },\n      reverse: function reverse() {\n        reverseAnimation();\n        return this;\n      }\n    };\n  });\n};\n\nvar clampProgress$1 =\n/*#__PURE__*/\nclamp(0, 1);\n\nvar defaultEasings = function defaultEasings(values, easing) {\n  return values.map(function () {\n    return easing || easeOut;\n  }).splice(0, values.length - 1);\n};\n\nvar defaultTimings = function defaultTimings(values) {\n  var numValues = values.length;\n  return values.map(function (value, i) {\n    return i !== 0 ? i / (numValues - 1) : 0;\n  });\n};\n\nvar interpolateScrubbers = function interpolateScrubbers(input, scrubbers, update) {\n  var rangeLength = input.length;\n  var finalInputIndex = rangeLength - 1;\n  var finalScrubberIndex = finalInputIndex - 1;\n  var subs = scrubbers.map(function (scrub) {\n    return scrub.start(update);\n  });\n  return function (v) {\n    if (v <= input[0]) {\n      subs[0].seek(0);\n    }\n\n    if (v >= input[finalInputIndex]) {\n      subs[finalScrubberIndex].seek(1);\n    }\n\n    var i = 1;\n\n    for (; i < rangeLength; i++) {\n      if (input[i] > v || i === finalInputIndex) break;\n    }\n\n    var progressInRange = progress(input[i - 1], input[i], v);\n    subs[i - 1].seek(clampProgress$1(progressInRange));\n  };\n};\n\nvar keyframes = function keyframes(_a) {\n  var easings = _a.easings,\n      _b = _a.ease,\n      ease = _b === void 0 ? linear : _b,\n      times = _a.times,\n      values = _a.values,\n      tweenProps = __rest(_a, [\"easings\", \"ease\", \"times\", \"values\"]);\n\n  easings = Array.isArray(easings) ? easings : defaultEasings(values, easings);\n  times = times || defaultTimings(values);\n  var scrubbers = easings.map(function (easing, i) {\n    return vectorScrubber({\n      from: values[i],\n      to: values[i + 1],\n      ease: easing\n    });\n  });\n  return tween(__assign({}, tweenProps, {\n    ease: ease\n  })).applyMiddleware(function (update) {\n    return interpolateScrubbers(times, scrubbers, update);\n  });\n};\n\nvar physics = function physics(props) {\n  if (props === void 0) {\n    props = {};\n  }\n\n  return action(function (_a) {\n    var complete = _a.complete,\n        update = _a.update;\n    var _b = props.acceleration,\n        acceleration = _b === void 0 ? 0 : _b,\n        _c = props.friction,\n        friction = _c === void 0 ? 0 : _c,\n        _d = props.velocity,\n        velocity = _d === void 0 ? 0 : _d,\n        springStrength = props.springStrength,\n        to = props.to;\n    var _e = props.restSpeed,\n        restSpeed = _e === void 0 ? 0.001 : _e,\n        _f = props.from,\n        from = _f === void 0 ? 0 : _f;\n    var current = from;\n    var process = sync.update(function (_a) {\n      var delta = _a.delta;\n      var elapsed = Math.max(delta, 16);\n      if (acceleration) velocity += velocityPerFrame(acceleration, elapsed);\n      if (friction) velocity *= Math.pow(1 - friction, elapsed / 100);\n\n      if (springStrength !== undefined && to !== undefined) {\n        var distanceToTarget = to - current;\n        velocity += distanceToTarget * velocityPerFrame(springStrength, elapsed);\n      }\n\n      current += velocityPerFrame(velocity, elapsed);\n      update(current);\n      var isComplete = restSpeed !== false && (!velocity || Math.abs(velocity) <= restSpeed);\n\n      if (isComplete) {\n        cancelSync.update(process);\n        complete();\n      }\n    }, true);\n    return {\n      set: function set(v) {\n        current = v;\n        return this;\n      },\n      setAcceleration: function setAcceleration(v) {\n        acceleration = v;\n        return this;\n      },\n      setFriction: function setFriction(v) {\n        friction = v;\n        return this;\n      },\n      setSpringStrength: function setSpringStrength(v) {\n        springStrength = v;\n        return this;\n      },\n      setSpringTarget: function setSpringTarget(v) {\n        to = v;\n        return this;\n      },\n      setVelocity: function setVelocity(v) {\n        velocity = v;\n        return this;\n      },\n      stop: function stop() {\n        return cancelSync.update(process);\n      }\n    };\n  });\n};\n\nvar vectorPhysics =\n/*#__PURE__*/\ncreateVectorAction(physics, {\n  acceleration: number.test,\n  friction: number.test,\n  velocity: number.test,\n  from: number.test,\n  to: number.test,\n  springStrength: number.test\n});\n\nvar multi = function multi(_a) {\n  var getCount = _a.getCount,\n      getFirst = _a.getFirst,\n      getOutput = _a.getOutput,\n      mapApi = _a.mapApi,\n      setProp = _a.setProp,\n      startActions = _a.startActions;\n  return function (actions) {\n    return action(function (_a) {\n      var update = _a.update,\n          _complete2 = _a.complete,\n          error = _a.error;\n      var numActions = getCount(actions);\n      var output = getOutput();\n\n      var updateOutput = function updateOutput() {\n        return update(output);\n      };\n\n      var numCompletedActions = 0;\n      var subs = startActions(actions, function (a, name) {\n        var hasCompleted = false;\n        return a.start({\n          complete: function complete() {\n            if (!hasCompleted) {\n              hasCompleted = true;\n              numCompletedActions++;\n              if (numCompletedActions === numActions) sync.update(_complete2);\n            }\n          },\n          error: error,\n          update: function update(v) {\n            setProp(output, name, v);\n            sync.update(updateOutput, false, true);\n          }\n        });\n      });\n      return Object.keys(getFirst(subs)).reduce(function (api, methodName) {\n        api[methodName] = mapApi(subs, methodName);\n        return api;\n      }, {});\n    });\n  };\n};\n\nvar composite =\n/*#__PURE__*/\nmulti({\n  getOutput: function getOutput() {\n    return {};\n  },\n  getCount: function getCount(subs) {\n    return Object.keys(subs).length;\n  },\n  getFirst: function getFirst(subs) {\n    return subs[Object.keys(subs)[0]];\n  },\n  mapApi: function mapApi(subs, methodName) {\n    return function () {\n      var args = [];\n\n      for (var _i = 0; _i < arguments.length; _i++) {\n        args[_i] = arguments[_i];\n      }\n\n      return Object.keys(subs).reduce(function (output, propKey) {\n        var _a;\n\n        if (subs[propKey][methodName]) {\n          args[0] && args[0][propKey] !== undefined ? output[propKey] = subs[propKey][methodName](args[0][propKey]) : output[propKey] = (_a = subs[propKey])[methodName].apply(_a, args);\n        }\n\n        return output;\n      }, {});\n    };\n  },\n  setProp: function setProp(output, name, v) {\n    return output[name] = v;\n  },\n  startActions: function startActions(actions, starter) {\n    return Object.keys(actions).reduce(function (subs, key) {\n      subs[key] = starter(actions[key], key);\n      return subs;\n    }, {});\n  }\n});\nvar DEFAULT_DURATION = 300;\n\nvar flattenTimings = function flattenTimings(instructions) {\n  var flatInstructions = [];\n  var lastArg = instructions[instructions.length - 1];\n  var isStaggered = typeof lastArg === 'number';\n  var staggerDelay = isStaggered ? lastArg : 0;\n  var segments = isStaggered ? instructions.slice(0, -1) : instructions;\n  var numSegments = segments.length;\n  var offset = 0;\n  segments.forEach(function (item, i) {\n    flatInstructions.push(item);\n\n    if (i !== numSegments - 1) {\n      var duration = item.duration || DEFAULT_DURATION;\n      offset += staggerDelay;\n      flatInstructions.push(\"-\" + (duration - offset));\n    }\n  });\n  return flatInstructions;\n};\n\nvar flattenArrayInstructions = function flattenArrayInstructions(instructions, instruction) {\n  Array.isArray(instruction) ? instructions.push.apply(instructions, flattenTimings(instruction)) : instructions.push(instruction);\n  return instructions;\n};\n\nvar convertDefToProps = function convertDefToProps(props, def, i) {\n  var duration = props.duration,\n      easings = props.easings,\n      times = props.times,\n      values = props.values;\n  var numValues = values.length;\n  var prevTimeTo = times[numValues - 1];\n  var timeFrom = def.at === 0 ? 0 : def.at / duration;\n  var timeTo = (def.at + def.duration) / duration;\n\n  if (i === 0) {\n    values.push(def.from);\n    times.push(timeFrom);\n  } else {\n    if (prevTimeTo !== timeFrom) {\n      if (def.from !== undefined) {\n        values.push(values[numValues - 1]);\n        times.push(timeFrom);\n        easings.push(linear);\n      }\n\n      var from = def.from !== undefined ? def.from : values[numValues - 1];\n      values.push(from);\n      times.push(timeFrom);\n      easings.push(linear);\n    } else if (def.from !== undefined) {\n      values.push(def.from);\n      times.push(timeFrom);\n      easings.push(linear);\n    }\n  }\n\n  values.push(def.to);\n  times.push(timeTo);\n  easings.push(def.ease || easeInOut);\n  return props;\n};\n\nvar timeline = function timeline(instructions, _a) {\n  var _b = _a === void 0 ? {} : _a,\n      duration = _b.duration,\n      elapsed = _b.elapsed,\n      ease = _b.ease,\n      loop = _b.loop,\n      flip = _b.flip,\n      yoyo = _b.yoyo;\n\n  var playhead = 0;\n  var calculatedDuration = 0;\n  var flatInstructions = instructions.reduce(flattenArrayInstructions, []);\n  var animationDefs = [];\n  flatInstructions.forEach(function (instruction) {\n    if (typeof instruction === 'string') {\n      playhead += parseFloat(instruction);\n    } else if (typeof instruction === 'number') {\n      playhead = instruction;\n    } else {\n      var def = __assign({}, instruction, {\n        at: playhead\n      });\n\n      def.duration = def.duration === undefined ? DEFAULT_DURATION : def.duration;\n      animationDefs.push(def);\n      playhead += def.duration;\n      calculatedDuration = Math.max(calculatedDuration, def.at + def.duration);\n    }\n  });\n  var tracks = {};\n  var numDefs = animationDefs.length;\n\n  for (var i = 0; i < numDefs; i++) {\n    var def = animationDefs[i];\n    var track = def.track;\n\n    if (track === undefined) {\n      throw new Error('No track defined');\n    }\n\n    if (!tracks.hasOwnProperty(track)) tracks[track] = [];\n    tracks[track].push(def);\n  }\n\n  var trackKeyframes = {};\n\n  for (var key in tracks) {\n    if (tracks.hasOwnProperty(key)) {\n      var keyframeProps = tracks[key].reduce(convertDefToProps, {\n        duration: calculatedDuration,\n        easings: [],\n        times: [],\n        values: []\n      });\n      trackKeyframes[key] = keyframes(__assign({}, keyframeProps, {\n        duration: duration || calculatedDuration,\n        ease: ease,\n        elapsed: elapsed,\n        loop: loop,\n        yoyo: yoyo,\n        flip: flip\n      }));\n    }\n  }\n\n  return composite(trackKeyframes);\n};\n\nvar listen = function listen(element, events, options) {\n  return action(function (_a) {\n    var update = _a.update;\n    var eventNames = events.split(' ').map(function (eventName) {\n      element.addEventListener(eventName, update, options);\n      return eventName;\n    });\n    return {\n      stop: function stop() {\n        return eventNames.forEach(function (eventName) {\n          return element.removeEventListener(eventName, update, options);\n        });\n      }\n    };\n  });\n};\n\nvar defaultPointerPos = function defaultPointerPos() {\n  return {\n    clientX: 0,\n    clientY: 0,\n    pageX: 0,\n    pageY: 0,\n    x: 0,\n    y: 0\n  };\n};\n\nvar eventToPoint = function eventToPoint(e, point) {\n  if (point === void 0) {\n    point = defaultPointerPos();\n  }\n\n  point.clientX = point.x = e.clientX;\n  point.clientY = point.y = e.clientY;\n  point.pageX = e.pageX;\n  point.pageY = e.pageY;\n  return point;\n};\n\nvar points = [\n/*#__PURE__*/\ndefaultPointerPos()];\nvar isTouchDevice = false;\n\nif (typeof document !== 'undefined') {\n  var updatePointsLocation = function updatePointsLocation(_a) {\n    var touches = _a.touches;\n    isTouchDevice = true;\n    var numTouches = touches.length;\n    points.length = 0;\n\n    for (var i = 0; i < numTouches; i++) {\n      var thisTouch = touches[i];\n      points.push(eventToPoint(thisTouch));\n    }\n  };\n\n  listen(document, 'touchstart touchmove', {\n    passive: true,\n    capture: true\n  }).start(updatePointsLocation);\n}\n\nvar multitouch = function multitouch(_a) {\n  var _b = _a === void 0 ? {} : _a,\n      _c = _b.preventDefault,\n      preventDefault = _c === void 0 ? true : _c,\n      _d = _b.scale,\n      scale = _d === void 0 ? 1.0 : _d,\n      _e = _b.rotate,\n      rotate = _e === void 0 ? 0.0 : _e;\n\n  return action(function (_a) {\n    var update = _a.update;\n    var output = {\n      touches: points,\n      scale: scale,\n      rotate: rotate\n    };\n    var initialDistance = 0.0;\n    var initialRotation = 0.0;\n    var isGesture = points.length > 1;\n\n    if (isGesture) {\n      var firstTouch = points[0],\n          secondTouch = points[1];\n      initialDistance = distance(firstTouch, secondTouch);\n      initialRotation = angle(firstTouch, secondTouch);\n    }\n\n    var updatePoint = function updatePoint() {\n      if (isGesture) {\n        var firstTouch = points[0],\n            secondTouch = points[1];\n        var newDistance = distance(firstTouch, secondTouch);\n        var newRotation = angle(firstTouch, secondTouch);\n        output.scale = scale * (newDistance / initialDistance);\n        output.rotate = rotate + (newRotation - initialRotation);\n      }\n\n      update(output);\n    };\n\n    var onMove = function onMove(e) {\n      if (preventDefault || e.touches.length > 1) e.preventDefault();\n      sync.update(updatePoint);\n    };\n\n    var updateOnMove = listen(document, 'touchmove', {\n      passive: !preventDefault\n    }).start(onMove);\n    if (isTouchDevice) sync.update(updatePoint);\n    return {\n      stop: function stop() {\n        cancelSync.update(updatePoint);\n        updateOnMove.stop();\n      }\n    };\n  });\n};\n\nvar getIsTouchDevice = function getIsTouchDevice() {\n  return isTouchDevice;\n};\n\nvar point =\n/*#__PURE__*/\ndefaultPointerPos();\nvar isMouseDevice = false;\n\nif (typeof document !== 'undefined') {\n  var updatePointLocation = function updatePointLocation(e) {\n    isMouseDevice = true;\n    eventToPoint(e, point);\n  };\n\n  listen(document, 'mousedown mousemove', true).start(updatePointLocation);\n}\n\nvar mouse = function mouse(_a) {\n  var _b = (_a === void 0 ? {} : _a).preventDefault,\n      preventDefault = _b === void 0 ? true : _b;\n  return action(function (_a) {\n    var update = _a.update;\n\n    var updatePoint = function updatePoint() {\n      return update(point);\n    };\n\n    var onMove = function onMove(e) {\n      if (preventDefault) e.preventDefault();\n      sync.update(updatePoint);\n    };\n\n    var updateOnMove = listen(document, 'mousemove').start(onMove);\n    if (isMouseDevice) sync.update(updatePoint);\n    return {\n      stop: function stop() {\n        cancelSync.update(updatePoint);\n        updateOnMove.stop();\n      }\n    };\n  });\n};\n\nvar getFirstTouch = function getFirstTouch(_a) {\n  var firstTouch = _a[0];\n  return firstTouch;\n};\n\nvar pointer = function pointer(props) {\n  if (props === void 0) {\n    props = {};\n  }\n\n  return getIsTouchDevice() ? multitouch(props).pipe(function (_a) {\n    var touches = _a.touches;\n    return touches;\n  }, getFirstTouch) : mouse(props);\n};\n\nvar index$1 = function index$1(_a) {\n  if (_a === void 0) {\n    _a = {};\n  }\n\n  var x = _a.x,\n      y = _a.y,\n      props = __rest(_a, [\"x\", \"y\"]);\n\n  if (x !== undefined || y !== undefined) {\n    var applyXOffset_1 = applyOffset(x || 0);\n    var applyYOffset_1 = applyOffset(y || 0);\n    var delta_1 = {\n      x: 0,\n      y: 0\n    };\n    return pointer(props).pipe(function (point) {\n      delta_1.x = applyXOffset_1(point.x);\n      delta_1.y = applyYOffset_1(point.y);\n      return delta_1;\n    });\n  } else {\n    return pointer(props);\n  }\n};\n\nvar chain = function chain() {\n  var actions = [];\n\n  for (var _i = 0; _i < arguments.length; _i++) {\n    actions[_i] = arguments[_i];\n  }\n\n  return action(function (_a) {\n    var update = _a.update,\n        _complete3 = _a.complete;\n    var i = 0;\n    var current;\n\n    var playCurrent = function playCurrent() {\n      current = actions[i].start({\n        complete: function complete() {\n          i++;\n          i >= actions.length ? _complete3() : playCurrent();\n        },\n        update: update\n      });\n    };\n\n    playCurrent();\n    return {\n      stop: function stop() {\n        return current && current.stop();\n      }\n    };\n  });\n};\n\nvar parallel =\n/*#__PURE__*/\nmulti({\n  getOutput: function getOutput() {\n    return [];\n  },\n  getCount: function getCount(subs) {\n    return subs.length;\n  },\n  getFirst: function getFirst(subs) {\n    return subs[0];\n  },\n  mapApi: function mapApi(subs, methodName) {\n    return function () {\n      var args = [];\n\n      for (var _i = 0; _i < arguments.length; _i++) {\n        args[_i] = arguments[_i];\n      }\n\n      return subs.map(function (sub, i) {\n        if (sub[methodName]) {\n          return Array.isArray(args[0]) ? sub[methodName](args[0][i]) : sub[methodName].apply(sub, args);\n        }\n      });\n    };\n  },\n  setProp: function setProp(output, name, v) {\n    return output[name] = v;\n  },\n  startActions: function startActions(actions, starter) {\n    return actions.map(function (action, i) {\n      return starter(action, i);\n    });\n  }\n});\n\nvar parallel$1 = function parallel$1() {\n  var actions = [];\n\n  for (var _i = 0; _i < arguments.length; _i++) {\n    actions[_i] = arguments[_i];\n  }\n\n  return parallel(actions);\n};\n\nvar crossfade = function crossfade(a, b) {\n  return action(function (observer) {\n    var balance = 0;\n    var fadable = parallel$1(a, b).start(__assign({}, observer, {\n      update: function update(_a) {\n        var va = _a[0],\n            vb = _a[1];\n        observer.update(mix(va, vb, balance));\n      }\n    }));\n    return {\n      setBalance: function setBalance(v) {\n        return balance = v;\n      },\n      stop: function stop() {\n        return fadable.stop();\n      }\n    };\n  });\n};\n\nvar delay = function delay(timeToDelay) {\n  return action(function (_a) {\n    var complete = _a.complete;\n    var timeout = setTimeout(complete, timeToDelay);\n    return {\n      stop: function stop() {\n        return clearTimeout(timeout);\n      }\n    };\n  });\n};\n\nvar merge = function merge() {\n  var actions = [];\n\n  for (var _i = 0; _i < arguments.length; _i++) {\n    actions[_i] = arguments[_i];\n  }\n\n  return action(function (observer) {\n    var subs = actions.map(function (thisAction) {\n      return thisAction.start(observer);\n    });\n    return {\n      stop: function stop() {\n        return subs.forEach(function (sub) {\n          return sub.stop();\n        });\n      }\n    };\n  });\n};\n\nvar schedule = function schedule(scheduler, schedulee) {\n  return action(function (_a) {\n    var _update = _a.update,\n        complete = _a.complete;\n    var latest;\n    var schedulerSub = scheduler.start({\n      update: function update() {\n        return latest !== undefined && _update(latest);\n      },\n      complete: complete\n    });\n    var scheduleeSub = schedulee.start({\n      update: function update(v) {\n        return latest = v;\n      },\n      complete: complete\n    });\n    return {\n      stop: function stop() {\n        schedulerSub.stop();\n        scheduleeSub.stop();\n      }\n    };\n  });\n};\n\nvar stagger = function stagger(actions, interval) {\n  var intervalIsNumber = typeof interval === 'number';\n  var actionsWithDelay = actions.map(function (a, i) {\n    var timeToDelay = intervalIsNumber ? interval * i : interval(i);\n    return chain(delay(timeToDelay), a);\n  });\n  return parallel$1.apply(void 0, actionsWithDelay);\n};\n\nvar styler = function styler() {\n  return invariant(false, 'styler has been removed from Popmotion in 9.0. Downgrade to 8.x or npm install stylefire');\n};\n\nexport { Action, ValueReaction, action, chain, composite, crossfade, vectorDecay as decay, delay, frame as everyFrame, index as inertia, keyframes, listen, merge, mouse, multicast, multitouch, parallel$1 as parallel, vectorPhysics as physics, index$1 as pointer, schedule, vectorSpring as spring, stagger, styler, timeline, tween, value };","import \"core-js/modules/es6.array.find-index\";\nimport \"core-js/modules/es7.object.values\";\nimport \"core-js/modules/es6.array.reduce\";\nimport \"core-js/modules/es6.regexp.match\";\nimport \"core-js/modules/es6.regexp.split\";\nimport \"core-js/modules/es6.array.some\";\nimport \"core-js/modules/es6.array.index-of\";\nimport \"core-js/modules/es6.array.from\";\nimport \"core-js/modules/es6.array.filter\";\nimport \"core-js/modules/es6.object.keys\";\nimport \"core-js/modules/es6.array.map\";\nimport \"core-js/modules/es6.string.starts-with\";\nimport \"core-js/modules/es6.array.find\";\nimport \"core-js/modules/es6.array.is-array\";\nimport \"core-js/modules/es6.map\";\nimport \"core-js/modules/es6.promise\";\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 \"core-js/modules/es6.array.for-each\";\nimport { __assign, __rest } from 'tslib';\nimport { useRef, useEffect, memo, forwardRef, createContext, useMemo, useContext, createElement, Fragment, useCallback, useState, useLayoutEffect, cloneElement, Children, isValidElement } from 'react';\nimport sync, { getFrameData, cancelSync } from 'framesync';\nimport { velocityPerSecond, distance, mix, interpolate, wrap } from '@popmotion/popcorn';\nimport styler, { createStylerFactory, buildStyleProperty, isTransformProp, transformProps, buildSVGAttrs } from 'stylefire';\nimport { invariant, warning } from 'hey-listen';\nimport { number, px, percent, degrees, vw, vh, color, complex } from 'style-value-types';\nimport { action, delay, tween, spring, keyframes as keyframes$1, inertia } from 'popmotion';\nimport * as easingLookup from '@popmotion/easing';\nimport { cubicBezier, linear } from '@popmotion/easing';\n/**\r\n * Uses the ref that is passed in, or creates a new one\r\n * @param external - External ref\r\n * @internal\r\n */\n\nfunction useExternalRef(external) {\n  // We're conditionally calling `useRef` here which is sort of naughty as hooks\n  // shouldn't be called conditionally. However, Framer Motion will break if this\n  // condition changes anyway. It might be possible to use an invariant here to\n  // make it explicit, but I expect changing `ref` is not normal behaviour.\n  var ref = !external || typeof external === \"function\" ? useRef(null) : external;\n  useEffect(function () {\n    if (external && typeof external === \"function\") {\n      external(ref.current);\n      return function () {\n        return external(null);\n      };\n    }\n  }, []);\n  return ref;\n}\n\nvar isFloat = function isFloat(value) {\n  return !isNaN(parseFloat(value));\n};\n/**\r\n * `MotionValue` is used to track the state and velocity of motion values.\r\n *\r\n * @public\r\n */\n\n\nvar MotionValue =\n/** @class */\nfunction () {\n  /**\r\n   * @param init - The initiating value\r\n   * @param config - Optional configuration options\r\n   *\r\n   * -  `transformer`: A function to transform incoming values with.\r\n   *\r\n   * @internal\r\n   */\n  function MotionValue(init, _a) {\n    var _this = this;\n\n    var _b = _a === void 0 ? {} : _a,\n        transformer = _b.transformer,\n        parent = _b.parent;\n    /**\r\n     * Duration, in milliseconds, since last updating frame.\r\n     *\r\n     * @internal\r\n     */\n\n\n    this.timeDelta = 0;\n    /**\r\n     * Timestamp of the last time this `MotionValue` was updated.\r\n     *\r\n     * @internal\r\n     */\n\n    this.lastUpdated = 0;\n    /**\r\n     * Tracks whether this value can output a velocity. Currently this is only true\r\n     * if the value is numerical, but we might be able to widen the scope here and support\r\n     * other value types.\r\n     *\r\n     * @internal\r\n     */\n\n    this.canTrackVelocity = false;\n\n    this.updateAndNotify = function (v, render) {\n      if (render === void 0) {\n        render = true;\n      }\n\n      _this.prev = _this.current;\n      _this.current = _this.transformer ? _this.transformer(v) : v;\n\n      if (_this.updateSubscribers && _this.prev !== _this.current) {\n        _this.updateSubscribers.forEach(_this.notifySubscriber);\n      }\n\n      if (_this.children) {\n        _this.children.forEach(_this.setChild);\n      }\n\n      if (render && _this.renderSubscribers) {\n        _this.renderSubscribers.forEach(_this.notifySubscriber);\n      } // Update timestamp\n\n\n      var _a = getFrameData(),\n          delta = _a.delta,\n          timestamp = _a.timestamp;\n\n      if (_this.lastUpdated !== timestamp) {\n        _this.timeDelta = delta;\n        _this.lastUpdated = timestamp;\n        sync.postRender(_this.scheduleVelocityCheck);\n      }\n    };\n    /**\r\n     * Notify a subscriber with the latest value.\r\n     *\r\n     * This is an instanced and bound function to prevent generating a new\r\n     * function once per frame.\r\n     *\r\n     * @param subscriber - The subscriber to notify.\r\n     *\r\n     * @internal\r\n     */\n\n\n    this.notifySubscriber = function (subscriber) {\n      subscriber(_this.current);\n    };\n    /**\r\n     * Schedule a velocity check for the next frame.\r\n     *\r\n     * This is an instanced and bound function to prevent generating a new\r\n     * function once per frame.\r\n     *\r\n     * @internal\r\n     */\n\n\n    this.scheduleVelocityCheck = function () {\n      return sync.postRender(_this.velocityCheck);\n    };\n    /**\r\n     * Updates `prev` with `current` if the value hasn't been updated this frame.\r\n     * This ensures velocity calculations return `0`.\r\n     *\r\n     * This is an instanced and bound function to prevent generating a new\r\n     * function once per frame.\r\n     *\r\n     * @internal\r\n     */\n\n\n    this.velocityCheck = function (_a) {\n      var timestamp = _a.timestamp;\n\n      if (timestamp !== _this.lastUpdated) {\n        _this.prev = _this.current;\n      }\n    };\n    /**\r\n     * Updates child `MotionValue`.\r\n     *\r\n     * @param child - Child `MotionValue`.\r\n     *\r\n     * @internal\r\n     */\n\n\n    this.setChild = function (child) {\n      return child.set(_this.current);\n    };\n\n    this.parent = parent;\n    this.transformer = transformer;\n    this.set(init, false);\n    this.canTrackVelocity = isFloat(this.current);\n  }\n  /**\r\n   * Creates a new `MotionValue` that's subscribed to the output of this one.\r\n   *\r\n   * @param config - Optional configuration options\r\n   *\r\n   * -  `transformer`: A function to transform incoming values with.\r\n   *\r\n   * @internal\r\n   */\n\n\n  MotionValue.prototype.addChild = function (config) {\n    if (config === void 0) {\n      config = {};\n    }\n\n    var child = new MotionValue(this.current, __assign({\n      parent: this\n    }, config));\n    if (!this.children) this.children = new Set();\n    this.children.add(child);\n    return child;\n  };\n  /**\r\n   * Stops a `MotionValue` from being subscribed to this one.\r\n   *\r\n   * @param child - The subscribed `MotionValue`\r\n   *\r\n   * @internal\r\n   */\n\n\n  MotionValue.prototype.removeChild = function (child) {\n    if (!this.children) {\n      return;\n    }\n\n    this.children[\"delete\"](child);\n  };\n  /**\r\n   * Subscribes a subscriber function to a subscription list.\r\n   *\r\n   * @param subscriptions - A `Set` of subscribers.\r\n   * @param subscription - A subscriber function.\r\n   */\n\n\n  MotionValue.prototype.subscribeTo = function (subscriptions, subscription) {\n    var _this = this;\n\n    var updateSubscriber = function updateSubscriber() {\n      return subscription(_this.current);\n    };\n\n    subscriptions.add(updateSubscriber);\n    return function () {\n      return subscriptions[\"delete\"](updateSubscriber);\n    };\n  };\n  /**\r\n   * Adds a function that will be notified when the `MotionValue` is updated.\r\n   *\r\n   * It returns a function that, when called, will cancel the subscription.\r\n   *\r\n   * When calling `onChange` inside a React component, it should be wrapped with the\r\n   * `useEffect` hook. As it returns an unsubscribe function, this should be returned\r\n   * from the `useEffect` function to ensure you don't add duplicate subscribers..\r\n   *\r\n   * @library\r\n   *\r\n   * ```jsx\r\n   * function MyComponent() {\r\n   *   const x = useMotionValue(0)\r\n   *   const y = useMotionValue(0)\r\n   *   const opacity = useMotionValue(1)\r\n   *\r\n   *   useEffect(() => {\r\n   *     function updateOpacity() {\r\n   *       const maxXY = Math.max(x.get(), y.get())\r\n   *       const newOpacity = transform(maxXY, [0, 100], [1, 0])\r\n   *       opacity.set(newOpacity)\r\n   *     }\r\n   *\r\n   *     const unsubscribeX = x.onChange(updateOpacity)\r\n   *     const unsubscribeY = y.onChange(updateOpacity)\r\n   *\r\n   *     return () => {\r\n   *       unsubscribeX()\r\n   *       unsubscribeY()\r\n   *     }\r\n   *   }, [])\r\n   *\r\n   *   return <Frame x={x} />\r\n   * }\r\n   * ```\r\n   *\r\n   * @motion\r\n   *\r\n   * ```jsx\r\n   * export const MyComponent = () => {\r\n   *   const x = useMotionValue(0)\r\n   *   const y = useMotionValue(0)\r\n   *   const opacity = useMotionValue(1)\r\n   *\r\n   *   useEffect(() => {\r\n   *     function updateOpacity() {\r\n   *       const maxXY = Math.max(x.get(), y.get())\r\n   *       const newOpacity = transform(maxXY, [0, 100], [1, 0])\r\n   *       opacity.set(newOpacity)\r\n   *     }\r\n   *\r\n   *     const unsubscribeX = x.onChange(updateOpacity)\r\n   *     const unsubscribeY = y.onChange(updateOpacity)\r\n   *\r\n   *     return () => {\r\n   *       unsubscribeX()\r\n   *       unsubscribeY()\r\n   *     }\r\n   *   }, [])\r\n   *\r\n   *   return <motion.div style={{ x }} />\r\n   * }\r\n   * ```\r\n   *\r\n   * @internalremarks\r\n   *\r\n   * We could look into a `useOnChange` hook if the above lifecycle management proves confusing.\r\n   *\r\n   * ```jsx\r\n   * useOnChange(x, () => {})\r\n   * ```\r\n   *\r\n   * @param subscriber - A function that receives the latest value.\r\n   * @returns A function that, when called, will cancel this subscription.\r\n   *\r\n   * @public\r\n   */\n\n\n  MotionValue.prototype.onChange = function (subscription) {\n    if (!this.updateSubscribers) this.updateSubscribers = new Set();\n    return this.subscribeTo(this.updateSubscribers, subscription);\n  };\n  /**\r\n   * Adds a function that will be notified when the `MotionValue` requests a render.\r\n   *\r\n   * @param subscriber - A function that's provided the latest value.\r\n   * @returns A function that, when called, will cancel this subscription.\r\n   *\r\n   * @internal\r\n   */\n\n\n  MotionValue.prototype.onRenderRequest = function (subscription) {\n    if (!this.renderSubscribers) this.renderSubscribers = new Set(); // Render immediately\n\n    this.notifySubscriber(subscription);\n    return this.subscribeTo(this.renderSubscribers, subscription);\n  };\n  /**\r\n   * Attaches a passive effect to the `MotionValue`.\r\n   *\r\n   * @internal\r\n   */\n\n\n  MotionValue.prototype.attach = function (passiveEffect) {\n    this.passiveEffect = passiveEffect;\n  };\n  /**\r\n   * Sets the state of the `MotionValue`.\r\n   *\r\n   * @remarks\r\n   *\r\n   * ```jsx\r\n   * const x = useMotionValue(0)\r\n   * x.set(10)\r\n   * ```\r\n   *\r\n   * @param latest - Latest value to set.\r\n   * @param render - Whether to notify render subscribers. Defaults to `true`\r\n   *\r\n   * @public\r\n   */\n\n\n  MotionValue.prototype.set = function (v, render) {\n    if (render === void 0) {\n      render = true;\n    }\n\n    if (!render || !this.passiveEffect) {\n      this.updateAndNotify(v, render);\n    } else {\n      this.passiveEffect(v, this.updateAndNotify);\n    }\n  };\n  /**\r\n   * Returns the latest state of `MotionValue`\r\n   *\r\n   * @returns - The latest state of `MotionValue`\r\n   *\r\n   * @public\r\n   */\n\n\n  MotionValue.prototype.get = function () {\n    return this.current;\n  };\n  /**\r\n   * Returns the latest velocity of `MotionValue`\r\n   *\r\n   * @returns - The latest velocity of `MotionValue`. Returns `0` if the state is non-numerical.\r\n   *\r\n   * @public\r\n   */\n\n\n  MotionValue.prototype.getVelocity = function () {\n    // This could be isFloat(this.prev) && isFloat(this.current), but that would be wasteful\n    return this.canTrackVelocity ? // These casts could be avoided if parseFloat would be typed better\n    velocityPerSecond(parseFloat(this.current) - parseFloat(this.prev), this.timeDelta) : 0;\n  };\n  /**\r\n   * Registers a new animation to control this `MotionValue`. Only one\r\n   * animation can drive a `MotionValue` at one time.\r\n   *\r\n   * ```jsx\r\n   * value.start()\r\n   * ```\r\n   *\r\n   * @param animation - A function that starts the provided animation\r\n   *\r\n   * @internal\r\n   */\n\n\n  MotionValue.prototype.start = function (animation) {\n    var _this = this;\n\n    this.stop();\n    return new Promise(function (resolve) {\n      _this.stopAnimation = animation(resolve);\n    }).then(function () {\n      return _this.clearAnimation();\n    });\n  };\n  /**\r\n   * Stop the currently active animation.\r\n   *\r\n   * @public\r\n   */\n\n\n  MotionValue.prototype.stop = function () {\n    if (this.stopAnimation) this.stopAnimation();\n    this.clearAnimation();\n  };\n  /**\r\n   * Returns `true` if this value is currently animating.\r\n   *\r\n   * @public\r\n   */\n\n\n  MotionValue.prototype.isAnimating = function () {\n    return !!this.stopAnimation;\n  };\n\n  MotionValue.prototype.clearAnimation = function () {\n    this.stopAnimation = null;\n  };\n  /**\r\n   * Destroy and clean up subscribers to this `MotionValue`.\r\n   *\r\n   * The `MotionValue` hooks like `useMotionValue` and `useTransform` automatically\r\n   * handle the lifecycle of the returned `MotionValue`, so this method is only necessary if you've manually\r\n   * created a `MotionValue` via the `motionValue` function.\r\n   *\r\n   * @public\r\n   */\n\n\n  MotionValue.prototype.destroy = function () {\n    this.updateSubscribers && this.updateSubscribers.clear();\n    this.renderSubscribers && this.renderSubscribers.clear();\n    this.parent && this.parent.removeChild(this);\n    this.stop();\n  };\n\n  return MotionValue;\n}();\n/**\r\n * @internal\r\n */\n\n\nfunction motionValue(init, opts) {\n  return new MotionValue(init, opts);\n}\n/**\r\n * Creates a constant value over the lifecycle of a component.\r\n *\r\n * Even if `useMemo` is provided an empty array as its final argument, it doesn't offer\r\n * a guarantee that it won't re-run for performance reasons later on. By using `useConstant`\r\n * you can ensure that initialisers don't execute twice or more.\r\n */\n\n\nfunction useConstant(init) {\n  var ref = useRef(null);\n\n  if (ref.current === null) {\n    ref.current = init();\n  }\n\n  return ref.current;\n}\n\nvar isMotionValue = function isMotionValue(value) {\n  return value instanceof MotionValue;\n};\n\nvar session = null;\nvar syncRenderSession = {\n  isOpen: function isOpen() {\n    return session !== null;\n  },\n  open: function open() {\n    invariant(!session, \"Sync render session already open\");\n    session = [];\n  },\n  flush: function flush() {\n    invariant(session !== null, \"No sync render session found\");\n    session && session.forEach(function (styler) {\n      return styler.render();\n    });\n    session = null;\n  },\n  push: function push(styler) {\n    invariant(session !== null, \"No sync render session found\");\n    session && session.push(styler);\n  }\n}; // Creating a styler factory for the `onUpdate` prop allows all values\n// to fire and the `onUpdate` prop will only fire once per frame\n\nvar updateStyler = createStylerFactory({\n  onRead: function onRead() {\n    return null;\n  },\n  onRender: function onRender(state, _a) {\n    var onUpdate = _a.onUpdate;\n    return onUpdate(state);\n  }\n});\n\nvar MotionValuesMap =\n/** @class */\nfunction () {\n  function MotionValuesMap() {\n    this.hasMounted = false;\n    this.values = new Map();\n    this.unsubscribers = new Map();\n  }\n\n  MotionValuesMap.prototype.has = function (key) {\n    return this.values.has(key);\n  };\n\n  MotionValuesMap.prototype.set = function (key, value) {\n    this.values.set(key, value);\n\n    if (this.hasMounted) {\n      this.bindValueToOutput(key, value);\n    }\n  };\n\n  MotionValuesMap.prototype.get = function (key, defaultValue) {\n    var value = this.values.get(key);\n\n    if (value === undefined && defaultValue !== undefined) {\n      value = new MotionValue(defaultValue);\n      this.set(key, value);\n    }\n\n    return value;\n  };\n\n  MotionValuesMap.prototype.forEach = function (callback) {\n    return this.values.forEach(callback);\n  };\n\n  MotionValuesMap.prototype.bindValueToOutput = function (key, value) {\n    var _this = this;\n\n    var onRender = function onRender(v) {\n      return _this.output && _this.output(key, v);\n    };\n\n    var unsubscribeOnRender = value.onRenderRequest(onRender);\n\n    var onChange = function onChange(v) {\n      _this.onUpdate && _this.onUpdate.set(key, v);\n    };\n\n    var unsubscribeOnChange = value.onChange(onChange);\n\n    if (this.unsubscribers.has(key)) {\n      this.unsubscribers.get(key)();\n    }\n\n    this.unsubscribers.set(key, function () {\n      unsubscribeOnRender();\n      unsubscribeOnChange();\n    });\n  };\n\n  MotionValuesMap.prototype.setOnUpdate = function (onUpdate) {\n    this.onUpdate = undefined;\n\n    if (onUpdate) {\n      this.onUpdate = updateStyler({\n        onUpdate: onUpdate\n      });\n    }\n  };\n\n  MotionValuesMap.prototype.setTransformTemplate = function (transformTemplate) {\n    if (this.transformTemplate !== transformTemplate) {\n      this.transformTemplate = transformTemplate;\n      this.updateTransformTemplate();\n    }\n  };\n\n  MotionValuesMap.prototype.getTransformTemplate = function () {\n    return this.transformTemplate;\n  };\n\n  MotionValuesMap.prototype.updateTransformTemplate = function () {\n    if (this.output) {\n      this.output(\"transform\", this.transformTemplate);\n    }\n  };\n\n  MotionValuesMap.prototype.mount = function (output) {\n    var _this = this;\n\n    this.hasMounted = true;\n    if (output) this.output = output;\n    this.values.forEach(function (value, key) {\n      return _this.bindValueToOutput(key, value);\n    });\n    this.updateTransformTemplate();\n  };\n\n  MotionValuesMap.prototype.unmount = function () {\n    var _this = this;\n\n    this.values.forEach(function (_value, key) {\n      var unsubscribe = _this.unsubscribers.get(key);\n\n      unsubscribe && unsubscribe();\n    });\n  };\n\n  return MotionValuesMap;\n}();\n\nvar specialMotionValueProps = new Set([\"dragOriginX\", \"dragOriginY\"]);\n\nvar useMotionValues = function useMotionValues(props) {\n  var motionValues = useConstant(function () {\n    var map = new MotionValuesMap();\n    /**\r\n     * Loop through every prop and add any detected `MotionValue`s. This is SVG-specific\r\n     * code that should be extracted, perhaps considered hollistically with `useMotionStyles`.\r\n     *\r\n     * <motion.circle cx={motionValue(0)} />\r\n     */\n\n    for (var key in props) {\n      if (isMotionValue(props[key]) && !specialMotionValueProps.has(key)) {\n        map.set(key, props[key]);\n      }\n    }\n\n    return map;\n  });\n  motionValues.setOnUpdate(props.onUpdate);\n  motionValues.setTransformTemplate(props.transformTemplate);\n  return motionValues;\n};\n/**\r\n * `useEffect` gets resolved bottom-up. We defer some optional functionality to child\r\n * components, so to ensure everything runs correctly we export the ref-binding logic\r\n * to a new component rather than in `useMotionValues`.\r\n */\n\n\nvar MountMotionValuesComponent = function MountMotionValuesComponent(_a, ref) {\n  var values = _a.values,\n      isStatic = _a.isStatic;\n  useEffect(function () {\n    invariant(ref.current instanceof Element, \"No `ref` found. Ensure components created with `motion.custom` forward refs using `React.forwardRef`\");\n    var domStyler = styler(ref.current, {\n      preparseOutput: false,\n      enableHardwareAcceleration: !isStatic\n    });\n    values.mount(function (key, value) {\n      domStyler.set(key, value);\n\n      if (syncRenderSession.isOpen()) {\n        syncRenderSession.push(domStyler);\n      }\n    });\n    return function () {\n      return values.unmount();\n    };\n  }, []);\n  return null;\n};\n\nvar MountMotionValues = memo(forwardRef(MountMotionValuesComponent));\n\nvar createValueResolver = function createValueResolver(resolver) {\n  return function (values) {\n    var resolvedValues = {};\n    values.forEach(function (value, key) {\n      return resolvedValues[key] = resolver(value);\n    });\n    return resolvedValues;\n  };\n};\n\nvar resolveCurrent = createValueResolver(function (value) {\n  return value.get();\n});\nvar transformOriginProps = new Set([\"originX\", \"originY\", \"originZ\"]);\n\nvar isTransformOriginProp = function isTransformOriginProp(key) {\n  return transformOriginProps.has(key);\n};\n\nvar buildStyleAttr = function buildStyleAttr(values, styleProp, isStatic) {\n  var motionValueStyles = resolveCurrent(values);\n  var transformTemplate = values.getTransformTemplate();\n\n  if (transformTemplate) {\n    // If `transform` has been manually set as a string, pass that through the template\n    // otherwise pass it forward to Stylefire's style property builder\n    motionValueStyles.transform = styleProp.transform ? transformTemplate({}, styleProp.transform) : transformTemplate;\n  }\n\n  return buildStyleProperty(__assign({}, styleProp, motionValueStyles), !isStatic);\n};\n\nvar useMotionStyles = function useMotionStyles(values, styleProp, isStatic, transformValues) {\n  if (styleProp === void 0) {\n    styleProp = {};\n  }\n\n  var style = {};\n  var prevMotionStyles = useRef({}).current;\n\n  for (var key in styleProp) {\n    var thisStyle = styleProp[key];\n\n    if (isMotionValue(thisStyle)) {\n      // If this is a motion value, add it to our MotionValuesMap\n      values.set(key, thisStyle);\n    } else if (!isStatic && (isTransformProp(key) || isTransformOriginProp(key))) {\n      // Or if it's a transform prop, create a motion value (or update an existing one)\n      // to ensure Stylefire can reconcile all the transform values together.\n      // A further iteration on this would be to create a single styler per component that gets\n      // used in the DOM renderer's buildStyleAttr *and* animations, then we would only\n      // have to convert animating values to `MotionValues` (we could probably remove this entire function).\n      // The only architectural consideration is to allow Stylefire to have elements mounted after\n      // a styler is created.\n      if (!values.has(key)) {\n        // If it doesn't exist as a motion value, create it\n        values.set(key, motionValue(thisStyle));\n      } else {\n        // Otherwise only update it if it's changed from a previous render\n        if (thisStyle !== prevMotionStyles[key]) {\n          var value = values.get(key);\n          value.set(thisStyle);\n        }\n      }\n\n      prevMotionStyles[key] = thisStyle;\n    } else {\n      style[key] = thisStyle;\n    }\n  }\n\n  return transformValues ? transformValues(style) : style;\n};\n\nvar isKeyframesTarget = function isKeyframesTarget(v) {\n  return Array.isArray(v);\n};\n\nvar isCustomValue = function isCustomValue(v) {\n  return Boolean(v && typeof v === \"object\" && v.mix && v.toValue);\n};\n\nvar resolveFinalValueInKeyframes = function resolveFinalValueInKeyframes(v) {\n  // TODO maybe throw if v.length - 1 is placeholder token?\n  return isKeyframesTarget(v) ? v[v.length - 1] || 0 : v;\n};\n\nvar auto = {\n  test: function test(v) {\n    return v === \"auto\";\n  },\n  parse: function parse(v) {\n    return v;\n  }\n};\nvar dimensionTypes = [number, px, percent, degrees, vw, vh, auto];\nvar valueTypes = dimensionTypes.concat([color, complex]);\n\nvar testValueType = function testValueType(v) {\n  return function (type) {\n    return type.test(v);\n  };\n};\n\nvar getDimensionValueType = function getDimensionValueType(v) {\n  return dimensionTypes.find(testValueType(v));\n};\n\nvar getValueType = function getValueType(v) {\n  return valueTypes.find(testValueType(v));\n};\n\nvar underDampedSpring = function underDampedSpring() {\n  return {\n    type: \"spring\",\n    stiffness: 500,\n    damping: 25,\n    restDelta: 0.5,\n    restSpeed: 10\n  };\n};\n\nvar overDampedSpring = function overDampedSpring(to) {\n  return {\n    type: \"spring\",\n    stiffness: 700,\n    damping: to === 0 ? 100 : 35\n  };\n};\n\nvar linearTween = function linearTween() {\n  return {\n    ease: \"linear\",\n    duration: 0.3\n  };\n};\n\nvar keyframes = function keyframes(values) {\n  return {\n    type: \"keyframes\",\n    duration: 0.8,\n    values: values\n  };\n};\n\nvar defaultTransitions = {\n  x: underDampedSpring,\n  y: underDampedSpring,\n  z: underDampedSpring,\n  rotate: underDampedSpring,\n  rotateX: underDampedSpring,\n  rotateY: underDampedSpring,\n  rotateZ: underDampedSpring,\n  scaleX: overDampedSpring,\n  scaleY: overDampedSpring,\n  scale: overDampedSpring,\n  opacity: linearTween,\n  backgroundColor: linearTween,\n  color: linearTween,\n  \"default\": overDampedSpring\n};\n\nvar getDefaultTransition = function getDefaultTransition(valueKey, to) {\n  var transitionFactory;\n\n  if (isKeyframesTarget(to)) {\n    transitionFactory = keyframes;\n  } else {\n    transitionFactory = defaultTransitions[valueKey] || defaultTransitions[\"default\"];\n  }\n\n  return __assign({\n    to: to\n  }, transitionFactory(to));\n};\n/**\r\n * A Popmotion action that accepts a single `to` prop. When it starts, it immediately\r\n * updates with `to` and then completes. By using this we can compose instant transitions\r\n * in with the same logic that applies `delay` or returns a `Promise` etc.\r\n *\r\n * Accepting `duration` is a little bit of a hack that simply defers the completetion of\r\n * the animation until after the duration finishes. This is for situations when you're **only**\r\n * animating non-animatable values and then setting something on `transitionEnd`. Really\r\n * you want this to fire after the \"animation\" finishes, rather than instantly.\r\n *\r\n * ```\r\n * animate={{\r\n *   display: 'block',\r\n *   transitionEnd: { display: 'none' }\r\n * }}\r\n * ```\r\n */\n\n\nvar just = function just(_a) {\n  var to = _a.to,\n      duration = _a.duration;\n  return action(function (_a) {\n    var update = _a.update,\n        complete = _a.complete;\n    update(to);\n    duration ? delay(duration).start({\n      complete: complete\n    }) : complete();\n  });\n};\n\nvar easingDefinitionToFunction = function easingDefinitionToFunction(definition) {\n  if (Array.isArray(definition)) {\n    // If cubic bezier definition, create bezier curve\n    invariant(definition.length === 4, \"Cubic bezier arrays must contain four numerical values.\");\n    var x1 = definition[0],\n        y1 = definition[1],\n        x2 = definition[2],\n        y2 = definition[3];\n    return cubicBezier(x1, y1, x2, y2);\n  } else if (typeof definition === \"string\") {\n    // Else lookup from table\n    invariant(easingLookup[definition] !== undefined, \"Invalid easing type '\" + definition + \"'\");\n    return easingLookup[definition];\n  }\n\n  return definition;\n};\n\nvar isEasingArray = function isEasingArray(ease) {\n  return Array.isArray(ease) && typeof ease[0] !== \"number\";\n};\n\nvar isDurationAnimation = function isDurationAnimation(v) {\n  return v.hasOwnProperty(\"duration\") || v.hasOwnProperty(\"repeatDelay\");\n};\n/**\r\n * Check if a value is animatable. Examples:\r\n *\r\n * ✅: 100, \"100px\", \"#fff\"\r\n * ❌: \"block\", \"url(2.jpg)\"\r\n * @param value\r\n *\r\n * @internal\r\n */\n\n\nvar isAnimatable = function isAnimatable(key, value) {\n  // If the list of keys tat might be non-animatable grows, replace with Set\n  if (key === \"zIndex\") return false; // If it's a number or a keyframes array, we can animate it. We might at some point\n  // need to do a deep isAnimatable check of keyframes, or let Popmotion handle this,\n  // but for now lets leave it like this for performance reasons\n\n  if (typeof value === \"number\" || Array.isArray(value)) return true;\n\n  if (typeof value === \"string\" && // It's animatable if we have a string\n  complex.test(value) && // And it contains numbers and/or colors\n  !value.startsWith(\"url(\") // Unless it starts with \"url(\"\n  ) {\n    return true;\n  }\n\n  return false;\n};\n/**\r\n * Converts seconds to milliseconds\r\n *\r\n * @param seconds - Time in seconds.\r\n * @return milliseconds - Converted time in milliseconds.\r\n */\n\n\nvar secondsToMilliseconds = function secondsToMilliseconds(seconds) {\n  return seconds * 1000;\n};\n\nvar transitions = {\n  tween: tween,\n  spring: spring,\n  keyframes: keyframes$1,\n  inertia: inertia,\n  just: just\n};\nvar transitionOptionParser = {\n  tween: function tween(opts) {\n    if (opts.ease) {\n      var ease = isEasingArray(opts.ease) ? opts.ease[0] : opts.ease;\n      opts.ease = easingDefinitionToFunction(ease);\n    }\n\n    return opts;\n  },\n  keyframes: function keyframes(_a) {\n    var from = _a.from,\n        to = _a.to,\n        velocity = _a.velocity,\n        opts = __rest(_a, [\"from\", \"to\", \"velocity\"]);\n\n    if (opts.values && opts.values[0] === null) {\n      var values = opts.values.slice();\n      values[0] = from;\n      opts.values = values;\n    }\n\n    if (opts.ease) {\n      opts.easings = isEasingArray(opts.ease) ? opts.ease.map(easingDefinitionToFunction) : easingDefinitionToFunction(opts.ease);\n    }\n\n    opts.ease = linear;\n    return opts;\n  }\n};\n\nvar isTransitionDefined = function isTransitionDefined(_a) {\n  var when = _a.when,\n      delay = _a.delay,\n      delayChildren = _a.delayChildren,\n      staggerChildren = _a.staggerChildren,\n      staggerDirection = _a.staggerDirection,\n      transition = __rest(_a, [\"when\", \"delay\", \"delayChildren\", \"staggerChildren\", \"staggerDirection\"]);\n\n  return Object.keys(transition).length;\n};\n\nvar getTransitionDefinition = function getTransitionDefinition(key, to, transitionDefinition) {\n  var delay = transitionDefinition ? transitionDefinition.delay : 0; // If no object, return default transition\n  // A better way to handle this would be to deconstruct out all the shared Orchestration props\n  // and see if there's any props remaining\n\n  if (transitionDefinition === undefined || !isTransitionDefined(transitionDefinition)) {\n    return __assign({\n      delay: delay\n    }, getDefaultTransition(key, to));\n  }\n\n  var valueTransitionDefinition = transitionDefinition[key] || transitionDefinition[\"default\"] || transitionDefinition;\n\n  if (valueTransitionDefinition.type === false) {\n    return {\n      delay: valueTransitionDefinition.hasOwnProperty(\"delay\") ? valueTransitionDefinition.delay : delay,\n      to: isKeyframesTarget(to) ? to[to.length - 1] : to,\n      type: \"just\"\n    };\n  } else if (isKeyframesTarget(to)) {\n    return __assign({\n      values: to,\n      duration: 0.8,\n      delay: delay,\n      ease: \"linear\"\n    }, valueTransitionDefinition, {\n      // This animation must be keyframes if we're animating through an array\n      type: \"keyframes\"\n    });\n  } else {\n    return __assign({\n      type: \"tween\",\n      to: to,\n      delay: delay\n    }, valueTransitionDefinition);\n  }\n};\n\nvar preprocessOptions = function preprocessOptions(type, opts) {\n  return transitionOptionParser[type] ? transitionOptionParser[type](opts) : opts;\n};\n\nvar getAnimation = function getAnimation(key, value, target, transition) {\n  var origin = value.get();\n  var isOriginAnimatable = isAnimatable(key, origin);\n  var isTargetAnimatable = isAnimatable(key, target); // TODO we could probably improve this check to ensure both values are of the same type -\n  // for instance 100 to #fff. This might live better in Popmotion.\n\n  warning(isOriginAnimatable === isTargetAnimatable, \"You are trying to animate \" + key + \" from \\\"\" + origin + \"\\\" to \" + target + \". \\\"\" + origin + \"\\\" is not an animatable value - to enable this animation set \" + origin + \" to a value animatable to \" + target + \" via the `style` property.\"); // Parse the `transition` prop and return options for the Popmotion animation\n\n  var _a = getTransitionDefinition(key, target, transition),\n      _b = _a.type,\n      type = _b === void 0 ? \"tween\" : _b,\n      transitionDefinition = __rest(_a, [\"type\"]); // If this is an animatable pair of values, return an animation, otherwise use `just`\n\n\n  var actionFactory = isOriginAnimatable && isTargetAnimatable ? transitions[type] : just;\n  var opts = preprocessOptions(type, __assign({\n    from: origin,\n    velocity: value.getVelocity()\n  }, transitionDefinition)); // Convert duration from Framer Motion's seconds into Popmotion's milliseconds\n\n  if (isDurationAnimation(opts)) {\n    if (opts.duration) {\n      opts.duration = secondsToMilliseconds(opts.duration);\n    }\n\n    if (opts.repeatDelay) {\n      opts.repeatDelay = secondsToMilliseconds(opts.repeatDelay);\n    }\n  }\n\n  return [actionFactory, opts];\n};\n/**\r\n * Start animation on a value. This function completely encapsulates Popmotion-specific logic.\r\n *\r\n * @internal\r\n */\n\n\nfunction startAnimation(key, value, target, _a) {\n  var _b = _a.delay,\n      delay$1 = _b === void 0 ? 0 : _b,\n      transition = __rest(_a, [\"delay\"]);\n\n  return value.start(function (complete) {\n    var activeAnimation;\n\n    var _a = getAnimation(key, value, target, transition),\n        animationFactory = _a[0],\n        _b = _a[1],\n        valueDelay = _b.delay,\n        options = __rest(_b, [\"delay\"]);\n\n    if (valueDelay !== undefined) {\n      delay$1 = valueDelay;\n    }\n\n    var animate = function animate() {\n      var animation = animationFactory(options); // Bind animation opts to animation\n\n      activeAnimation = animation.start({\n        update: function update(v) {\n          return value.set(v);\n        },\n        complete: complete\n      });\n    }; // If we're delaying this animation, only resolve it **after** the delay to\n    // ensure the value's resolve velocity is up-to-date.\n\n\n    if (delay$1) {\n      activeAnimation = delay(secondsToMilliseconds(delay$1)).start({\n        complete: animate\n      });\n    } else {\n      animate();\n    }\n\n    return function () {\n      if (activeAnimation) activeAnimation.stop();\n    };\n  });\n}\n/**\r\n * Get the current value of every `MotionValue`\r\n * @param values -\r\n */\n\n\nvar getCurrent = function getCurrent(values) {\n  var current = {};\n  values.forEach(function (value, key) {\n    return current[key] = value.get();\n  });\n  return current;\n};\n/**\r\n * Get the current velocity of every `MotionValue`\r\n * @param values -\r\n */\n\n\nvar getVelocity = function getVelocity(values) {\n  var velocity = {};\n  values.forEach(function (value, key) {\n    return velocity[key] = value.getVelocity();\n  });\n  return velocity;\n};\n/**\r\n * Check if value is a function that returns a `Target`. A generic typeof === 'function'\r\n * check, just helps with typing.\r\n * @param p -\r\n */\n\n\nvar isTargetResolver = function isTargetResolver(p) {\n  return typeof p === \"function\";\n};\n/**\r\n * Check if value is a list of variant labels\r\n * @param v -\r\n */\n\n\nvar isVariantLabels = function isVariantLabels(v) {\n  return Array.isArray(v);\n};\n/**\r\n * Check if value is a numerical string, ie \"100\" or \"100px\"\r\n */\n\n\nvar isNumericalString = function isNumericalString(v) {\n  return /^\\d*\\.?\\d+$/.test(v);\n};\n/**\r\n * Control animations for a single component\r\n * @internal\r\n */\n\n\nvar ValueAnimationControls =\n/** @class */\nfunction () {\n  function ValueAnimationControls(_a) {\n    var _this = this;\n\n    var values = _a.values,\n        readValueFromSource = _a.readValueFromSource,\n        makeTargetAnimatable = _a.makeTargetAnimatable;\n    /**\r\n     * The component's variants, as provided by `variants`\r\n     */\n\n    this.variants = {};\n    /**\r\n     * A set of values that we animate back to when a value is cleared of all overrides.\r\n     */\n\n    this.baseTarget = {};\n    /**\r\n     * A series of target overrides that we can animate to/from when overrides are set/cleared.\r\n     */\n\n    this.overrides = [];\n    /**\r\n     * A series of target overrides as they were originally resolved.\r\n     */\n\n    this.resolvedOverrides = [];\n    /**\r\n     * A Set of currently active override indexes\r\n     */\n\n    this.activeOverrides = new Set();\n    /**\r\n     * A Set of value keys that are currently animating.\r\n     */\n\n    this.isAnimating = new Set();\n    /**\r\n     * Check if the associated `MotionValueMap` has a key with the provided string.\r\n     * Pre-bound to the class so we can provide directly to the `filter` in `checkForNewValues`.\r\n     */\n\n    this.hasValue = function (key) {\n      return !_this.values.has(key);\n    };\n\n    this.values = values;\n    this.readValueFromSource = readValueFromSource;\n    this.makeTargetAnimatable = makeTargetAnimatable;\n    this.values.forEach(function (value, key) {\n      return _this.baseTarget[key] = value.get();\n    });\n  }\n  /**\r\n   * Set the reference to the component's props.\r\n   * @param props -\r\n   */\n\n\n  ValueAnimationControls.prototype.setProps = function (props) {\n    this.props = props;\n  };\n  /**\r\n   * Set the reference to the component's variants\r\n   * @param variants -\r\n   */\n\n\n  ValueAnimationControls.prototype.setVariants = function (variants) {\n    if (variants) this.variants = variants;\n  };\n  /**\r\n   * Set the component's default transition\r\n   * @param transition -\r\n   */\n\n\n  ValueAnimationControls.prototype.setDefaultTransition = function (transition) {\n    if (transition) this.defaultTransition = transition;\n  };\n  /**\r\n   * Set motion values without animation.\r\n   *\r\n   * @param target -\r\n   * @param isActive -\r\n   */\n\n\n  ValueAnimationControls.prototype.setValues = function (_a, _b) {\n    var _this = this;\n\n    var _c = _b === void 0 ? {} : _b,\n        _d = _c.isActive,\n        isActive = _d === void 0 ? new Set() : _d,\n        priority = _c.priority;\n\n    var transition = _a.transition,\n        transitionEnd = _a.transitionEnd,\n        target = __rest(_a, [\"transition\", \"transitionEnd\"]);\n\n    target = this.transformValues(__assign({}, target, transitionEnd));\n    return Object.keys(target).forEach(function (key) {\n      if (isActive.has(key)) return;\n      isActive.add(key);\n      var targetValue = resolveFinalValueInKeyframes(target[key]);\n\n      if (_this.values.has(key)) {\n        var value = _this.values.get(key);\n\n        value && value.set(targetValue);\n      } else {\n        _this.values.set(key, motionValue(targetValue));\n      }\n\n      if (!priority) _this.baseTarget[key] = targetValue;\n    });\n  };\n  /**\r\n   * Allows `transformValues` to be set by a component that allows us to\r\n   * transform the values in a given `Target`. This allows Framer Library\r\n   * to extend Framer Motion to animate `Color` variables etc. Currently we have\r\n   * to manually support these extended types here in Framer Motion.\r\n   *\r\n   * @param values -\r\n   */\n\n\n  ValueAnimationControls.prototype.transformValues = function (values) {\n    var transformValues = this.props.transformValues;\n    return transformValues ? transformValues(values) : values;\n  };\n  /**\r\n   * Check a `Target` for new values we haven't animated yet, and add them\r\n   * to the `MotionValueMap`.\r\n   *\r\n   * Currently there's functionality here that is DOM-specific, we should allow\r\n   * this functionality to be injected by the factory that creates DOM-specific\r\n   * components.\r\n   *\r\n   * @param target -\r\n   */\n\n\n  ValueAnimationControls.prototype.checkForNewValues = function (target) {\n    var newValueKeys = Object.keys(target).filter(this.hasValue);\n    var numNewValues = newValueKeys.length;\n    if (!numNewValues) return;\n\n    for (var i = 0; i < numNewValues; i++) {\n      var key = newValueKeys[i];\n      var targetValue = target[key];\n      var value = null; // If this is a keyframes value, we can attempt to use the first value in the\n      // array as that's going to be the first value of the animation anyway\n\n      if (Array.isArray(targetValue)) {\n        value = targetValue[0];\n      } // If it isn't a keyframes or the first keyframes value was set as `null`, read the\n      // value from the DOM. It might be worth investigating whether to check props (for SVG)\n      // or props.style (for HTML) if the value exists there before attempting to read.\n\n\n      if (value === null) {\n        value = this.readValueFromSource(key);\n        invariant(value !== null, \"No initial value for \\\"\" + key + \"\\\" can be inferred. Ensure an initial value for \\\"\" + key + \"\\\" is defined on the component.\");\n      }\n\n      if (typeof value === \"string\" && isNumericalString(value)) {\n        // If this is a number read as a string, ie \"0\" or \"200\", convert it to a number\n        value = parseFloat(value);\n      } else if (!getValueType(value) && complex.test(targetValue)) {\n        // If value is not recognised as animatable, ie \"none\", create an animatable version origin based on the target\n        value = complex.getAnimatableNone(targetValue);\n      }\n\n      this.values.set(key, motionValue(value));\n      this.baseTarget[key] = value;\n    }\n  };\n  /**\r\n   * Resolve a variant from its label or resolver into an actual `Target` we can animate to.\r\n   * @param variant -\r\n   */\n\n\n  ValueAnimationControls.prototype.resolveVariant = function (variant) {\n    if (!variant) {\n      return {\n        target: undefined,\n        transition: undefined,\n        transitionEnd: undefined\n      };\n    }\n\n    if (isTargetResolver(variant)) {\n      // resolve current and velocity\n      variant = variant(this.props.custom, getCurrent(this.values), getVelocity(this.values));\n    }\n\n    var _a = variant.transition,\n        transition = _a === void 0 ? this.defaultTransition : _a,\n        transitionEnd = variant.transitionEnd,\n        target = __rest(variant, [\"transition\", \"transitionEnd\"]);\n\n    return {\n      transition: transition,\n      transitionEnd: transitionEnd,\n      target: target\n    };\n  };\n  /**\r\n   * Get the highest active override priority index\r\n   */\n\n\n  ValueAnimationControls.prototype.getHighestPriority = function () {\n    if (!this.activeOverrides.size) return 0;\n    return Math.max.apply(Math, Array.from(this.activeOverrides));\n  };\n  /**\r\n   * Set an override. We add this layer of indirection so if, for instance, a tap gesture\r\n   * starts and overrides a hover gesture, when we clear the tap gesture and fallback to the\r\n   * hover gesture, if that hover gesture has changed in the meantime we can go to that rather\r\n   * than the one that was resolved when the hover gesture animation started.\r\n   *\r\n   * @param definition -\r\n   * @param overrideIndex -\r\n   */\n\n\n  ValueAnimationControls.prototype.setOverride = function (definition, overrideIndex) {\n    this.overrides[overrideIndex] = definition;\n\n    if (this.children) {\n      this.children.forEach(function (child) {\n        return child.setOverride(definition, overrideIndex);\n      });\n    }\n  };\n  /**\r\n   * Start an override animation.\r\n   * @param overrideIndex -\r\n   */\n\n\n  ValueAnimationControls.prototype.startOverride = function (overrideIndex) {\n    var override = this.overrides[overrideIndex];\n\n    if (override) {\n      return this.start(override, {\n        priority: overrideIndex\n      });\n    }\n  };\n  /**\r\n   * Clear an override. We check every value we animated to in this override to see if\r\n   * its present on any lower-priority overrides. If not, we animate it back to its base target.\r\n   * @param overrideIndex -\r\n   */\n\n\n  ValueAnimationControls.prototype.clearOverride = function (overrideIndex) {\n    var _this = this;\n\n    if (this.children) {\n      this.children.forEach(function (child) {\n        return child.clearOverride(overrideIndex);\n      });\n    }\n\n    var override = this.overrides[overrideIndex];\n    if (!override) return;\n    this.activeOverrides[\"delete\"](overrideIndex);\n    var highest = this.getHighestPriority();\n    this.resetIsAnimating();\n\n    if (highest) {\n      var highestOverride = this.overrides[highest];\n      highestOverride && this.startOverride(highest);\n    } // Figure out which remaining values were affected by the override and animate those\n\n\n    var overrideTarget = this.resolvedOverrides[overrideIndex];\n    if (!overrideTarget) return;\n    var remainingValues = {};\n\n    for (var key in this.baseTarget) {\n      if (overrideTarget[key] !== undefined) {\n        remainingValues[key] = this.baseTarget[key];\n      }\n    }\n\n    this.onStart();\n    this.animate(remainingValues).then(function () {\n      return _this.onComplete();\n    });\n  };\n  /**\r\n   * Apply a target/variant without any animation\r\n   */\n\n\n  ValueAnimationControls.prototype.apply = function (definition) {\n    if (Array.isArray(definition)) {\n      return this.applyVariantLabels(definition);\n    } else if (typeof definition === \"string\") {\n      return this.applyVariantLabels([definition]);\n    } else {\n      this.setValues(definition);\n    }\n  };\n  /**\r\n   * Apply variant labels without animation\r\n   */\n\n\n  ValueAnimationControls.prototype.applyVariantLabels = function (variantLabelList) {\n    var _this = this;\n\n    var isActive = new Set();\n    var reversedList = variantLabelList.slice().reverse();\n    reversedList.forEach(function (key) {\n      var _a = _this.resolveVariant(_this.variants[key]),\n          target = _a.target,\n          transitionEnd = _a.transitionEnd;\n\n      if (transitionEnd) {\n        _this.setValues(transitionEnd, {\n          isActive: isActive\n        });\n      }\n\n      if (target) {\n        _this.setValues(target, {\n          isActive: isActive\n        });\n      }\n\n      if (_this.children && _this.children.size) {\n        _this.children.forEach(function (child) {\n          return child.applyVariantLabels(variantLabelList);\n        });\n      }\n    });\n  };\n\n  ValueAnimationControls.prototype.start = function (definition, opts) {\n    var _this = this;\n\n    if (opts === void 0) {\n      opts = {};\n    }\n\n    if (opts.priority) {\n      this.activeOverrides.add(opts.priority);\n    }\n\n    this.resetIsAnimating(opts.priority);\n    var animation;\n\n    if (isVariantLabels(definition)) {\n      animation = this.animateVariantLabels(definition, opts);\n    } else if (typeof definition === \"string\") {\n      animation = this.animateVariant(definition, opts);\n    } else {\n      animation = this.animate(definition, opts);\n    }\n\n    this.onStart();\n    return animation.then(function () {\n      return _this.onComplete();\n    });\n  };\n\n  ValueAnimationControls.prototype.animate = function (animationDefinition, _a) {\n    var _this = this;\n\n    var _b = _a === void 0 ? {} : _a,\n        _c = _b.delay,\n        delay = _c === void 0 ? 0 : _c,\n        _d = _b.priority,\n        priority = _d === void 0 ? 0 : _d,\n        transitionOverride = _b.transitionOverride;\n\n    var _e = this.resolveVariant(animationDefinition),\n        target = _e.target,\n        transition = _e.transition,\n        transitionEnd = _e.transitionEnd;\n\n    if (transitionOverride) {\n      transition = transitionOverride;\n    }\n\n    if (!target) return Promise.resolve();\n    target = this.transformValues(target);\n\n    if (transitionEnd) {\n      transitionEnd = this.transformValues(transitionEnd);\n    }\n\n    this.checkForNewValues(target);\n\n    if (this.makeTargetAnimatable) {\n      var animatable = this.makeTargetAnimatable(target, transitionEnd);\n      target = animatable.target;\n      transitionEnd = animatable.transitionEnd;\n    }\n\n    if (priority) {\n      this.resolvedOverrides[priority] = target;\n    }\n\n    this.checkForNewValues(target);\n    var animations = [];\n\n    for (var key in target) {\n      var value = this.values.get(key);\n      if (!value || !target || target[key] === undefined) continue;\n      var valueTarget = target[key];\n\n      if (!priority) {\n        this.baseTarget[key] = resolveFinalValueInKeyframes(valueTarget);\n      }\n\n      if (this.isAnimating.has(key)) continue;\n      this.isAnimating.add(key);\n      animations.push(startAnimation(key, value, valueTarget, __assign({\n        delay: delay\n      }, transition)));\n    }\n\n    var allAnimations = Promise.all(animations);\n    return transitionEnd ? allAnimations.then(function () {\n      _this.setValues(transitionEnd, {\n        priority: priority\n      });\n    }) : allAnimations;\n  };\n\n  ValueAnimationControls.prototype.animateVariantLabels = function (variantLabels, opts) {\n    var _this = this;\n\n    var animations = variantLabels.slice().reverse().map(function (label) {\n      return _this.animateVariant(label, opts);\n    });\n    return Promise.all(animations);\n  };\n\n  ValueAnimationControls.prototype.animateVariant = function (variantLabel, opts) {\n    var _this = this;\n\n    var when = false;\n    var delayChildren = 0;\n    var staggerChildren = 0;\n    var staggerDirection = 1;\n    var priority = opts && opts.priority || 0;\n    var variant = this.variants[variantLabel];\n    var getAnimations = variant ? function () {\n      return _this.animate(variant, opts);\n    } : function () {\n      return Promise.resolve();\n    };\n    var getChildrenAnimations = this.children ? function () {\n      return _this.animateChildren(variantLabel, delayChildren, staggerChildren, staggerDirection, priority);\n    } : function () {\n      return Promise.resolve();\n    };\n\n    if (variant && this.children) {\n      var transition = this.resolveVariant(variant).transition;\n\n      if (transition) {\n        when = transition.when || when;\n        delayChildren = transition.delayChildren || delayChildren;\n        staggerChildren = transition.staggerChildren || staggerChildren;\n        staggerDirection = transition.staggerDirection || staggerDirection;\n      }\n    }\n\n    if (when) {\n      var _a = when === \"beforeChildren\" ? [getAnimations, getChildrenAnimations] : [getChildrenAnimations, getAnimations],\n          first = _a[0],\n          last = _a[1];\n\n      return first().then(last);\n    } else {\n      return Promise.all([getAnimations(), getChildrenAnimations()]);\n    }\n  };\n\n  ValueAnimationControls.prototype.animateChildren = function (variantLabel, delayChildren, staggerChildren, staggerDirection, priority) {\n    if (delayChildren === void 0) {\n      delayChildren = 0;\n    }\n\n    if (staggerChildren === void 0) {\n      staggerChildren = 0;\n    }\n\n    if (staggerDirection === void 0) {\n      staggerDirection = 1;\n    }\n\n    if (priority === void 0) {\n      priority = 0;\n    }\n\n    if (!this.children) {\n      return Promise.resolve();\n    }\n\n    var animations = [];\n    var maxStaggerDuration = (this.children.size - 1) * staggerChildren;\n    var generateStaggerDuration = staggerDirection === 1 ? function (i) {\n      return i * staggerChildren;\n    } : function (i) {\n      return maxStaggerDuration - i * staggerChildren;\n    };\n    Array.from(this.children).forEach(function (childControls, i) {\n      var animation = childControls.animateVariant(variantLabel, {\n        priority: priority,\n        delay: delayChildren + generateStaggerDuration(i)\n      });\n      animations.push(animation);\n    });\n    return Promise.all(animations);\n  };\n\n  ValueAnimationControls.prototype.onStart = function () {\n    var onAnimationStart = this.props.onAnimationStart;\n    onAnimationStart && onAnimationStart();\n  };\n\n  ValueAnimationControls.prototype.onComplete = function () {\n    var onAnimationComplete = this.props.onAnimationComplete;\n    onAnimationComplete && onAnimationComplete();\n  };\n\n  ValueAnimationControls.prototype.checkOverrideIsAnimating = function (priority) {\n    var numOverrides = this.overrides.length;\n\n    for (var i = priority + 1; i < numOverrides; i++) {\n      var resolvedOverride = this.resolvedOverrides[i];\n\n      if (resolvedOverride) {\n        for (var key in resolvedOverride) {\n          this.isAnimating.add(key);\n        }\n      }\n    }\n  };\n\n  ValueAnimationControls.prototype.resetIsAnimating = function (priority) {\n    if (priority === void 0) {\n      priority = 0;\n    }\n\n    this.isAnimating.clear(); // If this isn't the highest priority gesture, block the animation\n    // of anything that's currently being animated\n\n    if (priority < this.getHighestPriority()) {\n      this.checkOverrideIsAnimating(priority);\n    }\n\n    if (this.children) {\n      this.children.forEach(function (child) {\n        return child.resetIsAnimating(priority);\n      });\n    }\n  };\n\n  ValueAnimationControls.prototype.stop = function () {\n    this.values.forEach(function (value) {\n      return value.stop();\n    });\n  };\n  /**\r\n   * Add the controls of a child component.\r\n   * @param controls -\r\n   */\n\n\n  ValueAnimationControls.prototype.addChild = function (controls) {\n    if (!this.children) {\n      this.children = new Set();\n    }\n\n    this.children.add(controls); // We set child overrides when `setOverride` is called, but also have to do it here\n    // as the first time `setOverride` is called all the children might not have been added yet.\n\n    this.overrides.forEach(function (override, i) {\n      override && controls.setOverride(override, i);\n    });\n  };\n\n  ValueAnimationControls.prototype.removeChild = function (controls) {\n    if (!this.children) {\n      return;\n    }\n\n    this.children[\"delete\"](controls);\n  };\n\n  ValueAnimationControls.prototype.resetChildren = function () {\n    if (this.children) this.children.clear();\n  };\n\n  return ValueAnimationControls;\n}();\n/**\r\n * Use a callback a maximum number of times\r\n * @param callback - Callback to run\r\n * @param times - Maximum number of times to run the callback. Defaults to `1`\r\n *\r\n * @public\r\n */\n\n\nfunction useMaxTimes(callback, times) {\n  if (times === void 0) {\n    times = 1;\n  }\n\n  var count = useRef(0);\n  if (count.current++ < times) callback();\n}\n/**\r\n * Control animations on one or more components.\r\n *\r\n * @public\r\n */\n\n\nvar AnimationControls =\n/** @class */\nfunction () {\n  function AnimationControls() {\n    /**\r\n     * Track whether the host component has mounted.\r\n     *\r\n     * @internal\r\n     */\n    this.hasMounted = false;\n    /**\r\n     * Pending animations that are started before a component is mounted.\r\n     *\r\n     * @internal\r\n     */\n\n    this.pendingAnimations = [];\n    /**\r\n     * A collection of linked component animation controls.\r\n     *\r\n     * @internal\r\n     */\n\n    this.componentControls = new Set();\n  }\n  /**\r\n   * Set variants on this and all child components.\r\n   *\r\n   * @param variants - The variants to set\r\n   *\r\n   * @internal\r\n   */\n\n\n  AnimationControls.prototype.setVariants = function (variants) {\n    this.variants = variants;\n    this.componentControls.forEach(function (controls) {\n      return controls.setVariants(variants);\n    });\n  };\n  /**\r\n   * Set a default transition on this and all child components\r\n   *\r\n   * @param transition - The default transition to set\r\n   *\r\n   * @internal\r\n   */\n\n\n  AnimationControls.prototype.setDefaultTransition = function (transition) {\n    this.defaultTransition = transition;\n    this.componentControls.forEach(function (controls) {\n      return controls.setDefaultTransition(transition);\n    });\n  };\n  /**\r\n   * Subscribes a component's animation controls to this.\r\n   *\r\n   * @param controls - The controls to subscribe\r\n   * @returns An unsubscribe function.\r\n   *\r\n   * @internal\r\n   */\n\n\n  AnimationControls.prototype.subscribe = function (controls) {\n    var _this = this;\n\n    this.componentControls.add(controls);\n    if (this.variants) controls.setVariants(this.variants);\n    if (this.defaultTransition) controls.setDefaultTransition(this.defaultTransition);\n    return function () {\n      return _this.componentControls[\"delete\"](controls);\n    };\n  };\n  /**\r\n   * Starts an animation on all linked components.\r\n   *\r\n   * @remarks\r\n   *\r\n   * ```jsx\r\n   * controls.start(\"variantLabel\")\r\n   * controls.start({\r\n   *   x: 0,\r\n   *   transition: { duration: 1 }\r\n   * })\r\n   * ```\r\n   *\r\n   * @param definition - Properties or variant label to animate to\r\n   * @param transition - Optional `transtion` to apply to a variant\r\n   * @returns - A `Promise` that resolves when all animations have completed.\r\n   *\r\n   * @public\r\n   */\n\n\n  AnimationControls.prototype.start = function (definition, transitionOverride) {\n    var _this = this;\n\n    if (this.hasMounted) {\n      var animations_1 = [];\n      this.componentControls.forEach(function (controls) {\n        var animation = controls.start(definition, {\n          transitionOverride: transitionOverride\n        });\n        animations_1.push(animation);\n      });\n      return Promise.all(animations_1);\n    } else {\n      return new Promise(function (resolve) {\n        _this.pendingAnimations.push({\n          animation: [definition, transitionOverride],\n          resolve: resolve\n        });\n      });\n    }\n  };\n  /**\r\n   * Instantly set to a set of properties or a variant.\r\n   *\r\n   * ```jsx\r\n   * // With properties\r\n   * controls.set({ opacity: 0 })\r\n   *\r\n   * // With variants\r\n   * controls.set(\"hidden\")\r\n   * ```\r\n   *\r\n   * @internalremarks\r\n   * We could perform a similar trick to `.start` where this can be called before mount\r\n   * and we maintain a list of of pending actions that get applied on mount. But the\r\n   * expectation of `set` is that it happens synchronously and this would be difficult\r\n   * to do before any children have even attached themselves. It's also poor practise\r\n   * and we should discourage render-synchronous `.start` calls rather than lean into this.\r\n   *\r\n   * @public\r\n   */\n\n\n  AnimationControls.prototype.set = function (definition) {\n    invariant(this.hasMounted, \"controls.set() should only be called after a component has mounted. Consider calling within a useEffect hook.\");\n    return this.componentControls.forEach(function (controls) {\n      return controls.apply(definition);\n    });\n  };\n  /**\r\n   * Stops animations on all linked components.\r\n   *\r\n   * ```jsx\r\n   * controls.stop()\r\n   * ```\r\n   *\r\n   * @public\r\n   */\n\n\n  AnimationControls.prototype.stop = function () {\n    this.componentControls.forEach(function (controls) {\n      return controls.stop();\n    });\n  };\n  /**\r\n   * Initialises the animation controls.\r\n   *\r\n   * @internal\r\n   */\n\n\n  AnimationControls.prototype.mount = function () {\n    var _this = this;\n\n    this.hasMounted = true;\n    this.pendingAnimations.forEach(function (_a) {\n      var animation = _a.animation,\n          resolve = _a.resolve;\n      return _this.start.apply(_this, animation).then(resolve);\n    });\n  };\n  /**\r\n   * Stops all child animations when the host component unmounts.\r\n   *\r\n   * @internal\r\n   */\n\n\n  AnimationControls.prototype.unmount = function () {\n    this.hasMounted = false;\n    this.stop();\n  };\n\n  return AnimationControls;\n}();\n/**\r\n * @internal\r\n */\n\n\nvar animationControls = function animationControls() {\n  return new AnimationControls();\n};\n/**\r\n * @internal\r\n */\n\n\nvar MotionContext = createContext({\n  \"static\": false\n});\n\nvar isVariantLabel = function isVariantLabel(v) {\n  return typeof v === \"string\" || Array.isArray(v);\n};\n\nvar isAnimationControls = function isAnimationControls(v) {\n  return v instanceof AnimationControls;\n};\n/**\r\n * Set up the context for children motion components.\r\n *\r\n * We also use this opportunity to apply `initial` values\r\n */\n\n\nvar useMotionContext = function useMotionContext(parentContext, controls, values, isStatic, _a) {\n  if (isStatic === void 0) {\n    isStatic = false;\n  }\n\n  var initial = _a.initial,\n      animate = _a.animate,\n      variants = _a.variants,\n      whileTap = _a.whileTap,\n      whileHover = _a.whileHover;\n  var initialState;\n\n  if (initial === false && !isAnimationControls(animate)) {\n    initialState = animate;\n  } else if (typeof initial !== \"boolean\") {\n    initialState = initial;\n  } // Track mounted status so children can detect whether they were present during their\n  // parent's first render\n\n\n  var hasMounted = useRef(false); // We propagate this component's ValueAnimationControls *if* we're being provided variants,\n  // if we're being used to control variants, or if we're being passed animation controls.\n  // Otherwise this component should be \"invisible\" to variant propagation. This is a slight concession\n  // to Framer X where every `Frame` is a `motion` component and it might be if we change that in the future\n  // that this restriction is removed.\n\n  var shouldPropagateControls = variants || isVariantLabel(animate) || isVariantLabel(whileTap) || isVariantLabel(whileHover) || isAnimationControls(animate); // If this component's `initial` prop is a variant label, propagate it. Otherwise pass the parent's.\n\n  var targetInitial = isVariantLabel(initialState) ? initialState : parentContext.initial; // If this is a variant tree we need to propagate the `animate` prop in case new children are added after\n  // the tree initially animates.\n\n  var targetAnimate = isVariantLabel(animate) ? animate : parentContext.animate; // Only allow `initial` to trigger context re-renders if this is a `static` component (ie we're on the Framer canvas)\n  // or in another non-animation/interaction environment.\n\n  var initialDependency = isStatic ? targetInitial : null; // Only allow `animate` to trigger context re-renders if it's a variant label. If this is an array of\n  // variant labels there's probably an optimisation to deep-compare but it might be an over-optimisation.\n  // We want to do this as we rely on React's component rendering order each render cycle to determine\n  // the new order of any child components for the `staggerChildren` functionality.\n\n  var animateDependency = shouldPropagateControls && isVariantLabel(targetAnimate) ? targetAnimate : null; // The context to provide to the child. We `useMemo` because although `controls` and `initial` are\n  // unlikely to change, by making the context an object it'll be considered a new value every render.\n  // So all child motion components will re-render as a result.\n\n  var context = useMemo(function () {\n    return {\n      controls: shouldPropagateControls ? controls : parentContext.controls,\n      initial: targetInitial,\n      animate: targetAnimate,\n      values: values,\n      hasMounted: hasMounted\n    };\n  }, [initialDependency, animateDependency]); // Update the `static` property every render. This is unlikely to change but also essentially free.\n\n  context[\"static\"] = isStatic; // Set initial state. If this is a static component (ie in Framer canvas), respond to updates\n  // in `initial`.\n\n  useMaxTimes(function () {\n    var initialToApply = initialState || parentContext.initial;\n    initialToApply && controls.apply(initialToApply);\n  }, isStatic ? Infinity : 1);\n  useEffect(function () {\n    hasMounted.current = true;\n  }, []);\n  return context;\n};\n/**\r\n * Creates an imperative set of controls to trigger animations.\r\n *\r\n * This allows a consolidated, uniform API for animations, to be triggered by other APIs like the `animate` prop, or the gesture handlers.\r\n *\r\n * @param values\r\n * @param props\r\n * @param ref\r\n * @param subscribeToParentControls\r\n *\r\n * @internal\r\n */\n\n\nfunction useValueAnimationControls(config, props, subscribeToParentControls) {\n  var variants = props.variants,\n      transition = props.transition;\n  var parentControls = useContext(MotionContext).controls;\n  var controls = useConstant(function () {\n    return new ValueAnimationControls(config);\n  }); // Reset and resubscribe children every render to ensure stagger order is correct\n\n  controls.resetChildren();\n  controls.setProps(props);\n  controls.setVariants(variants);\n  controls.setDefaultTransition(transition);\n\n  if (subscribeToParentControls && parentControls) {\n    parentControls.addChild(controls);\n  }\n\n  useEffect(function () {\n    return function () {\n      // Remove reference to onAnimationComplete from controls. All the MotionValues\n      // are unsubscribed from this component separately. We let animations run out\n      // as they might be animating other components.\n      var onAnimationComplete = props.onAnimationComplete,\n          unmountProps = __rest(props, [\"onAnimationComplete\"]);\n\n      controls.setProps(unmountProps);\n      parentControls && parentControls.removeChild(controls);\n    };\n  }, []);\n  return controls;\n}\n\nfunction applyExitProps(props, _a) {\n  var initial = _a.initial,\n      isExiting = _a.isExiting,\n      custom = _a.custom,\n      onExitComplete = _a.onExitComplete;\n\n  if (isExiting) {\n    invariant(!!props.exit, \"No exit animation defined.\");\n    return __assign({}, props, {\n      /**\r\n       * Overwrite user-defined `custom` with the one incoming from `AnimatePresence`.\r\n       * This will only be defined when a component is exiting and it allows a user\r\n       * to update `custom` even when a component has been removed from the tree.\r\n       */\n      custom: custom !== undefined ? custom : props.custom,\n      // Animate to `exit` just by overwriting `animate`.\n      animate: props.exit,\n      onAnimationComplete: function onAnimationComplete() {\n        onExitComplete && onExitComplete();\n        props.onAnimationComplete && props.onAnimationComplete();\n      }\n    });\n  } else if (initial === false) {\n    return __assign({}, props, {\n      initial: initial\n    });\n  }\n\n  return props;\n}\n\nvar checkShouldInheritVariant = function checkShouldInheritVariant(_a) {\n  var animate = _a.animate,\n      variants = _a.variants,\n      _b = _a.inherit,\n      inherit = _b === void 0 ? true : _b;\n  return inherit && !!variants && (!animate || animate instanceof AnimationControls);\n};\n/**\r\n * @internal\r\n */\n\n\nvar createMotionComponent = function createMotionComponent(_a) {\n  var getValueControlsConfig = _a.getValueControlsConfig,\n      loadFunctionalityComponents = _a.loadFunctionalityComponents,\n      renderComponent = _a.renderComponent;\n\n  function MotionComponent(props, externalRef) {\n    var ref = useExternalRef(externalRef);\n\n    var _a = useContext(MotionContext),\n        exitProps = _a.exitProps,\n        parentContext = __rest(_a, [\"exitProps\"]);\n\n    if (exitProps) {\n      props = applyExitProps(props, exitProps);\n    }\n\n    var isStatic = parentContext[\"static\"] || props[\"static\"] || false;\n    var values = useMotionValues(props);\n    var style = useMotionStyles(values, props.style, isStatic, props.transformValues);\n    var shouldInheritVariant = checkShouldInheritVariant(props);\n    var controlsConfig = useConstant(function () {\n      return getValueControlsConfig(ref, values);\n    });\n    var controls = useValueAnimationControls(controlsConfig, props, shouldInheritVariant);\n    var context = useMotionContext(parentContext, controls, values, isStatic, props);\n    var functionality = isStatic ? null : loadFunctionalityComponents(ref, values, props, controls, shouldInheritVariant);\n    var renderedComponent = renderComponent(ref, style, values, props, isStatic);\n    return createElement(Fragment, null, createElement(MountMotionValues, {\n      ref: ref,\n      values: values,\n      isStatic: isStatic\n    }), functionality, createElement(MotionContext.Provider, {\n      value: context\n    }, renderedComponent));\n  }\n\n  return forwardRef(MotionComponent);\n};\n/**\r\n * @internal\r\n */\n\n\nvar htmlElements = [\"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\", \"webview\"];\n/**\r\n * @internal\r\n */\n\nvar svgElements = [\"animate\", \"circle\", \"clipPath\", \"defs\", \"desc\", \"ellipse\", \"feBlend\", \"feColorMatrix\", \"feComponentTransfer\", \"feComposite\", \"feConvolveMatrix\", \"feDiffuseLighting\", \"feDisplacementMap\", \"feDistantLight\", \"feDropShadow\", \"feFlood\", \"feFuncA\", \"feFuncB\", \"feFuncG\", \"feFuncR\", \"feGaussianBlur\", \"feImage\", \"feMerge\", \"feMergeNode\", \"feMorphology\", \"feOffset\", \"fePointLight\", \"feSpecularLighting\", \"feSpotLight\", \"feTile\", \"feTurbulence\", \"filter\", \"foreignObject\", \"g\", \"image\", \"line\", \"linearGradient\", \"marker\", \"mask\", \"metadata\", \"path\", \"pattern\", \"polygon\", \"polyline\", \"radialGradient\", \"rect\", \"stop\", \"svg\", \"switch\", \"symbol\", \"text\", \"textPath\", \"tspan\", \"use\", \"view\"];\n/** @public */\n\nvar Point;\n\n(function (Point) {\n  /** @beta */\n  Point.subtract = function (a, b) {\n    return {\n      x: a.x - b.x,\n      y: a.y - b.y\n    };\n  };\n  /** @beta */\n\n\n  Point.relativeTo = function (idOrElem) {\n    var elem;\n\n    var getElem = function getElem() {\n      // Caching element here could be leaky because of React lifecycle\n      if (elem !== undefined) return elem;\n\n      if (typeof idOrElem === \"string\") {\n        elem = document.getElementById(idOrElem);\n      } else {\n        elem = idOrElem;\n      }\n\n      return elem;\n    };\n\n    return function (_a) {\n      var x = _a.x,\n          y = _a.y;\n      var localElem = getElem();\n      if (!localElem) return undefined;\n      var rect = localElem.getBoundingClientRect();\n      return {\n        x: x - rect.left - window.scrollX,\n        y: y - rect.top - window.scrollY\n      };\n    };\n  };\n})(Point || (Point = {}));\n/**\r\n * @internal\r\n */\n\n\nvar MotionPluginContext = createContext({\n  transformPagePoint: function transformPagePoint(p) {\n    return p;\n  }\n});\n/**\r\n * @internal\r\n * @internalremarks For now I think this should remain a private API for our own use\r\n * until we can figure out a nicer way of allowing people to add these\r\n */\n\nfunction MotionPlugins(_a) {\n  var children = _a.children,\n      props = __rest(_a, [\"children\"]);\n\n  var pluginContext = useContext(MotionPluginContext);\n  var value = useRef(__assign({}, pluginContext)).current; // Mutative to prevent triggering rerenders in all listening\n  // components every time this component renders\n\n  for (var key in props) {\n    value[key] = props[key];\n  }\n\n  return createElement(MotionPluginContext.Provider, {\n    value: value\n  }, children);\n}\n\nvar isViewportScrollBlocked = false;\nvar isBrowser = typeof window !== \"undefined\";\n\nif (isBrowser) {\n  window.addEventListener(\"touchmove\", function (event) {\n    if (isViewportScrollBlocked) {\n      event.preventDefault();\n    }\n  }, {\n    passive: false\n  });\n}\n\nvar blockViewportScroll = function blockViewportScroll() {\n  return isViewportScrollBlocked = true;\n};\n\nvar unblockViewportScroll = function unblockViewportScroll() {\n  return isViewportScrollBlocked = false;\n};\n\nfunction isMouseEvent(event) {\n  // PointerEvent inherits from MouseEvent so we can't use a straight instanceof check.\n  if (typeof PointerEvent !== \"undefined\" && event instanceof PointerEvent) {\n    return !!(event.pointerType === \"mouse\");\n  }\n\n  return event instanceof MouseEvent;\n}\n\nfunction isTouchEvent(event) {\n  var hasTouches = !!event.touches;\n  return hasTouches;\n}\n\nfunction useUnmountEffect(callback) {\n  return useEffect(function () {\n    return function () {\n      return callback();\n    };\n  }, []);\n}\n\nfunction addDomEvent(target, eventName, handler, options) {\n  if (!handler) return;\n  target.addEventListener(eventName, handler, options);\n  return function () {\n    return target.removeEventListener(eventName, handler, options);\n  };\n}\n/**\r\n * Attaches an event listener directly to the provided DOM element.\r\n *\r\n * Bypassing React's event system can be desirable, for instance when attaching non-passive\r\n * event handlers.\r\n *\r\n * ```jsx\r\n * const ref = useRef(null)\r\n *\r\n * useDomEvent(ref, 'wheel', onWheel, { passive: false })\r\n *\r\n * return <div ref={ref} />\r\n * ```\r\n *\r\n * @param ref - React.RefObject that's been provided to the element you want to bind the listener to.\r\n * @param eventName - Name of the event you want listen for.\r\n * @param handler - Function to fire when receiving the event.\r\n * @param options - Options to pass to `Event.addEventListener`.\r\n *\r\n * @public\r\n */\n\n\nfunction useDomEvent(ref, eventName, handler, options) {\n  useEffect(function () {\n    var element = ref.current;\n\n    if (handler && element) {\n      return addDomEvent(element, eventName, handler, options);\n    }\n  }, [ref, eventName, handler, options]);\n}\n/**\r\n * Filters out events not attached to the primary pointer (currently left mouse button)\r\n * @param eventHandler\r\n */\n\n\nfunction filterPrimaryPointer(eventHandler) {\n  if (!eventHandler) return undefined;\n  return function (event) {\n    var isMouseEvent = event instanceof MouseEvent;\n    var isPrimaryPointer = !isMouseEvent || isMouseEvent && event.button === 0;\n\n    if (isPrimaryPointer) {\n      eventHandler(event);\n    }\n  };\n}\n\nvar defaultPagePoint = {\n  pageX: 0,\n  pageY: 0\n};\n\nfunction pointFromTouch(e) {\n  var primaryTouch = e.touches[0] || e.changedTouches[0];\n\n  var _a = primaryTouch || defaultPagePoint,\n      pageX = _a.pageX,\n      pageY = _a.pageY;\n\n  return {\n    x: pageX,\n    y: pageY\n  };\n}\n\nfunction pointFromMouse(_a) {\n  var _b = _a.pageX,\n      pageX = _b === void 0 ? 0 : _b,\n      _c = _a.pageY,\n      pageY = _c === void 0 ? 0 : _c;\n  return {\n    x: pageX,\n    y: pageY\n  };\n}\n\nfunction extractEventInfo(event) {\n  return {\n    point: isTouchEvent(event) ? pointFromTouch(event) : pointFromMouse(event)\n  };\n}\n\nvar wrapHandler = function wrapHandler(handler, shouldFilterPrimaryPointer) {\n  if (shouldFilterPrimaryPointer === void 0) {\n    shouldFilterPrimaryPointer = false;\n  }\n\n  if (!handler) return;\n\n  var listener = function listener(event) {\n    return handler(event, extractEventInfo(event));\n  };\n\n  return shouldFilterPrimaryPointer ? filterPrimaryPointer(listener) : listener;\n}; // We check for event support via functions in case they've been mocked by a testing suite.\n\n\nvar isBrowser$1 = typeof window !== \"undefined\";\n\nvar supportsPointerEvents = function supportsPointerEvents() {\n  return isBrowser$1 && window.onpointerdown === null;\n};\n\nvar supportsTouchEvents = function supportsTouchEvents() {\n  return isBrowser$1 && window.ontouchstart === null;\n};\n\nvar supportsMouseEvents = function supportsMouseEvents() {\n  return isBrowser$1 && window.onmousedown === null;\n};\n\nvar mouseEventNames = {\n  pointerdown: \"mousedown\",\n  pointermove: \"mousemove\",\n  pointerup: \"mouseup\",\n  pointercancel: \"mousecancel\",\n  pointerover: \"mouseover\",\n  pointerout: \"mouseout\",\n  pointerenter: \"mouseenter\",\n  pointerleave: \"mouseleave\"\n};\nvar touchEventNames = {\n  pointerdown: \"touchstart\",\n  pointermove: \"touchmove\",\n  pointerup: \"touchend\",\n  pointercancel: \"touchcancel\"\n};\n\nfunction getPointerEventName(name) {\n  if (supportsPointerEvents()) {\n    return name;\n  } else if (supportsTouchEvents()) {\n    return touchEventNames[name];\n  } else if (supportsMouseEvents()) {\n    return mouseEventNames[name];\n  }\n\n  return name;\n}\n\nfunction addPointerEvent(target, eventName, handler, options) {\n  return addDomEvent(target, getPointerEventName(eventName), wrapHandler(handler, eventName === \"pointerdown\"), options);\n}\n\nfunction usePointerEvent(ref, eventName, handler, options) {\n  return useDomEvent(ref, getPointerEventName(eventName), wrapHandler(handler, eventName === \"pointerdown\"), options);\n}\n\nfunction startDevicePoint(session) {\n  return session.pointHistory[0];\n}\n\nfunction lastDevicePoint(session) {\n  return session.pointHistory[session.pointHistory.length - 1];\n}\n\nfunction getVelocity$1(session, timeDelta) {\n  var pointHistory = session.pointHistory;\n\n  if (pointHistory.length < 2) {\n    return {\n      x: 0,\n      y: 0\n    };\n  }\n\n  var i = pointHistory.length - 1;\n  var timestampedPoint = null;\n  var lastPoint = lastDevicePoint(session);\n\n  while (i >= 0) {\n    timestampedPoint = pointHistory[i];\n\n    if (lastPoint.timestamp - timestampedPoint.timestamp > secondsToMilliseconds(timeDelta)) {\n      break;\n    }\n\n    i--;\n  }\n\n  if (!timestampedPoint) {\n    return {\n      x: 0,\n      y: 0\n    };\n  }\n\n  var time = (lastPoint.timestamp - timestampedPoint.timestamp) / 1000;\n\n  if (time === 0) {\n    return {\n      x: 0,\n      y: 0\n    };\n  }\n\n  var currentVelocity = {\n    x: (lastPoint.x - timestampedPoint.x) / time,\n    y: (lastPoint.y - timestampedPoint.y) / time\n  };\n\n  if (currentVelocity.x === Infinity) {\n    currentVelocity.x = 0;\n  }\n\n  if (currentVelocity.y === Infinity) {\n    currentVelocity.y = 0;\n  }\n\n  return currentVelocity;\n}\n/**\r\n *\r\n * @param handlers -\r\n * @param ref -\r\n *\r\n * @internalremarks\r\n * Currently this sets new pan gesture functions every render. The memo route has been explored\r\n * in the past but ultimately we're still creating new functions every render. An optimisation\r\n * to explore is creating the pan gestures and loading them into a `ref`.\r\n *\r\n * @internal\r\n */\n\n\nfunction usePanGesture(_a, ref) {\n  var onPan = _a.onPan,\n      onPanStart = _a.onPanStart,\n      onPanEnd = _a.onPanEnd,\n      onPanSessionStart = _a.onPanSessionStart;\n  var hasPanEvents = onPan || onPanStart || onPanEnd || onPanSessionStart;\n  var session = useRef(null);\n  var lastMoveEvent = useRef(null);\n  var lastMoveEventInfo = useRef(null);\n  var transformPagePoint = useContext(MotionPluginContext).transformPagePoint;\n  var pointerEventSubscription = useRef(null); // Load the callbacks into mutable state to ensure that even if we don't create a new\n  // gesture handler every render, we still reference the latest callbacks (which are almost certain to change per render)\n\n  var handlers = useRef({}).current;\n  handlers.onPanSessionStart = onPanSessionStart;\n  handlers.onPanStart = onPanStart;\n  handlers.onPan = onPan;\n  handlers.onPanEnd = onPanEnd;\n\n  function removePointerEvents() {\n    pointerEventSubscription.current && pointerEventSubscription.current();\n    pointerEventSubscription.current = null;\n  }\n\n  function getPanInfo(_a) {\n    var point = _a.point;\n    var currentPoint = session.current; // TODO: A potential optimisation here that might be a breaking change would be\n    // to keep one mutable ref to a point that we update\n\n    return {\n      point: point,\n      delta: Point.subtract(point, lastDevicePoint(currentPoint)),\n      offset: Point.subtract(point, startDevicePoint(currentPoint)),\n      velocity: getVelocity$1(currentPoint, 0.1)\n    };\n  }\n\n  function transformPoint(info) {\n    return {\n      point: transformPagePoint(info.point)\n    };\n  }\n\n  function cancelPan() {\n    removePointerEvents();\n    cancelSync.update(updatePoint);\n    unblockViewportScroll();\n  }\n\n  function updatePoint() {\n    if (!session.current || !lastMoveEvent.current || !lastMoveEventInfo.current) {\n      warning(false, \"onPointerMove fired without pointer session\");\n      cancelPan();\n      return;\n    }\n\n    var info = getPanInfo(lastMoveEventInfo.current);\n    var panStarted = session.current.startEvent !== undefined; // Only start panning if the offset is larger than 3 pixels. If we make it\n    // any larger than this we'll want to reset the pointer history\n    // on the first update to avoid visual snapping to the cursoe.\n\n    var distancePastThreshold = distance(info.offset, {\n      x: 0,\n      y: 0\n    }) >= 3;\n    if (!panStarted && !distancePastThreshold) return;\n    var point = info.point;\n    var timestamp = getFrameData().timestamp;\n    session.current.pointHistory.push(__assign({}, point, {\n      timestamp: timestamp\n    }));\n\n    if (!panStarted) {\n      handlers.onPanStart && handlers.onPanStart(lastMoveEvent.current, info);\n      session.current.startEvent = lastMoveEvent.current;\n    }\n\n    handlers.onPan && handlers.onPan(lastMoveEvent.current, info);\n  }\n\n  function onPointerMove(event, info) {\n    lastMoveEvent.current = event;\n    lastMoveEventInfo.current = transformPoint(info); // Because Safari doesn't trigger mouseup events when it's above a `<select>`\n\n    if (isMouseEvent(event) && event.buttons === 0) {\n      onPointerUp(event, info);\n      return;\n    } // Throttle mouse move event to once per frame\n\n\n    sync.update(updatePoint, true);\n  }\n\n  function onPointerUp(event, info) {\n    cancelPan();\n\n    if (!session.current) {\n      warning(false, \"onPointerUp fired without pointer session\");\n      return;\n    }\n\n    handlers.onPanEnd && handlers.onPanEnd(event, getPanInfo(transformPoint(info)));\n    session.current = null;\n  }\n\n  function onPointerDown(event, info) {\n    // If we have more than one touch, don't start detecting this gesture\n    if (isTouchEvent(event) && event.touches.length > 1) return;\n    var initialInfo = transformPoint(info);\n    var point = initialInfo.point;\n    var timestamp = getFrameData().timestamp;\n    session.current = {\n      target: event.target,\n      pointHistory: [__assign({}, point, {\n        timestamp: timestamp\n      })]\n    };\n    handlers.onPanSessionStart && handlers.onPanSessionStart(event, getPanInfo(initialInfo));\n    removePointerEvents();\n    var removeOnPointerMove = addPointerEvent(window, \"pointermove\", onPointerMove);\n    var removeOnPointerUp = addPointerEvent(window, \"pointerup\", onPointerUp);\n\n    pointerEventSubscription.current = function () {\n      removeOnPointerMove && removeOnPointerMove();\n      removeOnPointerUp && removeOnPointerUp();\n    };\n  }\n\n  usePointerEvent(ref, \"pointerdown\", hasPanEvents && onPointerDown);\n  useUnmountEffect(cancelPan);\n}\n/**\r\n * Recursively traverse up the tree to check whether the provided child node\r\n * is the parent or a descendant of it.\r\n *\r\n * @param parent - Element to find\r\n * @param child - Element to test against parent\r\n */\n\n\nvar isNodeOrChild = function isNodeOrChild(parent, child) {\n  if (!child) {\n    return false;\n  } else if (parent === child) {\n    return true;\n  } else {\n    return isNodeOrChild(parent, child.parentElement);\n  }\n};\n\nvar order = [\"whileHover\", \"whileTap\", \"whileDrag\"];\n\nvar getGesturePriority = function getGesturePriority(gesture) {\n  return order.indexOf(gesture) + 1;\n};\n\nfunction createLock(name) {\n  var lock = null;\n  return function () {\n    var openLock = function openLock() {\n      lock = null;\n    };\n\n    if (lock === null) {\n      lock = name;\n      return openLock;\n    }\n\n    return false;\n  };\n}\n\nvar globalHorizontalLock = createLock(\"dragHorizontal\");\nvar globalVerticalLock = createLock(\"dragVertical\");\n\nfunction getGlobalLock(drag) {\n  var lock = false;\n\n  if (drag === \"y\") {\n    lock = globalVerticalLock();\n  } else if (drag === \"x\") {\n    lock = globalHorizontalLock();\n  } else {\n    var openHorizontal_1 = globalHorizontalLock();\n    var openVertical_1 = globalVerticalLock();\n\n    if (openHorizontal_1 && openVertical_1) {\n      lock = function lock() {\n        openHorizontal_1();\n        openVertical_1();\n      };\n    } else {\n      // Release the locks because we don't use them\n      if (openHorizontal_1) openHorizontal_1();\n      if (openVertical_1) openVertical_1();\n    }\n  }\n\n  return lock;\n}\n\nvar tapGesturePriority = getGesturePriority(\"whileTap\");\n/**\r\n * @param handlers -\r\n * @internal\r\n */\n\nfunction useTapGesture(_a, ref) {\n  var onTap = _a.onTap,\n      onTapStart = _a.onTapStart,\n      onTapCancel = _a.onTapCancel,\n      whileTap = _a.whileTap,\n      controls = _a.controls;\n  var hasTapListeners = onTap || onTapStart || onTapCancel || whileTap;\n  var isTapping = useRef(false);\n  var cancelPointerEventListener = useRef(null);\n\n  function removePointerUp() {\n    cancelPointerEventListener.current && cancelPointerEventListener.current();\n    cancelPointerEventListener.current = null;\n  }\n\n  if (whileTap && controls) {\n    controls.setOverride(whileTap, tapGesturePriority);\n  } // We load this event handler into a ref so we can later refer to\n  // onPointerUp.current which will always have reference to the latest props\n\n\n  var onPointerUp = useRef(null);\n\n  onPointerUp.current = function (event, info) {\n    var element = ref.current;\n    removePointerUp();\n    if (!isTapping.current || !element) return;\n    isTapping.current = false;\n\n    if (controls && whileTap) {\n      controls.clearOverride(tapGesturePriority);\n    } // Check the gesture lock - if we get it, it means no drag gesture is active\n    // and we can safely fire the tap gesture.\n\n\n    var openGestureLock = getGlobalLock(true);\n    if (!openGestureLock) return;\n    openGestureLock();\n\n    if (!isNodeOrChild(element, event.target)) {\n      onTapCancel && onTapCancel(event, info);\n    } else {\n      onTap && onTap(event, info);\n    }\n  };\n\n  function onPointerDown(event, info) {\n    removePointerUp();\n    cancelPointerEventListener.current = addPointerEvent(window, \"pointerup\", function (event, info) {\n      return onPointerUp.current(event, info);\n    });\n    var element = ref.current;\n    if (!element || isTapping.current) return;\n    isTapping.current = true;\n    onTapStart && onTapStart(event, info);\n\n    if (controls && whileTap) {\n      controls.startOverride(tapGesturePriority);\n    }\n  }\n\n  usePointerEvent(ref, \"pointerdown\", hasTapListeners ? onPointerDown : undefined);\n  useUnmountEffect(removePointerUp);\n}\n\nvar hoverPriority = getGesturePriority(\"whileHover\");\n\nvar filterTouch = function filterTouch(listener) {\n  return function (event, info) {\n    if (isMouseEvent(event)) listener(event, info);\n  };\n};\n/**\r\n *\r\n * @param props\r\n * @param ref\r\n * @internal\r\n */\n\n\nfunction useHoverGesture(_a, ref) {\n  var whileHover = _a.whileHover,\n      onHoverStart = _a.onHoverStart,\n      onHoverEnd = _a.onHoverEnd,\n      controls = _a.controls;\n\n  if (whileHover && controls) {\n    controls.setOverride(whileHover, hoverPriority);\n  }\n\n  usePointerEvent(ref, \"pointerenter\", filterTouch(function (event, info) {\n    if (onHoverStart) onHoverStart(event, info);\n\n    if (whileHover && controls) {\n      controls.startOverride(hoverPriority);\n    }\n  }));\n  usePointerEvent(ref, \"pointerleave\", filterTouch(function (event, info) {\n    if (onHoverEnd) onHoverEnd(event, info);\n\n    if (whileHover && controls) {\n      controls.clearOverride(hoverPriority);\n    }\n  }));\n}\n/**\r\n * Add pan and tap gesture recognition to an element.\r\n *\r\n * @param props - Gesture event handlers\r\n * @param ref - React `ref` containing a DOM `Element`\r\n * @public\r\n */\n\n\nfunction useGestures(props, ref) {\n  usePanGesture(props, ref);\n  useTapGesture(props, ref);\n  useHoverGesture(props, ref);\n}\n\nvar makeHookComponent = function makeHookComponent(hook) {\n  return function (props) {\n    hook(props);\n    return null;\n  };\n};\n\nvar gestureProps = [\"drag\", \"onPan\", \"onPanStart\", \"onPanEnd\", \"onPanSessionStart\", \"onTap\", \"onTapStart\", \"onTapCancel\", \"whileTap\", \"whileHover\", \"onHoverStart\", \"onHoverEnd\"];\nvar Gestures = {\n  key: \"gestures\",\n  shouldRender: function shouldRender(props) {\n    return gestureProps.some(function (key) {\n      return props.hasOwnProperty(key);\n    });\n  },\n  Component: makeHookComponent(function (_a) {\n    var innerRef = _a.innerRef,\n        props = __rest(_a, [\"innerRef\"]);\n\n    useGestures(props, innerRef);\n  })\n};\n\nvar isRefObject = function isRefObject(ref) {\n  return typeof ref === \"object\" && ref.hasOwnProperty(\"current\");\n};\n/**\r\n * A hook to use the window resize listener. In future it might be cool to use `ResizeObserver`\r\n * but it currently needs to be polyfilled and the size trade-off isn't there for this use-case.\r\n *\r\n * TODO: Debounce this bad boy\r\n *\r\n * @param onResize\r\n */\n\n\nfunction useResize(element, onResize) {\n  useEffect(function () {\n    if (!element || !isRefObject(element)) return;\n    window.addEventListener(\"resize\", onResize);\n    return function () {\n      return window.removeEventListener(\"resize\", onResize);\n    };\n  }, [element, onResize]);\n}\n/**\r\n * Creates a `MotionValue` to track the state and velocity of a value.\r\n *\r\n * Usually, these are created automatically. For advanced use-cases, like use with `useTransform`, you can create `MotionValue`s externally and pass them into the animated component via the `style` prop.\r\n *\r\n * @library\r\n *\r\n * ```jsx\r\n * export function MyComponent() {\r\n *   const scale = useMotionValue(1)\r\n *\r\n *   return <Frame scale={scale} />\r\n * }\r\n * ```\r\n *\r\n * @motion\r\n *\r\n * ```jsx\r\n * export const MyComponent = () => {\r\n *   const scale = useMotionValue(1)\r\n *\r\n *   return <motion.div style={{ scale }} />\r\n * }\r\n * ```\r\n *\r\n * @param initial - The initial state.\r\n *\r\n * @public\r\n */\n\n\nfunction useMotionValue(initial) {\n  return useConstant(function () {\n    return motionValue(initial);\n  });\n}\n/**\r\n * Don't block the default pointerdown behaviour of these elements.\r\n */\n\n\nvar allowDefaultPointerDown = new Set([\"INPUT\", \"TEXTAREA\", \"SELECT\"]);\n\nvar getBoundingBox = function getBoundingBox(ref, transformPagePoint) {\n  var rect = ref.current.getBoundingClientRect();\n\n  var _a = transformPagePoint({\n    x: rect.left,\n    y: rect.top\n  }),\n      left = _a.x,\n      top = _a.y;\n\n  var _b = transformPagePoint({\n    x: rect.width,\n    y: rect.height\n  }),\n      width = _b.x,\n      height = _b.y;\n\n  return {\n    left: left,\n    top: top,\n    width: width,\n    height: height\n  };\n};\n\nvar getCurrentOffset = function getCurrentOffset(point) {\n  return point ? point.get() : 0;\n};\n/**\r\n * Takes a parent Element and a draggable Element and returns pixel-based drag constraints.\r\n *\r\n * @param constraintsRef\r\n * @param draggableRef\r\n */\n\n\nvar calculateConstraintsFromDom = function calculateConstraintsFromDom(constraintsRef, draggableRef, point, transformPagePoint) {\n  invariant(constraintsRef.current !== null && draggableRef.current !== null, \"If `dragConstraints` is set as a React ref, that ref must be passed to another component's `ref` prop.\");\n  var parentBoundingBox = getBoundingBox(constraintsRef, transformPagePoint);\n  var draggableBoundingBox = getBoundingBox(draggableRef, transformPagePoint);\n  var left = parentBoundingBox.left - draggableBoundingBox.left + getCurrentOffset(point.x);\n  var top = parentBoundingBox.top - draggableBoundingBox.top + getCurrentOffset(point.y);\n  var right = parentBoundingBox.width - draggableBoundingBox.width + left;\n  var bottom = parentBoundingBox.height - draggableBoundingBox.height + top;\n  return {\n    top: top,\n    left: left,\n    right: right,\n    bottom: bottom\n  };\n};\n\nfunction shouldDrag(direction, drag, currentDirection) {\n  return (drag === true || drag === direction) && (currentDirection === null || currentDirection === direction);\n}\n\nvar getConstraints = function getConstraints(axis, _a) {\n  var top = _a.top,\n      right = _a.right,\n      bottom = _a.bottom,\n      left = _a.left;\n\n  if (axis === \"x\") {\n    return {\n      min: left,\n      max: right\n    };\n  } else {\n    return {\n      min: top,\n      max: bottom\n    };\n  }\n};\n\nfunction applyConstraints(axis, value, constraints, dragElastic) {\n  var constrainedValue = value instanceof MotionValue ? value.get() : value;\n\n  if (!constraints) {\n    return constrainedValue;\n  }\n\n  var _a = getConstraints(axis, constraints),\n      min = _a.min,\n      max = _a.max;\n\n  if (min !== undefined && constrainedValue < min) {\n    constrainedValue = dragElastic ? applyOverdrag(min, constrainedValue, dragElastic) : Math.max(min, constrainedValue);\n  } else if (max !== undefined && constrainedValue > max) {\n    constrainedValue = dragElastic ? applyOverdrag(max, constrainedValue, dragElastic) : Math.min(max, constrainedValue);\n  }\n\n  if (value instanceof MotionValue) {\n    value.set(constrainedValue);\n  }\n\n  return constrainedValue;\n}\n\nfunction applyOverdrag(origin, current, dragElastic) {\n  var dragFactor = typeof dragElastic === \"number\" ? dragElastic : 0.35;\n  return mix(origin, current, dragFactor);\n}\n\nfunction bothAxis(handler) {\n  return [handler(\"x\"), handler(\"y\")];\n}\n/**\r\n * A hook that allows an element to be dragged.\r\n *\r\n * @param param\r\n * @param ref\r\n * @param values\r\n * @param controls\r\n *\r\n * @internal\r\n */\n\n\nfunction useDrag(_a, ref, values, controls) {\n  var _b = _a.drag,\n      drag = _b === void 0 ? false : _b,\n      _c = _a.dragDirectionLock,\n      dragDirectionLock = _c === void 0 ? false : _c,\n      _d = _a.dragPropagation,\n      dragPropagation = _d === void 0 ? false : _d,\n      _e = _a.dragConstraints,\n      dragConstraints = _e === void 0 ? false : _e,\n      _f = _a.dragElastic,\n      dragElastic = _f === void 0 ? true : _f,\n      _g = _a.dragMomentum,\n      dragMomentum = _g === void 0 ? true : _g,\n      _dragValueX = _a._dragValueX,\n      _dragValueY = _a._dragValueY,\n      _dragTransitionControls = _a._dragTransitionControls,\n      dragOriginX = _a.dragOriginX,\n      dragOriginY = _a.dragOriginY,\n      dragTransition = _a.dragTransition,\n      onDirectionLock = _a.onDirectionLock,\n      onDragStart = _a.onDragStart,\n      onDrag = _a.onDrag,\n      onDragEnd = _a.onDragEnd,\n      onDragTransitionEnd = _a.onDragTransitionEnd; // If `dragConstraints` is a React `ref`, we should resolve the constraints once the\n  // component has rendered.\n\n  var constraintsNeedResolution = isRefObject(dragConstraints); // We create a mutable state using a ref as we want to keep track of certain data, even across renders,\n  // but we don't want to re-render as a result of them.\n\n  var dragStatus = useRef({\n    isDragging: false,\n    currentDirection: null,\n    constraints: false,\n    handlers: {}\n  }).current; // Load the callbacks into mutable state to ensure that even if we don't create a new\n  // gesture handler every render, we still reference the latest callbacks (which are almost certain to change per render)\n\n  var handlers = dragStatus.handlers;\n  handlers.onDragStart = onDragStart;\n  handlers.onDrag = onDrag;\n  handlers.onDragEnd = onDragEnd;\n  handlers.onDirectionLock = onDirectionLock;\n  handlers.onDragTransitionEnd = onDragTransitionEnd;\n  var point = useRef({}).current; // Track origin\n\n  var defaultOriginX = useMotionValue(0);\n  var defaultOriginY = useMotionValue(0);\n  var origin = {\n    x: dragOriginX || defaultOriginX,\n    y: dragOriginY || defaultOriginY\n  }; // This is a reference to the global drag gesture lock, ensuring only one component\n  // can \"capture\" the drag of one or both axes.\n\n  var openGlobalLock = useRef(null);\n  var transformPagePoint = useContext(MotionPluginContext).transformPagePoint; // If `dragConstraints` is a React `ref`, we need to track changes in its\n  // size and update the current draggable position relative to that.\n\n  var prevConstraintsBox = useRef({\n    width: 0,\n    height: 0,\n    x: 0,\n    y: 0\n  }).current;\n\n  var scalePoint = function scalePoint() {\n    if (!isRefObject(dragConstraints)) return;\n    var constraintsBox = getBoundingBox(dragConstraints, transformPagePoint);\n    var draggableBox = getBoundingBox(ref, transformPagePoint); // Scale a point relative to the transformation of a constraints-providing element.\n\n    var scaleAxisPoint = function scaleAxisPoint(axis, dimension) {\n      var pointToScale = point[axis];\n      if (!pointToScale) return; // Stop any current animations as they bug out if you resize during one\n\n      if (pointToScale.isAnimating()) {\n        pointToScale.stop();\n        recordBoxInfo();\n        return;\n      } // If the previous dimension was `0` (default), set `scale` to `1` to prevent\n      // divide by zero errors.\n\n\n      var scale = prevConstraintsBox[dimension] ? (constraintsBox[dimension] - draggableBox[dimension]) / prevConstraintsBox[dimension] : 1;\n      pointToScale.set(prevConstraintsBox[axis] * scale);\n    };\n\n    scaleAxisPoint(\"x\", \"width\");\n    scaleAxisPoint(\"y\", \"height\");\n  };\n\n  useResize(dragConstraints, scalePoint); // If our drag constraints are a potentially live bounding box, record its previously-calculated\n  // dimensions and the current x/y\n\n  var recordBoxInfo = function recordBoxInfo(constraints) {\n    if (constraints) {\n      var right = constraints.right,\n          left = constraints.left,\n          bottom = constraints.bottom,\n          top_1 = constraints.top;\n      prevConstraintsBox.width = (right || 0) - (left || 0);\n      prevConstraintsBox.height = (bottom || 0) - (top_1 || 0);\n    }\n\n    if (point.x) prevConstraintsBox.x = point.x.get();\n    if (point.y) prevConstraintsBox.y = point.y.get();\n  };\n\n  var applyConstraintsToPoint = function applyConstraintsToPoint(constraints) {\n    return bothAxis(function (axis) {\n      var axisPoint = point[axis];\n      axisPoint && !axisPoint.isAnimating() && applyConstraints(axis, axisPoint, constraints, 0);\n    });\n  }; // On mount, if our bounding box is a ref, we need to resolve the constraints\n  // and immediately apply them to our point.\n\n\n  useEffect(function () {\n    if (!constraintsNeedResolution) return;\n    var constraints = calculateConstraintsFromDom(dragConstraints, ref, point, transformPagePoint);\n    applyConstraintsToPoint(constraints);\n    recordBoxInfo(constraints);\n  }, []); // If `dragConstraints` is set to `false` or `Constraints`, set constraints immediately.\n  // Otherwise we'll resolve on mount.\n\n  dragStatus.constraints = constraintsNeedResolution ? dragStatus.constraints || false : dragConstraints; // Get the `MotionValue` for both draggable axes, or create them if they don't already\n  // exist on this component.\n\n  bothAxis(function (axis) {\n    if (!shouldDrag(axis, drag, dragStatus.currentDirection)) return;\n    var defaultValue = axis === \"x\" ? _dragValueX : _dragValueY;\n    point[axis] = defaultValue || values.get(axis, 0);\n  }); // Apply constraints immediately, even before render, if our constraints are a plain object.\n\n  if (!dragStatus.isDragging && dragStatus.constraints && !constraintsNeedResolution) {\n    applyConstraintsToPoint(dragStatus.constraints);\n  } // Add additional information to the `PanInfo` object before passing it to drag listeners.\n\n\n  function convertPanToDrag(info) {\n    return __assign({}, info, {\n      point: {\n        x: point.x ? point.x.get() : 0,\n        y: point.y ? point.y.get() : 0\n      }\n    });\n  } // This function will be used to update each axis point every frame.\n\n\n  function updatePoint(axis, offset) {\n    var axisPoint = point[axis]; // If we're not dragging this axis, do an early return.\n\n    if (!shouldDrag(axis, drag, dragStatus.currentDirection) || !axisPoint) {\n      return;\n    }\n\n    var current = applyConstraints(axis, origin[axis].get() + offset[axis], dragStatus.constraints, dragElastic);\n    axisPoint.set(current);\n  }\n\n  function onPanSessionStart(event) {\n    // Prevent browser-specific behaviours like text selection or Chrome's image dragging.\n    if (event.target && !allowDefaultPointerDown.has(event.target.tagName)) {\n      event.preventDefault(); // Make sure input elements loose focus when we prevent the default.\n\n      if (document.activeElement instanceof HTMLElement) {\n        document.activeElement.blur();\n      }\n    } // Initiate viewport scroll blocking on touch start. This is a very aggressive approach\n    // which has come out of the difficulty in us being able to do this once a scroll gesture\n    // has initiated in mobile browsers. This means if there's a horizontally-scrolling carousel\n    // on a page we can't let a user scroll the page itself from it. Ideally what we'd do is\n    // trigger this once we've got a scroll direction determined. This approach sort-of worked\n    // but if the component was dragged too far in a single frame page scrolling would initiate.\n\n\n    blockViewportScroll(); // Stop any animations on both axis values immediately. This allows the user to throw and catch\n    // the component.\n\n    bothAxis(function (axis) {\n      var axisPoint = point[axis];\n      axisPoint && axisPoint.stop();\n    });\n  }\n\n  function onPanStart(event, info) {\n    dragStatus.isDragging = true; // Resolve the constraints again in case anything has changed in the meantime.\n\n    if (constraintsNeedResolution) {\n      dragStatus.constraints = calculateConstraintsFromDom(dragConstraints, ref, point, transformPagePoint);\n      applyConstraintsToPoint(dragStatus.constraints);\n    } // Set point origin and stop any existing animations.\n\n\n    bothAxis(function (axis) {\n      var axisPoint = point[axis];\n      if (!axisPoint) return;\n      origin[axis].set(axisPoint.get());\n      axisPoint.stop();\n    }); // Attempt to grab the global drag gesture lock.\n\n    if (!dragPropagation) {\n      if (openGlobalLock.current) openGlobalLock.current();\n      openGlobalLock.current = getGlobalLock(drag);\n\n      if (!openGlobalLock.current) {\n        return;\n      }\n    }\n\n    dragStatus.currentDirection = null;\n    var onDragStart = handlers.onDragStart;\n    onDragStart && onDragStart(event, convertPanToDrag(info));\n  }\n\n  function onPan(event, info) {\n    // If we didn't successfully receive the gesture lock, early return.\n    if (!dragPropagation && !openGlobalLock.current) {\n      return;\n    }\n\n    var offset = info.offset; // Attempt to detect drag direction if directionLock is true\n\n    if (dragDirectionLock && dragStatus.currentDirection === null) {\n      dragStatus.currentDirection = getCurrentDirection(offset); // If we've successfully set a direction, notify listener\n\n      if (dragStatus.currentDirection !== null) {\n        var onDirectionLock_1 = handlers.onDirectionLock;\n        onDirectionLock_1 && onDirectionLock_1(dragStatus.currentDirection);\n      }\n\n      return;\n    }\n\n    updatePoint(\"x\", offset);\n    updatePoint(\"y\", offset);\n    var onDrag = handlers.onDrag;\n    onDrag && onDrag(event, convertPanToDrag(info));\n  }\n\n  function cancelDrag() {\n    unblockViewportScroll();\n    dragStatus.isDragging = false;\n\n    if (!dragPropagation && openGlobalLock.current) {\n      openGlobalLock.current();\n      openGlobalLock.current = null;\n    }\n  }\n\n  function animateDragEnd(velocity) {\n    var momentumAnimations = bothAxis(function (axis) {\n      var _a;\n\n      if (!shouldDrag(axis, drag, dragStatus.currentDirection)) {\n        return;\n      }\n\n      var transition = dragStatus.constraints ? getConstraints(axis, dragStatus.constraints) : {};\n      /**\r\n       * Overdamp the boundary spring if `dragElastic` is disabled. There's still a frame\r\n       * of spring animations so we should look into adding a disable spring option to `inertia`.\r\n       * We could do something here where we affect the `bounceStiffness` and `bounceDamping`\r\n       * using the value of `dragElastic`.\r\n       */\n\n      var bounceStiffness = dragElastic ? 200 : 1000000;\n      var bounceDamping = dragElastic ? 40 : 10000000;\n      var animationControls = _dragTransitionControls || controls;\n      return animationControls.start((_a = {}, _a[axis] = 0, // TODO: It might be possible to allow `type` animations to be set as\n      // Popmotion animations as well as strings. Then people could define their own\n      // and it'd open another route for us to code-split.\n      _a.transition = __assign({\n        type: \"inertia\",\n        velocity: dragMomentum ? velocity[axis] : 0,\n        bounceStiffness: bounceStiffness,\n        bounceDamping: bounceDamping,\n        timeConstant: 750,\n        restDelta: 1\n      }, dragTransition, transition), _a));\n    }); // Run all animations and then resolve the new drag constraints.\n\n    Promise.all(momentumAnimations).then(function () {\n      recordBoxInfo(dragStatus.constraints);\n      scalePoint();\n      var onDragTransitionEnd = handlers.onDragTransitionEnd;\n      onDragTransitionEnd && onDragTransitionEnd();\n    });\n  }\n\n  function onPanEnd(event, info) {\n    var isDragging = dragStatus.isDragging;\n    cancelDrag();\n    if (!isDragging) return; // If we have either `dragMomentum` or `dragElastic`, initiate momentum and boundary spring animation for both axes.\n\n    if (dragMomentum || dragElastic) {\n      var velocity = info.velocity;\n      animateDragEnd(velocity);\n    } else {\n      recordBoxInfo(dragStatus.constraints);\n    }\n\n    var onDragEnd = handlers.onDragEnd;\n    onDragEnd && onDragEnd(event, convertPanToDrag(info));\n  }\n\n  usePanGesture(drag ? {\n    onPan: onPan,\n    onPanStart: onPanStart,\n    onPanEnd: onPanEnd,\n    onPanSessionStart: onPanSessionStart\n  } : {}, ref);\n  useUnmountEffect(function () {\n    return dragStatus.isDragging && cancelDrag();\n  });\n}\n/**\r\n * Based on an x/y offset determine the current drag direction. If both axis' offsets are lower\r\n * than the provided threshold, return `null`.\r\n *\r\n * @param offset - The x/y offset from origin.\r\n * @param lockThreshold - (Optional) - the minimum absolute offset before we can determine a drag direction.\r\n */\n\n\nfunction getCurrentDirection(offset, lockThreshold) {\n  if (lockThreshold === void 0) {\n    lockThreshold = 10;\n  }\n\n  var direction = null;\n\n  if (Math.abs(offset.y) > lockThreshold) {\n    direction = \"y\";\n  } else if (Math.abs(offset.x) > lockThreshold) {\n    direction = \"x\";\n  }\n\n  return direction;\n}\n\nvar Drag = {\n  key: \"drag\",\n  shouldRender: function shouldRender(props) {\n    return !!props.drag;\n  },\n  Component: makeHookComponent(function (_a) {\n    var innerRef = _a.innerRef,\n        values = _a.values,\n        controls = _a.controls,\n        props = __rest(_a, [\"innerRef\", \"values\", \"controls\"]);\n\n    return useDrag(props, innerRef, values, controls);\n  })\n};\n\nfunction isCSSVariable(value) {\n  return typeof value === \"string\" && value.startsWith(\"var(--\");\n}\n/**\r\n * Parse Framer's special CSS variable format into a CSS token and a fallback.\r\n *\r\n * ```\r\n * `var(--foo, #fff)` => [`--foo`, '#fff']\r\n * ```\r\n *\r\n * @param current\r\n */\n\n\nvar cssVariableRegex = /var\\((--[a-zA-Z0-9-_]+),? ?([a-zA-Z0-9 ()%#.,-]+)?\\)/;\n\nfunction parseCSSVariable(current) {\n  var match = cssVariableRegex.exec(current);\n  if (!match) return [,];\n  var token = match[1],\n      fallback = match[2];\n  return [token, fallback];\n}\n\nvar maxDepth = 4;\n\nfunction getVariableValue(current, element, depth) {\n  if (depth === void 0) {\n    depth = 1;\n  }\n\n  invariant(depth <= maxDepth, \"Max CSS variable fallback depth detected in property \\\"\" + current + \"\\\". This may indicate a circular fallback dependency.\");\n\n  var _a = parseCSSVariable(current),\n      token = _a[0],\n      fallback = _a[1]; // No CSS variable detected\n\n\n  if (!token) return; // Attempt to read this CSS variable off the element\n\n  var resolved = window.getComputedStyle(element).getPropertyValue(token);\n\n  if (resolved) {\n    return resolved;\n  } else if (isCSSVariable(fallback)) {\n    // The fallback might itself be a CSS variable, in which case we attempt to resolve it too.\n    return getVariableValue(fallback, element, depth + 1);\n  } else {\n    return fallback;\n  }\n}\n/**\r\n * Resolve CSS variables from\r\n *\r\n * @internal\r\n */\n\n\nfunction resolveCSSVariables(values, ref, _a, transitionEnd) {\n  var target = __rest(_a, []);\n\n  var element = ref.current;\n  if (!(element instanceof HTMLElement)) return {\n    target: target,\n    transitionEnd: transitionEnd\n  }; // If `transitionEnd` isn't `undefined`, clone it. We could clone `target` and `transitionEnd`\n  // only if they change but I think this reads clearer and this isn't a performance-critical path.\n\n  if (transitionEnd) {\n    transitionEnd = __assign({}, transitionEnd);\n  } // Go through existing `MotionValue`s and ensure any existing CSS variables are resolved\n\n\n  values.forEach(function (value) {\n    var current = value.get();\n    if (!isCSSVariable(current)) return;\n    var resolved = getVariableValue(current, element);\n    if (resolved) value.set(resolved);\n  }); // Cycle through every target property and resolve CSS variables. Currently\n  // we only read single-var properties like `var(--foo)`, not `calc(var(--foo) + 20px)`\n\n  for (var key in target) {\n    var current = target[key];\n    if (!isCSSVariable(current)) continue;\n    var resolved = getVariableValue(current, element);\n    if (!resolved) continue; // Clone target if it hasn't already been\n\n    target[key] = resolved; // If the user hasn't already set this key on `transitionEnd`, set it to the unresolved\n    // CSS variable. This will ensure that after the animation the component will reflect\n    // changes in the value of the CSS variable.\n\n    if (transitionEnd && transitionEnd[key] === undefined) {\n      transitionEnd[key] = current;\n    }\n  }\n\n  return {\n    target: target,\n    transitionEnd: transitionEnd\n  };\n}\n\nvar positionalKeys = new Set([\"width\", \"height\", \"top\", \"left\", \"right\", \"bottom\", \"x\", \"y\"]);\n\nvar isPositionalKey = function isPositionalKey(key) {\n  return positionalKeys.has(key);\n};\n\nvar hasPositionalKey = function hasPositionalKey(target) {\n  return Object.keys(target).some(isPositionalKey);\n};\n\nvar setAndResetVelocity = function setAndResetVelocity(value, to) {\n  // Looks odd but setting it twice doesn't render, it'll just\n  // set both prev and current to the latest value\n  value.set(to, false);\n  value.set(to);\n};\n\nvar isNumOrPxType = function isNumOrPxType(v) {\n  return v === number || v === px;\n};\n\nvar BoundingBoxDimension;\n\n(function (BoundingBoxDimension) {\n  BoundingBoxDimension[\"width\"] = \"width\";\n  BoundingBoxDimension[\"height\"] = \"height\";\n  BoundingBoxDimension[\"left\"] = \"left\";\n  BoundingBoxDimension[\"right\"] = \"right\";\n  BoundingBoxDimension[\"top\"] = \"top\";\n  BoundingBoxDimension[\"bottom\"] = \"bottom\";\n})(BoundingBoxDimension || (BoundingBoxDimension = {}));\n\nvar getPosFromMatrix = function getPosFromMatrix(matrix, pos) {\n  return parseFloat(matrix.split(\", \")[pos]);\n};\n\nvar getTranslateFromMatrix = function getTranslateFromMatrix(pos2, pos3) {\n  return function (_bbox, _a) {\n    var transform = _a.transform;\n    if (transform === \"none\" || !transform) return 0;\n    var matrix3d = transform.match(/^matrix3d\\((.+)\\)$/);\n\n    if (matrix3d) {\n      return getPosFromMatrix(matrix3d[1], pos3);\n    } else {\n      var matrix = transform.match(/^matrix\\((.+)\\)$/);\n      return getPosFromMatrix(matrix[1], pos2);\n    }\n  };\n};\n\nvar transformKeys = new Set([\"x\", \"y\", \"z\"]);\nvar nonTranslationalTransformKeys = transformProps.filter(function (key) {\n  return !transformKeys.has(key);\n});\n\nfunction removeNonTranslationalTransform(values, elementStyler) {\n  var removedTransforms = [];\n  nonTranslationalTransformKeys.forEach(function (key) {\n    var value = values.get(key);\n\n    if (value !== undefined) {\n      removedTransforms.push([key, value.get()]);\n      value.set(key.startsWith(\"scale\") ? 1 : 0);\n    }\n  }); // Apply changes to element before measurement\n\n  if (removedTransforms.length) elementStyler.render();\n  return removedTransforms;\n}\n\nvar positionalValues = {\n  // Dimensions\n  width: function width(_a) {\n    var width = _a.width;\n    return width;\n  },\n  height: function height(_a) {\n    var height = _a.height;\n    return height;\n  },\n  top: function top(_bbox, _a) {\n    var top = _a.top;\n    return parseFloat(top);\n  },\n  left: function left(_bbox, _a) {\n    var left = _a.left;\n    return parseFloat(left);\n  },\n  bottom: function bottom(_a, _b) {\n    var height = _a.height;\n    var top = _b.top;\n    return parseFloat(top) + height;\n  },\n  right: function right(_a, _b) {\n    var width = _a.width;\n    var left = _b.left;\n    return parseFloat(left) + width;\n  },\n  // Transform\n  x: getTranslateFromMatrix(4, 13),\n  y: getTranslateFromMatrix(5, 14)\n};\n\nvar convertChangedValueTypes = function convertChangedValueTypes(target, values, element, elementStyler, changedKeys) {\n  var originBbox = element.getBoundingClientRect();\n  var elementComputedStyle = getComputedStyle(element);\n  var display = elementComputedStyle.display,\n      top = elementComputedStyle.top,\n      left = elementComputedStyle.left,\n      bottom = elementComputedStyle.bottom,\n      right = elementComputedStyle.right,\n      transform = elementComputedStyle.transform;\n  var originComputedStyle = {\n    top: top,\n    left: left,\n    bottom: bottom,\n    right: right,\n    transform: transform\n  }; // If the element is currently set to display: \"none\", make it visible before\n  // measuring the target bounding box\n\n  if (display === \"none\") {\n    elementStyler.set(\"display\", target.display || \"block\");\n  } // Apply the latest values (as set in checkAndConvertChangedValueTypes)\n\n\n  elementStyler.render();\n  var targetBbox = element.getBoundingClientRect();\n  changedKeys.forEach(function (key) {\n    // Restore styles to their **calculated computed style**, not their actual\n    // originally set style. This allows us to animate between equivalent pixel units.\n    var value = values.get(key);\n    setAndResetVelocity(value, positionalValues[key](originBbox, originComputedStyle));\n    target[key] = positionalValues[key](targetBbox, elementComputedStyle);\n  });\n  return target;\n};\n\nvar checkAndConvertChangedValueTypes = function checkAndConvertChangedValueTypes(values, ref, target, transitionEnd) {\n  if (transitionEnd === void 0) {\n    transitionEnd = {};\n  }\n\n  target = __assign({}, target);\n  transitionEnd = __assign({}, transitionEnd);\n  var element = ref.current;\n  var elementStyler = styler(element);\n  var targetPositionalKeys = Object.keys(target).filter(isPositionalKey); // We want to remove any transform values that could affect the element's bounding box before\n  // it's measured. We'll reapply these later.\n\n  var removedTransformValues = [];\n  var hasAttemptedToRemoveTransformValues = false;\n  var changedValueTypeKeys = targetPositionalKeys.reduce(function (acc, key) {\n    var value = values.get(key);\n    if (!value) return acc;\n    var from = value.get();\n    var to = target[key];\n    var fromType = getDimensionValueType(from);\n    var toType; // TODO: The current implementation of this basically throws an error\n    // if you try and do value conversion via keyframes. There's probably\n    // a way of doing this but the performance implications would need greater scrutiny,\n    // as it'd be doing multiple resize-remeasure operations.\n\n    if (isKeyframesTarget(to)) {\n      var numKeyframes = to.length;\n\n      for (var i = to[0] === null ? 1 : 0; i < numKeyframes; i++) {\n        if (!toType) {\n          toType = getDimensionValueType(to[i]);\n          invariant(toType === fromType || isNumOrPxType(fromType) && isNumOrPxType(toType), \"Keyframes must be of the same dimension as the current value\");\n        } else {\n          invariant(getDimensionValueType(to[i]) === toType, \"All keyframes must be of the same type\");\n        }\n      }\n    } else {\n      toType = getDimensionValueType(to);\n    }\n\n    if (fromType !== toType) {\n      // If they're both just number or px, convert them both to numbers rather than\n      // relying on resize/remeasure to convert (which is wasteful in this situation)\n      if (isNumOrPxType(fromType) && isNumOrPxType(toType)) {\n        var current = value.get();\n\n        if (typeof current === \"string\") {\n          value.set(parseFloat(current));\n        }\n\n        if (typeof to === \"string\") {\n          target[key] = parseFloat(to);\n        } else if (Array.isArray(to) && toType === px) {\n          target[key] = to.map(parseFloat);\n        }\n      } else {\n        // If we're going to do value conversion via DOM measurements, we first\n        // need to remove non-positional transform values that could affect the bbox measurements.\n        if (!hasAttemptedToRemoveTransformValues) {\n          removedTransformValues = removeNonTranslationalTransform(values, elementStyler);\n          hasAttemptedToRemoveTransformValues = true;\n        }\n\n        acc.push(key);\n        transitionEnd[key] = transitionEnd[key] !== undefined ? transitionEnd[key] : target[key];\n        setAndResetVelocity(value, to);\n      }\n    }\n\n    return acc;\n  }, []);\n\n  if (changedValueTypeKeys.length) {\n    var convertedTarget = convertChangedValueTypes(target, values, element, elementStyler, changedValueTypeKeys); // If we removed transform values, reapply them before the next render\n\n    if (removedTransformValues.length) {\n      removedTransformValues.forEach(function (_a) {\n        var key = _a[0],\n            value = _a[1];\n        values.get(key).set(value);\n      });\n    } // Reapply original values\n\n\n    elementStyler.render();\n    return {\n      target: convertedTarget,\n      transitionEnd: transitionEnd\n    };\n  } else {\n    return {\n      target: target,\n      transitionEnd: transitionEnd\n    };\n  }\n};\n/**\r\n * Convert value types for x/y/width/height/top/left/bottom/right\r\n *\r\n * Allows animation between `'auto'` -> `'100%'` or `0` -> `'calc(50% - 10vw)'`\r\n *\r\n * @param values\r\n * @param ref\r\n * @param target\r\n * @param transitionEnd\r\n * @internal\r\n */\n\n\nfunction unitConversion(values, ref, target, transitionEnd) {\n  return hasPositionalKey(target) ? checkAndConvertChangedValueTypes(values, ref, target, transitionEnd) : {\n    target: target,\n    transitionEnd: transitionEnd\n  };\n}\n\nvar parseDomVariant = function parseDomVariant(values, ref) {\n  return function (target, transitionEnd) {\n    var resolved = resolveCSSVariables(values, ref, target, transitionEnd);\n    target = resolved.target;\n    transitionEnd = resolved.transitionEnd;\n    return unitConversion(values, ref, target, transitionEnd);\n  };\n};\n\nfunction useForceUpdate() {\n  var _a = useState(0),\n      forcedRenderCount = _a[0],\n      setForcedRenderCount = _a[1];\n\n  return useCallback(function () {\n    return setForcedRenderCount(forcedRenderCount + 1);\n  }, [forcedRenderCount]);\n}\n\nvar SyncLayoutContext = createContext(null);\n/**\r\n * When layout changes happen asynchronously to their instigating render (ie when exiting\r\n * children of `AnimatePresence` are removed), `SyncLayout` can wrap parent and sibling\r\n * components that need to animate as a result of this layout change.\r\n *\r\n * @motion\r\n *\r\n * ```jsx\r\n * const MyComponent = ({ isVisible }) => {\r\n *   return (\r\n *     <SyncLayout>\r\n *       <AnimatePresence>\r\n *         {isVisible && (\r\n *           <motion.div exit={{ opacity: 0 }} />\r\n *         )}\r\n *       </AnimatePresence>\r\n *       <motion.div positionTransition />\r\n *     </SyncLayout>\r\n *   )\r\n * }\r\n * ```\r\n *\r\n * @internalremarks\r\n *\r\n * The way this component works is by memoising a function and passing it down via context.\r\n * The function, when called, updates the local state, which is used to invalidate the\r\n * memoisation cache. A new function is called, performing a synced re-render of components\r\n * that are using the SyncLayoutContext.\r\n *\r\n * @internal\r\n */\n\nvar UnstableSyncLayout = function UnstableSyncLayout(_a) {\n  var children = _a.children;\n  var forceUpdate = useForceUpdate();\n  return createElement(SyncLayoutContext.Provider, {\n    value: forceUpdate\n  }, children);\n};\n\nvar _a;\n\nvar StepName;\n\n(function (StepName) {\n  StepName[\"Prepare\"] = \"prepare\";\n  StepName[\"Read\"] = \"read\";\n  StepName[\"Render\"] = \"render\";\n})(StepName || (StepName = {}));\n\nvar stepOrder = [StepName.Prepare, StepName.Read, StepName.Render];\nvar jobs = stepOrder.reduce(function (acc, key) {\n  acc[key] = [];\n  return acc;\n}, {});\nvar jobsNeedProcessing = false;\n\nfunction flushCallbackList(list) {\n  var numJobs = list.length;\n\n  for (var i = 0; i < numJobs; i++) {\n    list[i]();\n  }\n\n  list.length = 0;\n}\n\nfunction flushAllJobs() {\n  if (!jobsNeedProcessing) return;\n  flushCallbackList(jobs.prepare);\n  flushCallbackList(jobs.read);\n  flushCallbackList(jobs.render);\n  jobsNeedProcessing = false;\n} // Note: The approach of schedulng jobs during the render step is incompatible with concurrent mode\n// where multiple renders might happen without a DOM update. This would result in unneccessary batched\n// jobs. But this was already a problem with our previous approach to positionTransition.\n// Hopefully the React team offer a getSnapshotBeforeUpdate-esque hook and we can move to that.\n\n\nvar createUseSyncEffect = function createUseSyncEffect(stepName) {\n  return function (callback) {\n    if (!callback) return;\n    jobsNeedProcessing = true;\n    jobs[stepName].push(callback);\n  };\n};\n\nvar layoutSync = (_a = {}, _a[StepName.Prepare] = createUseSyncEffect(StepName.Prepare), _a[StepName.Read] = createUseSyncEffect(StepName.Read), _a[StepName.Render] = createUseSyncEffect(StepName.Render), _a); // TODO: If we ever make this a public hook, add a check within `createUseSyncEffect` that, in development mode,\n// adds a useEffect to check if there's any remaining jobs and throw an error that we must add the `useLayoutSync`\n// hook to every component that schedules a job.\n\nfunction useLayoutSync() {\n  return useLayoutEffect(flushAllJobs);\n}\n\nfunction isHTMLElement(element) {\n  return element instanceof HTMLElement;\n}\n\nvar defaultLayoutTransition = {\n  duration: 0.8,\n  ease: [0.45, 0.05, 0.19, 1.0]\n};\nvar defaultPositionTransition = underDampedSpring();\n\nfunction getDefaultLayoutTransition(positionOnly) {\n  return positionOnly ? defaultPositionTransition : defaultLayoutTransition;\n}\n\nfunction isResolver(transition) {\n  return typeof transition === \"function\";\n} // Find the center of a Layout definition. We do this to account for potential changes\n// in the top/left etc that are actually just as a result of width/height changes.\n\n\nfunction centerOf(_a) {\n  var top = _a.top,\n      left = _a.left,\n      width = _a.width,\n      height = _a.height;\n  var right = left + width;\n  var bottom = top + height;\n  return {\n    x: (left + right) / 2,\n    y: (top + bottom) / 2\n  };\n}\n\nfunction calcDelta(prev, next) {\n  var prevCenter = centerOf(prev);\n  var nextCenter = centerOf(next);\n  return {\n    x: prevCenter.x - nextCenter.x,\n    y: prevCenter.y - nextCenter.y,\n    width: prev.width - next.width,\n    height: prev.height - next.height\n  };\n}\n\nvar offset = {\n  getLayout: function getLayout(_a) {\n    var offset = _a.offset;\n    return offset;\n  },\n  measure: function measure(element) {\n    var offsetLeft = element.offsetLeft,\n        offsetTop = element.offsetTop,\n        offsetWidth = element.offsetWidth,\n        offsetHeight = element.offsetHeight;\n    return {\n      left: offsetLeft,\n      top: offsetTop,\n      width: offsetWidth,\n      height: offsetHeight\n    };\n  }\n};\nvar boundingBox = {\n  getLayout: function getLayout(_a) {\n    var boundingBox = _a.boundingBox;\n    return boundingBox;\n  },\n  measure: function measure(element) {\n    var _a = element.getBoundingClientRect(),\n        left = _a.left,\n        top = _a.top,\n        width = _a.width,\n        height = _a.height;\n\n    return {\n      left: left,\n      top: top,\n      width: width,\n      height: height\n    };\n  }\n};\n\nfunction readPositionStyle(element) {\n  return window.getComputedStyle(element).position;\n}\n\nfunction getLayoutType(prev, next, positionOnly) {\n  return positionOnly && prev === next ? offset : boundingBox;\n}\n\nfunction isSizeKey(key) {\n  return key === \"width\" || key === \"height\";\n}\n\nfunction useLayoutAnimation(ref, values, controls, layoutTransition, positionOnly) {\n  if (positionOnly === void 0) {\n    positionOnly = false;\n  } // Allow any parent SyncLayoutContext components to force-update this component\n\n\n  useContext(SyncLayoutContext);\n  var element = ref.current;\n  useLayoutSync(); // If we don't have a HTML element we can early return here. We've already called all the hooks.\n\n  if (!isHTMLElement(element)) return; // Keep track of the position style prop. Ideally we'd compare offset as this is uneffected by\n  // the same transforms that we want to use to performantly animate the layout. But if position changes,\n  // for example between \"static\" and \"fixed\", we can no longer rely on the offset and need\n  // to use the visual bounding box.\n\n  var prevPosition = readPositionStyle(element);\n  var prev = {\n    offset: offset.measure(element),\n    boundingBox: boundingBox.measure(element)\n  }; // Keep track of any existing transforms so we can reapply them after measuring the target bounding box.\n\n  var transform = \"\";\n  var next;\n  var compare; // We split the unsetting, read and reapplication of the `transform` style prop into\n  // different steps via useSyncEffect. Multiple components might all be doing the same\n  // thing and by splitting these jobs and flushing them in batches we prevent layout thrashing.\n\n  layoutSync.prepare(function () {\n    // Unset the transform of all layoutTransition components so we can accurately measure\n    // the target bounding box\n    transform = element.style.transform;\n    element.style.transform = \"\";\n  });\n  layoutSync.read(function () {\n    // Read the target VisualInfo of all layoutTransition components\n    next = {\n      offset: offset.measure(element),\n      boundingBox: boundingBox.measure(element)\n    };\n    var nextPosition = readPositionStyle(element);\n    compare = getLayoutType(prevPosition, nextPosition, positionOnly);\n  });\n  layoutSync.render(function () {\n    // Reverse the layout delta of all newly laid-out layoutTransition components into their\n    // prev visual state and then animate them into their new one using transforms.\n    var prevLayout = compare.getLayout(prev);\n    var nextLayout = compare.getLayout(next);\n    var delta = calcDelta(prevLayout, nextLayout);\n    var hasAnyChanged = delta.x || delta.y || delta.width || delta.height;\n\n    if (!hasAnyChanged) {\n      // If layout hasn't changed, reapply the transform and get out of here.\n      transform && (element.style.transform = transform);\n      return;\n    }\n\n    syncRenderSession.open();\n    var target = {};\n    var transition = {};\n    var transitionDefinition = isResolver(layoutTransition) ? layoutTransition({\n      delta: delta\n    }) : layoutTransition;\n\n    function makeTransition(layoutKey, transformKey, targetValue, visualOrigin) {\n      // If this dimension hasn't changed, early return\n      var deltaKey = isSizeKey(layoutKey) ? layoutKey : transformKey;\n      if (!delta[deltaKey]) return;\n      var baseTransition = typeof transitionDefinition === \"boolean\" ? __assign({}, getDefaultLayoutTransition(positionOnly)) : transitionDefinition;\n      var value = values.get(transformKey, targetValue);\n      var velocity = value.getVelocity();\n      transition[transformKey] = baseTransition[transformKey] ? __assign({}, baseTransition[transformKey]) : __assign({}, baseTransition);\n\n      if (transition[transformKey].velocity === undefined) {\n        transition[transformKey].velocity = velocity || 0;\n      } // The target value of all transforms is the default value of that prop (ie x = 0, scaleX = 1)\n      // This is because we're inverting the layout change with `transform` and then animating to `transform: none`\n\n\n      target[transformKey] = targetValue;\n      var offsetToApply = !isSizeKey(layoutKey) && compare === offset ? value.get() : 0;\n      value.set(visualOrigin + offsetToApply);\n    }\n\n    makeTransition(\"left\", \"x\", 0, delta.x);\n    makeTransition(\"top\", \"y\", 0, delta.y);\n\n    if (!positionOnly) {\n      makeTransition(\"width\", \"scaleX\", 1, prev.boundingBox.width / next.boundingBox.width);\n      makeTransition(\"height\", \"scaleY\", 1, prev.boundingBox.height / next.boundingBox.height);\n    }\n\n    target.transition = transition; // Only start the transition if `transitionDefinition` isn't `false`. Otherwise we want\n    // to leave the values in their newly-inverted state and let the user cope with the rest.\n\n    transitionDefinition && controls.start(target); // Force a render to ensure there's no visual flickering\n\n    syncRenderSession.flush();\n  });\n}\n\nvar Layout = {\n  key: \"layout\",\n  shouldRender: function shouldRender(_a) {\n    var positionTransition = _a.positionTransition,\n        layoutTransition = _a.layoutTransition;\n    invariant(!(positionTransition && layoutTransition), \"Don't set both positionTransition and layoutTransition on the same component\");\n    return typeof window !== \"undefined\" && !!(positionTransition || layoutTransition);\n  },\n  Component: makeHookComponent(function (_a) {\n    var innerRef = _a.innerRef,\n        controls = _a.controls,\n        values = _a.values,\n        positionTransition = _a.positionTransition,\n        layoutTransition = _a.layoutTransition;\n    useLayoutAnimation(innerRef, values, controls, layoutTransition || positionTransition, !!positionTransition);\n  })\n};\n/**\r\n * A list of all valid MotionProps\r\n *\r\n * @internalremarks\r\n * This doesn't throw if a `MotionProp` name is missing - it should.\r\n */\n\nvar validMotionProps = new Set([\"initial\", \"animate\", \"exit\", \"style\", \"variants\", \"transition\", \"transformTemplate\", \"transformValues\", \"custom\", \"inherit\", \"static\", \"positionTransition\", \"layoutTransition\", \"onAnimationComplete\", \"onUpdate\", \"onDragStart\", \"onDrag\", \"onDragEnd\", \"onDirectionLock\", \"onDragTransitionEnd\", \"drag\", \"dragConstraints\", \"dragDirectionLock\", \"dragElastic\", \"dragMomentum\", \"dragPropagation\", \"dragTransition\", \"_dragValueX\", \"_dragValueY\", \"_dragTransitionControls\", \"dragOriginX\", \"dragOriginY\", \"onPan\", \"onPanStart\", \"onPanEnd\", \"onPanSessionStart\", \"onTap\", \"onTapStart\", \"onTapCancel\", \"whileHover\", \"whileTap\", \"onHoverEnd\", \"onHoverStart\"]);\n/**\r\n * Check whether a prop name is a valid `MotionProp` key.\r\n *\r\n * @param key - Name of the property to check\r\n * @returns `true` is key is a valid `MotionProp`.\r\n *\r\n * @public\r\n */\n\nfunction isValidMotionProp(key) {\n  return validMotionProps.has(key);\n}\n\nvar AnimatePropType;\n\n(function (AnimatePropType) {\n  AnimatePropType[\"Target\"] = \"Target\";\n  AnimatePropType[\"VariantLabel\"] = \"VariantLabel\";\n  AnimatePropType[\"AnimationSubscription\"] = \"AnimationSubscription\";\n})(AnimatePropType || (AnimatePropType = {}));\n\nfunction shallowCompare(next, prev) {\n  if (prev === null) return false;\n  var prevLength = prev.length;\n  if (prevLength !== next.length) return false;\n\n  for (var i = 0; i < prevLength; i++) {\n    if (prev[i] !== next[i]) return false;\n  }\n\n  return true;\n}\n\nvar hasUpdated = function hasUpdated(prev, next) {\n  return next !== undefined && (Array.isArray(prev) && Array.isArray(next) ? !shallowCompare(next, prev) : prev !== next);\n};\n\nfunction targetWithoutTransition(_a, mergeTransitionEnd) {\n  if (mergeTransitionEnd === void 0) {\n    mergeTransitionEnd = false;\n  }\n\n  var transition = _a.transition,\n      transitionEnd = _a.transitionEnd,\n      target = __rest(_a, [\"transition\", \"transitionEnd\"]);\n\n  return mergeTransitionEnd ? __assign({}, target, transitionEnd) : target;\n}\n/**\r\n * Handle the `animate` prop when its an object of values, ie:\r\n *\r\n * ```jsx\r\n * <motion.div animate={{ opacity: 1 }} />\r\n * ```\r\n *\r\n * @internalremarks\r\n * It might be worth consolidating this with `use-variants`\r\n *\r\n * ```jsx\r\n * <motion.div animate=\"visible\" />\r\n * ```\r\n *\r\n * @param target\r\n * @param controls\r\n * @param values\r\n * @param transition\r\n *\r\n * @internal\r\n */\n\n\nfunction useAnimateProp(targetAndTransition, controls, values, defaultTransition) {\n  var isInitialRender = useRef(true);\n  var prevValues = useRef(null);\n\n  if (!prevValues.current) {\n    prevValues.current = targetWithoutTransition(targetAndTransition, true);\n  }\n\n  useEffect(function () {\n    var targetToAnimate = {}; // These are the values we're actually animating\n\n    var animatingTarget = targetWithoutTransition(targetAndTransition); // This is the target as it'll be once transitionEnd values are applied\n\n    var finalTarget = targetWithoutTransition(targetAndTransition, true); // Detect which values have changed between renders\n\n    for (var key in animatingTarget) {\n      // This value should animate on mount if this value doesn't already exist (wasn't\n      // defined in `style` or `initial`) or if it does exist and it's already changed.\n      var shouldAnimateOnMount = isInitialRender.current && (!values.has(key) || values.get(key).get() !== finalTarget[key]); // If this value has updated between renders or it's we're animating this value on mount,\n      // add it to the animate target.\n\n      var isValidValue = finalTarget[key] !== null;\n      var valueHasUpdated = hasUpdated(prevValues.current[key], finalTarget[key]);\n\n      if (isValidValue && (valueHasUpdated || shouldAnimateOnMount)) {\n        targetToAnimate[key] = animatingTarget[key];\n      }\n    }\n\n    isInitialRender.current = false;\n    prevValues.current = __assign({}, prevValues.current, finalTarget);\n\n    if (Object.keys(targetToAnimate).length) {\n      controls.start(__assign({}, targetToAnimate, {\n        transition: targetAndTransition.transition || defaultTransition,\n        transitionEnd: targetAndTransition.transitionEnd\n      }));\n    }\n  }, [targetAndTransition]);\n}\n\nvar labelsToArray = function labelsToArray(label) {\n  if (!label) {\n    return [];\n  }\n\n  if (Array.isArray(label)) {\n    return label;\n  }\n\n  return [label];\n};\n\nvar resolveVariantLabels = function resolveVariantLabels(variant) {\n  var unresolvedVariant = variant instanceof MotionValue ? variant.get() : variant;\n  return Array.from(new Set(labelsToArray(unresolvedVariant)));\n};\n/**\r\n * Hooks in React sometimes accept a dependency array as their final argument. (ie useEffect/useMemo)\r\n * When values in this array change, React re-runs the dependency. However if the array\r\n * contains a variable number of items, React throws an error.\r\n */\n\n\nvar asDependencyList = function asDependencyList(list) {\n  return [list.join(\",\")];\n};\n\nvar hasVariantChanged = function hasVariantChanged(oldVariant, newVariant) {\n  return oldVariant.join(\",\") !== newVariant.join(\",\");\n};\n/**\r\n * Handle variants and the `animate` prop when its set as variant labels.\r\n *\r\n * @param initial - Initial variant(s)\r\n * @param animate - Variant(s) to animate to\r\n * @param inherit - `true` is inheriting animations from parent\r\n * @param controls - Animation controls\r\n *\r\n * @internal\r\n */\n\n\nfunction useVariants(initial, animate, inherit, controls) {\n  var targetVariants = resolveVariantLabels(animate);\n  var context = useContext(MotionContext);\n  var parentAlreadyMounted = context.hasMounted && context.hasMounted.current;\n  var hasMounted = useRef(false);\n  useEffect(function () {\n    var shouldAnimate = false;\n\n    if (inherit) {\n      // If we're inheriting variant changes and the parent has already\n      // mounted when this component loads, we need to manually trigger\n      // this animation.\n      shouldAnimate = !!parentAlreadyMounted;\n      targetVariants = resolveVariantLabels(context.animate);\n    } else {\n      shouldAnimate = hasMounted.current || hasVariantChanged(resolveVariantLabels(initial), targetVariants);\n    }\n\n    shouldAnimate && controls.start(targetVariants);\n    hasMounted.current = true;\n  }, asDependencyList(targetVariants));\n}\n/**\r\n * `useAnimationGroupSubscription` allows a component to subscribe to an\r\n * externally-created `AnimationControls`, created by the `useAnimation` hook.\r\n *\r\n * @param animation\r\n * @param controls\r\n *\r\n * @internal\r\n */\n\n\nfunction useAnimationGroupSubscription(animation, controls) {\n  var unsubscribe = useMemo(function () {\n    return animation.subscribe(controls);\n  }, [animation]);\n  useEffect(function () {\n    return function () {\n      unsubscribe && unsubscribe();\n    };\n  }, [unsubscribe]);\n}\n\nvar _a$1, _b;\n\nvar AnimatePropComponents = (_a$1 = {}, _a$1[AnimatePropType.Target] = makeHookComponent(function (_a) {\n  var animate = _a.animate,\n      controls = _a.controls,\n      values = _a.values,\n      transition = _a.transition;\n  return useAnimateProp(animate, controls, values, transition);\n}), _a$1[AnimatePropType.VariantLabel] = makeHookComponent(function (_a) {\n  var animate = _a.animate,\n      _b = _a.inherit,\n      inherit = _b === void 0 ? true : _b,\n      controls = _a.controls,\n      initial = _a.initial;\n  return useVariants(initial, animate, inherit, controls);\n}), _a$1[AnimatePropType.AnimationSubscription] = makeHookComponent(function (_a) {\n  var animate = _a.animate,\n      controls = _a.controls;\n  return useAnimationGroupSubscription(animate, controls);\n}), _a$1);\n\nvar isVariantLabel$1 = function isVariantLabel$1(prop) {\n  return Array.isArray(prop) || typeof prop === \"string\";\n};\n\nvar isAnimationSubscription = function isAnimationSubscription(_a) {\n  var animate = _a.animate;\n  return animate instanceof AnimationControls;\n};\n\nvar animationProps = [\"initial\", \"animate\", \"whileTap\", \"whileHover\"];\nvar animatePropTypeTests = (_b = {}, _b[AnimatePropType.Target] = function (props) {\n  return props.animate !== undefined && !isVariantLabel$1(props.animate) && !isAnimationSubscription(props);\n}, _b[AnimatePropType.VariantLabel] = function (props) {\n  return props.variants !== undefined || animationProps.some(function (key) {\n    return typeof props[key] === \"string\";\n  });\n}, _b[AnimatePropType.AnimationSubscription] = isAnimationSubscription, _b);\n\nvar getAnimationComponent = function getAnimationComponent(props) {\n  var animatePropType = undefined;\n\n  for (var key in AnimatePropType) {\n    if (animatePropTypeTests[key](props)) {\n      animatePropType = key;\n    }\n  }\n\n  return animatePropType ? AnimatePropComponents[animatePropType] : undefined;\n};\n\nvar isPropValid = function isPropValid(key) {\n  return !isValidMotionProp(key);\n};\n/**\r\n * Emotion and Styled Components both allow users to pass through arbitrary props to their components\r\n * to dynamically generate CSS. They both use the `@emotion/is-prop-valid` package to determine which\r\n * of these should be passed to the underlying DOM node.\r\n *\r\n * However, when styling a Motion component `styled(motion.div)`, both packages pass through *all* props\r\n * as it's seen as an arbitrary component rather than a DOM node. Motion only allows arbitrary props\r\n * passed through the `custom` prop so it doesn't *need* the payload or computational overhead of\r\n * `@emotion/is-prop-valid`, however to fix this problem we need to use it.\r\n *\r\n * By making it an optionalDependency we can offer this functionality only in the situations where it's\r\n * actually required.\r\n */\n\n\ntry {\n  var emotionIsPropValid_1 = require(\"@emotion/is-prop-valid\")[\"default\"];\n\n  isPropValid = function isPropValid(key) {\n    // Handle events explicitly as Emotion validates them all as true\n    if (key.startsWith(\"on\")) {\n      return !isValidMotionProp(key);\n    } else {\n      return emotionIsPropValid_1(key);\n    }\n  };\n} catch (_a) {// We don't need to actually do anything here - the fallback is the existing `isPropValid`.\n}\n\nfunction filterValidProps(props) {\n  var domProps = {};\n\n  for (var key in props) {\n    if (isPropValid(key)) {\n      domProps[key] = props[key];\n    }\n  }\n\n  return domProps;\n}\n\nvar buildSVGProps = function buildSVGProps(values, style) {\n  var motionValueStyles = resolveCurrent(values);\n  var props = buildSVGAttrs(motionValueStyles, undefined, undefined, undefined, undefined, false);\n  props.style = __assign({}, style, props.style);\n  return props;\n};\n\nvar functionalityComponents = [Layout, Drag, Gestures];\nvar numFunctionalityComponents = functionalityComponents.length;\n/**\r\n * Create a configuration for `motion` components that provides DOM-specific functionality.\r\n *\r\n * @internal\r\n */\n\nfunction createDomMotionConfig(Component) {\n  var isDOM = typeof Component === \"string\";\n  var isSVG = isDOM && svgElements.indexOf(Component) !== -1;\n  return {\n    renderComponent: function renderComponent(ref, style, values, props, isStatic) {\n      var forwardedProps = isDOM ? filterValidProps(props) : props;\n      var staticVisualStyles = isSVG ? buildSVGProps(values, style) : {\n        style: buildStyleAttr(values, style, isStatic)\n      };\n      return createElement(Component, __assign({}, forwardedProps, {\n        ref: ref\n      }, staticVisualStyles));\n    },\n\n    /**\r\n     * loadFunctionalityComponents gets used by the `motion` component\r\n     *\r\n     * Each functionality component gets provided the `ref`, animation controls and the `MotionValuesMap`\r\n     * generated for that component, as well as all the `props` passed to it by the user.\r\n     *\r\n     * The pattern used to determine whether to load and use each piece of functionality is\r\n     * consistent (should render? Then push component) and could be used to extend functionality.\r\n     *\r\n     * By exposing a mutable piece of memory via an API like `extendMotionComponent` we could\r\n     * allow users to add `FunctionalComponentDefinition`s. This would allow us to offer file size\r\n     * reductions by shipping an entry point that doesn't load gesture and drag functionality, and\r\n     * also offer a way for users to develop plugins/other functionality. Because these functionalities\r\n     * are loaded as components, we can look into using Suspense for this purpose.\r\n     *\r\n     * For user-defined functionality we'd need to allow\r\n     *  1) User-defined prop typing (extending `P`)\r\n     *  2) User-defined \"clean props\" function that removes their plugin's props before being passed to the DOM.\r\n     */\n    loadFunctionalityComponents: function loadFunctionalityComponents(ref, values, props, controls, inherit) {\n      var activeComponents = []; // TODO: Consolidate Animation functionality loading strategy with other functionality components\n\n      var Animation = getAnimationComponent(props);\n\n      if (Animation) {\n        activeComponents.push(createElement(Animation, {\n          key: \"animation\",\n          initial: props.initial,\n          animate: props.animate,\n          variants: props.variants,\n          transition: props.transition,\n          controls: controls,\n          inherit: inherit,\n          values: values\n        }));\n      }\n\n      for (var i = 0; i < numFunctionalityComponents; i++) {\n        var _a = functionalityComponents[i],\n            shouldRender = _a.shouldRender,\n            key = _a.key,\n            Component_1 = _a.Component;\n\n        if (shouldRender(props)) {\n          activeComponents.push(createElement(Component_1, __assign({\n            key: key\n          }, props, {\n            values: values,\n            controls: controls,\n            innerRef: ref\n          })));\n        }\n      }\n\n      return activeComponents;\n    },\n    getValueControlsConfig: function getValueControlsConfig(ref, values) {\n      return {\n        values: values,\n        readValueFromSource: function readValueFromSource(key) {\n          return styler(ref.current).get(key);\n        },\n        // TODO: This is a good second source of plugins. This function contains the CSS variable\n        // and unit conversion support. These functions share a common signature. We could make another\n        // API for adding these.\n        makeTargetAnimatable: parseDomVariant(values, ref)\n      };\n    }\n  };\n}\n\nvar htmlMotionComponents = htmlElements.reduce(function (acc, Component) {\n  var config = createDomMotionConfig(Component); // Suppress \"Expression produces a union type that is too complex to represent\" error\n  // @ts-ignore\n\n  acc[Component] = createMotionComponent(config);\n  return acc;\n}, {});\nvar svgMotionComponents = svgElements.reduce(function (acc, Component) {\n  // Suppress \"Expression produces a union type that is too complex to represent\" error\n  // @ts-ignore\n  acc[Component] = createMotionComponent(createDomMotionConfig(Component));\n  return acc;\n}, {});\n/**\r\n * HTML & SVG components, optimised for use with gestures and animation. These can be used as\r\n * drop-in replacements for any HTML & SVG component, all CSS & SVG properties are supported.\r\n *\r\n * @internalremarks\r\n *\r\n * I'd like to make it possible for these to be loaded \"on demand\" - to reduce bundle size by only\r\n * including HTML/SVG stylers, animation and/or gesture support when necessary.\r\n *\r\n * ```jsx\r\n * <motion.div animate={{ x: 100 }} />\r\n *\r\n * <motion.p animate={{ height: 200 }} />\r\n *\r\n * <svg><motion.circle r={10} animate={{ r: 20 }} /></svg>\r\n * ```\r\n *\r\n * @public\r\n */\n\nvar motion = __assign({\n  custom: function custom(Component) {\n    return createMotionComponent(createDomMotionConfig(Component));\n  }\n}, htmlMotionComponents, svgMotionComponents);\n/**\r\n * If the provided value is a MotionValue, this returns the actual value, otherwise just the value itself\r\n *\r\n * TODO: Remove and move to library\r\n *\r\n * @internal\r\n */\n\n\nfunction unwrapMotionValue(value) {\n  var unwrappedValue = value instanceof MotionValue ? value.get() : value;\n  return isCustomValue(unwrappedValue) ? unwrappedValue.toValue() : unwrappedValue;\n}\n\nvar isCustomValueType = function isCustomValueType(v) {\n  return typeof v === \"object\" && v.mix;\n};\n\nvar getMixer = function getMixer(v) {\n  return isCustomValueType(v) ? v.mix : undefined;\n};\n\nfunction transform() {\n  var args = [];\n\n  for (var _i = 0; _i < arguments.length; _i++) {\n    args[_i] = arguments[_i];\n  }\n\n  var useImmediate = !Array.isArray(args[0]);\n  var argOffset = useImmediate ? 0 : -1;\n  var inputValue = args[0 + argOffset];\n  var inputRange = args[1 + argOffset];\n  var outputRange = args[2 + argOffset];\n  var options = args[3 + argOffset];\n  var interpolator = interpolate(inputRange, outputRange, __assign({\n    mixer: getMixer(outputRange[0])\n  }, options));\n  return useImmediate ? interpolator(inputValue) : interpolator;\n}\n\nvar isTransformer = function isTransformer(v) {\n  return typeof v === \"function\";\n};\n\nvar noop = function noop(v) {\n  return v;\n};\n\nfunction useTransform(parent, customTransform, to, options) {\n  var value = useRef(null);\n  var comparitor = [parent];\n  var transformer = noop;\n\n  if (isTransformer(customTransform)) {\n    transformer = customTransform;\n  } else if (Array.isArray(to)) {\n    var from = customTransform;\n    transformer = transform(from, to, options);\n    comparitor = [parent, from.join(\",\"), to.join(\",\")];\n  }\n\n  return useMemo(function () {\n    if (value.current) value.current.destroy();\n    value.current = parent.addChild({\n      transformer: transformer\n    });\n    return value.current;\n  }, comparitor);\n} // Keep things reasonable and avoid scale: Infinity. In practise we might need\n// to add another value, opacity, that could interpolate scaleX/Y [0,0.01] => [0,1]\n// to simply hide content at unreasonable scales.\n\n\nvar maxScale = 100000;\n\nvar invertScale = function invertScale(scale) {\n  return scale > 0.001 ? 1 / scale : maxScale;\n};\n/**\r\n * Returns a `MotionValue` each for `scaleX` and `scaleY` that update with the inverse\r\n * of their respective parent scales.\r\n *\r\n * This is useful for undoing the distortion of content when scaling a parent component.\r\n *\r\n * By default, `useInvertedScale` will automatically fetch `scaleX` and `scaleY` from the nearest parent.\r\n * By passing other `MotionValue`s in as `useInvertedScale({ scaleX, scaleY })`, it will invert the output\r\n * of those instead.\r\n *\r\n * @motion\r\n *\r\n * ```jsx\r\n * const MyComponent = () => {\r\n *   const { scaleX, scaleY } = useInvertedScale()\r\n *   return <motion.div style={{ scaleX, scaleY }} />\r\n * }\r\n * ```\r\n *\r\n * @library\r\n *\r\n * ```jsx\r\n * function MyComponent() {\r\n *   const { scaleX, scaleY } = useInvertedScale()\r\n *   return <Frame scaleX={scaleX} scaleY={scaleY} />\r\n * }\r\n * ```\r\n *\r\n * @public\r\n */\n\n\nfunction useInvertedScale(scale) {\n  var parentScaleX = useMotionValue(1);\n  var parentScaleY = useMotionValue(1);\n  var values = useContext(MotionContext).values;\n  invariant(!!(scale || values), \"If no scale values are provided, useInvertedScale must be used within a child of another motion component.\");\n\n  if (scale) {\n    parentScaleX = scale.scaleX || parentScaleX;\n    parentScaleY = scale.scaleY || parentScaleY;\n  } else if (values) {\n    parentScaleX = values.get(\"scaleX\", 1);\n    parentScaleY = values.get(\"scaleY\", 1);\n  }\n\n  var scaleX = useTransform(parentScaleX, invertScale);\n  var scaleY = useTransform(parentScaleY, invertScale);\n  return {\n    scaleX: scaleX,\n    scaleY: scaleY\n  };\n}\n\nfunction useOnChange(value, callback) {\n  useEffect(function () {\n    return isMotionValue(value) ? value.onChange(callback) : undefined;\n  }, [value]);\n}\n/**\r\n * Creates a `MotionValue` that, when `set`, will use a spring animation to animate to its new state.\r\n *\r\n * It can either work as a stand-alone `MotionValue` by initialising it with a value, or as a subscriber\r\n * to another `MotionValue`.\r\n *\r\n * @remarks\r\n *\r\n * ```jsx\r\n * const x = useSpring(0, { stiffness: 300 })\r\n * const y = useSpring(x, { damping: 10 })\r\n * ```\r\n *\r\n * @param inputValue - `MotionValue` or number. If provided a `MotionValue`, when the input `MotionValue` changes, the created `MotionValue` will spring towards that value.\r\n * @param springConfig - Configuration options for the spring.\r\n * @returns `MotionValue`\r\n *\r\n * @public\r\n */\n\n\nfunction useSpring(source, config) {\n  if (config === void 0) {\n    config = {};\n  }\n\n  var activeSpringAnimation = useRef(null);\n  var value = useMotionValue(isMotionValue(source) ? source.get() : source);\n  useMemo(function () {\n    return value.attach(function (v, set) {\n      if (activeSpringAnimation.current) {\n        activeSpringAnimation.current.stop();\n      }\n\n      activeSpringAnimation.current = spring(__assign({\n        from: value.get(),\n        to: v,\n        velocity: value.getVelocity()\n      }, config)).start(set);\n      return value.get();\n    });\n  }, Object.values(config));\n  useOnChange(source, function (v) {\n    return value.set(parseFloat(v));\n  });\n  return value;\n}\n\nvar scrollX = motionValue(0);\nvar scrollY = motionValue(0);\nvar scrollXProgress = motionValue(0);\nvar scrollYProgress = motionValue(0);\n\nvar setProgress = function setProgress(offset, maxOffset, value) {\n  value.set(!maxOffset || !offset ? 0 : offset / maxOffset);\n};\n\nvar hasEventListener = false;\n\nvar addScrollListener = function addScrollListener() {\n  hasEventListener = true;\n  if (typeof window === \"undefined\") return;\n\n  var updateScrollValues = function updateScrollValues() {\n    var xOffset = window.pageXOffset;\n    var yOffset = window.pageYOffset; // Set absolute positions\n\n    scrollX.set(xOffset);\n    scrollY.set(yOffset); // Set 0-1 progress\n\n    setProgress(xOffset, document.body.clientWidth - window.innerWidth, scrollXProgress);\n    setProgress(yOffset, document.body.clientHeight - window.innerHeight, scrollYProgress);\n  };\n\n  updateScrollValues();\n  window.addEventListener(\"resize\", updateScrollValues);\n  window.addEventListener(\"scroll\", updateScrollValues, {\n    passive: true\n  });\n};\n\nvar viewportMotionValues = {\n  scrollX: scrollX,\n  scrollY: scrollY,\n  scrollXProgress: scrollXProgress,\n  scrollYProgress: scrollYProgress\n};\n/**\r\n * Provides `MotionValue`s that update when the viewport scrolls:\r\n *\r\n * - `scrollX` — Horizontal scroll distance in pixels.\r\n * - `scrollY` — Vertical scroll distance in pixels.\r\n * - `scrollXProgress` — Horizontal scroll progress between `0` and `1`.\r\n * - `scrollYProgress` — Vertical scroll progress between `0` and `1`.\r\n *\r\n * **Note:** If the returned scroll `MotionValue`s don't seem to be updating,\r\n * double check if the `body` tag styles are set to `width: 100%; height: 100%` or\r\n * similar, as this can break accurate measurement of viewport scroll.\r\n *\r\n * @library\r\n *\r\n * ```jsx\r\n * import * as React from \"react\"\r\n * import {\r\n *   Frame,\r\n *   useViewportScroll,\r\n *   useTransform\r\n * } from \"framer\"\r\n *\r\n * export function MyComponent() {\r\n *   const { scrollYProgress } = useViewportScroll()\r\n *   return <Frame scaleX={scrollYProgress} />\r\n * }\r\n * ```\r\n *\r\n * @motion\r\n *\r\n * ```jsx\r\n * export const MyComponent = () => {\r\n *   const { scrollYProgress } = useViewportScroll()\r\n *   return <motion.div style={{ scaleX: scrollYProgress }} />\r\n * }\r\n * ```\r\n *\r\n * @internalremarks\r\n * This isn't technically a hook yet, but in the future it might be nice\r\n * to accept refs to elements and add scroll listeners to those, which\r\n * may involve the use of lifecycle.\r\n *\r\n * @public\r\n */\n\nfunction useViewportScroll() {\n  if (!hasEventListener) {\n    addScrollListener();\n  }\n\n  return viewportMotionValues;\n}\n/**\r\n * Creates `AnimationControls`, which can be used to manually start, stop\r\n * and sequence animations on one or more components.\r\n *\r\n * The returned `AnimationControls` should be passed to the `animate` property\r\n * of the components you want to animate.\r\n *\r\n * These components can then be animated with the `start` method.\r\n *\r\n * @library\r\n *\r\n * ```jsx\r\n * import * as React from 'react'\r\n * import { Frame, useAnimation } from 'framer'\r\n *\r\n * export function MyComponent(props) {\r\n *    const controls = useAnimation()\r\n *\r\n *    controls.start({\r\n *        x: 100,\r\n *        transition: { duration: 0.5 },\r\n *    })\r\n *\r\n *    return <Frame animate={controls} />\r\n * }\r\n * ```\r\n *\r\n * @motion\r\n *\r\n * ```jsx\r\n * import * as React from 'react'\r\n * import { motion, useAnimation } from 'framer-motion'\r\n *\r\n * export function MyComponent(props) {\r\n *    const controls = useAnimation()\r\n *\r\n *    controls.start({\r\n *        x: 100,\r\n *        transition: { duration: 0.5 },\r\n *    })\r\n *\r\n *    return <motion.div animate={controls} />\r\n * }\r\n * ```\r\n *\r\n * @returns Animation controller with `start` and `stop` methods\r\n *\r\n * @public\r\n */\n\n\nfunction useAnimation() {\n  var animationControls = useConstant(function () {\n    return new AnimationControls();\n  });\n  useEffect(function () {\n    animationControls.mount();\n    return function () {\n      return animationControls.unmount();\n    };\n  }, []);\n  return animationControls;\n}\n/**\r\n * Experimental API.\r\n *\r\n * Makes an animated version of `useState`.\r\n *\r\n * @remarks\r\n *\r\n * When the returned state setter is called, values will be animated to their new target.\r\n *\r\n * This allows the animation of arbitrary React components.\r\n *\r\n * **Note:** When animating DOM components, it's always preferable to use the `animate` prop, as Framer\r\n * will bypass React's rendering cycle with one optimised for 60fps motion. This Hook is specifically\r\n * for animating props on arbitrary React components, or for animating text content.\r\n *\r\n * ```jsx\r\n * const [state, setState] = useAnimatedState({ percentage: 0 })\r\n *\r\n * return (\r\n *   <Graph\r\n *     percentage={state.percentage}\r\n *     onTap={() => setState({ percentage: 50 })}\r\n *   />\r\n * )\r\n * ```\r\n *\r\n * @internalremarks\r\n *\r\n * TODO:\r\n * - Make hook accept a typed version of Target that accepts any value (not just DOM values)\r\n * - Allow hook to accept single values. ie useAnimatedState(0)\r\n * - Allow providing MotionValues via initialState.\r\n *\r\n * @beta\r\n */\n\n\nfunction useAnimatedState(initialState) {\n  var _a = useState(initialState),\n      animationState = _a[0],\n      onUpdate = _a[1];\n\n  var config = useConstant(function () {\n    return {\n      onUpdate: onUpdate\n    };\n  });\n  var values = useMotionValues(config);\n  var controls = useValueAnimationControls({\n    values: values,\n    readValueFromSource: function readValueFromSource(key) {\n      return animationState[key];\n    }\n  }, {}, false);\n  var startAnimation = useConstant(function () {\n    return function (animationDefinition) {\n      return controls.start(animationDefinition);\n    };\n  });\n  useEffect(function () {\n    values.mount();\n    return function () {\n      return values.unmount();\n    };\n  }, []);\n  return [animationState, startAnimation];\n}\n/**\r\n * Cycles through a series of visual properties. Can be used to toggle between or cycle through animations. It works similar to `useState` in React. It is provided an initial array of possible states, and returns an array of two arguments.\r\n *\r\n * @library\r\n *\r\n * ```jsx\r\n * import * as React from \"react\"\r\n * import { Frame, useCycle } from \"framer\"\r\n *\r\n * export function MyComponent() {\r\n *   const [x, cycleX] = useCycle(0, 50, 100)\r\n *\r\n *   return (\r\n *     <Frame\r\n *       animate={{ x: x }}\r\n *       onTap={() => cycleX()}\r\n *      />\r\n *    )\r\n * }\r\n * ```\r\n *\r\n * @motion\r\n *\r\n * An index value can be passed to the returned `cycle` function to cycle to a specific index.\r\n *\r\n * ```jsx\r\n * import * as React from \"react\"\r\n * import { motion, useCycle } from \"framer-motion\"\r\n *\r\n * export const MyComponent = () => {\r\n *   const [x, cycleX] = useCycle(0, 50, 100)\r\n *\r\n *   return (\r\n *     <motion.div\r\n *       animate={{ x: x }}\r\n *       onTap={() => cycleX()}\r\n *      />\r\n *    )\r\n * }\r\n * ```\r\n *\r\n * @param items - items to cycle through\r\n * @returns [currentState, cycleState]\r\n *\r\n * @public\r\n */\n\n\nfunction useCycle() {\n  var items = [];\n\n  for (var _i = 0; _i < arguments.length; _i++) {\n    items[_i] = arguments[_i];\n  } // TODO: After Framer X beta, remove this warning\n\n\n  warning(items.length > 1, \"useCycle syntax has changed. `useCycle([0, 1, 2])` becomes `useCycle(0, 1, 2)`\");\n  var index = useRef(0);\n\n  var _a = useState(items[index.current]),\n      item = _a[0],\n      setItem = _a[1];\n\n  return [item, function (next) {\n    index.current = typeof next !== \"number\" ? wrap(0, items.length, index.current + 1) : next;\n    setItem(items[index.current]);\n  }];\n}\n\nvar PresenceChild = function PresenceChild(_a) {\n  var children = _a.children,\n      exitProps = _a.exitProps;\n  var context = useContext(MotionContext); // Create a new `value` in all instances to ensure `motion` children re-render\n  // and detect any layout changes that might have occurred.\n\n  context = exitProps ? __assign({}, context, {\n    exitProps: exitProps\n  }) : __assign({}, context);\n  return createElement(MotionContext.Provider, {\n    value: context\n  }, children);\n};\n\nfunction getChildKey(child) {\n  return child.key || \"\";\n}\n\nfunction updateChildLookup(children, allChildren) {\n  var seenChildren = process.env.NODE_ENV !== \"production\" ? new Set() : null;\n  children.forEach(function (child) {\n    var key = getChildKey(child);\n\n    if (process.env.NODE_ENV !== \"production\" && seenChildren) {\n      if (seenChildren.has(key)) {\n        console.warn(\"Children of AnimatePresence require unique keys. \\\"\" + key + \"\\\" is a duplicate.\");\n      }\n\n      seenChildren.add(key);\n    }\n\n    allChildren.set(key, child);\n  });\n}\n\nfunction onlyElements(children) {\n  var filtered = []; // We use forEach here instead of map as map mutates the component key by preprending `.$`\n\n  Children.forEach(children, function (child) {\n    if (isValidElement(child)) filtered.push(child);\n  });\n  return filtered;\n}\n/**\r\n * The `AnimatePresence` component enables the use of the `exit` prop to animate components\r\n * when they're removed from the component tree.\r\n *\r\n * When adding/removing more than a single child component, every component\r\n * **must** be given a unique `key` prop.\r\n *\r\n * You can propagate exit animations throughout a tree by using variants.\r\n *\r\n * @library\r\n *\r\n * You can use any component(s) within `AnimatePresence`, but the first `Frame` in each should\r\n * have an `exit` property defined.\r\n *\r\n * ```jsx\r\n * import { Frame, AnimatePresence } from 'framer'\r\n *\r\n * // As items are added and removed from `items`\r\n * export function Items({ items }) {\r\n *   return (\r\n *     <AnimatePresence>\r\n *       {items.map(item => (\r\n *         <Frame\r\n *           key={item.id}\r\n *           initial={{ opacity: 0 }}\r\n *           animate={{ opacity: 1 }}\r\n *           exit={{ opacity: 0 }}\r\n *         />\r\n *       ))}\r\n *     </AnimatePresence>\r\n *   )\r\n * }\r\n * ```\r\n *\r\n * @motion\r\n *\r\n * You can use any component(s) within `AnimatePresence`, but the first `motion` component in each should\r\n * have an `exit` property defined.\r\n *\r\n * ```jsx\r\n * import { motion, AnimatePresence } from 'framer-motion'\r\n *\r\n * export const Items = ({ items }) => (\r\n *   <AnimatePresence>\r\n *     {items.map(item => (\r\n *       <motion.div\r\n *         key={item.id}\r\n *         initial={{ opacity: 0 }}\r\n *         animate={{ opacity: 1 }}\r\n *         exit={{ opacity: 0 }}\r\n *       />\r\n *     ))}\r\n *   </AnimatePresence>\r\n * )\r\n * ```\r\n *\r\n * @public\r\n */\n\n\nvar AnimatePresence = function AnimatePresence(_a) {\n  var children = _a.children,\n      custom = _a.custom,\n      _b = _a.initial,\n      initial = _b === void 0 ? true : _b,\n      onExitComplete = _a.onExitComplete,\n      exitBeforeEnter = _a.exitBeforeEnter; // We want to force a re-render once all exiting animations have finished. We\n  // either use a local forceUpdate function, or one from a parent context if it exists.\n\n  var localForceUpdate = useForceUpdate();\n  var contextForceUpdate = useContext(SyncLayoutContext);\n  var forceUpdate = contextForceUpdate || localForceUpdate;\n  var isInitialRender = useRef(true); // Filter out any children that aren't ReactElements. We can only track ReactElements with a props.key\n\n  var filteredChildren = onlyElements(children); // Keep a living record of the children we're actually rendering so we\n  // can diff to figure out which are entering and exiting\n\n  var presentChildren = useRef(filteredChildren); // A lookup table to quickly reference components by key\n\n  var allChildren = useRef(new Map()).current; // A living record of all currently exiting components.\n\n  var exiting = useRef(new Set()).current;\n  updateChildLookup(filteredChildren, allChildren); // If this is the initial component render, just deal with logic surrounding whether\n  // we play onMount animations or not.\n\n  if (isInitialRender.current) {\n    isInitialRender.current = false;\n    return createElement(Fragment, null, filteredChildren.map(function (child) {\n      return createElement(PresenceChild, {\n        key: getChildKey(child),\n        exitProps: initial ? undefined : {\n          initial: false\n        }\n      }, child);\n    }));\n  } // If this is a subsequent render, deal with entering and exiting children\n\n\n  var childrenToRender = filteredChildren.slice(); // Diff the keys of the currently-present and target children to update our\n  // exiting list.\n\n  var presentKeys = presentChildren.current.map(getChildKey);\n  var targetKeys = filteredChildren.map(getChildKey); // Diff the present children with our target children and mark those that are exiting\n\n  var numPresent = presentKeys.length;\n\n  for (var i = 0; i < numPresent; i++) {\n    var key = presentKeys[i];\n\n    if (targetKeys.indexOf(key) === -1) {\n      exiting.add(key);\n    } else {\n      // In case this key has re-entered, remove from the exiting list\n      exiting[\"delete\"](key);\n    }\n  } // If we currently have exiting children, and we're deferring rendering incoming children\n  // until after all current children have exiting, empty the childrenToRender array\n\n\n  if (exitBeforeEnter && exiting.size) {\n    childrenToRender = [];\n  } // Loop through all currently exiting components and clone them to overwrite `animate`\n  // with any `exit` prop they might have defined.\n\n\n  exiting.forEach(function (key) {\n    // If this component is actually entering again, early return\n    if (targetKeys.indexOf(key) !== -1) return;\n    var child = allChildren.get(key);\n    if (!child) return;\n    var insertionIndex = presentKeys.indexOf(key);\n\n    var onExit = function onExit() {\n      exiting[\"delete\"](key); // Remove this child from the present children\n\n      var removeIndex = presentChildren.current.findIndex(function (child) {\n        return child.key === key;\n      });\n      presentChildren.current.splice(removeIndex, 1); // Defer re-rendering until all exiting children have indeed left\n\n      if (!exiting.size) {\n        presentChildren.current = filteredChildren;\n        forceUpdate();\n        onExitComplete && onExitComplete();\n      }\n    };\n\n    var exitProps = {\n      custom: custom,\n      isExiting: true,\n      onExitComplete: onExit\n    };\n    childrenToRender.splice(insertionIndex, 0, createElement(PresenceChild, {\n      key: getChildKey(child),\n      exitProps: exitProps\n    }, child));\n  }); // Add `MotionContext` even to children that don't need it to ensure we're rendering\n  // the same tree between renders\n\n  childrenToRender = childrenToRender.map(function (child) {\n    var key = child.key;\n    return exiting.has(key) ? child : createElement(PresenceChild, {\n      key: getChildKey(child)\n    }, child);\n  });\n  presentChildren.current = childrenToRender;\n\n  if (process.env.NODE_ENV !== \"production\" && exitBeforeEnter && childrenToRender.length > 1) {\n    console.warn(\"You're attempting to animate multiple children within AnimatePresence, but its exitBeforeEnter prop is set to true. This will lead to odd visual behaviour.\");\n  }\n\n  return createElement(Fragment, null, exiting.size ? childrenToRender : childrenToRender.map(function (child) {\n    return cloneElement(child);\n  }));\n};\n\nexport { AnimatePresence, AnimationControls, MotionContext, MotionPluginContext, MotionPlugins, MotionValue, Point, UnstableSyncLayout, animationControls, createMotionComponent, isValidMotionProp, motion, motionValue, transform, unwrapMotionValue, useAnimatedState, useAnimation, useCycle, useDomEvent, useExternalRef, useGestures, useInvertedScale, useMotionValue, usePanGesture, useSpring, useTapGesture, useTransform, useViewportScroll };","var React = require('react');\n\nfunction FacebookFBrandsInline (props) {\n    return React.createElement(\"svg\",props,React.createElement(\"path\",{\"fill\":\"currentColor\",\"d\":\"M279.14 288l14.22-92.66h-88.91v-60.13c0-25.35 12.42-50.06 52.24-50.06h40.42V6.26S260.43 0 225.36 0c-73.22 0-121.08 44.38-121.08 124.72v70.62H22.89V288h81.39v224h100.17V288z\"}));\n}\n\nFacebookFBrandsInline.defaultProps = {\"aria-hidden\":\"true\",\"focusable\":\"false\",\"data-prefix\":\"fab\",\"data-icon\":\"facebook-f\",\"className\":\"svg-inline--fa fa-facebook-f fa-w-10\",\"role\":\"img\",\"viewBox\":\"0 0 320 512\"};\n\nmodule.exports = FacebookFBrandsInline;\n\nFacebookFBrandsInline.default = FacebookFBrandsInline;\n","var React = require('react');\n\nfunction TwitterBrandsInline (props) {\n    return React.createElement(\"svg\",props,React.createElement(\"path\",{\"fill\":\"currentColor\",\"d\":\"M459.37 151.716c.325 4.548.325 9.097.325 13.645 0 138.72-105.583 298.558-298.558 298.558-59.452 0-114.68-17.219-161.137-47.106 8.447.974 16.568 1.299 25.34 1.299 49.055 0 94.213-16.568 130.274-44.832-46.132-.975-84.792-31.188-98.112-72.772 6.498.974 12.995 1.624 19.818 1.624 9.421 0 18.843-1.3 27.614-3.573-48.081-9.747-84.143-51.98-84.143-102.985v-1.299c13.969 7.797 30.214 12.67 47.431 13.319-28.264-18.843-46.781-51.005-46.781-87.391 0-19.492 5.197-37.36 14.294-52.954 51.655 63.675 129.3 105.258 216.365 109.807-1.624-7.797-2.599-15.918-2.599-24.04 0-57.828 46.782-104.934 104.934-104.934 30.213 0 57.502 12.67 76.67 33.137 23.715-4.548 46.456-13.32 66.599-25.34-7.798 24.366-24.366 44.833-46.132 57.827 21.117-2.273 41.584-8.122 60.426-16.243-14.292 20.791-32.161 39.308-52.628 54.253z\"}));\n}\n\nTwitterBrandsInline.defaultProps = {\"aria-hidden\":\"true\",\"focusable\":\"false\",\"data-prefix\":\"fab\",\"data-icon\":\"twitter\",\"className\":\"svg-inline--fa fa-twitter fa-w-16\",\"role\":\"img\",\"viewBox\":\"0 0 512 512\"};\n\nmodule.exports = TwitterBrandsInline;\n\nTwitterBrandsInline.default = TwitterBrandsInline;\n","var React = require('react');\n\nfunction InstagramBrandsInline (props) {\n    return React.createElement(\"svg\",props,React.createElement(\"path\",{\"fill\":\"currentColor\",\"d\":\"M224.1 141c-63.6 0-114.9 51.3-114.9 114.9s51.3 114.9 114.9 114.9S339 319.5 339 255.9 287.7 141 224.1 141zm0 189.6c-41.1 0-74.7-33.5-74.7-74.7s33.5-74.7 74.7-74.7 74.7 33.5 74.7 74.7-33.6 74.7-74.7 74.7zm146.4-194.3c0 14.9-12 26.8-26.8 26.8-14.9 0-26.8-12-26.8-26.8s12-26.8 26.8-26.8 26.8 12 26.8 26.8zm76.1 27.2c-1.7-35.9-9.9-67.7-36.2-93.9-26.2-26.2-58-34.4-93.9-36.2-37-2.1-147.9-2.1-184.9 0-35.8 1.7-67.6 9.9-93.9 36.1s-34.4 58-36.2 93.9c-2.1 37-2.1 147.9 0 184.9 1.7 35.9 9.9 67.7 36.2 93.9s58 34.4 93.9 36.2c37 2.1 147.9 2.1 184.9 0 35.9-1.7 67.7-9.9 93.9-36.2 26.2-26.2 34.4-58 36.2-93.9 2.1-37 2.1-147.8 0-184.8zM398.8 388c-7.8 19.6-22.9 34.7-42.6 42.6-29.5 11.7-99.5 9-132.1 9s-102.7 2.6-132.1-9c-19.6-7.8-34.7-22.9-42.6-42.6-11.7-29.5-9-99.5-9-132.1s-2.6-102.7 9-132.1c7.8-19.6 22.9-34.7 42.6-42.6 29.5-11.7 99.5-9 132.1-9s102.7-2.6 132.1 9c19.6 7.8 34.7 22.9 42.6 42.6 11.7 29.5 9 99.5 9 132.1s2.7 102.7-9 132.1z\"}));\n}\n\nInstagramBrandsInline.defaultProps = {\"aria-hidden\":\"true\",\"focusable\":\"false\",\"data-prefix\":\"fab\",\"data-icon\":\"instagram\",\"className\":\"svg-inline--fa fa-instagram fa-w-14\",\"role\":\"img\",\"viewBox\":\"0 0 448 512\"};\n\nmodule.exports = InstagramBrandsInline;\n\nInstagramBrandsInline.default = InstagramBrandsInline;\n","'use strict';\n// 22.1.3.9 Array.prototype.findIndex(predicate, thisArg = undefined)\nvar $export = require('./_export');\nvar $find = require('./_array-methods')(6);\nvar KEY = 'findIndex';\nvar forced = true;\n// Shouldn't skip holes\nif (KEY in []) Array(1)[KEY](function () { forced = false; });\n$export($export.P + $export.F * forced, 'Array', {\n  findIndex: function findIndex(callbackfn /* , that = undefined */) {\n    return $find(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);\n  }\n});\nrequire('./_add-to-unscopables')(KEY);\n","// https://github.com/tc39/proposal-object-values-entries\nvar $export = require('./_export');\nvar $values = require('./_object-to-array')(false);\n\n$export($export.S, 'Object', {\n  values: function values(it) {\n    return $values(it);\n  }\n});\n","var DESCRIPTORS = require('./_descriptors');\nvar getKeys = require('./_object-keys');\nvar toIObject = require('./_to-iobject');\nvar isEnum = require('./_object-pie').f;\nmodule.exports = function (isEntries) {\n  return function (it) {\n    var O = toIObject(it);\n    var keys = getKeys(O);\n    var length = keys.length;\n    var i = 0;\n    var result = [];\n    var key;\n    while (length > i) {\n      key = keys[i++];\n      if (!DESCRIPTORS || isEnum.call(O, key)) {\n        result.push(isEntries ? [key, O[key]] : O[key]);\n      }\n    }\n    return result;\n  };\n};\n","require('./_typed-array')('Float32', 4, function (init) {\n  return function Float32Array(data, byteOffset, length) {\n    return init(this, data, byteOffset, length);\n  };\n});\n","'use strict';\nif (require('./_descriptors')) {\n  var LIBRARY = require('./_library');\n  var global = require('./_global');\n  var fails = require('./_fails');\n  var $export = require('./_export');\n  var $typed = require('./_typed');\n  var $buffer = require('./_typed-buffer');\n  var ctx = require('./_ctx');\n  var anInstance = require('./_an-instance');\n  var propertyDesc = require('./_property-desc');\n  var hide = require('./_hide');\n  var redefineAll = require('./_redefine-all');\n  var toInteger = require('./_to-integer');\n  var toLength = require('./_to-length');\n  var toIndex = require('./_to-index');\n  var toAbsoluteIndex = require('./_to-absolute-index');\n  var toPrimitive = require('./_to-primitive');\n  var has = require('./_has');\n  var classof = require('./_classof');\n  var isObject = require('./_is-object');\n  var toObject = require('./_to-object');\n  var isArrayIter = require('./_is-array-iter');\n  var create = require('./_object-create');\n  var getPrototypeOf = require('./_object-gpo');\n  var gOPN = require('./_object-gopn').f;\n  var getIterFn = require('./core.get-iterator-method');\n  var uid = require('./_uid');\n  var wks = require('./_wks');\n  var createArrayMethod = require('./_array-methods');\n  var createArrayIncludes = require('./_array-includes');\n  var speciesConstructor = require('./_species-constructor');\n  var ArrayIterators = require('./es6.array.iterator');\n  var Iterators = require('./_iterators');\n  var $iterDetect = require('./_iter-detect');\n  var setSpecies = require('./_set-species');\n  var arrayFill = require('./_array-fill');\n  var arrayCopyWithin = require('./_array-copy-within');\n  var $DP = require('./_object-dp');\n  var $GOPD = require('./_object-gopd');\n  var dP = $DP.f;\n  var gOPD = $GOPD.f;\n  var RangeError = global.RangeError;\n  var TypeError = global.TypeError;\n  var Uint8Array = global.Uint8Array;\n  var ARRAY_BUFFER = 'ArrayBuffer';\n  var SHARED_BUFFER = 'Shared' + ARRAY_BUFFER;\n  var BYTES_PER_ELEMENT = 'BYTES_PER_ELEMENT';\n  var PROTOTYPE = 'prototype';\n  var ArrayProto = Array[PROTOTYPE];\n  var $ArrayBuffer = $buffer.ArrayBuffer;\n  var $DataView = $buffer.DataView;\n  var arrayForEach = createArrayMethod(0);\n  var arrayFilter = createArrayMethod(2);\n  var arraySome = createArrayMethod(3);\n  var arrayEvery = createArrayMethod(4);\n  var arrayFind = createArrayMethod(5);\n  var arrayFindIndex = createArrayMethod(6);\n  var arrayIncludes = createArrayIncludes(true);\n  var arrayIndexOf = createArrayIncludes(false);\n  var arrayValues = ArrayIterators.values;\n  var arrayKeys = ArrayIterators.keys;\n  var arrayEntries = ArrayIterators.entries;\n  var arrayLastIndexOf = ArrayProto.lastIndexOf;\n  var arrayReduce = ArrayProto.reduce;\n  var arrayReduceRight = ArrayProto.reduceRight;\n  var arrayJoin = ArrayProto.join;\n  var arraySort = ArrayProto.sort;\n  var arraySlice = ArrayProto.slice;\n  var arrayToString = ArrayProto.toString;\n  var arrayToLocaleString = ArrayProto.toLocaleString;\n  var ITERATOR = wks('iterator');\n  var TAG = wks('toStringTag');\n  var TYPED_CONSTRUCTOR = uid('typed_constructor');\n  var DEF_CONSTRUCTOR = uid('def_constructor');\n  var ALL_CONSTRUCTORS = $typed.CONSTR;\n  var TYPED_ARRAY = $typed.TYPED;\n  var VIEW = $typed.VIEW;\n  var WRONG_LENGTH = 'Wrong length!';\n\n  var $map = createArrayMethod(1, function (O, length) {\n    return allocate(speciesConstructor(O, O[DEF_CONSTRUCTOR]), length);\n  });\n\n  var LITTLE_ENDIAN = fails(function () {\n    // eslint-disable-next-line no-undef\n    return new Uint8Array(new Uint16Array([1]).buffer)[0] === 1;\n  });\n\n  var FORCED_SET = !!Uint8Array && !!Uint8Array[PROTOTYPE].set && fails(function () {\n    new Uint8Array(1).set({});\n  });\n\n  var toOffset = function (it, BYTES) {\n    var offset = toInteger(it);\n    if (offset < 0 || offset % BYTES) throw RangeError('Wrong offset!');\n    return offset;\n  };\n\n  var validate = function (it) {\n    if (isObject(it) && TYPED_ARRAY in it) return it;\n    throw TypeError(it + ' is not a typed array!');\n  };\n\n  var allocate = function (C, length) {\n    if (!(isObject(C) && TYPED_CONSTRUCTOR in C)) {\n      throw TypeError('It is not a typed array constructor!');\n    } return new C(length);\n  };\n\n  var speciesFromList = function (O, list) {\n    return fromList(speciesConstructor(O, O[DEF_CONSTRUCTOR]), list);\n  };\n\n  var fromList = function (C, list) {\n    var index = 0;\n    var length = list.length;\n    var result = allocate(C, length);\n    while (length > index) result[index] = list[index++];\n    return result;\n  };\n\n  var addGetter = function (it, key, internal) {\n    dP(it, key, { get: function () { return this._d[internal]; } });\n  };\n\n  var $from = function from(source /* , mapfn, thisArg */) {\n    var O = toObject(source);\n    var aLen = arguments.length;\n    var mapfn = aLen > 1 ? arguments[1] : undefined;\n    var mapping = mapfn !== undefined;\n    var iterFn = getIterFn(O);\n    var i, length, values, result, step, iterator;\n    if (iterFn != undefined && !isArrayIter(iterFn)) {\n      for (iterator = iterFn.call(O), values = [], i = 0; !(step = iterator.next()).done; i++) {\n        values.push(step.value);\n      } O = values;\n    }\n    if (mapping && aLen > 2) mapfn = ctx(mapfn, arguments[2], 2);\n    for (i = 0, length = toLength(O.length), result = allocate(this, length); length > i; i++) {\n      result[i] = mapping ? mapfn(O[i], i) : O[i];\n    }\n    return result;\n  };\n\n  var $of = function of(/* ...items */) {\n    var index = 0;\n    var length = arguments.length;\n    var result = allocate(this, length);\n    while (length > index) result[index] = arguments[index++];\n    return result;\n  };\n\n  // iOS Safari 6.x fails here\n  var TO_LOCALE_BUG = !!Uint8Array && fails(function () { arrayToLocaleString.call(new Uint8Array(1)); });\n\n  var $toLocaleString = function toLocaleString() {\n    return arrayToLocaleString.apply(TO_LOCALE_BUG ? arraySlice.call(validate(this)) : validate(this), arguments);\n  };\n\n  var proto = {\n    copyWithin: function copyWithin(target, start /* , end */) {\n      return arrayCopyWithin.call(validate(this), target, start, arguments.length > 2 ? arguments[2] : undefined);\n    },\n    every: function every(callbackfn /* , thisArg */) {\n      return arrayEvery(validate(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined);\n    },\n    fill: function fill(value /* , start, end */) { // eslint-disable-line no-unused-vars\n      return arrayFill.apply(validate(this), arguments);\n    },\n    filter: function filter(callbackfn /* , thisArg */) {\n      return speciesFromList(this, arrayFilter(validate(this), callbackfn,\n        arguments.length > 1 ? arguments[1] : undefined));\n    },\n    find: function find(predicate /* , thisArg */) {\n      return arrayFind(validate(this), predicate, arguments.length > 1 ? arguments[1] : undefined);\n    },\n    findIndex: function findIndex(predicate /* , thisArg */) {\n      return arrayFindIndex(validate(this), predicate, arguments.length > 1 ? arguments[1] : undefined);\n    },\n    forEach: function forEach(callbackfn /* , thisArg */) {\n      arrayForEach(validate(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined);\n    },\n    indexOf: function indexOf(searchElement /* , fromIndex */) {\n      return arrayIndexOf(validate(this), searchElement, arguments.length > 1 ? arguments[1] : undefined);\n    },\n    includes: function includes(searchElement /* , fromIndex */) {\n      return arrayIncludes(validate(this), searchElement, arguments.length > 1 ? arguments[1] : undefined);\n    },\n    join: function join(separator) { // eslint-disable-line no-unused-vars\n      return arrayJoin.apply(validate(this), arguments);\n    },\n    lastIndexOf: function lastIndexOf(searchElement /* , fromIndex */) { // eslint-disable-line no-unused-vars\n      return arrayLastIndexOf.apply(validate(this), arguments);\n    },\n    map: function map(mapfn /* , thisArg */) {\n      return $map(validate(this), mapfn, arguments.length > 1 ? arguments[1] : undefined);\n    },\n    reduce: function reduce(callbackfn /* , initialValue */) { // eslint-disable-line no-unused-vars\n      return arrayReduce.apply(validate(this), arguments);\n    },\n    reduceRight: function reduceRight(callbackfn /* , initialValue */) { // eslint-disable-line no-unused-vars\n      return arrayReduceRight.apply(validate(this), arguments);\n    },\n    reverse: function reverse() {\n      var that = this;\n      var length = validate(that).length;\n      var middle = Math.floor(length / 2);\n      var index = 0;\n      var value;\n      while (index < middle) {\n        value = that[index];\n        that[index++] = that[--length];\n        that[length] = value;\n      } return that;\n    },\n    some: function some(callbackfn /* , thisArg */) {\n      return arraySome(validate(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined);\n    },\n    sort: function sort(comparefn) {\n      return arraySort.call(validate(this), comparefn);\n    },\n    subarray: function subarray(begin, end) {\n      var O = validate(this);\n      var length = O.length;\n      var $begin = toAbsoluteIndex(begin, length);\n      return new (speciesConstructor(O, O[DEF_CONSTRUCTOR]))(\n        O.buffer,\n        O.byteOffset + $begin * O.BYTES_PER_ELEMENT,\n        toLength((end === undefined ? length : toAbsoluteIndex(end, length)) - $begin)\n      );\n    }\n  };\n\n  var $slice = function slice(start, end) {\n    return speciesFromList(this, arraySlice.call(validate(this), start, end));\n  };\n\n  var $set = function set(arrayLike /* , offset */) {\n    validate(this);\n    var offset = toOffset(arguments[1], 1);\n    var length = this.length;\n    var src = toObject(arrayLike);\n    var len = toLength(src.length);\n    var index = 0;\n    if (len + offset > length) throw RangeError(WRONG_LENGTH);\n    while (index < len) this[offset + index] = src[index++];\n  };\n\n  var $iterators = {\n    entries: function entries() {\n      return arrayEntries.call(validate(this));\n    },\n    keys: function keys() {\n      return arrayKeys.call(validate(this));\n    },\n    values: function values() {\n      return arrayValues.call(validate(this));\n    }\n  };\n\n  var isTAIndex = function (target, key) {\n    return isObject(target)\n      && target[TYPED_ARRAY]\n      && typeof key != 'symbol'\n      && key in target\n      && String(+key) == String(key);\n  };\n  var $getDesc = function getOwnPropertyDescriptor(target, key) {\n    return isTAIndex(target, key = toPrimitive(key, true))\n      ? propertyDesc(2, target[key])\n      : gOPD(target, key);\n  };\n  var $setDesc = function defineProperty(target, key, desc) {\n    if (isTAIndex(target, key = toPrimitive(key, true))\n      && isObject(desc)\n      && has(desc, 'value')\n      && !has(desc, 'get')\n      && !has(desc, 'set')\n      // TODO: add validation descriptor w/o calling accessors\n      && !desc.configurable\n      && (!has(desc, 'writable') || desc.writable)\n      && (!has(desc, 'enumerable') || desc.enumerable)\n    ) {\n      target[key] = desc.value;\n      return target;\n    } return dP(target, key, desc);\n  };\n\n  if (!ALL_CONSTRUCTORS) {\n    $GOPD.f = $getDesc;\n    $DP.f = $setDesc;\n  }\n\n  $export($export.S + $export.F * !ALL_CONSTRUCTORS, 'Object', {\n    getOwnPropertyDescriptor: $getDesc,\n    defineProperty: $setDesc\n  });\n\n  if (fails(function () { arrayToString.call({}); })) {\n    arrayToString = arrayToLocaleString = function toString() {\n      return arrayJoin.call(this);\n    };\n  }\n\n  var $TypedArrayPrototype$ = redefineAll({}, proto);\n  redefineAll($TypedArrayPrototype$, $iterators);\n  hide($TypedArrayPrototype$, ITERATOR, $iterators.values);\n  redefineAll($TypedArrayPrototype$, {\n    slice: $slice,\n    set: $set,\n    constructor: function () { /* noop */ },\n    toString: arrayToString,\n    toLocaleString: $toLocaleString\n  });\n  addGetter($TypedArrayPrototype$, 'buffer', 'b');\n  addGetter($TypedArrayPrototype$, 'byteOffset', 'o');\n  addGetter($TypedArrayPrototype$, 'byteLength', 'l');\n  addGetter($TypedArrayPrototype$, 'length', 'e');\n  dP($TypedArrayPrototype$, TAG, {\n    get: function () { return this[TYPED_ARRAY]; }\n  });\n\n  // eslint-disable-next-line max-statements\n  module.exports = function (KEY, BYTES, wrapper, CLAMPED) {\n    CLAMPED = !!CLAMPED;\n    var NAME = KEY + (CLAMPED ? 'Clamped' : '') + 'Array';\n    var GETTER = 'get' + KEY;\n    var SETTER = 'set' + KEY;\n    var TypedArray = global[NAME];\n    var Base = TypedArray || {};\n    var TAC = TypedArray && getPrototypeOf(TypedArray);\n    var FORCED = !TypedArray || !$typed.ABV;\n    var O = {};\n    var TypedArrayPrototype = TypedArray && TypedArray[PROTOTYPE];\n    var getter = function (that, index) {\n      var data = that._d;\n      return data.v[GETTER](index * BYTES + data.o, LITTLE_ENDIAN);\n    };\n    var setter = function (that, index, value) {\n      var data = that._d;\n      if (CLAMPED) value = (value = Math.round(value)) < 0 ? 0 : value > 0xff ? 0xff : value & 0xff;\n      data.v[SETTER](index * BYTES + data.o, value, LITTLE_ENDIAN);\n    };\n    var addElement = function (that, index) {\n      dP(that, index, {\n        get: function () {\n          return getter(this, index);\n        },\n        set: function (value) {\n          return setter(this, index, value);\n        },\n        enumerable: true\n      });\n    };\n    if (FORCED) {\n      TypedArray = wrapper(function (that, data, $offset, $length) {\n        anInstance(that, TypedArray, NAME, '_d');\n        var index = 0;\n        var offset = 0;\n        var buffer, byteLength, length, klass;\n        if (!isObject(data)) {\n          length = toIndex(data);\n          byteLength = length * BYTES;\n          buffer = new $ArrayBuffer(byteLength);\n        } else if (data instanceof $ArrayBuffer || (klass = classof(data)) == ARRAY_BUFFER || klass == SHARED_BUFFER) {\n          buffer = data;\n          offset = toOffset($offset, BYTES);\n          var $len = data.byteLength;\n          if ($length === undefined) {\n            if ($len % BYTES) throw RangeError(WRONG_LENGTH);\n            byteLength = $len - offset;\n            if (byteLength < 0) throw RangeError(WRONG_LENGTH);\n          } else {\n            byteLength = toLength($length) * BYTES;\n            if (byteLength + offset > $len) throw RangeError(WRONG_LENGTH);\n          }\n          length = byteLength / BYTES;\n        } else if (TYPED_ARRAY in data) {\n          return fromList(TypedArray, data);\n        } else {\n          return $from.call(TypedArray, data);\n        }\n        hide(that, '_d', {\n          b: buffer,\n          o: offset,\n          l: byteLength,\n          e: length,\n          v: new $DataView(buffer)\n        });\n        while (index < length) addElement(that, index++);\n      });\n      TypedArrayPrototype = TypedArray[PROTOTYPE] = create($TypedArrayPrototype$);\n      hide(TypedArrayPrototype, 'constructor', TypedArray);\n    } else if (!fails(function () {\n      TypedArray(1);\n    }) || !fails(function () {\n      new TypedArray(-1); // eslint-disable-line no-new\n    }) || !$iterDetect(function (iter) {\n      new TypedArray(); // eslint-disable-line no-new\n      new TypedArray(null); // eslint-disable-line no-new\n      new TypedArray(1.5); // eslint-disable-line no-new\n      new TypedArray(iter); // eslint-disable-line no-new\n    }, true)) {\n      TypedArray = wrapper(function (that, data, $offset, $length) {\n        anInstance(that, TypedArray, NAME);\n        var klass;\n        // `ws` module bug, temporarily remove validation length for Uint8Array\n        // https://github.com/websockets/ws/pull/645\n        if (!isObject(data)) return new Base(toIndex(data));\n        if (data instanceof $ArrayBuffer || (klass = classof(data)) == ARRAY_BUFFER || klass == SHARED_BUFFER) {\n          return $length !== undefined\n            ? new Base(data, toOffset($offset, BYTES), $length)\n            : $offset !== undefined\n              ? new Base(data, toOffset($offset, BYTES))\n              : new Base(data);\n        }\n        if (TYPED_ARRAY in data) return fromList(TypedArray, data);\n        return $from.call(TypedArray, data);\n      });\n      arrayForEach(TAC !== Function.prototype ? gOPN(Base).concat(gOPN(TAC)) : gOPN(Base), function (key) {\n        if (!(key in TypedArray)) hide(TypedArray, key, Base[key]);\n      });\n      TypedArray[PROTOTYPE] = TypedArrayPrototype;\n      if (!LIBRARY) TypedArrayPrototype.constructor = TypedArray;\n    }\n    var $nativeIterator = TypedArrayPrototype[ITERATOR];\n    var CORRECT_ITER_NAME = !!$nativeIterator\n      && ($nativeIterator.name == 'values' || $nativeIterator.name == undefined);\n    var $iterator = $iterators.values;\n    hide(TypedArray, TYPED_CONSTRUCTOR, true);\n    hide(TypedArrayPrototype, TYPED_ARRAY, NAME);\n    hide(TypedArrayPrototype, VIEW, true);\n    hide(TypedArrayPrototype, DEF_CONSTRUCTOR, TypedArray);\n\n    if (CLAMPED ? new TypedArray(1)[TAG] != NAME : !(TAG in TypedArrayPrototype)) {\n      dP(TypedArrayPrototype, TAG, {\n        get: function () { return NAME; }\n      });\n    }\n\n    O[NAME] = TypedArray;\n\n    $export($export.G + $export.W + $export.F * (TypedArray != Base), O);\n\n    $export($export.S, NAME, {\n      BYTES_PER_ELEMENT: BYTES\n    });\n\n    $export($export.S + $export.F * fails(function () { Base.of.call(TypedArray, 1); }), NAME, {\n      from: $from,\n      of: $of\n    });\n\n    if (!(BYTES_PER_ELEMENT in TypedArrayPrototype)) hide(TypedArrayPrototype, BYTES_PER_ELEMENT, BYTES);\n\n    $export($export.P, NAME, proto);\n\n    setSpecies(NAME);\n\n    $export($export.P + $export.F * FORCED_SET, NAME, { set: $set });\n\n    $export($export.P + $export.F * !CORRECT_ITER_NAME, NAME, $iterators);\n\n    if (!LIBRARY && TypedArrayPrototype.toString != arrayToString) TypedArrayPrototype.toString = arrayToString;\n\n    $export($export.P + $export.F * fails(function () {\n      new TypedArray(1).slice();\n    }), NAME, { slice: $slice });\n\n    $export($export.P + $export.F * (fails(function () {\n      return [1, 2].toLocaleString() != new TypedArray([1, 2]).toLocaleString();\n    }) || !fails(function () {\n      TypedArrayPrototype.toLocaleString.call([1, 2]);\n    })), NAME, { toLocaleString: $toLocaleString });\n\n    Iterators[NAME] = CORRECT_ITER_NAME ? $nativeIterator : $iterator;\n    if (!LIBRARY && !CORRECT_ITER_NAME) hide(TypedArrayPrototype, ITERATOR, $iterator);\n  };\n} else module.exports = function () { /* empty */ };\n","'use strict';\nvar global = require('./_global');\nvar DESCRIPTORS = require('./_descriptors');\nvar LIBRARY = require('./_library');\nvar $typed = require('./_typed');\nvar hide = require('./_hide');\nvar redefineAll = require('./_redefine-all');\nvar fails = require('./_fails');\nvar anInstance = require('./_an-instance');\nvar toInteger = require('./_to-integer');\nvar toLength = require('./_to-length');\nvar toIndex = require('./_to-index');\nvar gOPN = require('./_object-gopn').f;\nvar dP = require('./_object-dp').f;\nvar arrayFill = require('./_array-fill');\nvar setToStringTag = require('./_set-to-string-tag');\nvar ARRAY_BUFFER = 'ArrayBuffer';\nvar DATA_VIEW = 'DataView';\nvar PROTOTYPE = 'prototype';\nvar WRONG_LENGTH = 'Wrong length!';\nvar WRONG_INDEX = 'Wrong index!';\nvar $ArrayBuffer = global[ARRAY_BUFFER];\nvar $DataView = global[DATA_VIEW];\nvar Math = global.Math;\nvar RangeError = global.RangeError;\n// eslint-disable-next-line no-shadow-restricted-names\nvar Infinity = global.Infinity;\nvar BaseBuffer = $ArrayBuffer;\nvar abs = Math.abs;\nvar pow = Math.pow;\nvar floor = Math.floor;\nvar log = Math.log;\nvar LN2 = Math.LN2;\nvar BUFFER = 'buffer';\nvar BYTE_LENGTH = 'byteLength';\nvar BYTE_OFFSET = 'byteOffset';\nvar $BUFFER = DESCRIPTORS ? '_b' : BUFFER;\nvar $LENGTH = DESCRIPTORS ? '_l' : BYTE_LENGTH;\nvar $OFFSET = DESCRIPTORS ? '_o' : BYTE_OFFSET;\n\n// IEEE754 conversions based on https://github.com/feross/ieee754\nfunction packIEEE754(value, mLen, nBytes) {\n  var buffer = new Array(nBytes);\n  var eLen = nBytes * 8 - mLen - 1;\n  var eMax = (1 << eLen) - 1;\n  var eBias = eMax >> 1;\n  var rt = mLen === 23 ? pow(2, -24) - pow(2, -77) : 0;\n  var i = 0;\n  var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;\n  var e, m, c;\n  value = abs(value);\n  // eslint-disable-next-line no-self-compare\n  if (value != value || value === Infinity) {\n    // eslint-disable-next-line no-self-compare\n    m = value != value ? 1 : 0;\n    e = eMax;\n  } else {\n    e = floor(log(value) / LN2);\n    if (value * (c = pow(2, -e)) < 1) {\n      e--;\n      c *= 2;\n    }\n    if (e + eBias >= 1) {\n      value += rt / c;\n    } else {\n      value += rt * pow(2, 1 - eBias);\n    }\n    if (value * c >= 2) {\n      e++;\n      c /= 2;\n    }\n    if (e + eBias >= eMax) {\n      m = 0;\n      e = eMax;\n    } else if (e + eBias >= 1) {\n      m = (value * c - 1) * pow(2, mLen);\n      e = e + eBias;\n    } else {\n      m = value * pow(2, eBias - 1) * pow(2, mLen);\n      e = 0;\n    }\n  }\n  for (; mLen >= 8; buffer[i++] = m & 255, m /= 256, mLen -= 8);\n  e = e << mLen | m;\n  eLen += mLen;\n  for (; eLen > 0; buffer[i++] = e & 255, e /= 256, eLen -= 8);\n  buffer[--i] |= s * 128;\n  return buffer;\n}\nfunction unpackIEEE754(buffer, mLen, nBytes) {\n  var eLen = nBytes * 8 - mLen - 1;\n  var eMax = (1 << eLen) - 1;\n  var eBias = eMax >> 1;\n  var nBits = eLen - 7;\n  var i = nBytes - 1;\n  var s = buffer[i--];\n  var e = s & 127;\n  var m;\n  s >>= 7;\n  for (; nBits > 0; e = e * 256 + buffer[i], i--, nBits -= 8);\n  m = e & (1 << -nBits) - 1;\n  e >>= -nBits;\n  nBits += mLen;\n  for (; nBits > 0; m = m * 256 + buffer[i], i--, nBits -= 8);\n  if (e === 0) {\n    e = 1 - eBias;\n  } else if (e === eMax) {\n    return m ? NaN : s ? -Infinity : Infinity;\n  } else {\n    m = m + pow(2, mLen);\n    e = e - eBias;\n  } return (s ? -1 : 1) * m * pow(2, e - mLen);\n}\n\nfunction unpackI32(bytes) {\n  return bytes[3] << 24 | bytes[2] << 16 | bytes[1] << 8 | bytes[0];\n}\nfunction packI8(it) {\n  return [it & 0xff];\n}\nfunction packI16(it) {\n  return [it & 0xff, it >> 8 & 0xff];\n}\nfunction packI32(it) {\n  return [it & 0xff, it >> 8 & 0xff, it >> 16 & 0xff, it >> 24 & 0xff];\n}\nfunction packF64(it) {\n  return packIEEE754(it, 52, 8);\n}\nfunction packF32(it) {\n  return packIEEE754(it, 23, 4);\n}\n\nfunction addGetter(C, key, internal) {\n  dP(C[PROTOTYPE], key, { get: function () { return this[internal]; } });\n}\n\nfunction get(view, bytes, index, isLittleEndian) {\n  var numIndex = +index;\n  var intIndex = toIndex(numIndex);\n  if (intIndex + bytes > view[$LENGTH]) throw RangeError(WRONG_INDEX);\n  var store = view[$BUFFER]._b;\n  var start = intIndex + view[$OFFSET];\n  var pack = store.slice(start, start + bytes);\n  return isLittleEndian ? pack : pack.reverse();\n}\nfunction set(view, bytes, index, conversion, value, isLittleEndian) {\n  var numIndex = +index;\n  var intIndex = toIndex(numIndex);\n  if (intIndex + bytes > view[$LENGTH]) throw RangeError(WRONG_INDEX);\n  var store = view[$BUFFER]._b;\n  var start = intIndex + view[$OFFSET];\n  var pack = conversion(+value);\n  for (var i = 0; i < bytes; i++) store[start + i] = pack[isLittleEndian ? i : bytes - i - 1];\n}\n\nif (!$typed.ABV) {\n  $ArrayBuffer = function ArrayBuffer(length) {\n    anInstance(this, $ArrayBuffer, ARRAY_BUFFER);\n    var byteLength = toIndex(length);\n    this._b = arrayFill.call(new Array(byteLength), 0);\n    this[$LENGTH] = byteLength;\n  };\n\n  $DataView = function DataView(buffer, byteOffset, byteLength) {\n    anInstance(this, $DataView, DATA_VIEW);\n    anInstance(buffer, $ArrayBuffer, DATA_VIEW);\n    var bufferLength = buffer[$LENGTH];\n    var offset = toInteger(byteOffset);\n    if (offset < 0 || offset > bufferLength) throw RangeError('Wrong offset!');\n    byteLength = byteLength === undefined ? bufferLength - offset : toLength(byteLength);\n    if (offset + byteLength > bufferLength) throw RangeError(WRONG_LENGTH);\n    this[$BUFFER] = buffer;\n    this[$OFFSET] = offset;\n    this[$LENGTH] = byteLength;\n  };\n\n  if (DESCRIPTORS) {\n    addGetter($ArrayBuffer, BYTE_LENGTH, '_l');\n    addGetter($DataView, BUFFER, '_b');\n    addGetter($DataView, BYTE_LENGTH, '_l');\n    addGetter($DataView, BYTE_OFFSET, '_o');\n  }\n\n  redefineAll($DataView[PROTOTYPE], {\n    getInt8: function getInt8(byteOffset) {\n      return get(this, 1, byteOffset)[0] << 24 >> 24;\n    },\n    getUint8: function getUint8(byteOffset) {\n      return get(this, 1, byteOffset)[0];\n    },\n    getInt16: function getInt16(byteOffset /* , littleEndian */) {\n      var bytes = get(this, 2, byteOffset, arguments[1]);\n      return (bytes[1] << 8 | bytes[0]) << 16 >> 16;\n    },\n    getUint16: function getUint16(byteOffset /* , littleEndian */) {\n      var bytes = get(this, 2, byteOffset, arguments[1]);\n      return bytes[1] << 8 | bytes[0];\n    },\n    getInt32: function getInt32(byteOffset /* , littleEndian */) {\n      return unpackI32(get(this, 4, byteOffset, arguments[1]));\n    },\n    getUint32: function getUint32(byteOffset /* , littleEndian */) {\n      return unpackI32(get(this, 4, byteOffset, arguments[1])) >>> 0;\n    },\n    getFloat32: function getFloat32(byteOffset /* , littleEndian */) {\n      return unpackIEEE754(get(this, 4, byteOffset, arguments[1]), 23, 4);\n    },\n    getFloat64: function getFloat64(byteOffset /* , littleEndian */) {\n      return unpackIEEE754(get(this, 8, byteOffset, arguments[1]), 52, 8);\n    },\n    setInt8: function setInt8(byteOffset, value) {\n      set(this, 1, byteOffset, packI8, value);\n    },\n    setUint8: function setUint8(byteOffset, value) {\n      set(this, 1, byteOffset, packI8, value);\n    },\n    setInt16: function setInt16(byteOffset, value /* , littleEndian */) {\n      set(this, 2, byteOffset, packI16, value, arguments[2]);\n    },\n    setUint16: function setUint16(byteOffset, value /* , littleEndian */) {\n      set(this, 2, byteOffset, packI16, value, arguments[2]);\n    },\n    setInt32: function setInt32(byteOffset, value /* , littleEndian */) {\n      set(this, 4, byteOffset, packI32, value, arguments[2]);\n    },\n    setUint32: function setUint32(byteOffset, value /* , littleEndian */) {\n      set(this, 4, byteOffset, packI32, value, arguments[2]);\n    },\n    setFloat32: function setFloat32(byteOffset, value /* , littleEndian */) {\n      set(this, 4, byteOffset, packF32, value, arguments[2]);\n    },\n    setFloat64: function setFloat64(byteOffset, value /* , littleEndian */) {\n      set(this, 8, byteOffset, packF64, value, arguments[2]);\n    }\n  });\n} else {\n  if (!fails(function () {\n    $ArrayBuffer(1);\n  }) || !fails(function () {\n    new $ArrayBuffer(-1); // eslint-disable-line no-new\n  }) || fails(function () {\n    new $ArrayBuffer(); // eslint-disable-line no-new\n    new $ArrayBuffer(1.5); // eslint-disable-line no-new\n    new $ArrayBuffer(NaN); // eslint-disable-line no-new\n    return $ArrayBuffer.name != ARRAY_BUFFER;\n  })) {\n    $ArrayBuffer = function ArrayBuffer(length) {\n      anInstance(this, $ArrayBuffer);\n      return new BaseBuffer(toIndex(length));\n    };\n    var ArrayBufferProto = $ArrayBuffer[PROTOTYPE] = BaseBuffer[PROTOTYPE];\n    for (var keys = gOPN(BaseBuffer), j = 0, key; keys.length > j;) {\n      if (!((key = keys[j++]) in $ArrayBuffer)) hide($ArrayBuffer, key, BaseBuffer[key]);\n    }\n    if (!LIBRARY) ArrayBufferProto.constructor = $ArrayBuffer;\n  }\n  // iOS Safari 7.x bug\n  var view = new $DataView(new $ArrayBuffer(2));\n  var $setInt8 = $DataView[PROTOTYPE].setInt8;\n  view.setInt8(0, 2147483648);\n  view.setInt8(1, 2147483649);\n  if (view.getInt8(0) || !view.getInt8(1)) redefineAll($DataView[PROTOTYPE], {\n    setInt8: function setInt8(byteOffset, value) {\n      $setInt8.call(this, byteOffset, value << 24 >> 24);\n    },\n    setUint8: function setUint8(byteOffset, value) {\n      $setInt8.call(this, byteOffset, value << 24 >> 24);\n    }\n  }, true);\n}\nsetToStringTag($ArrayBuffer, ARRAY_BUFFER);\nsetToStringTag($DataView, DATA_VIEW);\nhide($DataView[PROTOTYPE], $typed.VIEW, true);\nexports[ARRAY_BUFFER] = $ArrayBuffer;\nexports[DATA_VIEW] = $DataView;\n","// 22.1.3.3 Array.prototype.copyWithin(target, start, end = this.length)\n'use strict';\nvar toObject = require('./_to-object');\nvar toAbsoluteIndex = require('./_to-absolute-index');\nvar toLength = require('./_to-length');\n\nmodule.exports = [].copyWithin || function copyWithin(target /* = 0 */, start /* = 0, end = @length */) {\n  var O = toObject(this);\n  var len = toLength(O.length);\n  var to = toAbsoluteIndex(target, len);\n  var from = toAbsoluteIndex(start, len);\n  var end = arguments.length > 2 ? arguments[2] : undefined;\n  var count = Math.min((end === undefined ? len : toAbsoluteIndex(end, len)) - from, len - to);\n  var inc = 1;\n  if (from < to && to < from + count) {\n    inc = -1;\n    from += count - 1;\n    to += count - 1;\n  }\n  while (count-- > 0) {\n    if (from in O) O[to] = O[from];\n    else delete O[to];\n    to += inc;\n    from += inc;\n  } return O;\n};\n","var React = require('react');\n\nfunction ChevronLeftSolidInline (props) {\n    return React.createElement(\"svg\",props,React.createElement(\"path\",{\"fill\":\"currentColor\",\"d\":\"M34.52 239.03L228.87 44.69c9.37-9.37 24.57-9.37 33.94 0l22.67 22.67c9.36 9.36 9.37 24.52.04 33.9L131.49 256l154.02 154.75c9.34 9.38 9.32 24.54-.04 33.9l-22.67 22.67c-9.37 9.37-24.57 9.37-33.94 0L34.52 272.97c-9.37-9.37-9.37-24.57 0-33.94z\"}));\n}\n\nChevronLeftSolidInline.defaultProps = {\"aria-hidden\":\"true\",\"focusable\":\"false\",\"data-prefix\":\"fas\",\"data-icon\":\"chevron-left\",\"className\":\"svg-inline--fa fa-chevron-left fa-w-10\",\"role\":\"img\",\"viewBox\":\"0 0 320 512\"};\n\nmodule.exports = ChevronLeftSolidInline;\n\nChevronLeftSolidInline.default = ChevronLeftSolidInline;\n","'use strict';\n// B.2.3.14 String.prototype.sup()\nrequire('./_string-html')('sup', function (createHTML) {\n  return function sup() {\n    return createHTML(this, 'sup', '', '');\n  };\n});\n","'use strict';\n// B.2.3.13 String.prototype.sub()\nrequire('./_string-html')('sub', function (createHTML) {\n  return function sub() {\n    return createHTML(this, 'sub', '', '');\n  };\n});\n","'use strict';\n// B.2.3.11 String.prototype.small()\nrequire('./_string-html')('small', function (createHTML) {\n  return function small() {\n    return createHTML(this, 'small', '', '');\n  };\n});\n","'use strict';\nvar $export = require('./_export');\nvar createProperty = require('./_create-property');\n\n// WebKit Array.of isn't generic\n$export($export.S + $export.F * require('./_fails')(function () {\n  function F() { /* empty */ }\n  return !(Array.of.call(F) instanceof F);\n}), 'Array', {\n  // 22.1.2.3 Array.of( ...items)\n  of: function of(/* ...args */) {\n    var index = 0;\n    var aLen = arguments.length;\n    var result = new (typeof this == 'function' ? this : Array)(aLen);\n    while (aLen > index) createProperty(result, index, arguments[index++]);\n    result.length = aLen;\n    return result;\n  }\n});\n","import * as tslib_1 from \"tslib\";\nimport * as React from 'react';\n\nvar SideCar = function SideCar(_a) {\n  var sideCar = _a.sideCar,\n      rest = tslib_1.__rest(_a, [\"sideCar\"]);\n\n  if (!sideCar) {\n    throw new Error('Sidecar: please provide `sideCar` property to import the right car');\n  }\n\n  var Target = sideCar.read();\n\n  if (!Target) {\n    throw new Error('Sidecar medium not found');\n  }\n\n  return React.createElement(Target, tslib_1.__assign({}, rest));\n};\n\nSideCar.isSideCarExport = true;\nexport function exportSidecar(medium, exported) {\n  medium.useMedium(exported);\n  return SideCar;\n}","function makeStyleTag() {\n  if (!document) return null;\n  var tag = document.createElement('style');\n  tag.type = 'text/css';\n  return tag;\n}\n\nfunction injectStyles(tag, css) {\n  if (tag.styleSheet) {\n    tag.styleSheet.cssText = css;\n  } else {\n    tag.appendChild(document.createTextNode(css));\n  }\n}\n\nfunction insertStyleTag(tag) {\n  var head = document.head || document.getElementsByTagName('head')[0];\n  head.appendChild(tag);\n}\n\nexport var stylesheetSingleton = function stylesheetSingleton() {\n  var counter = 0;\n  var stylesheet = null;\n  return {\n    add: function add(style) {\n      if (counter == 0) {\n        if (stylesheet = makeStyleTag()) {\n          injectStyles(stylesheet, style);\n          insertStyleTag(stylesheet);\n        }\n      }\n\n      counter++;\n    },\n    remove: function remove() {\n      counter--;\n\n      if (!counter && stylesheet) {\n        stylesheet.parentNode && stylesheet.parentNode.removeChild(stylesheet);\n        stylesheet = null;\n      }\n    }\n  };\n};","import { styleHookSingleton } from \"./hook\";\nexport var styleSingleton = function styleSingleton() {\n  var useStyle = styleHookSingleton();\n\n  var Sheet = function Sheet(_a) {\n    var styles = _a.styles;\n    useStyle(styles);\n    return null;\n  };\n\n  return Sheet;\n};","import * as React from 'react';\nimport { stylesheetSingleton } from \"./singleton\";\nexport var styleHookSingleton = function styleHookSingleton() {\n  var sheet = stylesheetSingleton();\n  return function (styles) {\n    React.useEffect(function () {\n      sheet.add(styles);\n      return function () {\n        sheet.remove();\n      };\n    }, []);\n  };\n};","export var zeroGap = {\n  left: 0,\n  top: 0,\n  right: 0,\n  gap: 0\n};\n\nvar parse = function parse(x) {\n  return parseInt(x || '', 10) || 0;\n};\n\nvar getOffset = function getOffset(gapMode) {\n  var cs = window.getComputedStyle(document.body);\n  var left = cs[gapMode === 'padding' ? 'paddingLeft' : 'marginLeft'];\n  var top = cs[gapMode === 'padding' ? 'paddingTop' : 'marginTop'];\n  var right = cs[gapMode === 'padding' ? 'paddingRight' : 'marginRight'];\n  return [parse(left), parse(top), parse(right)];\n};\n\nexport var getGapWidth = function getGapWidth(gapMode) {\n  if (gapMode === void 0) {\n    gapMode = 'margin';\n  }\n\n  if (typeof window === 'undefined') {\n    return zeroGap;\n  }\n\n  var offsets = getOffset(gapMode);\n  var documentWidth = document.documentElement.clientWidth;\n  var windowWidth = window.innerWidth;\n  return {\n    left: offsets[0],\n    top: offsets[1],\n    right: offsets[2],\n    gap: Math.max(0, windowWidth - documentWidth + offsets[2] - offsets[0])\n  };\n};","import \"core-js/modules/es6.array.filter\";\nimport * as React from 'react';\nimport { styleSingleton } from 'react-style-singleton';\nimport { getGapWidth } from './utils';\nimport { fullWidthClassName, zeroRightClassName, noScrollbarsClassName } from \"./constants\";\nvar Style = styleSingleton();\n\nvar getStyles = function getStyles(_a, allowRelative, gapMode, important) {\n  var left = _a.left,\n      top = _a.top,\n      right = _a.right,\n      gap = _a.gap;\n\n  if (gapMode === void 0) {\n    gapMode = 'margin';\n  }\n\n  return \"\\n  .\" + noScrollbarsClassName + \" {\\n   overflow: hidden \" + important + \";\\n   padding-right: \" + gap + \"px \" + important + \";\\n  }\\n  body {\\n    overflow: hidden \" + important + \";\\n    \" + [allowRelative && \"position: relative \" + important + \";\", gapMode === 'margin' && \"\\n    padding-left: \" + left + \"px;\\n    padding-top: \" + top + \"px;\\n    padding-right: \" + right + \"px;\\n    margin-left:0;\\n    margin-top:0;\\n    margin-right: \" + gap + \"px \" + important + \";\\n    \", gapMode === 'padding' && \"padding-right: \" + gap + \"px \" + important + \";\"].filter(Boolean).join('') + \"\\n  }\\n  \\n  .\" + zeroRightClassName + \" {\\n    right: \" + gap + \"px \" + important + \";\\n  }\\n  \\n  .\" + fullWidthClassName + \" {\\n    margin-right: \" + gap + \"px \" + important + \";\\n  }\\n  \\n  .\" + zeroRightClassName + \" .\" + zeroRightClassName + \" {\\n    right: 0 \" + important + \";\\n  }\\n  \\n  .\" + fullWidthClassName + \" .\" + fullWidthClassName + \" {\\n    margin-right: 0 \" + important + \";\\n  }\\n\";\n};\n\nexport var RemoveScrollBar = function RemoveScrollBar(props) {\n  var _a = React.useState(getGapWidth(props.gapMode)),\n      gap = _a[0],\n      setGap = _a[1];\n\n  React.useEffect(function () {\n    setGap(getGapWidth(props.gapMode));\n  }, [props.gapMode]);\n  var noRelative = props.noRelative,\n      noImportant = props.noImportant,\n      _b = props.gapMode,\n      gapMode = _b === void 0 ? 'margin' : _b;\n  return React.createElement(Style, {\n    styles: getStyles(gap, !noRelative, gapMode, !noImportant ? \"!important\" : '')\n  });\n};","var elementCouldBeVScrolled = function elementCouldBeVScrolled(node) {\n  var styles = window.getComputedStyle(node);\n  return styles.overflowY !== 'hidden' && !(styles.overflowY === styles.overflowX && styles.overflowY === 'visible');\n};\n\nvar elementCouldBeHScrolled = function elementCouldBeHScrolled(node) {\n  var styles = window.getComputedStyle(node);\n  return styles.overflowX !== 'hidden' && !(styles.overflowY === styles.overflowX && styles.overflowX === 'visible');\n};\n\nexport var locationCouldBeScrolled = function locationCouldBeScrolled(axis, node) {\n  var current = node;\n\n  do {\n    var isScrollable = elementCouldBeScrolled(axis, current);\n\n    if (isScrollable) {\n      var _a = getScrollVariables(axis, current),\n          s = _a[1],\n          d = _a[2];\n\n      if (s > d) {\n        return true;\n      }\n    }\n\n    current = current.parentNode;\n  } while (current && current !== document.body);\n\n  return false;\n};\n\nvar getVScrollVariables = function getVScrollVariables(_a) {\n  var scrollTop = _a.scrollTop,\n      scrollHeight = _a.scrollHeight,\n      clientHeight = _a.clientHeight;\n  return [scrollTop, scrollHeight, clientHeight];\n};\n\nvar getHScrollVariables = function getHScrollVariables(_a) {\n  var scrollLeft = _a.scrollLeft,\n      scrollWidth = _a.scrollWidth,\n      clientWidth = _a.clientWidth;\n  return [scrollLeft, scrollWidth, clientWidth];\n};\n\nvar elementCouldBeScrolled = function elementCouldBeScrolled(axis, node) {\n  return axis === 'v' ? elementCouldBeVScrolled(node) : elementCouldBeHScrolled(node);\n};\n\nvar getScrollVariables = function getScrollVariables(axis, node) {\n  return axis === 'v' ? getVScrollVariables(node) : getHScrollVariables(node);\n};\n\nexport var handleScroll = function handleScroll(axis, endTarget, event, sourceDelta) {\n  var delta = sourceDelta;\n  var target = event.target;\n  var targetInLock = endTarget.contains(target);\n  var shouldCancelScroll = false;\n  var isDeltaPositive = delta > 0;\n  var availableScroll = 0;\n  var availableScrollTop = 0;\n\n  do {\n    var _a = getScrollVariables(axis, target),\n        position = _a[0],\n        scroll_1 = _a[1],\n        capacity = _a[2];\n\n    var elementScroll = scroll_1 - capacity - position;\n\n    if (position || elementScroll) {\n      if (elementCouldBeScrolled(axis, target)) {\n        availableScroll += elementScroll;\n        availableScrollTop += position;\n      }\n    }\n\n    target = target.parentNode;\n  } while (!targetInLock && target !== document.body || targetInLock && (endTarget.contains(target) || endTarget === target));\n\n  if (isDeltaPositive && delta > availableScroll) {\n    shouldCancelScroll = true;\n  } else if (!isDeltaPositive && -delta > availableScrollTop) {\n    shouldCancelScroll = true;\n  }\n\n  return shouldCancelScroll;\n};","import \"core-js/modules/es6.object.define-property\";\nvar passiveSupported = false;\n\nif (typeof window !== 'undefined') {\n  try {\n    var options = Object.defineProperty({}, 'passive', {\n      get: function get() {\n        passiveSupported = true;\n        return true;\n      }\n    });\n    window.addEventListener('test', options, options);\n    window.removeEventListener('test', options, options);\n  } catch (err) {\n    passiveSupported = false;\n  }\n}\n\nexport var nonPassive = passiveSupported ? {\n  passive: false\n} : false;","import \"core-js/modules/es6.function.name\";\nimport \"core-js/modules/es6.array.for-each\";\nimport \"core-js/modules/es6.array.map\";\nimport \"core-js/modules/es6.array.filter\";\nimport * as React from 'react';\nimport { RemoveScrollBar } from 'react-remove-scroll-bar';\nimport { styleSingleton } from 'react-style-singleton';\nimport { handleScroll, locationCouldBeScrolled } from \"./handleScroll\";\nimport { nonPassive } from './aggresiveCapture';\nexport var getTouchXY = function getTouchXY(event) {\n  return event.changedTouches ? [event.changedTouches[0].clientX, event.changedTouches[0].clientY] : [0, 0];\n};\nexport var getDeltaXY = function getDeltaXY(event) {\n  return [event.deltaX, event.deltaY];\n};\n\nvar extractRef = function extractRef(ref) {\n  return ref && 'current' in ref ? ref.current : ref;\n};\n\nvar deltaCompare = function deltaCompare(x, y) {\n  return x[0] === y[0] && x[1] === y[1];\n};\n\nvar generateStyle = function generateStyle(id) {\n  return \"\\n  .block-interactivity-\" + id + \" {pointer-events: none;}\\n  .allow-interactivity-\" + id + \" {pointer-events: all;}\\n\";\n};\n\nvar idCounter = 0;\nvar lockStack = [];\nexport function RemoveScrollSideCar(props) {\n  var shouldPreventQueue = React.useRef([]);\n  var touchStartRef = React.useRef([0, 0]);\n  var activeAxis = React.useRef();\n  var id = React.useState(idCounter++)[0];\n  var Style = React.useState(function () {\n    return styleSingleton();\n  })[0];\n  var lastProps = React.useRef(props);\n  React.useEffect(function () {\n    lastProps.current = props;\n  }, [props]);\n  React.useEffect(function () {\n    if (props.inert) {\n      document.body.classList.add(\"block-interactivity-\" + id);\n      var allow_1 = [props.lockRef.current].concat((props.shards || []).map(extractRef)).filter(Boolean);\n      allow_1.forEach(function (el) {\n        return el.classList.add(\"allow-interactivity-\" + id);\n      });\n      return function () {\n        document.body.classList.remove(\"block-interactivity-\" + id);\n        allow_1.forEach(function (el) {\n          return el.classList.remove(\"allow-interactivity-\" + id);\n        });\n      };\n    }\n\n    return;\n  }, [props.inert, props.lockRef.current, props.shards]);\n  var shouldCancelEvent = React.useCallback(function (event, parent) {\n    var touch = getTouchXY(event);\n    var touchStart = touchStartRef.current;\n    var deltaX = 'deltaX' in event ? event.deltaX : touchStart[0] - touch[0];\n    var deltaY = 'deltaY' in event ? event.deltaY : touchStart[1] - touch[1];\n    var currentAxis;\n    var target = event.target;\n    var moveDirection = Math.abs(deltaX) > Math.abs(deltaY) ? 'h' : 'v';\n    var canBeScrolledInMainDirection = locationCouldBeScrolled(moveDirection, target);\n\n    if (!canBeScrolledInMainDirection) {\n      return true;\n    }\n\n    if (canBeScrolledInMainDirection) {\n      currentAxis = moveDirection;\n    } else {\n      currentAxis = moveDirection === 'v' ? 'h' : 'v';\n      canBeScrolledInMainDirection = locationCouldBeScrolled(moveDirection, target);\n    }\n\n    if (!canBeScrolledInMainDirection) {\n      return false;\n    }\n\n    if (!activeAxis.current && event.changedTouches && (deltaX || deltaY)) {\n      activeAxis.current = currentAxis;\n    }\n\n    if (!currentAxis) {\n      return true;\n    }\n\n    var cancelingAxis = activeAxis.current || currentAxis;\n    return handleScroll(cancelingAxis, parent, event, cancelingAxis == 'h' ? deltaX : deltaY);\n  }, []);\n  var shouldPrevent = React.useCallback(function (event) {\n    if (!lockStack.length || lockStack[lockStack.length - 1] !== Style) {\n      return;\n    }\n\n    var delta = 'deltaY' in event ? getDeltaXY(event) : getTouchXY(event);\n    var sourceEvent = shouldPreventQueue.current.filter(function (e) {\n      return e.name === event.type && e.target === event.target && deltaCompare(e.delta, delta);\n    })[0];\n\n    if (sourceEvent && sourceEvent.should) {\n      event.preventDefault();\n      return;\n    }\n\n    if (!sourceEvent) {\n      var shardNodes = (lastProps.current.shards || []).map(extractRef).filter(Boolean).filter(function (node) {\n        return node.contains(event.target);\n      });\n      var shouldStop = shardNodes.length > 0 ? shouldCancelEvent(event, shardNodes[0]) : !lastProps.current.noIsolation;\n\n      if (shouldStop) {\n        event.preventDefault();\n      }\n    }\n  }, []);\n  var shouldCancel = React.useCallback(function (name, delta, target, should) {\n    var event = {\n      name: name,\n      delta: delta,\n      target: target,\n      should: should\n    };\n    shouldPreventQueue.current.push(event);\n    setTimeout(function () {\n      shouldPreventQueue.current = shouldPreventQueue.current.filter(function (e) {\n        return e !== event;\n      });\n    }, 1);\n  }, []);\n  var scrollTouchStart = React.useCallback(function (event) {\n    touchStartRef.current = getTouchXY(event);\n    activeAxis.current = undefined;\n  }, []);\n  var scrollWheel = React.useCallback(function (event) {\n    shouldCancel(event.type, getDeltaXY(event), event.target, shouldCancelEvent(event, props.lockRef.current));\n  }, []);\n  var scrollTouchMove = React.useCallback(function (event) {\n    shouldCancel(event.type, getTouchXY(event), event.target, shouldCancelEvent(event, props.lockRef.current));\n  }, []);\n  React.useEffect(function () {\n    lockStack.push(Style);\n    props.setCallbacks({\n      onScrollCapture: scrollWheel,\n      onWheelCapture: scrollWheel,\n      onTouchMoveCapture: scrollTouchMove\n    });\n    document.addEventListener('wheel', shouldPrevent, nonPassive);\n    document.addEventListener('touchmove', shouldPrevent, nonPassive);\n    document.addEventListener('touchstart', scrollTouchStart, nonPassive);\n    return function () {\n      lockStack = lockStack.filter(function (inst) {\n        return inst !== Style;\n      });\n      document.removeEventListener('wheel', shouldPrevent, nonPassive);\n      document.removeEventListener('touchmove', shouldPrevent, nonPassive);\n      document.removeEventListener('touchstart', scrollTouchStart, nonPassive);\n    };\n  }, []);\n  var removeScrollBar = props.removeScrollBar,\n      inert = props.inert;\n  return React.createElement(React.Fragment, null, inert ? React.createElement(Style, {\n    styles: generateStyle(id)\n  }) : null, removeScrollBar ? React.createElement(RemoveScrollBar, {\n    gapMode: \"margin\"\n  }) : null);\n}","import \"core-js/modules/es6.promise\";\nimport \"core-js/modules/es6.object.to-string\";\nimport \"core-js/modules/es6.array.for-each\";\nimport \"core-js/modules/es6.array.filter\";\nimport * as tslib_1 from \"tslib\";\n\nfunction ItoI(a) {\n  return a;\n}\n\nfunction innerCreateMedium(defaults, middleware) {\n  if (middleware === void 0) {\n    middleware = ItoI;\n  }\n\n  var buffer = [];\n  var assigned = false;\n  var medium = {\n    read: function read() {\n      if (assigned) {\n        throw new Error('Sidecar: could not `read` from an `assigned` medium. `read` could be used only with `useMedium`.');\n      }\n\n      if (buffer.length) {\n        return buffer[buffer.length - 1];\n      }\n\n      return defaults;\n    },\n    useMedium: function useMedium(data) {\n      var item = middleware(data, assigned);\n      buffer.push(item);\n      return function () {\n        buffer = buffer.filter(function (x) {\n          return x !== item;\n        });\n      };\n    },\n    assignSyncMedium: function assignSyncMedium(cb) {\n      assigned = true;\n\n      while (buffer.length) {\n        var cbs = buffer;\n        buffer = [];\n        cbs.forEach(cb);\n      }\n\n      buffer = {\n        push: function push(x) {\n          return cb(x);\n        },\n        filter: function filter() {\n          return buffer;\n        }\n      };\n    },\n    assignMedium: function assignMedium(cb) {\n      assigned = true;\n      var pendingQueue = [];\n\n      if (buffer.length) {\n        var cbs = buffer;\n        buffer = [];\n        cbs.forEach(cb);\n        pendingQueue = buffer;\n      }\n\n      var executeQueue = function executeQueue() {\n        var cbs = pendingQueue;\n        pendingQueue = [];\n        cbs.forEach(cb);\n      };\n\n      var cycle = function cycle() {\n        return Promise.resolve().then(executeQueue);\n      };\n\n      cycle();\n      buffer = {\n        push: function push(x) {\n          pendingQueue.push(x);\n          cycle();\n        },\n        filter: function filter(_filter) {\n          pendingQueue = pendingQueue.filter(_filter);\n          return buffer;\n        }\n      };\n    }\n  };\n  return medium;\n}\n\nexport function createMedium(defaults, middleware) {\n  if (middleware === void 0) {\n    middleware = ItoI;\n  }\n\n  return innerCreateMedium(defaults, middleware);\n}\nexport function createSidecarMedium(options) {\n  if (options === void 0) {\n    options = {};\n  }\n\n  var medium = innerCreateMedium(null);\n  medium.options = tslib_1.__assign({\n    async: true,\n    ssr: false\n  }, options);\n  return medium;\n}","import { createSidecarMedium } from 'use-sidecar';\nexport var effectCar = createSidecarMedium();","import { exportSidecar } from \"use-sidecar\";\nimport { RemoveScrollSideCar } from \"./SideEffect\";\nimport { effectCar } from \"./medium\";\nexport default exportSidecar(effectCar, RemoveScrollSideCar);","import * as tslib_1 from \"tslib\";\nimport * as React from 'react';\nimport { fullWidthClassName, zeroRightClassName } from 'react-remove-scroll-bar/constants';\nimport { effectCar } from \"./medium\";\n\nvar nothing = function nothing() {\n  return;\n};\n\nfunction RemoveScroll(props) {\n  var ref = React.useRef(null);\n\n  var _a = React.useState({\n    onScrollCapture: nothing,\n    onWheelCapture: nothing,\n    onTouchMoveCapture: nothing\n  }),\n      callbacks = _a[0],\n      setCallbacks = _a[1];\n\n  var forwardProps = props.forwardProps,\n      children = props.children,\n      className = props.className,\n      removeScrollBar = props.removeScrollBar,\n      enabled = props.enabled,\n      shards = props.shards,\n      sideCar = props.sideCar,\n      noIsolation = props.noIsolation,\n      inert = props.inert;\n  var SideCar = sideCar;\n\n  var containerProps = tslib_1.__assign({\n    ref: ref\n  }, callbacks);\n\n  return React.createElement(React.Fragment, null, enabled && React.createElement(SideCar, {\n    sideCar: effectCar,\n    removeScrollBar: removeScrollBar,\n    shards: shards,\n    noIsolation: noIsolation,\n    inert: inert,\n    setCallbacks: setCallbacks,\n    lockRef: ref\n  }), forwardProps ? React.cloneElement(React.Children.only(children), containerProps) : React.createElement(\"div\", tslib_1.__assign({}, containerProps, {\n    className: className\n  }), children));\n}\n\nRemoveScroll.defaultProps = {\n  enabled: true,\n  removeScrollBar: true,\n  inert: false\n};\n\n(function (RemoveScroll) {\n  RemoveScroll.classNames = {\n    fullWidth: fullWidthClassName,\n    zeroRight: zeroRightClassName\n  };\n})(RemoveScroll || (RemoveScroll = {}));\n\nexport { RemoveScroll };","export var zeroRightClassName = 'right-scroll-bar-position';\nexport var fullWidthClassName = 'width-before-scroll-bar';\nexport var noScrollbarsClassName = 'with-scroll-bars-hidden';","export const PHOTOS = {\r\n  \"1. Pocock_Tassie-304\": {\r\n     \"model\": \"EOS 5D Mark IV\",\r\n     \"lens\": \"EF 50mm f/1.2L USM\",\r\n     \"settings\": \"ISO 1000, f/5.0, 1/500s\",\r\n     \"caption\": \"Almost 500,000ha of wild rainforests and bushland stretches across the north-west of Tasmania making it a photographer's paradise. \"\r\n  },\r\n  \"2. Pocock_Tassie-69\": {\r\n     \"model\": \"EOS R\",\r\n     \"lens\": \"RF 24-105mm F4 L IS USM\",\r\n     \"settings\": \"ISO 2000, f/4.0, 1/2500s\",\r\n     \"caption\": \"Day break across the Tarkine Wilderness Lodge run by local Maree Jenkins who's been fighting to protect her neighbour for over 30 years. \"\r\n  },\r\n  \"3. Pocock_Tassie-83\": {\r\n     \"model\": \"EOS 5D Mark IV\",\r\n     \"lens\": \"EF 50mm f/1.2L USM\",\r\n     \"settings\": \"ISO 640, f/4.0, 1/100s\",\r\n     \"caption\": \"\\\"It's under threat from mining and logging, so it would be really nice for it to be made a National Park or put it on the World Heritage listing,\\\" Maree says. \"\r\n  },\r\n  \"4. Pocock_Tassie-136\": {\r\n     \"model\": \"EOS 5D Mark IV\",\r\n     \"lens\": \"EF 24-105mm f/4L IS II USM\",\r\n     \"settings\": \"ISO 800, f/4.0, 1/125s\",\r\n     \"caption\": \"Mutual appreciation to preserve and protect between Maree and David. \"\r\n  },\r\n  \"5. Pocock_Tassie-98\": {\r\n     \"model\": \"EOS-1D X Mark II\",\r\n     \"lens\": \"EF 16-35mm f/2.8L II USM\",\r\n     \"settings\": \"ISO 2000, f/2.8, 1/125s\",\r\n     \"caption\": \"Scenes of green lit up by the breaks in the canopy. \"\r\n  },\r\n  \"6. Pocock_Tassie-91\": {\r\n     \"model\": \"EOS 5D Mark IV\",\r\n     \"lens\": \"EF 50mm f/1.2L USM\",\r\n     \"settings\": \"ISO 640, f/3.5, 1/160s\",\r\n     \"caption\": \"3/4 of Australia's rainforests have already been lost. This tract is the largest single tract in the country. \"\r\n  },\r\n  \"7. Pocock_Tassie-170\": {\r\n     \"model\": \"EOS-1D X Mark II\",\r\n     \"lens\": \"EF 100mm f/2.8L Macro IS USM\",\r\n     \"settings\": \"ISO 12800, f/2.8, 1/160s\",\r\n     \"caption\": \"Home to an abundance of flora and fungi… ideal macro photography subjects.\"\r\n  },\r\n  \"8. Pocock_Tassie-94\": {\r\n     \"model\": \"EOS 5D Mark IV\",\r\n     \"lens\": \"EF 50mm f/1.2L USM\",\r\n     \"settings\": \"ISO 640, f/3.5, 1/80s\",\r\n     \"caption\": \"David hadn't spent much time shooting with the EF100mm macro but quickly became a fan of its uncompromising detail. \"\r\n  },\r\n  \"9. Pocock_Tassie-109\": {\r\n     \"model\": \"EOS 5D Mark IV\",\r\n     \"lens\": \"EF 24-105mm f/4L IS II USM\",\r\n     \"settings\": \"ISO 800, f/4.0, 1/80s\",\r\n     \"caption\": \"Surrounds which even dwarf one of Australia's strongest rugby players.  \"\r\n  },\r\n  \"10. Pocock_Tassie-131\": {\r\n     \"model\": \"EOS R\",\r\n     \"lens\": \"RF 24-105mm F4 L IS USM\",\r\n     \"settings\": \"ISO 640, f/4.0, 1/60s\",\r\n     \"caption\": \"Eternally damp and growing. \"\r\n  },\r\n  \"11. Pocock_Tassie-205\": {\r\n     \"model\": \"EOS R\",\r\n     \"lens\": \"RF 24-105mm F4 L IS USM\",\r\n     \"settings\": \"ISO 2000, f/4.0, 1/160s\",\r\n     \"caption\": \"Macro lenses have the capability to bring character and perspective to the smallest of subjects. \"\r\n  },\r\n  \"12. Pocock_Tassie-318\": {\r\n     \"model\": \"EOS-1D X Mark II\",\r\n     \"lens\": \"EF 16-35mm f/2.8L II USM\",\r\n     \"settings\": \"ISO 1250, f/3.2, 1/40s\",\r\n     \"caption\": \"Myrtle trees dominate the rainforests of the Tarkine and you can't help but feel their overwhelming presence.\"\r\n  },\r\n  \"13. Pocock_Tassie-327\": {\r\n     \"model\": \"EOS 5D Mark IV\",\r\n     \"lens\": \"EF 50mm f/1.2L USM\",\r\n     \"settings\": \"ISO 3200, f/3.5, 1/125s\",\r\n     \"caption\": \"David shooting from a slice of the many kilometres of eco-walks Maree personally maintains year-round. \"\r\n  },\r\n  \"14. Pocock_Tassie-349\": {\r\n     \"model\": \"EOS 5D Mark IV\",\r\n     \"lens\": \"EF 50mm f/1.2L USM\",\r\n     \"settings\": \"ISO 1000, f/2.8, 1/800s\",\r\n     \"caption\": \"Tasmania's weather, like the Tarkine, is refreshingly wild, unpredictable and alive. Here, David begins stalking the local family of wedgies.\"\r\n  },\r\n  \"15. Pocock_Tassie-379\": {\r\n     \"model\": \"EOS-1D X Mark II\",\r\n     \"lens\": \"EF 200-400mm f/4L IS USM EXT\",\r\n     \"settings\": \"ISO 16000, f/5.6, 1/1600s\",\r\n     \"caption\": \"\\\"I always felt being able to take a photo I could show someone how close I got and how special that bird was to me,” David says. \"\r\n  },\r\n  \"16. Pocock_Tassie-231\": {\r\n     \"model\": \"EOS-1D X Mark II\",\r\n     \"lens\": \"EF 200-400mm f/4L IS USM EXT\",\r\n     \"settings\": \"ISO 3200, f/7.1, 1/800s\",\r\n     \"caption\": \"A flame robin captured by David in a brief moment of stillness. \"\r\n  },\r\n  \"17. Pocock_Tassie-201\": {\r\n     \"model\": \"EOS-1D X Mark II\",\r\n     \"lens\": \"EF 200-400mm f/4L IS USM EXT\",\r\n     \"settings\": \"ISO 800, f/5.6, 1/500s\",\r\n     \"caption\": \"A yellow-tailed black cockatoo darts across the canopy. \"\r\n  },\r\n  \"18. Pocock_Tassie-294\": {\r\n     \"model\": \"EOS R\",\r\n     \"lens\": \"RF 24-105mm F4 L IS USM\",\r\n     \"settings\": \"ISO 10000, f/4.0, 1/125s\",\r\n     \"caption\": \"The spotted-tail quoll, a marsupial carnivore endangered on the mainland, captured feasting on a nearby roadkill. \"\r\n  },\r\n  \"19. Pocock_Tassie-19\": {\r\n     \"model\": \"EOS-1D X Mark II\",\r\n     \"lens\": \"EF 70-200mm f/2.8L IS II USM\",\r\n     \"settings\": \"ISO 1600, f/4.0, 1/500s\",\r\n     \"caption\": \"A large female wedge-tailed eagle blends cleverly into its surroundings.\"\r\n  },\r\n  \"20. Pocock_Tassie-284\": {\r\n     \"model\": \"EOS-1D X Mark II\",\r\n     \"lens\": \"EF 200-400mm f/4L IS USM EXT\",\r\n     \"settings\": \"ISO 12800, f/7.1, 1/1600s\",\r\n     \"caption\": \"Weighing up to 5kgs and with a wing span of up to 2.2 metres, these birds of prey are something to behold as they soar over-head. \"\r\n  },\r\n  \"21. Pocock_Tassie-217\": {\r\n     \"model\": \"EOS 5D Mark IV\",\r\n     \"lens\": \"EF 24-105mm f/4L IS II USM\",\r\n     \"settings\": \"ISO 320, f/4.0, 1/500s\",\r\n     \"caption\": \"Never one to shy away from what he believes in. \"\r\n  },\r\n  \"22. Pocock_Tassie-267\": {\r\n     \"model\": \"EOS 5D Mark IV\",\r\n     \"lens\": \"EF 24-105mm f/4L IS II USM\",\r\n     \"settings\": \"ISO 1000, f/5.0, 1/200s\",\r\n     \"caption\": \"It's not all about rugby for this Australian Wallaby. \"\r\n  },\r\n  \"23. Pocock_Tassie-386\": {\r\n     \"model\": \"EOS 5D Mark IV\",\r\n     \"lens\": \"EF 24-105mm f/4L IS II USM\",\r\n     \"settings\": \"ISO 800, f/5.0, 1/400s\",\r\n     \"caption\": \"Local teacher, Adam Hardy runs Raptor Care North West, an organisation of civilians who rescue injured birds of prey.  \"\r\n  },\r\n  \"24. Pocock_Tassie-397\": {\r\n     \"model\": \"EOS 5D Mark IV\",\r\n     \"lens\": \"EF 24-105mm f/4L IS II USM\",\r\n     \"settings\": \"ISO 1000, f/2.8, 1/640s\",\r\n     \"caption\": \"This male wedgie is about four years old and sustained a damaged wing flying into electrical infrastructure.  \"\r\n  },\r\n  \"25. Pocock_Tassie-400\": {\r\n     \"model\": \"EOS 5D Mark IV\",\r\n     \"lens\": \"EF 24-105mm f/4L IS II USM\",\r\n     \"settings\": \"ISO 1000, f/2.8, 1/640s\",\r\n     \"caption\": \"An unlikely union unfolds in Tasmania. \"\r\n  },\r\n  \"26. Pocock_Tassie-406\": {\r\n     \"model\": \"EOS 5D Mark IV\",\r\n     \"lens\": \"EF 24-105mm f/4L IS II USM\",\r\n     \"settings\": \"ISO 1000, f/2.8, 1/1000s\",\r\n     \"caption\": \"David was visibly taken aback by their strength and ability to keep their head perfectly still.  \"\r\n  },\r\n  \"27. Pocock_Tassie-398\": {\r\n     \"model\": \"EOS 5D Mark IV\",\r\n     \"lens\": \"EF 24-105mm f/4L IS II USM\",\r\n     \"settings\": \"ISO 1000, f/2.8, 1/640s\",\r\n     \"caption\": \"In 1/160s the 5D Mark IV is able to capture the moment the wedgie blinks. \"\r\n  },\r\n  \"28. Pocock_Tassie-419\": {\r\n     \"model\": \"EOS 5D Mark IV\",\r\n     \"lens\": \"EF 24-105mm f/4L IS II USM\",\r\n     \"settings\": \"ISO 1000, f/2.8, 1/640s\",\r\n     \"caption\": \"Another bird of prey often rehabilitating in Adam's care is the Tasmanian grey goshawk. \"\r\n  },\r\n  \"29. Pocock_Tassie-431\": {\r\n     \"model\": \"EOS-1D X Mark II\",\r\n     \"lens\": \"EF 100mm f/2.8L Macro IS USM\",\r\n     \"settings\": \"ISO 3200, f/6.3, 1/320s\",\r\n     \"caption\": \"The goshawk's breeding is restricted to wet rainforests. Preserving the Tarkine is making sure that birds like this, and many others, keep their habitats. \"\r\n  },\r\n  \"30. Pocock_Tassie-411\": {\r\n     \"model\": \"EOS 5D Mark IV\",\r\n     \"lens\": \"EF 24-105mm f/4L IS II USM\",\r\n     \"settings\": \"ISO 1000, f/2.8, 1/1000s\",\r\n     \"caption\": \"For someone fascinated by birds his entire life, this was an story important for David to tell. \"\r\n  },\r\n  \"31. Pocock_Tassie-247\": {\r\n     \"model\": \"EOS-1D X Mark II\",\r\n     \"lens\": \"EF 200-400mm f/4L IS USM EXT\",\r\n     \"settings\": \"ISO 3200, f/7.1, 1/1250s\",\r\n     \"caption\": \"Wild, raw and over 60 million years of history. \"\r\n  },\r\n  \"32. Pocock_Tassie-303\": {\r\n     \"model\": \"EOS 5D Mark IV\",\r\n     \"lens\": \"EF 50mm f/1.2L USM\",\r\n     \"settings\": \"ISO 1000, f/5.0, 1/500s\",\r\n     \"caption\": \"For David, wearing the green and gold as a proud Australian is representing country – all its people, and importantly, all its land and creatures. \"\r\n  }\r\n}","import React from 'react';\r\nimport Img from 'gatsby-image';\r\nimport { StaticQuery, graphql } from 'gatsby';\r\n\r\nfunction renderImage(file) {\r\n  console.log('file is', file)\r\n  return (\r\n    <Img\r\n      fluid={file.node.childImageSharp.fluid}\r\n      imgStyle={{objectFit: 'contain'}}\r\n      style={{height: '100%'}}\r\n    />\r\n  )\r\n}\r\n\r\nconst ModalImg = function (props) {\r\n\r\n  return <StaticQuery\r\n    query={graphql`\r\n    query {\r\n      images: allFile(filter: {extension: {regex: \"/(jpg)|(jpeg)|(png)/\"}, relativeDirectory: {eq: \"photos\"}}) {\r\n        edges {\r\n          node {\r\n            name\r\n            extension\r\n            relativePath\r\n            childImageSharp {\r\n            fluid(maxWidth: 6400) {\r\n              ...GatsbyImageSharpFluid\r\n            }\r\n          }\r\n        }\r\n      }\r\n    }\r\n  }\r\n    `}\r\n    render={(data) => {\r\n      console.log(data.images.edges[0].node)\r\n      const image = data.images.edges.find(\r\n        image => {\r\n          console.log(image)\r\n          return image.node.name === props.image\r\n        }\r\n      )\r\n      return(renderImage(image))\r\n    }}\r\n  />\r\n}\r\n\r\nexport default ModalImg;","import { AnimatePresence, motion } from \"framer-motion\";\r\nimport Img from 'gatsby-image';\r\nimport { rgba } from 'polished';\r\nimport React, { useEffect } from \"react\";\r\nimport sidecar from \"react-remove-scroll/sidecar\";\r\nimport { RemoveScroll } from 'react-remove-scroll/UI';\r\nimport styled from 'styled-components';\r\nimport PrevIcon from '../images/chevron-left-solid.inline.svg';\r\nimport NextIcon from '../images/chevron-right-solid.inline.svg';\r\nimport CloseIcon from '../images/times-light.inline.svg';\r\nimport { STYLES } from \"../styles/Styles\";\r\nimport { COLOURS } from './../styles/Colours';\r\nimport Header from \"./Header\";\r\nimport { ProductLink } from './ProductLink';\r\nimport { PHOTOS } from './../data/Photos';\r\nimport { useState } from \"react\";\r\nimport ModalImg from \"./ImageModalPhoto\";\r\n\r\nconst variants = {\r\n  enter: (direction: number) => ({\r\n    x: direction < 0 ? 1000 : -1000,\r\n    opacity: 0\r\n  }),\r\n  center: {\r\n    zIndex: 1,\r\n    x: 0,\r\n    opacity: 1\r\n  },\r\n  exit: (direction: number) => ({\r\n    zIndex: 0,\r\n    x: direction < 0 ? 1000 : -1000,\r\n    opacity: 0\r\n  })\r\n};\r\n\r\nconst swipeConfidenceThreshold = 10000;\r\nconst swipePower = (offset: number, velocity: number) => {\r\n  return Math.abs(offset) * velocity;\r\n};\r\n\r\n\r\ninterface Props {\r\n  visible: boolean;\r\n  setIsImageModalVisible: any;\r\n  selectedImage?: string;\r\n  setSelectedImage: any;\r\n  handleChangePhoto: any;\r\n  //imageSrc: string;\r\n  image: any;\r\n  direction: 1 | -1 | 0;\r\n}\r\n\r\n\r\nexport const ImageModal = React.memo((props: Props) => {\r\n  const {\r\n    visible,\r\n    setIsImageModalVisible,\r\n    selectedImage,\r\n    setSelectedImage,\r\n    handleChangePhoto,\r\n    direction = 1,\r\n    image\r\n  } = props;\r\n\r\n  const [photoDetails, setPhotoDetails] = useState({\r\n    caption: undefined,\r\n    model: undefined,\r\n    lens: undefined,\r\n    settings: undefined,\r\n  });\r\n  const [imageSrc, setImageSrc] = useState();\r\n\r\n\r\n  const downHandler = (e) => {\r\n    if (e.keyCode === 37) {\r\n      ///left\r\n      handleChangePhoto('prev');\r\n    } else if (e.keyCode === 39) {\r\n      //right\r\n      handleChangePhoto('next');\r\n    }\r\n  }\r\n\r\n  const getSrc = (fileName: string) => {\r\n    if (fileName) {\r\n      const parsedFilename = encodeURIComponent(fileName.trim());\r\n      return `/photos/${parsedFilename}.jpg`;\r\n    }\r\n  }\r\n\r\n  useEffect(() => {\r\n    window.addEventListener(\"keydown\", downHandler);\r\n\r\n    return () => {\r\n      window.removeEventListener(\"keydown\", downHandler);\r\n    };\r\n  }, []);\r\n\r\n  useEffect(() => {\r\n    //const imageSrc = props.image ? props.image.node.childImageSharp.fluid.src : undefined;\r\n    const imageSrc = props.image ? props.image.node.name : undefined;\r\n    const caption = PHOTOS[props.image.node.name].caption;\r\n    const model = PHOTOS[props.image.node.name].model;\r\n    const lens = PHOTOS[props.image.node.name].lens;\r\n    const settings = PHOTOS[props.image.node.name].settings;\r\n\r\n    setPhotoDetails({\r\n      caption,\r\n      model,\r\n      lens,\r\n      settings\r\n    });\r\n    setImageSrc(imageSrc);\r\n  }, [image]);\r\n\r\n  console.log('image props is', props);\r\n\r\n  return (\r\n    <>\r\n      {visible &&\r\n        <RemoveScroll sideCar={sidecar}>\r\n          <ImageModalWrapper>\r\n            <ModalContent>\r\n              <Close onClick={() => setIsImageModalVisible(false)}><CloseIcon /> Close</Close>\r\n              <PhotoContainer>\r\n                <SwitchControl onClick={() => handleChangePhoto('prev')}>\r\n                  <PrevIcon />\r\n                </SwitchControl>\r\n                <PhotoWrapper>\r\n                  <AnimatePresence initial={false}>\r\n                    {/* <Photo\r\n                      key={Math.random()}\r\n                      src={getSrc(imageSrc)}\r\n                      custom={direction}\r\n                      variants={variants}\r\n                      initial=\"enter\"\r\n                      animate=\"center\"\r\n                      exit=\"exit\"\r\n                      transition={{\r\n                        x: { type: \"spring\", stiffness: 300, damping: 200 },\r\n                        opacity: { duration: 0.2 }\r\n                      }}\r\n                      drag=\"x\"\r\n                      dragConstraints={{ left: 0, right: 0 }}\r\n                      dragElastic={1}\r\n                      onDragEnd={(e, { offset, velocity }) => {\r\n                        const swipe = swipePower(offset.x, velocity.x);\r\n\r\n                        if (swipe < -swipeConfidenceThreshold) {\r\n                          handleChangePhoto('next');\r\n                        } else if (swipe > swipeConfidenceThreshold) {\r\n                          handleChangePhoto('prev');\r\n                        }\r\n                      }}\r\n                    />         */}\r\n                    <MotionContainer\r\n                      key={Math.random()}\r\n                      custom={direction}\r\n                      variants={variants}\r\n                      initial=\"enter\"\r\n                      animate=\"center\"\r\n                      exit=\"exit\"\r\n                      transition={{\r\n                        x: { type: \"spring\", stiffness: 300, damping: 200 },\r\n                        opacity: { duration: 0.2 }\r\n                      }}\r\n                      drag=\"x\"\r\n                      dragConstraints={{ left: 0, right: 0 }}\r\n                      dragElastic={1}\r\n                      onDragEnd={(e, { offset, velocity }) => {\r\n                        const swipe = swipePower(offset.x, velocity.x);\r\n\r\n                        if (swipe < -swipeConfidenceThreshold) {\r\n                          handleChangePhoto('next');\r\n                        } else if (swipe > swipeConfidenceThreshold) {\r\n                          handleChangePhoto('prev');\r\n                        }\r\n                      }}\r\n\r\n                    >\r\n                      <ModalImg image={props.image.node.name}  />\r\n                    </MotionContainer>\r\n                  </AnimatePresence>\r\n                </PhotoWrapper>\r\n                <SwitchControl onClick={() => handleChangePhoto('next')}>\r\n                  <NextIcon />\r\n                </SwitchControl>\r\n              </PhotoContainer>\r\n              {photoDetails &&\r\n                <ImageInfo>\r\n                  <ProductInfo>\r\n                    <Model>Shot on <ProductLink product={photoDetails.model} /></Model>\r\n                    <Details>{photoDetails.settings}</Details>\r\n                  </ProductInfo>\r\n                  <ImageCaption>\r\n                    {photoDetails.caption}\r\n                  </ImageCaption>\r\n                </ImageInfo>\r\n              }\r\n            </ModalContent>\r\n          </ImageModalWrapper>\r\n        </RemoveScroll>\r\n      }\r\n    </>\r\n  )\r\n});\r\n\r\nconst ImageModalWrapper = styled.div`\r\n  position: fixed;\r\n  height: 100%;\r\n  width: 100%;\r\n  display: flex;\r\n  align-items: center;\r\n  justify-content: center;\r\n  top: ${STYLES.headerSize};\r\n  top: 0;\r\n  left: 0;\r\n  background-color: ${rgba(COLOURS.charcoal, 0.9)};\r\n  color: ${COLOURS.white};\r\n  @media(min-width: ${STYLES.desktopSize}) {\r\n    \r\n  }\r\n`;\r\n\r\nconst ModalContent = styled.div`\r\n  display: flex;\r\n  max-height: 100vh;\r\n  height: 100vh;\r\n  flex-direction: column;\r\n  align-items: center;\r\n  justify-content: center;\r\n  width: 100%;\r\n  overflow: hidden;\r\n  @media(min-width: ${STYLES.desktopSize}) {\r\n    padding: 6rem 4rem 3rem 4rem;\r\n  }\r\n  @media(max-width: ${STYLES.desktopSize}) {\r\n    max-height: 100vh;\r\n    height: 100vh;\r\n    padding: 6rem 0 0 0;\r\n  }\r\n`;\r\n\r\nconst PhotoWrapper = styled.div`\r\n  margin: 0 auto;\r\n  height: 100%;\r\n  width: 100%;\r\n  display: flex;\r\n  position: relative;\r\n  align-items: center;\r\n  justify-content: center;\r\n`;\r\n\r\nconst Photo = styled(motion.img)`\r\n  object-fit: contain;\r\n  user-select: none;\r\n  height: 100%;\r\n  position: absolute;\r\n`;\r\n\r\nconst MotionContainer = styled(motion.div)`\r\n  position: absolute;\r\n  width: 100%;\r\n  height: 100%;\r\n  user-select: none;\r\n`;\r\n\r\nexport const Close = styled.div`\r\n  display: flex;\r\n  padding: 1rem;\r\n  flex-shrink: 0;\r\n  margin-left: auto;\r\n  align-items: center;\r\n  @media(max-width: ${STYLES.desktopSize}) {\r\n    padding: 0 2rem 0 2rem;\r\n    height: 50px;\r\n    flex-shrink: 0;\r\n  }\r\n  :hover {\r\n    cursor: pointer;\r\n    opacity: 0.8;\r\n  }\r\n  svg {\r\n    margin-right: 1rem;\r\n    width: 20px;\r\n  }\r\n`;\r\n\r\nconst PhotoContainer = styled.div`\r\n  display: flex;\r\n  align-items: center;\r\n  justify-content: space-between;\r\n  width: 100%;\r\n  height: 100%;\r\n  position: relative;\r\n`;\r\n\r\nconst ImageInfo = styled.div`\r\n  display: flex;\r\n  user-select: none;\r\n  @media(min-width: ${STYLES.desktopSize}) {\r\n    width: 60vw;\r\n    margin-top: 1rem;\r\n  }\r\n  @media(max-width: ${STYLES.desktopSize}) {\r\n    flex-direction: column;\r\n    padding: 1.5rem;\r\n    font-size: ${STYLES.textSize2};\r\n    width: 100%;\r\n    height: 30vh;\r\n    min-height: min-content;\r\n    max-height: 180px;\r\n  }\r\n`;\r\n\r\nconst ProductInfo = styled.div`\r\n  flex: 1;\r\n  margin-right: 1rem;\r\n`;\r\n\r\nconst Model = styled.div`\r\n  font-weight: 700;\r\n`;\r\n\r\nconst Details = styled.div`\r\n`;\r\n\r\nconst ImageCaption = styled.div`\r\n  flex: 3;\r\n  @media(max-width: ${STYLES.desktopSize}) {\r\n    margin-top: 1rem;\r\n  }\r\n`;\r\n\r\nconst SwitchControl = styled.div`\r\n  width: 54px;\r\n  height: 54px;\r\n  display: flex;\r\n  align-items: center;\r\n  justify-content: center;\r\n  flex-shrink: 0;\r\n  transition: background-color 250ms ${STYLES.easeOutQuint};\r\n  border-radius: 50%;\r\n  z-index: 3;\r\n  @media(max-width: ${STYLES.desktopSize}) {\r\n    position: absolute;\r\n    :first-child {\r\n      left: 0;\r\n    }\r\n    :last-child {\r\n      right: 0;\r\n    }\r\n  }\r\n  :hover {\r\n    cursor: pointer;\r\n    background-color: rgba(255,255,255,0.2);\r\n  }\r\n  svg {\r\n    height: 50%;\r\n    width: 50%;\r\n  }\r\n`;\r\n","import React, { useState } from \"react\";\r\nimport styled from 'styled-components';\r\nimport { COLOURS } from \"../styles/Colours\";\r\nimport { STYLES } from \"../styles/Styles\";\r\nimport FacebookIcon from '../images/facebook-f-brands.inline.svg';\r\nimport TwitterIcon from '../images/twitter-brands.inline.svg';\r\nimport InstagramIcon from '../images/instagram-brands.inline.svg';\r\nimport { baseUrl } from \"../config\";\r\n\r\ninterface Props {\r\n  displayStyle?: 'text' | 'icons';\r\n  linkTo?: 'share' | 'david';\r\n  style?: React.CSSProperties;\r\n}\r\n\r\nexport const ShareLinks = (props: Props) => {\r\n\r\n  const {\r\n    displayStyle = 'text',\r\n    linkTo = 'share',\r\n    style\r\n  } = props;\r\n\r\n  const [hasLinkBeenCopied, setHasLinkBeenCopied] = useState(false);\r\n\r\n  const handleCopyLink = () => {\r\n    const text = baseUrl;\r\n    const textArea = document.createElement(\"textarea\");\r\n    textArea.value = text;\r\n    document.body.appendChild(textArea);\r\n    textArea.select();\r\n\r\n    try {\r\n      const successful = document.execCommand('copy');\r\n      const msg = successful ? 'successful' : 'unsuccessful';\r\n      setHasLinkBeenCopied(true);\r\n    } catch (err) {\r\n    }\r\n\r\n    document.body.removeChild(textArea);\r\n  }\r\n\r\n  const handleTwitterLink = () => {\r\n    window.open('https://twitter.com/intent/tweet', 'name', 'width=600,height=400');\r\n  }\r\n\r\n  const handleFacebookLink = () => {\r\n    window.open('https://www.facebook.com/sharer/sharer.php?u=https%3A%2F%2Fanunlikelyunion.canon.com.au%2F&amp;src=sdkpreparse', 'Name', 'width=600,height=400')\r\n  }\r\n\r\n  return (\r\n    <ShareLinksContainer style={style}>\r\n      {displayStyle === 'icons' &&\r\n        <>\r\n          <IconLink\r\n            onClick={linkTo === 'share' ? handleTwitterLink : null}\r\n            href={linkTo === 'share' ? null : 'https://twitter.com/pocockdavid'}\r\n            target={linkTo === 'share' ? null : '_blank'}\r\n            rel='noreferrer noopener'\r\n            aria-label={linkTo === 'share' ? 'Share on Twitter' : 'David Pocock\\'s Twitter'}\r\n            >\r\n            <TwitterIcon />\r\n          </IconLink>\r\n          {linkTo === 'david' &&\r\n          <IconLink\r\n            href='https://www.instagram.com/davidpocock/' target='_blank' rel='noreferrer noopener'\r\n            >\r\n            <InstagramIcon />\r\n          </IconLink>\r\n          }\r\n          <IconLink\r\n            onClick={linkTo === 'share' ? handleFacebookLink : null}\r\n            href={linkTo === 'share' ? null : 'https://www.facebook.com/pocock.page/'}\r\n            target={linkTo === 'share' ? null : '_blank'}\r\n            rel='noreferrer noopener'\r\n            aria-label={linkTo === 'share' ? 'Share on Facebook' : 'David Pocock\\'s Facebook'}\r\n            >\r\n            <FacebookIcon />\r\n          </IconLink>\r\n        </>\r\n      }\r\n      {displayStyle === 'text' &&\r\n        <>\r\n          <ShareLabel>Share -</ShareLabel>\r\n          <ShareLink\r\n            onClick={() => window.open('https://twitter.com/intent/tweet', 'name', 'width=600,height=400')}\r\n            aria-label='Share on Twitter'\r\n            >Twitter</ShareLink>\r\n          <ShareLink\r\n            onClick={() => window.open('https://www.facebook.com/sharer/sharer.php?u=https%3A%2F%2Fanunlikelyunion.canon.com.au%2F&amp;src=sdkpreparse', 'Name', 'width=600,height=400')}\r\n            aria-label='Share on Facebook'\r\n          >\r\n            Facebook\r\n          </ShareLink>\r\n          <ShareLink\r\n              onClick={hasLinkBeenCopied ? null : handleCopyLink}\r\n              aria-label='Copy the link to this website'\r\n            >\r\n            {hasLinkBeenCopied ? 'Link copied' : 'Copy link'}\r\n          </ShareLink>\r\n        </>\r\n      }\r\n    </ShareLinksContainer>\r\n  )\r\n}\r\n\r\nexport const ShareLinksContainer = styled.div`\r\n  display: flex;\r\n  align-items: center;\r\n  justify-content: center;\r\n`;\r\n\r\nconst ShareLabel = styled.span`\r\n  font-weight: 700;\r\n  font-size: ${STYLES.textSize3};\r\n  white-space: nowrap;\r\n`;\r\n\r\nconst ShareLink = styled.a`\r\n  margin-left: 1.5rem;\r\n  color: ${COLOURS.blue};\r\n  font-size: ${STYLES.textSize3};\r\n  :hover {\r\n    cursor: pointer;\r\n  }\r\n`;\r\n\r\nconst IconLink = styled.a`\r\n  display: flex;\r\n  align-items: center;\r\n  justify-content: center;\r\n  background-color: ${COLOURS.charcoal};\r\n  border-radius: 50%;\r\n  width: 70px;\r\n  height: 70px;\r\n  padding: 0.5rem;\r\n  margin: 0 auto;\r\n  @media(min-width: ${STYLES.desktopSize}) {\r\n    padding: 1rem;\r\n    width: 100px;\r\n    height: 100px;\r\n  }\r\n  :hover {\r\n    cursor: pointer;\r\n    opacity: 0.8;\r\n  }\r\n  svg {\r\n    width: 50%;\r\n    height: 50%;\r\n    path {\r\n      fill: ${COLOURS.white};\r\n    }\r\n  }\r\n`;","export const baseUrl = 'https://canon.com.au/unlikelyunion';","var React = require('react');\n\nfunction PlayCircleLightInline (props) {\n    return React.createElement(\"svg\",props,React.createElement(\"path\",{\"fill\":\"currentColor\",\"d\":\"M256 504c137 0 248-111 248-248S393 8 256 8 8 119 8 256s111 248 248 248zM40 256c0-118.7 96.1-216 216-216 118.7 0 216 96.1 216 216 0 118.7-96.1 216-216 216-118.7 0-216-96.1-216-216zm331.7-18l-176-107c-15.8-8.8-35.7 2.5-35.7 21v208c0 18.4 19.8 29.8 35.7 21l176-101c16.4-9.1 16.4-32.8 0-42zM192 335.8V176.9c0-4.7 5.1-7.6 9.1-5.1l134.5 81.7c3.9 2.4 3.8 8.1-.1 10.3L201 341c-4 2.3-9-.6-9-5.2z\"}));\n}\n\nPlayCircleLightInline.defaultProps = {\"aria-hidden\":\"true\",\"focusable\":\"false\",\"data-prefix\":\"fal\",\"data-icon\":\"play-circle\",\"className\":\"svg-inline--fa fa-play-circle fa-w-16\",\"role\":\"img\",\"viewBox\":\"0 0 512 512\"};\n\nmodule.exports = PlayCircleLightInline;\n\nPlayCircleLightInline.default = PlayCircleLightInline;\n"],"sourceRoot":""}