{"version":3,"sources":["webpack://animateCSSGrid/webpack/universalModuleDefinition","webpack://animateCSSGrid/webpack/bootstrap","webpack://animateCSSGrid/./node_modules/lodash/isObject.js","webpack://animateCSSGrid/./node_modules/lodash/throttle.js","webpack://animateCSSGrid/./node_modules/lodash/_root.js","webpack://animateCSSGrid/./node_modules/lodash/_Symbol.js","webpack://animateCSSGrid/./node_modules/lodash/debounce.js","webpack://animateCSSGrid/./node_modules/lodash/now.js","webpack://animateCSSGrid/./node_modules/lodash/_freeGlobal.js","webpack://animateCSSGrid/(webpack)/buildin/global.js","webpack://animateCSSGrid/./node_modules/lodash/toNumber.js","webpack://animateCSSGrid/./node_modules/lodash/isSymbol.js","webpack://animateCSSGrid/./node_modules/lodash/_baseGetTag.js","webpack://animateCSSGrid/./node_modules/lodash/_getRawTag.js","webpack://animateCSSGrid/./node_modules/lodash/_objectToString.js","webpack://animateCSSGrid/./node_modules/lodash/isObjectLike.js","webpack://animateCSSGrid/./node_modules/@popmotion/easing/dist/easing.es.js","webpack://animateCSSGrid/./node_modules/framesync/dist/framesync.es.js","webpack://animateCSSGrid/./node_modules/tslib/tslib.es6.js","webpack://animateCSSGrid/./node_modules/style-value-types/dist/style-value-types.es.js","webpack://animateCSSGrid/./node_modules/@popmotion/popcorn/dist/popcorn.es.js","webpack://animateCSSGrid/./node_modules/popmotion/node_modules/@popmotion/easing/dist/easing.es.js","webpack://animateCSSGrid/./node_modules/stylefire/dist/stylefire.es.js","webpack://animateCSSGrid/./node_modules/popmotion/dist/popmotion.es.js","webpack://animateCSSGrid/./src/index.ts"],"names":["root","factory","exports","module","define","amd","window","installedModules","__webpack_require__","moduleId","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","prototype","hasOwnProperty","p","s","type","debounce","isObject","FUNC_ERROR_TEXT","func","wait","options","leading","trailing","TypeError","freeGlobal","freeSelf","self","Function","now","toNumber","nativeMax","Math","max","nativeMin","min","lastArgs","lastThis","maxWait","result","timerId","lastCallTime","lastInvokeTime","maxing","invokeFunc","time","args","thisArg","undefined","apply","shouldInvoke","timeSinceLastCall","timerExpired","trailingEdge","setTimeout","timeWaiting","remainingWait","debounced","isInvoking","arguments","this","leadingEdge","clearTimeout","cancel","flush","Date","global","g","e","isSymbol","NAN","reTrim","reIsBadHex","reIsBinary","reIsOctal","freeParseInt","parseInt","other","valueOf","replace","isBinary","test","slice","baseGetTag","isObjectLike","symbolTag","getRawTag","objectToString","nullTag","undefinedTag","symToStringTag","objectProto","nativeObjectToString","toString","isOwn","tag","unmasked","reversed","easing","mirrored","createBackIn","power","createAnticipateEasing","backEasing","pow","easeIn","createExpoIn","easeOut","easeInOut","circIn","sin","acos","circOut","circInOut","backIn","backOut","backInOut","anticipate","StepId","prevTime","onNextFrame","requestAnimationFrame","callback","timestamp","timeToCall","defaultElapsed","useDefaultElapsed","willRunNextFrame","delta","stepsOrder","Read","Update","Render","PostRender","setWillRunNextFrame","willRun","reduce","acc","setRunNextFrame","processToRun","processToRunNextFrame","numThisFrame","isProcessing","cancelled","toKeepAlive","renderStep","step","WeakSet","process","indexOfCallback","indexOf","add","splice","frame","_a","process_1","length","has","schedule","keepAlive","immediate","addToCurrentBuffer","buffer","push","sync","startLoop","cancelSync","steps","processStep","stepId","processFrame","forEach","extendStatics","b","setPrototypeOf","__proto__","Array","__extends","__","constructor","__assign","assign","__rest","getOwnPropertySymbols","v","isFirstChars","term","sanitize","Number","toFixed","number","parse","parseFloat","transform","createUnitType","default","unit","endsWith","split","degrees","percent","px","vh","vw","clampRgbUnit","onlyColorRegex","isRgba","red","isHsla","hue","splitColorValues","terms","numTerms","values","valuesArray","splitCommaDelimited","substring","lastIndexOf","rgbUnit","round","testRgbaString","rgba","green","blue","alpha$$1","alpha","_b","rgbaTemplate","testHslaString","hsla","saturation","lightness","hslaTemplate","hex","substr","color","floatRegex","colorRegex","complex","isNaN","numValues","foundNumbers","match","foundColors","input","parsed","map","prop","template","token","numColors","numNumbers","output","isNum","curryRange","cv","clamp$1","progress","from","to","toFromDifference","mix","mixLinearColor","fromExpo","toExpo","sqrt","colorTypes","getColorType","find","mixColor","fromColorType","toColorType","fromColor","toColor","blended","mixFunc","combineFunctions","a","pipe","transformers","_i","mixArray","blendValue","fromThis","toThis","mixComplex","valueTemplate","identity","springForce","alterDisplacement","constant","origin","displacement","springModifiedDisplacement","abs","rangeSize","Chainable","props","applyMiddleware","middleware","concat","funcs","pipedUpdate","update","while","predicate","complete","filter","Observer","observer","onComplete","_this","isActive","updateObserver","error","err","createObserver","observerCandidate","_super","Action","start","isComplete","subscription","stop","init","observerProps","api","registerParent","multi","getCount","getFirst","getOutput","mapApi","setProp","startActions","actions","numActions","updateOutput","numCompletedActions","subs","hasCompleted","keys","methodName","composite","propKey","starter","parallel","sub","isArray","action","parallel$1","unitTypes","findUnitType","createAction","createArrayAction","vectorKeys","firstVectorKey","actionList","childActionProps","reduceArrayValue","getActionCreator","createObjectAction","actionMap","reduceObjectValue","createUnitAction","unitType","createColorAction","createComplexAction","createVectorAction","typeTests","testNames","isVectorProp","getVectorKeys","testVectorProps","some","createVectorTests","testProp","actionCreator","Boolean","isUnitProp","vectorScrubber","_c","_d","ease","seek","progress$$1","tween","duration","flip","_e","loop","_f","yoyo","_g","_h","_j","elapsed","_k","playDirection","_l","flipCount","_m","yoyoCount","_o","loopCount","playhead","currentProgress","reverseTween","updateTween","startTimer","isStepTaken","isTweenComplete","stopTimer","getElapsed","getProgress","pause","resume","newProgress","reverse","listen","element","events","eventNames","eventName","addEventListener","removeEventListener","defaultPointerPos","clientX","clientY","pageX","pageY","x","y","eventToPoint","point","points","document","passive","capture","touches","numTouches","thisTouch","popmotionEasing","linear","DATASET_KEY","toArray","arrLike","getGridAwareBoundingClientRect","gridBoundingClientRect","el","getBoundingClientRect","rect","top","left","width","height","applyCoordTransform","translateX","translateY","scaleX","scaleY","isFinished","styleEl","style","render","firstChild","children","styleChild","wrapGrid","container","stagger","onStart","onEnd","Error","mutationsDisabled","disableMutationsWhileFunctionRuns","cachedPositionData","recordPositions","elements","dataset","newId","random","animateGridId","throttledResizeListener","throttle","bodyElement","querySelector","containerIsNoLongerInPage","contains","throttledScrollListener","mutationCallback","mutationsList","attributeName","addedNodes","removedNodes","childrenElements","itemPosition","stopTween","animatedGridChildren","childCoords","boundingClientRect","animatedElements","completionPromises","data","childTop","childLeft","coords","transformOrigin","cachedResolve","completionPromise","Promise","resolve","startAnimation","transforms","postRender","timeoutId","all","then","MutationObserver","observe","childList","attributes","subtree","attributeFilter","unwrapGrid","disconnect","forceGridAnimation"],"mappings":"CAAA,SAA2CA,EAAMC,GAC1B,iBAAZC,SAA0C,iBAAXC,OACxCA,OAAOD,QAAUD,IACQ,mBAAXG,QAAyBA,OAAOC,IAC9CD,OAAO,GAAIH,GACe,iBAAZC,QACdA,QAAwB,eAAID,IAE5BD,EAAqB,eAAIC,IAR3B,CASGK,QAAQ,WACX,O,YCTE,IAAIC,EAAmB,GAGvB,SAASC,EAAoBC,GAG5B,GAAGF,EAAiBE,GACnB,OAAOF,EAAiBE,GAAUP,QAGnC,IAAIC,EAASI,EAAiBE,GAAY,CACzCC,EAAGD,EACHE,GAAG,EACHT,QAAS,IAUV,OANAU,EAAQH,GAAUI,KAAKV,EAAOD,QAASC,EAAQA,EAAOD,QAASM,GAG/DL,EAAOQ,GAAI,EAGJR,EAAOD,QA0Df,OArDAM,EAAoBM,EAAIF,EAGxBJ,EAAoBO,EAAIR,EAGxBC,EAAoBQ,EAAI,SAASd,EAASe,EAAMC,GAC3CV,EAAoBW,EAAEjB,EAASe,IAClCG,OAAOC,eAAenB,EAASe,EAAM,CAAEK,YAAY,EAAMC,IAAKL,KAKhEV,EAAoBgB,EAAI,SAAStB,GACX,oBAAXuB,QAA0BA,OAAOC,aAC1CN,OAAOC,eAAenB,EAASuB,OAAOC,YAAa,CAAEC,MAAO,WAE7DP,OAAOC,eAAenB,EAAS,aAAc,CAAEyB,OAAO,KAQvDnB,EAAoBoB,EAAI,SAASD,EAAOE,GAEvC,GADU,EAAPA,IAAUF,EAAQnB,EAAoBmB,IAC/B,EAAPE,EAAU,OAAOF,EACpB,GAAW,EAAPE,GAA8B,iBAAVF,GAAsBA,GAASA,EAAMG,WAAY,OAAOH,EAChF,IAAII,EAAKX,OAAOY,OAAO,MAGvB,GAFAxB,EAAoBgB,EAAEO,GACtBX,OAAOC,eAAeU,EAAI,UAAW,CAAET,YAAY,EAAMK,MAAOA,IACtD,EAAPE,GAA4B,iBAATF,EAAmB,IAAI,IAAIM,KAAON,EAAOnB,EAAoBQ,EAAEe,EAAIE,EAAK,SAASA,GAAO,OAAON,EAAMM,IAAQC,KAAK,KAAMD,IAC9I,OAAOF,GAIRvB,EAAoB2B,EAAI,SAAShC,GAChC,IAAIe,EAASf,GAAUA,EAAO2B,WAC7B,WAAwB,OAAO3B,EAAgB,SAC/C,WAA8B,OAAOA,GAEtC,OADAK,EAAoBQ,EAAEE,EAAQ,IAAKA,GAC5BA,GAIRV,EAAoBW,EAAI,SAASiB,EAAQC,GAAY,OAAOjB,OAAOkB,UAAUC,eAAe1B,KAAKuB,EAAQC,IAGzG7B,EAAoBgC,EAAI,GAIjBhC,EAAoBA,EAAoBiC,EAAI,I,gBCpDrDtC,EAAOD,QALP,SAAkByB,GAChB,IAAIe,SAAcf,EAClB,OAAgB,MAATA,IAA0B,UAARe,GAA4B,YAARA,K,gBC3B/C,IAAIC,EAAW,EAAQ,GACnBC,EAAW,EAAQ,GAGnBC,EAAkB,sBAgEtB1C,EAAOD,QAlBP,SAAkB4C,EAAMC,EAAMC,GAC5B,IAAIC,GAAU,EACVC,GAAW,EAEf,GAAmB,mBAARJ,EACT,MAAM,IAAIK,UAAUN,GAMtB,OAJID,EAASI,KACXC,EAAU,YAAaD,IAAYA,EAAQC,QAAUA,EACrDC,EAAW,aAAcF,IAAYA,EAAQE,SAAWA,GAEnDP,EAASG,EAAMC,EAAM,CAC1B,QAAWE,EACX,QAAWF,EACX,SAAYG,M,gBChEhB,IAAIE,EAAa,EAAQ,GAGrBC,EAA0B,iBAARC,MAAoBA,MAAQA,KAAKlC,SAAWA,QAAUkC,KAGxEtD,EAAOoD,GAAcC,GAAYE,SAAS,cAATA,GAErCpD,EAAOD,QAAUF,G,gBCRjB,IAGIyB,EAHO,EAAQ,GAGDA,OAElBtB,EAAOD,QAAUuB,G,gBCLjB,IAAImB,EAAW,EAAQ,GACnBY,EAAM,EAAQ,GACdC,EAAW,EAAQ,GAGnBZ,EAAkB,sBAGlBa,EAAYC,KAAKC,IACjBC,EAAYF,KAAKG,IAqLrB3D,EAAOD,QA7HP,SAAkB4C,EAAMC,EAAMC,GAC5B,IAAIe,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EAAiB,EACjBpB,GAAU,EACVqB,GAAS,EACTpB,GAAW,EAEf,GAAmB,mBAARJ,EACT,MAAM,IAAIK,UAAUN,GAUtB,SAAS0B,EAAWC,GAClB,IAAIC,EAAOV,EACPW,EAAUV,EAKd,OAHAD,EAAWC,OAAWW,EACtBN,EAAiBG,EACjBN,EAASpB,EAAK8B,MAAMF,EAASD,GAuB/B,SAASI,EAAaL,GACpB,IAAIM,EAAoBN,EAAOJ,EAM/B,YAAyBO,IAAjBP,GAA+BU,GAAqB/B,GACzD+B,EAAoB,GAAOR,GANJE,EAAOH,GAM8BJ,EAGjE,SAASc,IACP,IAAIP,EAAOhB,IACX,GAAIqB,EAAaL,GACf,OAAOQ,EAAaR,GAGtBL,EAAUc,WAAWF,EA3BvB,SAAuBP,GACrB,IAEIU,EAAcnC,GAFMyB,EAAOJ,GAI/B,OAAOE,EACHT,EAAUqB,EAAajB,GAJDO,EAAOH,IAK7Ba,EAoB+BC,CAAcX,IAGnD,SAASQ,EAAaR,GAKpB,OAJAL,OAAUQ,EAINzB,GAAYa,EACPQ,EAAWC,IAEpBT,EAAWC,OAAWW,EACfT,GAeT,SAASkB,IACP,IAAIZ,EAAOhB,IACP6B,EAAaR,EAAaL,GAM9B,GAJAT,EAAWuB,UACXtB,EAAWuB,KACXnB,EAAeI,EAEXa,EAAY,CACd,QAAgBV,IAAZR,EACF,OAzEN,SAAqBK,GAMnB,OAJAH,EAAiBG,EAEjBL,EAAUc,WAAWF,EAAchC,GAE5BE,EAAUsB,EAAWC,GAAQN,EAmEzBsB,CAAYpB,GAErB,GAAIE,EAIF,OAFAmB,aAAatB,GACbA,EAAUc,WAAWF,EAAchC,GAC5BwB,EAAWH,GAMtB,YAHgBO,IAAZR,IACFA,EAAUc,WAAWF,EAAchC,IAE9BmB,EAIT,OA3GAnB,EAAOU,EAASV,IAAS,EACrBH,EAASI,KACXC,IAAYD,EAAQC,QAEpBgB,GADAK,EAAS,YAAatB,GACHU,EAAUD,EAAST,EAAQiB,UAAY,EAAGlB,GAAQkB,EACrEf,EAAW,aAAcF,IAAYA,EAAQE,SAAWA,GAoG1DkC,EAAUM,OApCV,gBACkBf,IAAZR,GACFsB,aAAatB,GAEfE,EAAiB,EACjBN,EAAWK,EAAeJ,EAAWG,OAAUQ,GAgCjDS,EAAUO,MA7BV,WACE,YAAmBhB,IAAZR,EAAwBD,EAASc,EAAaxB,MA6BhD4B,I,gBC3LT,IAAIpF,EAAO,EAAQ,GAsBnBG,EAAOD,QAJG,WACR,OAAOF,EAAK4F,KAAKpC,Q,iBCnBnB,YACA,IAAIJ,EAA8B,iBAAVyC,GAAsBA,GAAUA,EAAOzE,SAAWA,QAAUyE,EAEpF1F,EAAOD,QAAUkD,I,+BCHjB,IAAI0C,EAGJA,EAAI,WACH,OAAOP,KADJ,GAIJ,IAECO,EAAIA,GAAK,IAAIvC,SAAS,cAAb,GACR,MAAOwC,GAEc,iBAAXzF,SAAqBwF,EAAIxF,QAOrCH,EAAOD,QAAU4F,G,gBCnBjB,IAAIlD,EAAW,EAAQ,GACnBoD,EAAW,EAAQ,GAGnBC,EAAM,IAGNC,EAAS,aAGTC,EAAa,qBAGbC,EAAa,aAGbC,EAAY,cAGZC,EAAeC,SA8CnBpG,EAAOD,QArBP,SAAkByB,GAChB,GAAoB,iBAATA,EACT,OAAOA,EAET,GAAIqE,EAASrE,GACX,OAAOsE,EAET,GAAIrD,EAASjB,GAAQ,CACnB,IAAI6E,EAAgC,mBAAjB7E,EAAM8E,QAAwB9E,EAAM8E,UAAY9E,EACnEA,EAAQiB,EAAS4D,GAAUA,EAAQ,GAAMA,EAE3C,GAAoB,iBAAT7E,EACT,OAAiB,IAAVA,EAAcA,GAASA,EAEhCA,EAAQA,EAAM+E,QAAQR,EAAQ,IAC9B,IAAIS,EAAWP,EAAWQ,KAAKjF,GAC/B,OAAQgF,GAAYN,EAAUO,KAAKjF,GAC/B2E,EAAa3E,EAAMkF,MAAM,GAAIF,EAAW,EAAI,GAC3CR,EAAWS,KAAKjF,GAASsE,GAAOtE,I,gBC9DvC,IAAImF,EAAa,EAAQ,IACrBC,EAAe,EAAQ,IAGvBC,EAAY,kBAwBhB7G,EAAOD,QALP,SAAkByB,GAChB,MAAuB,iBAATA,GACXoF,EAAapF,IAAUmF,EAAWnF,IAAUqF,I,gBCzBjD,IAAIvF,EAAS,EAAQ,GACjBwF,EAAY,EAAQ,IACpBC,EAAiB,EAAQ,IAGzBC,EAAU,gBACVC,EAAe,qBAGfC,EAAiB5F,EAASA,EAAOC,iBAAciD,EAkBnDxE,EAAOD,QATP,SAAoByB,GAClB,OAAa,MAATA,OACegD,IAAVhD,EAAsByF,EAAeD,EAEtCE,GAAkBA,KAAkBjG,OAAOO,GAC/CsF,EAAUtF,GACVuF,EAAevF,K,gBCxBrB,IAAIF,EAAS,EAAQ,GAGjB6F,EAAclG,OAAOkB,UAGrBC,EAAiB+E,EAAY/E,eAO7BgF,EAAuBD,EAAYE,SAGnCH,EAAiB5F,EAASA,EAAOC,iBAAciD,EA6BnDxE,EAAOD,QApBP,SAAmByB,GACjB,IAAI8F,EAAQlF,EAAe1B,KAAKc,EAAO0F,GACnCK,EAAM/F,EAAM0F,GAEhB,IACE1F,EAAM0F,QAAkB1C,EACxB,IAAIgD,GAAW,EACf,MAAO5B,IAET,IAAI7B,EAASqD,EAAqB1G,KAAKc,GAQvC,OAPIgG,IACEF,EACF9F,EAAM0F,GAAkBK,SAEjB/F,EAAM0F,IAGVnD,I,cCzCT,IAOIqD,EAPcnG,OAAOkB,UAOckF,SAavCrH,EAAOD,QAJP,SAAwByB,GACtB,OAAO4F,EAAqB1G,KAAKc,K,cCUnCxB,EAAOD,QAJP,SAAsByB,GACpB,OAAgB,MAATA,GAAiC,iBAATA,I,oCCzBjC,IACIiG,EAAW,SAAUC,GACrB,OAAO,SAAUrF,GACb,OAAO,EAAIqF,EAAO,EAAIrF,KAG1BsF,EAAW,SAAUD,GACrB,OAAO,SAAUrF,GACb,OAAOA,GAAK,GAAMqF,EAAO,EAAIrF,GAAK,GAAK,EAAIqF,EAAO,GAAK,EAAIrF,KAAO,IAUtEuF,EAAe,SAAUC,GACzB,OAAO,SAAUxF,GACb,OAAOA,EAAIA,IAAMwF,EAAQ,GAAKxF,EAAIwF,KAGtCC,EAAyB,SAAUD,GACnC,IAAIE,EAAaH,EAAaC,GAC9B,OAAO,SAAUxF,GACb,OAAQA,GAAK,GAAK,EAAI,GAAM0F,EAAW1F,GAAK,IAAO,EAAImB,KAAKwE,IAAI,GAAI,IAAM3F,EAAI,OAMlF4F,EAnBe,SAAUJ,GACzB,OAAO,SAAUxF,GACb,OAAOmB,KAAKwE,IAAI3F,EAAGwF,IAiBDK,CAAa,GACnCC,EAAuBV,EAASQ,GAChCG,EAAyBT,EAASM,GAClCI,EAAS,SAAUhG,GACnB,OAAO,EAAImB,KAAK8E,IAAI9E,KAAK+E,KAAKlG,KAE9BmG,EAAuBf,EAASY,GAChCI,EAAyBd,EAASa,GAClCE,EAAsBd,EAxCO,OAyC7Be,EAAuBlB,EAASiB,GAChCE,EAAyBjB,EAASe,GAClCG,EAA0Bf,EA3CG,OCEjC,IAgEIgB,EAhEAC,EAAW,EACXC,EAAgC,oBAAX7I,aAA2DqE,IAAjCrE,OAAO8I,sBACpD,SAAUC,GAAY,OAAO/I,OAAO8I,sBAAsBC,IAC1D,SAAUA,GACR,IAAIC,EAAY1D,KAAKpC,MACjB+F,EAAa5F,KAAKC,IAAI,EAAG,MAAQ0F,EAAYJ,IACjDA,EAAWI,EAAYC,EACvBtE,YAAW,WAAc,OAAOoE,EAASH,KAAcK,KA0D/D,SAAWN,GACPA,EAAa,KAAI,OACjBA,EAAe,OAAI,SACnBA,EAAe,OAAI,SACnBA,EAAmB,WAAI,aACvBA,EAAoB,YAAI,cAL5B,CAMGA,IAAWA,EAAS,KAEvB,IACIO,EAAkB,EAAI,GAAM,IAC5BC,GAAoB,EACpBC,GAAmB,EACnB,GAAe,EACf,EAAQ,CACRC,MAAO,EACPL,UAAW,GAEXM,EAAa,CACbX,EAAOY,KACPZ,EAAOa,OACPb,EAAOc,OACPd,EAAOe,YAEPC,EAAsB,SAAUC,GAAW,OAAQR,EAAmBQ,GACtE,EAAKN,EAAWO,QAAO,SAAUC,EAAKnI,GACtC,IAhFwBoI,EACpBC,EACAC,EACAC,EACAC,EACA/J,EACAgK,EACAC,EACAC,EAwEAC,GAhFoBR,EAgFFJ,EA/ElBK,EAAe,GACfC,EAAwB,GACxBC,EAAe,EACfC,GAAe,EACf/J,EAAI,EACJgK,EAAY,IAAII,QAChBH,EAAc,IAAIG,QAClBF,EAAa,CACblF,OAAQ,SAAUqF,GACd,IAAIC,EAAkBT,EAAsBU,QAAQF,GACpDL,EAAUQ,IAAIH,IACW,IAArBC,GACAT,EAAsBY,OAAOH,EAAiB,IAGtDD,QAAS,SAAUK,GACf,IAAIC,EASIC,EADR,GAPAb,GAAe,EAIZH,GAHHe,EAAK,CACDd,EACAD,IACiB,IAAIC,EAAwBc,EAAG,IAC9BE,OAAS,EAC/Bf,EAAeF,EAAaiB,OAGxB,IAAK7K,EAAI,EAAGA,EAAI8J,EAAc9J,KAC1B4K,EAAYhB,EAAa5J,IACf0K,IACyB,IAA/BT,EAAYa,IAAIF,IAAwBZ,EAAUc,IAAIF,KACtDV,EAAWa,SAASH,GACpBjB,GAAgB,IAI5BI,GAAe,GAEnBgB,SAAU,SAAUV,EAASW,EAAWC,GAEpC,IAAIC,EAAqBD,GAAalB,EAClCoB,EAASD,EAAqBtB,EAAeC,EAC7CmB,GACAf,EAAYO,IAAIH,IACa,IAA7Bc,EAAOZ,QAAQF,KACfc,EAAOC,KAAKf,GACRa,IACApB,EAAeF,EAAaiB,YA4C5C,OAVAnB,EAAI2B,KAAK9J,GAAO,SAAU8I,EAASW,EAAWC,GAM1C,YALkB,IAAdD,IAAwBA,GAAY,QACtB,IAAdC,IAAwBA,GAAY,GACnCjC,GACDsC,IACJnB,EAAKY,SAASV,EAASW,EAAWC,GAC3BZ,GAEXX,EAAI6B,WAAWhK,GAAO,SAAU8I,GAAW,OAAOF,EAAKnF,OAAOqF,IAC9DX,EAAI8B,MAAMjK,GAAO4I,EACVT,IACR,CACC8B,MAAO,GACPH,KAAM,GACNE,WAAY,KACZC,EAAQ,EAAGA,MAAOH,EAAO,EAAGA,KAAME,EAAa,EAAGA,WAClDE,EAAc,SAAUC,GAAU,OAAOF,EAAME,GAAQrB,QAAQ,IAC/DsB,EAAe,SAAU/C,GACzBI,GAAmB,EACnB,EAAMC,MAAQF,EACRD,EACA7F,KAAKC,IAAID,KAAKG,IAAIwF,EAAY,EAAMA,UAvC7B,IAuCqD,GAC7DG,IACDD,EAAiB,EAAMG,OAC3B,EAAML,UAAYA,EAClB,GAAe,EACfM,EAAW0C,QAAQH,GACnB,GAAe,EACXzC,IACAD,GAAoB,EACpBN,EAAYkD,KAGhBL,EAAY,WACZtC,GAAmB,EACnBD,GAAoB,EACf,GACDN,EAAYkD,IAIL,I,gBCtHXE,EAAgB,SAASvL,EAAGwL,GAI5B,OAHAD,EAAgBnL,OAAOqL,gBAClB,CAAEC,UAAW,cAAgBC,OAAS,SAAU3L,EAAGwL,GAAKxL,EAAE0L,UAAYF,IACvE,SAAUxL,EAAGwL,GAAK,IAAK,IAAIhK,KAAKgK,EAAOA,EAAEjK,eAAeC,KAAIxB,EAAEwB,GAAKgK,EAAEhK,MACpDxB,EAAGwL,IAGrB,SAASI,EAAU5L,EAAGwL,GAEzB,SAASK,IAAOtH,KAAKuH,YAAc9L,EADnCuL,EAAcvL,EAAGwL,GAEjBxL,EAAEsB,UAAkB,OAANkK,EAAapL,OAAOY,OAAOwK,IAAMK,EAAGvK,UAAYkK,EAAElK,UAAW,IAAIuK,GAG5E,IAAIE,EAAW,WAQlB,OAPAA,EAAW3L,OAAO4L,QAAU,SAAkBpL,GAC1C,IAAK,IAAIa,EAAG/B,EAAI,EAAGyB,EAAImD,UAAUiG,OAAQ7K,EAAIyB,EAAGzB,IAE5C,IAAK,IAAI8B,KADTC,EAAI6C,UAAU5E,GACOU,OAAOkB,UAAUC,eAAe1B,KAAK4B,EAAGD,KAAIZ,EAAEY,GAAKC,EAAED,IAE9E,OAAOZ,IAEKgD,MAAMW,KAAMD,YAGzB,SAAS2H,EAAOxK,EAAGsD,GACtB,IAAInE,EAAI,GACR,IAAK,IAAIY,KAAKC,EAAOrB,OAAOkB,UAAUC,eAAe1B,KAAK4B,EAAGD,IAAMuD,EAAEkF,QAAQzI,GAAK,IAC9EZ,EAAEY,GAAKC,EAAED,IACb,GAAS,MAALC,GAAqD,mBAAjCrB,OAAO8L,sBACtB,KAAIxM,EAAI,EAAb,IAAgB8B,EAAIpB,OAAO8L,sBAAsBzK,GAAI/B,EAAI8B,EAAE+I,OAAQ7K,IAASqF,EAAEkF,QAAQzI,EAAE9B,IAAM,IAC1FkB,EAAEY,EAAE9B,IAAM+B,EAAED,EAAE9B,KACtB,OAAOkB;;;;;;;;;;;;;;;AChCX,IAAI,EAAW,WAQX,OAPA,EAAWR,OAAO4L,QAAU,SAAkBpL,GAC1C,IAAK,IAAIa,EAAG/B,EAAI,EAAGyB,EAAImD,UAAUiG,OAAQ7K,EAAIyB,EAAGzB,IAE5C,IAAK,IAAI8B,KADTC,EAAI6C,UAAU5E,GACOU,OAAOkB,UAAUC,eAAe1B,KAAK4B,EAAGD,KAAIZ,EAAEY,GAAKC,EAAED,IAE9E,OAAOZ,IAEKgD,MAAMW,KAAMD,YAG5B,EAAQ,SAAUxB,EAAKF,GAAO,OAAO,SAAUuJ,GAC/C,OAAOxJ,KAAKC,IAAID,KAAKG,IAAIqJ,EAAGvJ,GAAME,KAElCsJ,EAAe,SAAUC,GAAQ,OAAO,SAAUF,GAClD,MAAoB,iBAANA,GAAsC,IAApBA,EAAElC,QAAQoC,KAQ1CC,EAAW,SAAUH,GAAK,OAAQA,EAAI,EAAII,OAAOJ,EAAEK,QAAQ,IAAML,GAEjEM,EAAS,CACT7G,KAAM,SAAUuG,GAAK,MAAoB,iBAANA,GACnCO,MAAOC,WACPC,UAAW,SAAUT,GAAK,OAAOA,IAKjCU,GAHQ,EAAS,GAAIJ,EAAQ,CAAEG,UAAW,EAAM,EAAG,KAC3C,EAAS,GAAIH,EAAQ,CAAEK,QAAS,IAEvB,SAAUC,GAAQ,MAAO,CAC1CnH,KAAM,SAAUuG,GACZ,MAAoB,iBAANA,GAAkBA,EAAEa,SAASD,IAAiC,IAAxBZ,EAAEc,MAAM,KAAK1C,QAErEmC,MAAOC,WACPC,UAAW,SAAUT,GAAK,MAAO,GAAKA,EAAIY,MAE1CG,EAAUL,EAAe,OACzBM,EAAUN,EAAe,KACzBO,EAAKP,EAAe,MACpBQ,EAAKR,EAAe,MACpBS,EAAKT,EAAe,MAEpBU,EAAe,EAAM,EAAG,KACxBC,EAAiB,0FACjBC,GAAS,SAAUtB,GAAK,YAAiBxI,IAAVwI,EAAEuB,KACjCC,GAAS,SAAUxB,GAAK,YAAiBxI,IAAVwI,EAAEyB,KACjCC,GAAmB,SAAUC,GAC7B,IAAIC,EAAWD,EAAMvD,OACrB,OAAO,SAAU4B,GACb,GAAiB,iBAANA,EACP,OAAOA,EAGX,IAFA,IAtCmCxL,EAsC/BqN,EAAS,GACTC,EApCc,SAAUtN,GAChC,MAAwB,iBAAVA,EAAqBA,EAAMsM,MAAM,QAAU,CAACtM,GAmCpCuN,EAvCiBvN,EAuC8BwL,GAtCxDgC,UAAUxN,EAAMsJ,QAAQ,KAAO,EAAGtJ,EAAMyN,YAAY,OAuCpD1O,EAAI,EAAGA,EAAIqO,EAAUrO,IAC1BsO,EAAOF,EAAMpO,SACUiE,IAAnBsK,EAAYvO,GAAmBiN,WAAWsB,EAAYvO,IAAM,EAEpE,OAAOsO,IAWXK,GAAU,EAAS,GAAI5B,EAAQ,CAAEG,UAAW,SAAUT,GAAK,OAAOxJ,KAAK2L,MAAMf,EAAapB,OAC1FoC,GAAiBnC,EAAa,OAC9BoC,GAAO,CACP5I,KAAM,SAAUuG,GAAK,MAAqB,iBAANA,EAAiBoC,GAAepC,GAAKsB,GAAOtB,IAChFO,MAAOmB,GAAiB,CAAC,MAAO,QAAS,OAAQ,UACjDjB,UAAW,SAAUvC,GACjB,IAAIqD,EAAMrD,EAAGqD,IAAKe,EAAQpE,EAAGoE,MAAOC,EAAOrE,EAAGqE,KAAMC,EAAWtE,EAAGuE,MAClE,OAfW,SAAUvE,GACzB,IAAIqD,EAAMrD,EAAGqD,IAAKe,EAAQpE,EAAGoE,MAAOC,EAAOrE,EAAGqE,KAAMG,EAAKxE,EAAGuE,MAC5D,MAAO,QAAUlB,EAAM,KAAOe,EAAQ,KAAOC,EAAO,WADiC,IAAPG,EAAgB,EAAIA,GAC5B,IAa3DC,CAAa,CAChBpB,IAAKW,GAAQzB,UAAUc,GACvBe,MAAOJ,GAAQzB,UAAU6B,GACzBC,KAAML,GAAQzB,UAAU8B,GACxBE,MAAOtC,EAASqC,OAIxBI,GAAiB3C,EAAa,OAC9B4C,GAAO,CACPpJ,KAAM,SAAUuG,GAAK,MAAqB,iBAANA,EAAiB4C,GAAe5C,GAAKwB,GAAOxB,IAChFO,MAAOmB,GAAiB,CAAC,MAAO,aAAc,YAAa,UAC3DjB,UAAW,SAAUvC,GACjB,IAAIuD,EAAMvD,EAAGuD,IAAKqB,EAAa5E,EAAG4E,WAAYC,EAAY7E,EAAG6E,UAAWP,EAAWtE,EAAGuE,MACtF,OAzBW,SAAUvE,GACzB,IAAIuD,EAAMvD,EAAGuD,IAAKqB,EAAa5E,EAAG4E,WAAYC,EAAY7E,EAAG6E,UAAWL,EAAKxE,EAAGuE,MAChF,MAAO,QAAUhB,EAAM,KAAOqB,EAAa,KAAOC,EAAY,WAD2C,IAAPL,EAAgB,EAAIA,GACtC,IAuBrEM,CAAa,CAChBvB,IAAKjL,KAAK2L,MAAMV,GAChBqB,WAAY9B,EAAQP,UAAUN,EAAS2C,IACvCC,UAAW/B,EAAQP,UAAUN,EAAS4C,IACtCN,MAAOtC,EAASqC,OAIxBS,GAAM,EAAS,GAAIZ,GAAM,CAAE5I,KAAMwG,EAAa,KAAMM,MAAO,SAAUP,GACjE,IAAI3L,EAAI,GACJsE,EAAI,GACJ0G,EAAI,GAcR,OAbIW,EAAE5B,OAAS,GACX/J,EAAI2L,EAAEkD,OAAO,EAAG,GAChBvK,EAAIqH,EAAEkD,OAAO,EAAG,GAChB7D,EAAIW,EAAEkD,OAAO,EAAG,KAGhB7O,EAAI2L,EAAEkD,OAAO,EAAG,GAChBvK,EAAIqH,EAAEkD,OAAO,EAAG,GAChB7D,EAAIW,EAAEkD,OAAO,EAAG,GAChB7O,GAAKA,EACLsE,GAAKA,EACL0G,GAAKA,GAEF,CACHkC,IAAKnI,SAAS/E,EAAG,IACjBiO,MAAOlJ,SAAST,EAAG,IACnB4J,KAAMnJ,SAASiG,EAAG,IAClBoD,MAAO,MAGfU,GAAQ,CACR1J,KAAM,SAAUuG,GACZ,MAAqB,iBAANA,GAAkBqB,EAAe5H,KAAKuG,IACjDqC,GAAK5I,KAAKuG,IACV6C,GAAKpJ,KAAKuG,IACViD,GAAIxJ,KAAKuG,IAEjBO,MAAO,SAAUP,GACb,OAAIqC,GAAK5I,KAAKuG,GACHqC,GAAK9B,MAAMP,GAEb6C,GAAKpJ,KAAKuG,GACR6C,GAAKtC,MAAMP,GAEbiD,GAAIxJ,KAAKuG,GACPiD,GAAI1C,MAAMP,GAEdA,GAEXS,UAAW,SAAUT,GACjB,OAAIsB,GAAOtB,GACAqC,GAAK5B,UAAUT,GAEjBwB,GAAOxB,GACL6C,GAAKpC,UAAUT,GAEnBA,IAIXoD,GAAa,mBACbC,GAAa,sGAGbC,GACM,SAAUtD,GACZ,GAAiB,iBAANA,IAAmBuD,MAAMvD,GAChC,OAAO,EACX,IAAIwD,EAAY,EACZC,EAAezD,EAAE0D,MAAMN,IACvBO,EAAc3D,EAAE0D,MAAML,IAK1B,OAJII,IACAD,GAAaC,EAAarF,QAC1BuF,IACAH,GAAaG,EAAYvF,QACtBoF,EAAY,GAXvBF,GAaO,SAAUtD,GACb,IAAI4D,EAAQ5D,EACR6D,EAAS,GACTF,EAAcC,EAAMF,MAAML,IAC1BM,IACAC,EAAQA,EAAMrK,QAAQ8J,GApBhB,QAqBNQ,EAAOlF,KAAKlH,MAAMoM,EAAQF,EAAYG,IAAIX,GAAM5C,SAEpD,IAAIkD,EAAeG,EAAMF,MAAMN,IAI/B,OAHIK,GACAI,EAAOlF,KAAKlH,MAAMoM,EAAQJ,EAAaK,IAAIxD,EAAOC,QAE/CsD,GAzBXP,GA2BmB,SAAUS,GACzB,IAAIC,EAAWD,EACXE,EAAQ,EACRN,EAAcI,EAAKL,MAAML,IACzBa,EAAYP,EAAcA,EAAYvF,OAAS,EACnD,GAAIuF,EACA,IAAK,IAAIpQ,EAAI,EAAGA,EAAI2Q,EAAW3Q,IAC3ByQ,EAAWA,EAASzK,QAAQoK,EAAYpQ,GApCtC,QAqCF0Q,IAGR,IAAIR,EAAeO,EAASN,MAAMN,IAC9Be,EAAaV,EAAeA,EAAarF,OAAS,EACtD,GAAIqF,EACA,IAASlQ,EAAI,EAAGA,EAAI4Q,EAAY5Q,IAC5ByQ,EAAWA,EAASzK,QAAQkK,EAAalQ,GA3CtC,QA4CH0Q,IAGR,OAAO,SAAUjE,GAEb,IADA,IAAIoE,EAASJ,EACJzQ,EAAI,EAAGA,EAAI0Q,EAAO1Q,IACvB6Q,EAASA,EAAO7K,QAAQhG,EAAI2Q,EAnD1B,OACC,OAkDiE3Q,EAAI2Q,EAAYf,GAAM1C,UAAUT,EAAEzM,IAAM4M,EAASH,EAAEzM,KAE3H,OAAO6Q,IC3NnB,IAKIC,GAAQ,SAAUrE,GAAK,MAAoB,iBAANA,GA2BrCsE,GAAa,SAAW3O,GAAQ,OAAO,SAAUgB,EAAKF,EAAKuJ,GAAK,YAAcxI,IAANwI,EAAkBrK,EAAKgB,EAAKF,EAAKuJ,GAAK,SAAUuE,GAAM,OAAO5O,EAAKgB,EAAKF,EAAK8N,MAKpJC,GAAUF,IAHF,SAAU3N,EAAKF,EAAKuJ,GAC5B,OAAOxJ,KAAKG,IAAIH,KAAKC,IAAIuJ,EAAGrJ,GAAMF,MAiClCgO,GAAW,SAAWC,EAAMC,EAAInQ,GAChC,IAAIoQ,EAAmBD,EAAKD,EAC5B,OAA4B,IAArBE,EAAyB,GAAKpQ,EAAQkQ,GAAQE,GAGrDC,GAAM,SAAWH,EAAMC,EAAIF,GAC3B,OAAQA,EAAWC,EAAOD,EAAWE,EAAKD,GAkB1C,GAAW,WAQX,OAPA,GAAWzQ,OAAO4L,QAAU,SAAkBpL,GAC1C,IAAK,IAAIa,EAAG/B,EAAI,EAAGyB,EAAImD,UAAUiG,OAAQ7K,EAAIyB,EAAGzB,IAE5C,IAAK,IAAI8B,KADTC,EAAI6C,UAAU5E,GACOU,OAAOkB,UAAUC,eAAe1B,KAAK4B,EAAGD,KAAIZ,EAAEY,GAAKC,EAAED,IAE9E,OAAOZ,IAEKgD,MAAMW,KAAMD,YAG5B2M,GAAiB,SAAUJ,EAAMC,EAAI3E,GACrC,IAAI+E,EAAWL,EAAOA,EAClBM,EAASL,EAAKA,EAClB,OAAOnO,KAAKyO,KAAKjF,GAAKgF,EAASD,GAAYA,IAE3CG,GAAa,CAACjC,GAAKZ,GAAMQ,IACzBsC,GAAe,SAAUnF,GACzB,OAAOkF,GAAWE,MAAK,SAAU7P,GAAQ,OAAOA,EAAKkE,KAAKuG,OAE1DqF,GAAW,SAAWX,EAAMC,GAC5B,IAAIW,EAAgBH,GAAaT,GAC7Ba,EAAcJ,GAAaR,GACrBW,EAAc7E,UAAc8E,EAAY9E,UAClD,IAAI+E,EAAYF,EAAc/E,MAAMmE,GAChCe,EAAUF,EAAYhF,MAAMoE,GAC5Be,EAAU,GAAS,GAAIF,GACvBG,EAAUL,IAAkBzC,GAAOgC,GAAMC,GAC7C,OAAO,SAAU9E,GACb,IAAK,IAAIlL,KAAO4Q,EACA,UAAR5Q,IACA4Q,EAAQ5Q,GAAO6Q,EAAQH,EAAU1Q,GAAM2Q,EAAQ3Q,GAAMkL,IAI7D,OADA0F,EAAQjD,MAAQoC,GAAIW,EAAU/C,MAAOgD,EAAQhD,MAAOzC,GAC7CsF,EAAc7E,UAAUiF,KAInCE,GAAmB,SAAUC,EAAGxG,GAAK,OAAO,SAAUW,GAAK,OAAOX,EAAEwG,EAAE7F,MACtE8F,GAAO,WAEP,IADA,IAAIC,EAAe,GACVC,EAAK,EAAGA,EAAK7N,UAAUiG,OAAQ4H,IACpCD,EAAaC,GAAM7N,UAAU6N,GAEjC,OAAOD,EAAa/I,OAAO4I,KAG3BK,GAAW,SAAUvB,EAAMC,GAC3B,IAAIP,EAASM,EAAKhL,QACd8J,EAAYY,EAAOhG,OACnB8H,EAAaxB,EAAKZ,KAAI,SAAUqC,EAAU5S,GAC1C,IAAI6S,EAASzB,EAAGpR,GAChB,OAAI8Q,GAAM8B,GACC,SAAUnG,GAAK,OAAO6E,GAAIsB,EAAUC,EAAQpG,IAE9CmD,GAAM1J,KAAK0M,GACTd,GAASc,EAAUC,GAGnBC,GAAWF,EAAUC,MAGpC,OAAO,SAAUpG,GACb,IAAK,IAAIzM,EAAI,EAAGA,EAAIiQ,EAAWjQ,IAC3B6Q,EAAO7Q,GAAK2S,EAAW3S,GAAGyM,GAE9B,OAAOoE,IAGXiC,GAAa,SAAU3B,EAAMC,GAC7B,IAAI2B,EAAgBhD,GAA0BoB,GAE9C,OADU4B,EAAc5B,GAAUpB,GAA0BqB,EAA1BrB,CAA8BoB,GACzDoB,GAAKG,GAAS3C,GAAcoB,GAAOpB,GAAcqB,IAAM2B,IAwI9DC,IArIYjC,GAAWO,IAqIZ,SAAU7E,GAAK,OAAOA,IACjCwG,GAAc,SAAUC,GAExB,YAD0B,IAAtBA,IAAgCA,EAAoBF,IACjDjC,IAAW,SAAUoC,EAAUC,EAAQ3G,GAC1C,IAAI4G,EAAeD,EAAS3G,EACxB6G,IAA+B,EAAIH,EAAW,IAAM,EAAID,EAAkBjQ,KAAKsQ,IAAIF,KACvF,OAAOA,GAAgB,EACjBD,EAASE,EACTF,EAASE,MC1TnB,ID6ToBL,KACFA,GAAYhQ,KAAKyO,MAc1BX,IAJF,SAAU3N,EAAKF,EAAKuJ,GAC3B,IAAI+G,EAAYtQ,EAAME,EACtB,QAAWqJ,EAAIrJ,GAAOoQ,EAAaA,GAAaA,EAAapQ,KAI7C6N,GAAQ,EAAG,GC9UhB,SAAU9J,GACrB,OAAO,SAAUrF,GACb,OAAO,EAAIqF,EAAO,EAAIrF,MA0B1B,GAAS,SAAUA,GACnB,OAAOA,GAEP,GAnBe,SAAUwF,GACzB,OAAO,SAAUxF,GACb,OAAOmB,KAAKwE,IAAI3F,EAAGwF,IAiBD,CAAa,GACnC,GAAuB,GAAS,ICodrB,ICxeX,GAAyB,WACzB,SAASmM,EAAUC,QACD,IAAVA,IACAA,EAAQ,IAEZ7O,KAAK6O,MAAQA,EA+BjB,OA7BAD,EAAU7R,UAAU+R,gBAAkB,SAAUC,GAC5C,OAAO/O,KAAKvD,OAAO+K,EAAS,GAAIxH,KAAK6O,MAAO,CAAEE,WAAY/O,KAAK6O,MAAME,WAAa,CAACA,GAAYC,OAAOhP,KAAK6O,MAAME,YAAc,CAACA,OAEpIH,EAAU7R,UAAU2Q,KAAO,WAEvB,IADA,IAAIuB,EAAQ,GACHrB,EAAK,EAAGA,EAAK7N,UAAUiG,OAAQ4H,IACpCqB,EAAMrB,GAAM7N,UAAU6N,GAE1B,IAAIsB,EAA+B,IAAjBD,EAAMjJ,OAAeiJ,EAAM,GAAKvB,GAAKrO,WAAM,EAAQ4P,GACrE,OAAOjP,KAAK8O,iBAAgB,SAAUK,GAClC,OAAO,SAAUvH,GACb,OAAOuH,EAAOD,EAAYtH,SAItCgH,EAAU7R,UAAUqS,MAAQ,SAAUC,GAClC,OAAOrP,KAAK8O,iBAAgB,SAAUK,EAAQG,GAC1C,OAAO,SAAU1H,GACb,OAAOyH,EAAUzH,GAAKuH,EAAOvH,GAAK0H,SAI9CV,EAAU7R,UAAUwS,OAAS,SAAUF,GACnC,OAAOrP,KAAK8O,iBAAgB,SAAUK,GAClC,OAAO,SAAUvH,GACb,OAAOyH,EAAUzH,IAAMuH,EAAOvH,QAInCgH,EApCkB,GAuCzBY,GAAwB,WA6BxB,OA5BA,SAAkB1J,EAAI2J,GAClB,IAAIV,EAAajJ,EAAGiJ,WAChBW,EAAa5J,EAAG4J,WAChBC,EAAQ3P,KACZA,KAAK4P,UAAW,EAChB5P,KAAKmP,OAAS,SAAUvH,GAChB+H,EAAMF,SAASN,QAAQQ,EAAME,eAAejI,IAEpD5H,KAAKsP,SAAW,WACRK,EAAMF,SAASH,UAAYK,EAAMC,UAAUD,EAAMF,SAASH,WAC1DK,EAAMD,YAAYC,EAAMD,aAC5BC,EAAMC,UAAW,GAErB5P,KAAK8P,MAAQ,SAAUC,GACfJ,EAAMF,SAASK,OAASH,EAAMC,UAAUD,EAAMF,SAASK,MAAMC,GACjEJ,EAAMC,UAAW,GAErB5P,KAAKyP,SAAWA,EAChBzP,KAAK6P,eAAiB,SAAUjI,GAC5B,OAAO6H,EAASN,OAAOvH,IAE3B5H,KAAK0P,WAAaA,EACdD,EAASN,QAAUJ,GAAcA,EAAW/I,QAC5C+I,EAAWhI,SAAQ,SAAUxL,GACzB,OAAOoU,EAAME,eAAiBtU,EAAEoU,EAAME,eAAgBF,EAAML,cAzBhD,GA+BxBU,GAAiB,SAAUC,EAAmBnK,EAAI4J,GAClD,IAAIX,EAAajJ,EAAGiJ,WACpB,OACW,IAAIS,GAAS,CAAET,WAAYA,EAAYW,WAAYA,GAD7B,mBAAtBO,EACiE,CAAEd,OAAQc,GAEVA,IAI5E,GAAsB,SAAUC,GAEhC,SAASC,IACL,OAAkB,OAAXD,GAAmBA,EAAO7Q,MAAMW,KAAMD,YAAcC,KA8B/D,OAhCAqH,EAAU8I,EAAQD,GAIlBC,EAAOpT,UAAUN,OAAS,SAAUoS,GAChC,OAAO,IAAIsB,EAAOtB,IAEtBsB,EAAOpT,UAAUqT,MAAQ,SAAUH,QACL,IAAtBA,IACAA,EAAoB,IAExB,IAAII,GAAa,EACbC,EAAe,CACfC,KAAM,cAINzK,EAAK9F,KAAK6O,MACV2B,EAAO1K,EAAG0K,KACVC,EAAgB/I,EAAO5B,EAAI,CAAC,SAK5B4K,EAAMF,EAJKR,GAAeC,EAAmBQ,GAAe,WAC5DJ,GAAa,EACbC,EAAaC,WAQjB,OALAD,EAAeI,EAAMlJ,EAAS,GAAI8I,EAAcI,GAAOJ,EACnDL,EAAkBU,gBAClBV,EAAkBU,eAAeL,GAEjCD,GAAYC,EAAaC,OACtBD,GAEJH,EAjCe,CAkCxB,IACE,GAAS,SAAUK,GACnB,OAAO,IAAI,GAAO,CAAEA,KAAMA,KA2L1BI,GAAQ,SAAU9K,GAClB,IAAI+K,EAAW/K,EAAG+K,SACdC,EAAWhL,EAAGgL,SACdC,EAAYjL,EAAGiL,UACfC,EAASlL,EAAGkL,OACZC,EAAUnL,EAAGmL,QACbC,EAAepL,EAAGoL,aACtB,OAAO,SAAUC,GACb,OAAO,IAAO,SAAUrL,GACpB,IAAIqJ,EAASrJ,EAAGqJ,OACZG,EAAWxJ,EAAGwJ,SACdQ,EAAQhK,EAAGgK,MACXsB,EAAaP,EAASM,GACtBnF,EAAS+E,IACTM,EAAe,WACf,OAAOlC,EAAOnD,IAEdsF,EAAsB,EACtBC,EAAOL,EAAaC,GAAS,SAAU1D,EAAG/R,GAC1C,IAAI8V,GAAe,EACnB,OAAO/D,EAAE2C,MAAM,CACXd,SAAU,WACDkC,IACDA,GAAe,IACfF,IAC4BF,GAAY,EAAKjC,OAAOG,KAG5DQ,MAAOA,EACPX,OAAQ,SAAUvH,GACdqJ,EAAQjF,EAAQtQ,EAAMkM,GACtB,EAAKuH,OAAOkC,GAAc,GAAO,SAI7C,OAAOxV,OAAO4V,KAAKX,EAASS,IAAO3M,QAAO,SAAU8L,EAAKgB,GAErD,OADAhB,EAAIgB,GAAcV,EAAOO,EAAMG,GACxBhB,IACR,SAKXiB,GAAyBf,GAAM,CAC/BG,UAAW,WACP,MAAO,IAEXF,SAAU,SAAUU,GAChB,OAAO1V,OAAO4V,KAAKF,GAAMvL,QAE7B8K,SAAU,SAAUS,GAChB,OAAOA,EAAK1V,OAAO4V,KAAKF,GAAM,KAElCP,OAAQ,SAAUO,EAAMG,GACpB,OAAO,WAEH,IADA,IAAIxS,EAAO,GACF0O,EAAK,EAAGA,EAAK7N,UAAUiG,OAAQ4H,IACpC1O,EAAK0O,GAAM7N,UAAU6N,GAEzB,OAAO/R,OAAO4V,KAAKF,GAAM3M,QAAO,SAAUoH,EAAQ4F,GAC9C,IAAI9L,EAIJ,OAHIyL,EAAKK,GAASF,KACdxS,EAAK,SAA2BE,IAArBF,EAAK,GAAG0S,GAAyB5F,EAAO4F,GAAWL,EAAKK,GAASF,GAAYxS,EAAK,GAAG0S,IAAY5F,EAAO4F,IAAY9L,EAAKyL,EAAKK,IAAUF,GAAYrS,MAAMyG,EAAI5G,IAEtK8M,IACR,MAGXiF,QAAS,SAAUjF,EAAQtQ,EAAMkM,GAC7B,OAAOoE,EAAOtQ,GAAQkM,GAE1BsJ,aAAc,SAAUC,EAASU,GAC7B,OAAOhW,OAAO4V,KAAKN,GAASvM,QAAO,SAAU2M,EAAM7U,GAE/C,OADA6U,EAAK7U,GAAOmV,EAAQV,EAAQzU,GAAMA,GAC3B6U,IACR,OAIPO,GAAwBlB,GAAM,CAC9BG,UAAW,WACP,MAAO,IAEXF,SAAU,SAAUU,GAChB,OAAOA,EAAKvL,QAEhB8K,SAAU,SAAUS,GAChB,OAAOA,EAAK,IAEhBP,OAAQ,SAAUO,EAAMG,GACpB,OAAO,WAEH,IADA,IAAIxS,EAAO,GACF0O,EAAK,EAAGA,EAAK7N,UAAUiG,OAAQ4H,IACpC1O,EAAK0O,GAAM7N,UAAU6N,GAEzB,OAAO2D,EAAK7F,KAAI,SAAUqG,EAAK5W,GAC3B,GAAI4W,EAAIL,GACJ,OAAOtK,MAAM4K,QAAQ9S,EAAK,IAAM6S,EAAIL,GAAYxS,EAAK,GAAG/D,IAAM4W,EAAIL,GAAYrS,MAAM0S,EAAK7S,QAKzG+R,QAAS,SAAUjF,EAAQtQ,EAAMkM,GAC7B,OAAOoE,EAAOtQ,GAAQkM,GAE1BsJ,aAAc,SAAUC,EAASU,GAC7B,OAAOV,EAAQzF,KAAI,SAAUuG,EAAQ9W,GACjC,OAAO0W,EAAQI,EAAQ9W,SAI/B+W,GAAa,WAEb,IADA,IAAIf,EAAU,GACLvD,EAAK,EAAGA,EAAK7N,UAAUiG,OAAQ4H,IACpCuD,EAAQvD,GAAM7N,UAAU6N,GAE5B,OAAOkE,GAASX,IAqBhBgB,GAAY,CAACtJ,EAAID,EAASD,EAASG,EAAIC,GACvCqJ,GAAe,SAAUzG,GACzB,OAAOwG,GAAUnF,MAAK,SAAU7P,GAC5B,OAAOA,EAAKkE,KAAKsK,OAMrB0G,GAAe,SAAUJ,EAAQpD,GACjC,OAAOoD,EAAOpD,IAQdyD,GAAoB,SAAUL,EAAQpD,EAAO0D,GAC7C,IAAIC,EAAiBD,EAAW,GAC5BE,EAAa5D,EAAM2D,GAAgB9G,KAAI,SAAU9D,EAAGzM,GACpD,IAAIuX,EAAmBH,EAAW3N,OATnB,SAAUzJ,GAC7B,OAAO,SAAU0T,EAAOnS,GAEpB,OADAmS,EAAMnS,GAAOmS,EAAMnS,GAAKvB,GACjB0T,GAMkC8D,CAAiBxX,GAAIqM,EAAS,GAAIqH,IAC3E,OAAO+D,GAAiBhL,EAAjBgL,CAAoBX,EAAQS,MAEvC,OAAOR,GAAW7S,WAAM,EAAQoT,IAQhCI,GAAqB,SAAUZ,EAAQpD,EAAO0D,GAC9C,IAAIC,EAAiBD,EAAW,GAC5BO,EAAYjX,OAAO4V,KAAK5C,EAAM2D,IAAiB5N,QAAO,SAAU8G,EAAKhP,GACrE,IAAIgW,EAAmBH,EAAW3N,OATlB,SAAUlI,GAC9B,OAAO,SAAUmS,EAAO+C,GAEpB,OADA/C,EAAM+C,GAAW/C,EAAM+C,GAASlV,GACzBmS,GAMkCkE,CAAkBrW,GAAM8K,EAAS,GAAIqH,IAE9E,OADAnD,EAAIhP,GAAOkW,GAAiB/D,EAAM2D,GAAgB9V,GAAvCkW,CAA6CX,EAAQS,GACzDhH,IACR,IACH,OAAOiG,GAAUmB,IAEjBE,GAAmB,SAAUf,EAAQnM,GACrC,IAAIwG,EAAOxG,EAAGwG,KACVC,EAAKzG,EAAGyG,GACRsC,EAAQnH,EAAO5B,EAAI,CAAC,OAAQ,OAC5BmN,EAAWb,GAAa9F,IAAS8F,GAAa7F,GAC9ClE,EAAY4K,EAAS5K,UACrBF,EAAQ8K,EAAS9K,MACrB,OAAO8J,EAAOzK,EAAS,GAAIqH,EAAO,CAAEvC,KAAsB,iBAATA,EAAoBnE,EAAMmE,GAAQA,EAAMC,GAAkB,iBAAPA,EAAkBpE,EAAMoE,GAAMA,KAAOmB,KAAKrF,IAE9I6K,GAAoB,SAAUjB,EAAQnM,GACtC,IAAIwG,EAAOxG,EAAGwG,KACVC,EAAKzG,EAAGyG,GACRsC,EAAQnH,EAAO5B,EAAI,CAAC,OAAQ,OAChC,OAAOmM,EAAOzK,EAAS,GAAIqH,EAAO,CAAEvC,KAAM,EAAGC,GAAI,KAAMmB,KAAKT,GAASX,EAAMC,GAAKxB,GAAM1C,YAEtF8K,GAAsB,SAAUlB,EAAQnM,GACxC,IAAIwG,EAAOxG,EAAGwG,KACVC,EAAKzG,EAAGyG,GACRsC,EAAQnH,EAAO5B,EAAI,CAAC,OAAQ,OAC5BoI,EAAgBhD,GAA0BoB,GAE9C,OADU4B,EAAc5B,GAAUpB,GAA0BqB,EAA1BrB,CAA8BoB,GACzD2F,EAAOzK,EAAS,GAAIqH,EAAO,CAAEvC,KAAM,EAAGC,GAAI,KAAMmB,KAAKG,GAAS3C,GAAcoB,GAAOpB,GAAcqB,IAAM2B,IAE9GkF,GAAqB,SAAUnB,EAAQoB,GACvC,IAAIvN,EAnFgB,SAAUuN,GAC9B,IAAIC,EAAYzX,OAAO4V,KAAK4B,GACxBE,EAAe,SAAU5H,EAAMjP,GAC/B,YAAgB0C,IAATuM,IAAuB0H,EAAU3W,GAAKiP,IAajD,MAAO,CAAE6H,cAXW,SAAU3E,GAC1B,OAAOyE,EAAU1O,QAAO,SAAU2N,EAAY7V,GAE1C,OADI6W,EAAa1E,EAAMnS,GAAMA,IAAM6V,EAAWhM,KAAK7J,GAC5C6V,IACR,KAOgCkB,gBALjB,SAAU5E,GAC5B,OAAOA,GAASyE,EAAUI,MAAK,SAAUhX,GACrC,OAAO6W,EAAa1E,EAAMnS,GAAMA,QAsE/BiX,CAAkBN,GACvBI,EAAkB3N,EAAG2N,gBACrBD,EAAgB1N,EAAG0N,cASvB,OARmB,SAAU3E,GAEzB,IADe4E,EAAgB5E,GAChB,OAAOoD,EAAOpD,GAC7B,IAAI0D,EAAaiB,EAAc3E,GAE3B+E,EAAW/E,EADD0D,EAAW,IAEzB,OAAOK,GAAiBgB,EAAjBhB,CAA2BX,EAAQpD,EAAO0D,KAIrDK,GAAmB,SAAUjH,GAC7B,IAAIkI,EAAgBxB,GAcpB,MAboB,iBAAT1G,EACPkI,EAAgBxB,GACTjL,MAAM4K,QAAQrG,GACrBkI,EAAgBvB,IA7EP,SAAU3G,GACvB,OAAOmI,QAAQ1B,GAAazG,IA6EjBoI,CAAWpI,GAEXZ,GAAM1J,KAAKsK,GAClBkI,EAAgBX,GACThI,GAAaS,GACpBkI,EAAgBV,GACO,iBAATxH,IACdkI,EAAgBhB,IANhBgB,EAAgBb,GAQba,GAuFPG,GAA8BZ,IAlBnB,SAAUtN,GACrB,IAAIwE,EAAKxE,EAAGwG,KACRA,OAAc,IAAPhC,EAAgB,EAAIA,EAC3B2J,EAAKnO,EAAGyG,GACRA,OAAY,IAAP0H,EAAgB,EAAIA,EACzBC,EAAKpO,EAAGqO,KACRA,OAAc,IAAPD,EAAgB,GAASA,EACpC,OAAO,IAAO,SAAUpO,GACpB,IAAIqJ,EAASrJ,EAAGqJ,OAChB,MAAO,CACHiF,KAAM,SAAUC,GACZ,OAAOlF,EAAOkF,QAGvB3G,KAAKyG,GAAM,SAAUvM,GACpB,OAAO6E,GAAIH,EAAMC,EAAI3E,QAGkC,CAC3DuM,KAAM,SAAU5W,GACZ,MAAuB,mBAATA,GAElB+O,KAAMpE,EAAO7G,KACbkL,GAAIrE,EAAO7G,OAGX,GAA6B,GAAM,EAAG,GACtCiT,GAAQ,SAAUzF,GAIlB,YAHc,IAAVA,IACAA,EAAQ,IAEL,IAAO,SAAU/I,GACpB,IA4BIN,EA5BA2J,EAASrJ,EAAGqJ,OACZG,EAAWxJ,EAAGwJ,SACdhF,EAAKuE,EAAM0F,SACXA,OAAkB,IAAPjK,EAAgB,IAAMA,EACjC2J,EAAKpF,EAAMsF,KACXA,OAAc,IAAPF,EAAgB,GAAUA,EACjCC,EAAKrF,EAAM2F,KACXA,OAAc,IAAPN,EAAgB,EAAIA,EAC3BO,EAAK5F,EAAM6F,KACXA,OAAc,IAAPD,EAAgB,EAAIA,EAC3BE,EAAK9F,EAAM+F,KACXA,OAAc,IAAPD,EAAgB,EAAIA,EAC3BE,EAAKhG,EAAMvC,KACXA,OAAc,IAAPuI,EAAgB,EAAIA,EAC3BC,EAAKjG,EAAMtC,GACXA,OAAY,IAAPuI,EAAgB,EAAIA,EACzBC,EAAKlG,EAAMmG,QACXA,OAAiB,IAAPD,EAAgB,EAAIA,EAC9BE,EAAKpG,EAAMqG,cACXA,OAAuB,IAAPD,EAAgB,EAAIA,EACpCE,EAAKtG,EAAMuG,UACXA,OAAmB,IAAPD,EAAgB,EAAIA,EAChCE,EAAKxG,EAAMyG,UACXA,OAAmB,IAAPD,EAAgB,EAAIA,EAChCE,EAAK1G,EAAM2G,UACXA,OAAmB,IAAPD,EAAgB,EAAIA,EAChCE,EAAWzB,GAAe,CAAE1H,KAAMA,EAAMC,GAAIA,EAAI4H,KAAMA,IAAQ/D,MAAMjB,GACpEuG,EAAkB,EAElB9F,GAAW,EACX+F,EAAe,WACf,OAAOT,IAAkB,GAyBzBU,EAAc,WACdF,EAAkB,GAAcrJ,GAAS,EAAGkI,EAAUS,IACtDS,EAASrB,KAAKsB,IAEdG,EAAa,WACbjG,GAAW,EACXpK,EAAU,EAAK2J,QAAO,SAAUrJ,GAC5B,IAAI1B,EAAQ0B,EAAG1B,MACf4Q,GAAW5Q,EAAQ8Q,EACnBU,IAhCc,WAClB,IAAI9P,EACAuK,EAA+B,IAAlB6E,EAAsBtF,GAAYoF,GAAWT,EAAW3E,GAAYoF,GAAW,EAChG,IAAK3E,EAAY,OAAO,EACxB,GAAIA,IAAeqE,IAASF,IAASI,EAAM,OAAO,EAClD,IAAIkB,GAAc,EAgBlB,OAfIpB,GAAQc,EAAYd,GACpBM,EAAU,EACVQ,IACAM,GAAc,GACPtB,GAAQY,EAAYZ,GAC3BQ,EAAUT,EAAWS,EAErBS,EAAWzB,GAAe,CAAE1H,KADXA,GAAjBxG,EAAK,CAACyG,EAAID,IAAiB,GACaC,GADTA,EAAKzG,EAAG,GACSqO,KAAMA,IAAQ/D,MAAMjB,GACpEiG,IACAU,GAAc,GACPlB,GAAQU,EAAYV,IAC3Be,IACAL,IACAQ,GAAc,IAEVA,EAYAC,IAAqBzG,IACrB5I,EAAWyI,OAAO3J,GAClB,EAAK2J,OAAOG,GAAU,GAAO,OAElC,IAEH0G,EAAY,WACZpG,GAAW,EACPpK,GAASkB,EAAWyI,OAAO3J,IAGnC,OADAqQ,IACO,CACHjG,SAAU,WACN,OAAOA,GAEXqG,WAAY,WACR,OAAO,GAAM,EAAG1B,EAAUS,IAE9BkB,YAAa,WACT,OAAOR,GAEXnF,KAAM,WACFyF,KAEJG,MAAO,WAEH,OADAH,IACOhW,MAEXoW,OAAQ,WAEJ,OADKxG,GAAUiG,IACR7V,MAEXoU,KAAM,SAAUiC,GAGZ,OAFArB,EAAUvI,GAAI,EAAG8H,EAAU8B,GAC3B,EAAKlH,OAAOyG,GAAa,GAAO,GACzB5V,MAEXsW,QAAS,WAEL,OADAX,IACO3V,WAgUnBuW,GAAS,SAAUC,EAASC,EAAQhZ,GACpC,OAAO,IAAO,SAAUqI,GACpB,IAAIqJ,EAASrJ,EAAGqJ,OACZuH,EAAaD,EAAO/N,MAAM,KAAKgD,KAAI,SAAUiL,GAE7C,OADAH,EAAQI,iBAAiBD,EAAWxH,EAAQ1R,GACrCkZ,KAEX,MAAO,CACHpG,KAAM,WACF,OAAOmG,EAAW3P,SAAQ,SAAU4P,GAChC,OAAOH,EAAQK,oBAAoBF,EAAWxH,EAAQ1R,YAOtEqZ,GAAoB,WACpB,MAAO,CACHC,QAAS,EACTC,QAAS,EACTC,MAAO,EACPC,MAAO,EACPC,EAAG,EACHC,EAAG,IAGPC,GAAe,SAAU7W,EAAG8W,GAQ5B,YAPc,IAAVA,IACAA,EAXG,CACHP,QAAS,EACTC,QAAS,EACTC,MAAO,EACPC,MAAO,EACPC,EAAG,EACHC,EAAG,IAOPE,EAAMP,QAAUO,EAAMH,EAAI3W,EAAEuW,QAC5BO,EAAMN,QAAUM,EAAMF,EAAI5W,EAAEwW,QAC5BM,EAAML,MAAQzW,EAAEyW,MAChBK,EAAMJ,MAAQ1W,EAAE0W,MACTI,GAGPC,GAAS,CAAcT,MAE3B,GAAwB,oBAAbU,SAA0B,CAWjCjB,GAAOiB,SAAU,uBAAwB,CACrCC,SAAS,EACTC,SAAS,IACVtH,OAbwB,SAAUtK,GACjC,IAAI6R,EAAU7R,EAAG6R,SACD,EAChB,IAAIC,EAAaD,EAAQ3R,OACzBuR,GAAOvR,OAAS,EAChB,IAAK,IAAI7K,EAAI,EAAGA,EAAIyc,EAAYzc,IAAK,CACjC,IAAI0c,EAAYF,EAAQxc,GACxBoc,GAAOhR,KAAK8Q,GAAaQ,QAQrC,IAuDIP,GAAqBR,KAEzB,GAAwB,oBAAbU,SAA0B,CAKjCjB,GAAOiB,SAAU,uBAAuB,GAAMpH,OAJpB,SAAU5P,IAChB,EAChB6W,GAAa7W,EAAG8W,OCnqCxB,0CA2BA,IAAMQ,GAAmC,CACvCrU,aACAH,SACAE,YACAD,UACAN,SACAI,YACAD,UACAP,SACAG,YACAD,UACAgV,ORTW,SAAU9a,GACnB,OAAOA,IQWL+a,GAAc,gBAEdC,GAAU,SAACC,GACf,OAAKA,EACE9Q,MAAMrK,UAAUuE,MAAMhG,KAAK4c,GADb,IAOjBC,GAAiC,SACrCC,EACAC,GACuB,MACcA,EAAGC,wBAClCC,EAAO,CAAEC,IAFQ,EACfA,IACYC,KAFG,EACVA,KACaC,MAFH,EACJA,MACcC,OAFV,EACGA,QAU1B,OARAJ,EAAKC,KAAOJ,EAAuBI,IACnCD,EAAKE,MAAQL,EAAuBK,KAKpCF,EAAKC,IAAMpa,KAAKC,IAAIka,EAAKC,IAAK,GAC9BD,EAAKE,KAAOra,KAAKC,IAAIka,EAAKE,KAAM,GACzBF,GAIHK,GAAsB,SAC1BP,EAD0B,GAIjB,IAFPQ,EAEO,EAFPA,WAAYC,EAEL,EAFKA,WAAYC,EAEjB,EAFiBA,OAAQC,EAEzB,EAFyBA,OAEzB,yDADgC,GAAvC5S,EACO,EADPA,UAEI6S,EACW,IAAfJ,GAAmC,IAAfC,GAA+B,IAAXC,GAA2B,IAAXC,EACpDE,EAAU,WACdb,EAAGc,MAAM9Q,UAAY4Q,EACjB,GAD2B,qBAEbJ,EAFa,0BAEeC,EAFf,sBAEuCC,EAFvC,oBAEyDC,EAFzD,MAI7B5S,EACF8S,IAEA1S,EAAK4S,OAAOF,GAEd,IAAMG,EAAahB,EAAGiB,SAAS,GAC/B,GAAID,EAAY,CACd,IAAME,EAAa,WACjBF,EAAWF,MAAM9Q,UAAY4Q,EACzB,GADmC,iBAEzB,EAAIF,EAFqB,oBAEH,EAAIC,EAFD,MAIrC5S,EACFmT,IAEA/S,EAAK4S,OAAOG,KAMLC,GAAW,SACtBC,GAQG,6DADoB,GACpB,IANDlF,gBAMC,MANU,IAMV,MALDmF,eAKC,MALS,EAKT,MAJDpX,cAIC,MAJQ,YAIR,MAHDqX,eAGC,MAHS,aAGT,MAFDC,aAEC,MAFO,aAEP,EACH,IAAK9B,GAAgBxV,GACnB,MAAM,IAAIuX,MAAJ,UAAavX,EAAb,gCAGR,IAAIwX,GAA6B,EAE3BC,EAAoC,SAACxc,GACzCuc,GAAoB,EACpBvc,IACAmC,YAAW,WACToa,GAAoB,IACnB,IAICE,EAAyC,GAEzCC,EAAkB,SACtBC,GAEA,IAAM9B,EAAyBqB,EAAUnB,wBACzCL,GAAQiC,GAAUnT,SAAQ,SAAAsR,GACxB,GAAwC,mBAA7BA,EAAGC,sBAAd,CAGA,IAAKD,EAAG8B,QAAQnC,IAAc,CAC5B,IAAMoC,EAAQ,GAAH,OAAMhc,KAAKic,UACtBhC,EAAG8B,QAAQnC,IAAeoC,EAE5B,IAAME,EAAgBjC,EAAG8B,QAAQnC,IAE5BgC,EAAmBM,KACtBN,EAAmBM,GAAiB,IAGtC,IAAM/B,EAAOJ,GAA+BC,EAAwBC,GACpE2B,EAAmBM,GAAe/B,KAAOA,EACzCyB,EACEM,GACAlC,uBAAyBA,OAG/B6B,EAAgBR,EAAUH,UAE1B,IAAMiB,EAA0BC,KAAS,WACvC,IAAMC,EAAcjD,SAASkD,cAAc,QACrCC,EACJF,IAAgBA,EAAYG,SAASnB,GAClCA,IAAakB,GAChB5f,OAAO8b,oBAAoB,SAAU0D,GAEvCN,EAAgBR,EAAUH,YACzB,KACHve,OAAO6b,iBAAiB,SAAU2D,GAElC,IAAMM,EAA0BL,KAAS,WACvCP,EAAgBR,EAAUH,YACzB,IACHG,EAAU7C,iBAAiB,SAAUiE,GAErC,IAAMC,EAAmB,SACvBC,GAEA,GAAsB,uBAAlBA,EAAwC,CAQ1C,IANiCA,EAAcxL,QAC7C,SAAChU,GAAD,MACsB,UAApBA,EAAEyf,eACFzf,EAAE0f,WAAWjV,QACbzK,EAAE2f,aAAalV,UACjBA,OAEA,OAEF,GAAI8T,EAAmB,OAEzB,IAAM1B,EAAyBqB,EAAUnB,wBACnC6C,EAAmBlD,GAAQwB,EAAUH,UAE3C6B,EACG5L,QAAO,SAAA8I,GACN,IAAM+C,EACJpB,EAAmB3B,EAAG8B,QAAQnC,KAChC,GAAIoD,GAAgBA,EAAaC,UAG/B,OAFAD,EAAaC,mBACND,EAAaC,WACb,KAGVtU,SAAQ,SAAAsR,GACPA,EAAGc,MAAM9Q,UAAY,GACrB,IAAMgR,EAAahB,EAAGiB,SAAS,GAC3BD,IACFA,EAAWF,MAAM9Q,UAAY,OAGnC,IAAMiT,EAAuBH,EAC1BzP,KAAI,SAAA2M,GAAE,MAAK,CACVkD,YAAa,GACblD,KACAmD,mBAAoBrD,GAClBC,EACAC,OAGH9I,QAAO,YAAgC,IAA7B8I,EAA6B,EAA7BA,GAAImD,EAAyB,EAAzBA,mBACPJ,EACJpB,EAAmB3B,EAAG8B,QAAQnC,KAGhC,OAAKoD,EAIHI,EAAmBhD,MAAQ4C,EAAa7C,KAAKC,KAC7CgD,EAAmB/C,OAAS2C,EAAa7C,KAAKE,MAC9C+C,EAAmB9C,QAAU0C,EAAa7C,KAAKG,OAC/C8C,EAAmB7C,SAAWyC,EAAa7C,KAAKI,QANhDsB,EAAgB,CAAC5B,KACV,MAsBb,GARAiD,EAAqBvU,SAAQ,YAAY,IAATsR,EAAS,EAATA,GAC9B,GAAIJ,GAAQI,EAAGiB,UAAUtT,OAAS,EAChC,MAAM,IAAI6T,MACR,wFAKDyB,EAAqBtV,OAA1B,CAIA,IAAMyV,EAAmBH,EAAqB5P,KAAI,qBAAG2M,MACrD0B,GAAkC,kBAAMJ,EAAQ8B,MAEhD,IAAMC,EAA0C,GAEhDJ,EAEG5P,KAAI,SAAAiQ,GACH,IAAMtC,EAAasC,EAAKtD,GAAGiB,SAAS,GAQpC,OANID,IACFsC,EAAKJ,YAAcpD,GACjBC,EACAiB,IAGGsC,KAER5U,SACC,WAME5L,GACG,IALDkd,EAKC,EALDA,GAKC,IAJDmD,mBAAsBhD,EAIrB,EAJqBA,IAAKC,EAI1B,EAJ0BA,KAAMC,EAIhC,EAJgCA,MAAOC,EAIvC,EAJuCA,OAIvC,IAHD4C,YAAoBK,EAGnB,EAHcpD,IAAqBqD,EAGnC,EAH6BpD,KAI1BY,EAAahB,EAAGiB,SAAS,GACzB8B,EACJpB,EAAmB3B,EAAG8B,QAAQnC,KAC1B8D,EAAiB,CACrB/C,OAAQqC,EAAa7C,KAAKG,MAAQA,EAClCM,OAAQoC,EAAa7C,KAAKI,OAASA,EACnCE,WAAYuC,EAAa7C,KAAKE,KAAOA,EACrCK,WAAYsC,EAAa7C,KAAKC,IAAMA,GAGtCH,EAAGc,MAAM4C,gBAAkB,MACvB1C,GAAcwC,IAAcpD,GAAQmD,IAAapD,IACnDa,EAAWF,MAAM4C,gBAAkB,OAGrC,IAAIC,EAAgB,aAEdC,EAAoB,IAAIC,SAAQ,SAAAC,GACpCH,EAAgBG,KAGlBT,EAAmBnV,KAAK0V,GAExBrD,GAAoBP,EAAIyD,EAAQ,CAAE1V,WAAW,IAE7C,IAAMgW,EAAiB,WAAM,IACnB7L,EAAS+D,GAAM,CACrBhI,KAAMwP,EACNvP,GAAI,CAAEsM,WAAY,EAAGC,WAAY,EAAGC,OAAQ,EAAGC,OAAQ,GACvDzE,WACAJ,KAAM2D,GAAgBxV,KACrB8N,MAAM,CACPjB,OAAQ,SAACkN,GACPzD,GAAoBP,EAAIgE,GAExB7V,EAAK8V,YAAW,kBAAMrC,EAAgB,CAAC5B,QAEzC/I,SAAU0M,IAXJzL,KAaR6K,EAAaC,UAAY9K,GAG3B,GAAuB,iBAAZmJ,EACT0C,QACK,CACL,IAAMG,EAAY7c,YAAW,WAC3B8G,EAAK2I,OAAOiN,KACX1C,EAAUve,GACbigB,EAAaC,UAAY,kBAAMnb,aAAaqc,QAKpDL,QAAQM,IAAId,GAAoBe,MAAK,WACnC7C,EAAM6B,QAIJhM,EAAW,IAAIiN,iBAAiB5B,GACtCrL,EAASkN,QAAQlD,EAAW,CAC1BmD,WAAW,EACXC,YAAY,EACZC,SAAS,EACTC,gBAAiB,CAAC,WAEpB,IAAMC,EAAa,WACjBjiB,OAAO8b,oBAAoB,SAAU0D,GACrCd,EAAU5C,oBAAoB,SAAUgE,GACxCpL,EAASwN,cAELC,EAAqB,kBAAMpC,EAAiB,uBAClD,MAAO,CAAEkC,aAAYE","file":"main.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"animateCSSGrid\"] = factory();\n\telse\n\t\troot[\"animateCSSGrid\"] = factory();\n})(window, function() {\nreturn "," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 14);\n","/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return value != null && (type == 'object' || type == 'function');\n}\n\nmodule.exports = isObject;\n","var debounce = require('./debounce'),\n    isObject = require('./isObject');\n\n/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/**\n * Creates a throttled function that only invokes `func` at most once per\n * every `wait` milliseconds. The throttled function comes with a `cancel`\n * method to cancel delayed `func` invocations and a `flush` method to\n * immediately invoke them. Provide `options` to indicate whether `func`\n * should be invoked on the leading and/or trailing edge of the `wait`\n * timeout. The `func` is invoked with the last arguments provided to the\n * throttled function. Subsequent calls to the throttled function return the\n * result of the last `func` invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the throttled function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.throttle` and `_.debounce`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to throttle.\n * @param {number} [wait=0] The number of milliseconds to throttle invocations to.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=true]\n *  Specify invoking on the leading edge of the timeout.\n * @param {boolean} [options.trailing=true]\n *  Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new throttled function.\n * @example\n *\n * // Avoid excessively updating the position while scrolling.\n * jQuery(window).on('scroll', _.throttle(updatePosition, 100));\n *\n * // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes.\n * var throttled = _.throttle(renewToken, 300000, { 'trailing': false });\n * jQuery(element).on('click', throttled);\n *\n * // Cancel the trailing throttled invocation.\n * jQuery(window).on('popstate', throttled.cancel);\n */\nfunction throttle(func, wait, options) {\n  var leading = true,\n      trailing = true;\n\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  if (isObject(options)) {\n    leading = 'leading' in options ? !!options.leading : leading;\n    trailing = 'trailing' in options ? !!options.trailing : trailing;\n  }\n  return debounce(func, wait, {\n    'leading': leading,\n    'maxWait': wait,\n    'trailing': trailing\n  });\n}\n\nmodule.exports = throttle;\n","var freeGlobal = require('./_freeGlobal');\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\nmodule.exports = root;\n","var root = require('./_root');\n\n/** Built-in value references. */\nvar Symbol = root.Symbol;\n\nmodule.exports = Symbol;\n","var isObject = require('./isObject'),\n    now = require('./now'),\n    toNumber = require('./toNumber');\n\n/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max,\n    nativeMin = Math.min;\n\n/**\n * Creates a debounced function that delays invoking `func` until after `wait`\n * milliseconds have elapsed since the last time the debounced function was\n * invoked. The debounced function comes with a `cancel` method to cancel\n * delayed `func` invocations and a `flush` method to immediately invoke them.\n * Provide `options` to indicate whether `func` should be invoked on the\n * leading and/or trailing edge of the `wait` timeout. The `func` is invoked\n * with the last arguments provided to the debounced function. Subsequent\n * calls to the debounced function return the result of the last `func`\n * invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the debounced function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.debounce` and `_.throttle`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to debounce.\n * @param {number} [wait=0] The number of milliseconds to delay.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=false]\n *  Specify invoking on the leading edge of the timeout.\n * @param {number} [options.maxWait]\n *  The maximum time `func` is allowed to be delayed before it's invoked.\n * @param {boolean} [options.trailing=true]\n *  Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new debounced function.\n * @example\n *\n * // Avoid costly calculations while the window size is in flux.\n * jQuery(window).on('resize', _.debounce(calculateLayout, 150));\n *\n * // Invoke `sendMail` when clicked, debouncing subsequent calls.\n * jQuery(element).on('click', _.debounce(sendMail, 300, {\n *   'leading': true,\n *   'trailing': false\n * }));\n *\n * // Ensure `batchLog` is invoked once after 1 second of debounced calls.\n * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });\n * var source = new EventSource('/stream');\n * jQuery(source).on('message', debounced);\n *\n * // Cancel the trailing debounced invocation.\n * jQuery(window).on('popstate', debounced.cancel);\n */\nfunction debounce(func, wait, options) {\n  var lastArgs,\n      lastThis,\n      maxWait,\n      result,\n      timerId,\n      lastCallTime,\n      lastInvokeTime = 0,\n      leading = false,\n      maxing = false,\n      trailing = true;\n\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  wait = toNumber(wait) || 0;\n  if (isObject(options)) {\n    leading = !!options.leading;\n    maxing = 'maxWait' in options;\n    maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;\n    trailing = 'trailing' in options ? !!options.trailing : trailing;\n  }\n\n  function invokeFunc(time) {\n    var args = lastArgs,\n        thisArg = lastThis;\n\n    lastArgs = lastThis = undefined;\n    lastInvokeTime = time;\n    result = func.apply(thisArg, args);\n    return result;\n  }\n\n  function leadingEdge(time) {\n    // Reset any `maxWait` timer.\n    lastInvokeTime = time;\n    // Start the timer for the trailing edge.\n    timerId = setTimeout(timerExpired, wait);\n    // Invoke the leading edge.\n    return leading ? invokeFunc(time) : result;\n  }\n\n  function remainingWait(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime,\n        timeWaiting = wait - timeSinceLastCall;\n\n    return maxing\n      ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke)\n      : timeWaiting;\n  }\n\n  function shouldInvoke(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime;\n\n    // Either this is the first call, activity has stopped and we're at the\n    // trailing edge, the system time has gone backwards and we're treating\n    // it as the trailing edge, or we've hit the `maxWait` limit.\n    return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||\n      (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));\n  }\n\n  function timerExpired() {\n    var time = now();\n    if (shouldInvoke(time)) {\n      return trailingEdge(time);\n    }\n    // Restart the timer.\n    timerId = setTimeout(timerExpired, remainingWait(time));\n  }\n\n  function trailingEdge(time) {\n    timerId = undefined;\n\n    // Only invoke if we have `lastArgs` which means `func` has been\n    // debounced at least once.\n    if (trailing && lastArgs) {\n      return invokeFunc(time);\n    }\n    lastArgs = lastThis = undefined;\n    return result;\n  }\n\n  function cancel() {\n    if (timerId !== undefined) {\n      clearTimeout(timerId);\n    }\n    lastInvokeTime = 0;\n    lastArgs = lastCallTime = lastThis = timerId = undefined;\n  }\n\n  function flush() {\n    return timerId === undefined ? result : trailingEdge(now());\n  }\n\n  function debounced() {\n    var time = now(),\n        isInvoking = shouldInvoke(time);\n\n    lastArgs = arguments;\n    lastThis = this;\n    lastCallTime = time;\n\n    if (isInvoking) {\n      if (timerId === undefined) {\n        return leadingEdge(lastCallTime);\n      }\n      if (maxing) {\n        // Handle invocations in a tight loop.\n        clearTimeout(timerId);\n        timerId = setTimeout(timerExpired, wait);\n        return invokeFunc(lastCallTime);\n      }\n    }\n    if (timerId === undefined) {\n      timerId = setTimeout(timerExpired, wait);\n    }\n    return result;\n  }\n  debounced.cancel = cancel;\n  debounced.flush = flush;\n  return debounced;\n}\n\nmodule.exports = debounce;\n","var root = require('./_root');\n\n/**\n * Gets the timestamp of the number of milliseconds that have elapsed since\n * the Unix epoch (1 January 1970 00:00:00 UTC).\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Date\n * @returns {number} Returns the timestamp.\n * @example\n *\n * _.defer(function(stamp) {\n *   console.log(_.now() - stamp);\n * }, _.now());\n * // => Logs the number of milliseconds it took for the deferred invocation.\n */\nvar now = function() {\n  return root.Date.now();\n};\n\nmodule.exports = now;\n","/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\nmodule.exports = freeGlobal;\n","var g;\n\n// This works in non-strict mode\ng = (function() {\n\treturn this;\n})();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || new Function(\"return this\")();\n} catch (e) {\n\t// This works if the window reference is available\n\tif (typeof window === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n","var isObject = require('./isObject'),\n    isSymbol = require('./isSymbol');\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** Used to match leading and trailing whitespace. */\nvar reTrim = /^\\s+|\\s+$/g;\n\n/** Used to detect bad signed hexadecimal string values. */\nvar reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n/** Used to detect binary string values. */\nvar reIsBinary = /^0b[01]+$/i;\n\n/** Used to detect octal string values. */\nvar reIsOctal = /^0o[0-7]+$/i;\n\n/** Built-in method references without a dependency on `root`. */\nvar freeParseInt = parseInt;\n\n/**\n * Converts `value` to a number.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n * @example\n *\n * _.toNumber(3.2);\n * // => 3.2\n *\n * _.toNumber(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toNumber(Infinity);\n * // => Infinity\n *\n * _.toNumber('3.2');\n * // => 3.2\n */\nfunction toNumber(value) {\n  if (typeof value == 'number') {\n    return value;\n  }\n  if (isSymbol(value)) {\n    return NAN;\n  }\n  if (isObject(value)) {\n    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n    value = isObject(other) ? (other + '') : other;\n  }\n  if (typeof value != 'string') {\n    return value === 0 ? value : +value;\n  }\n  value = value.replace(reTrim, '');\n  var isBinary = reIsBinary.test(value);\n  return (isBinary || reIsOctal.test(value))\n    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n    : (reIsBadHex.test(value) ? NAN : +value);\n}\n\nmodule.exports = toNumber;\n","var baseGetTag = require('./_baseGetTag'),\n    isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar symbolTag = '[object Symbol]';\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n  return typeof value == 'symbol' ||\n    (isObjectLike(value) && baseGetTag(value) == symbolTag);\n}\n\nmodule.exports = isSymbol;\n","var Symbol = require('./_Symbol'),\n    getRawTag = require('./_getRawTag'),\n    objectToString = require('./_objectToString');\n\n/** `Object#toString` result references. */\nvar nullTag = '[object Null]',\n    undefinedTag = '[object Undefined]';\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n  if (value == null) {\n    return value === undefined ? undefinedTag : nullTag;\n  }\n  return (symToStringTag && symToStringTag in Object(value))\n    ? getRawTag(value)\n    : objectToString(value);\n}\n\nmodule.exports = baseGetTag;\n","var Symbol = require('./_Symbol');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\nfunction getRawTag(value) {\n  var isOwn = hasOwnProperty.call(value, symToStringTag),\n      tag = value[symToStringTag];\n\n  try {\n    value[symToStringTag] = undefined;\n    var unmasked = true;\n  } catch (e) {}\n\n  var result = nativeObjectToString.call(value);\n  if (unmasked) {\n    if (isOwn) {\n      value[symToStringTag] = tag;\n    } else {\n      delete value[symToStringTag];\n    }\n  }\n  return result;\n}\n\nmodule.exports = getRawTag;\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\nfunction objectToString(value) {\n  return nativeObjectToString.call(value);\n}\n\nmodule.exports = objectToString;\n","/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return value != null && typeof value == 'object';\n}\n\nmodule.exports = isObjectLike;\n","var DEFAULT_OVERSHOOT_STRENGTH = 1.525;\nvar reversed = function (easing) {\n    return function (p) {\n        return 1 - easing(1 - p);\n    };\n};\nvar mirrored = function (easing) {\n    return function (p) {\n        return p <= 0.5 ? easing(2 * p) / 2 : (2 - easing(2 * (1 - p))) / 2;\n    };\n};\nvar createReversedEasing = reversed;\nvar createMirroredEasing = mirrored;\nvar createExpoIn = function (power) {\n    return function (p) {\n        return Math.pow(p, power);\n    };\n};\nvar createBackIn = function (power) {\n    return function (p) {\n        return p * p * ((power + 1) * p - power);\n    };\n};\nvar createAnticipateEasing = function (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};\nvar linear = function (p) {\n    return p;\n};\nvar easeIn = /*#__PURE__*/createExpoIn(2);\nvar easeOut = /*#__PURE__*/reversed(easeIn);\nvar easeInOut = /*#__PURE__*/mirrored(easeIn);\nvar circIn = function (p) {\n    return 1 - Math.sin(Math.acos(p));\n};\nvar circOut = /*#__PURE__*/reversed(circIn);\nvar circInOut = /*#__PURE__*/mirrored(circOut);\nvar backIn = /*#__PURE__*/createBackIn(DEFAULT_OVERSHOOT_STRENGTH);\nvar backOut = /*#__PURE__*/reversed(backIn);\nvar backInOut = /*#__PURE__*/mirrored(backIn);\nvar anticipate = /*#__PURE__*/createAnticipateEasing(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;\nvar bounceOut = function (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};\nvar bounceIn = function (p) {\n    return 1.0 - bounceOut(1.0 - p);\n};\nvar bounceInOut = function (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};\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';\nvar a = function (a1, a2) {\n    return 1.0 - 3.0 * a2 + 3.0 * a1;\n};\nvar b = function (a1, a2) {\n    return 3.0 * a2 - 6.0 * a1;\n};\nvar c = function (a1) {\n    return 3.0 * a1;\n};\nvar getSlope = function (t, a1, a2) {\n    return 3.0 * a(a1, a2) * t * t + 2.0 * b(a1, a2) * t + c(a1);\n};\nvar calcBezier = function (t, a1, a2) {\n    return ((a(a1, a2) * t + b(a1, a2)) * t + c(a1)) * t;\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    var binarySubdivide = function (aX, aA, aB) {\n        var i = 0;\n        var currentX;\n        var currentT;\n        do {\n            currentT = aA + (aB - aA) / 2.0;\n            currentX = calcBezier(currentT, mX1, mX2) - aX;\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        return currentT;\n    };\n    var newtonRaphsonIterate = function (aX, aGuessT) {\n        var i = 0;\n        var currentSlope = 0;\n        var currentX;\n        for (; i < NEWTON_ITERATIONS; ++i) {\n            currentSlope = getSlope(aGuessT, mX1, mX2);\n            if (currentSlope === 0.0) {\n                return aGuessT;\n            }\n            currentX = calcBezier(aGuessT, mX1, mX2) - aX;\n            aGuessT -= currentX / currentSlope;\n        }\n        return aGuessT;\n    };\n    var calcSampleValues = function () {\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    var getTForX = function (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        for (; currentSample !== lastSample && sampleValues[currentSample] <= aX; ++currentSample) {\n            intervalStart += K_SAMPLE_STEP_SIZE;\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        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    calcSampleValues();\n    var resolver = function (aX) {\n        var returnValue;\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        return returnValue;\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 };\n","import { invariant } from 'hey-listen';\n\nvar prevTime = 0;\r\nvar onNextFrame = typeof window !== 'undefined' && window.requestAnimationFrame !== undefined\r\n    ? function (callback) { return window.requestAnimationFrame(callback); }\r\n    : function (callback) {\r\n        var timestamp = Date.now();\r\n        var timeToCall = Math.max(0, 16.7 - (timestamp - prevTime));\r\n        prevTime = timestamp + timeToCall;\r\n        setTimeout(function () { return callback(prevTime); }, timeToCall);\r\n    };\n\nvar createStep = (function (setRunNextFrame) {\r\n    var processToRun = [];\r\n    var processToRunNextFrame = [];\r\n    var numThisFrame = 0;\r\n    var isProcessing = false;\r\n    var i = 0;\r\n    var cancelled = new WeakSet();\r\n    var toKeepAlive = new WeakSet();\r\n    var renderStep = {\r\n        cancel: function (process) {\r\n            var indexOfCallback = processToRunNextFrame.indexOf(process);\r\n            cancelled.add(process);\r\n            if (indexOfCallback !== -1) {\r\n                processToRunNextFrame.splice(indexOfCallback, 1);\r\n            }\r\n        },\r\n        process: function (frame) {\r\n            var _a;\r\n            isProcessing = true;\r\n            _a = [\r\n                processToRunNextFrame,\r\n                processToRun\r\n            ], processToRun = _a[0], processToRunNextFrame = _a[1];\r\n            processToRunNextFrame.length = 0;\r\n            numThisFrame = processToRun.length;\r\n            if (numThisFrame) {\r\n                var process_1;\r\n                for (i = 0; i < numThisFrame; i++) {\r\n                    process_1 = processToRun[i];\r\n                    process_1(frame);\r\n                    if (toKeepAlive.has(process_1) === true && !cancelled.has(process_1)) {\r\n                        renderStep.schedule(process_1);\r\n                        setRunNextFrame(true);\r\n                    }\r\n                }\r\n            }\r\n            isProcessing = false;\r\n        },\r\n        schedule: function (process, keepAlive, immediate) {\r\n            invariant(typeof process === 'function', 'Argument must be a function');\r\n            var addToCurrentBuffer = immediate && isProcessing;\r\n            var buffer = addToCurrentBuffer ? processToRun : processToRunNextFrame;\r\n            if (keepAlive)\r\n                toKeepAlive.add(process);\r\n            if (buffer.indexOf(process) === -1) {\r\n                buffer.push(process);\r\n                if (addToCurrentBuffer)\r\n                    numThisFrame = processToRun.length;\r\n            }\r\n        }\r\n    };\r\n    return renderStep;\r\n});\n\nvar StepId;\r\n(function (StepId) {\r\n    StepId[\"Read\"] = \"read\";\r\n    StepId[\"Update\"] = \"update\";\r\n    StepId[\"Render\"] = \"render\";\r\n    StepId[\"PostRender\"] = \"postRender\";\r\n    StepId[\"FixedUpdate\"] = \"fixedUpdate\";\r\n})(StepId || (StepId = {}));\n\nvar maxElapsed = 40;\r\nvar defaultElapsed = (1 / 60) * 1000;\r\nvar useDefaultElapsed = true;\r\nvar willRunNextFrame = false;\r\nvar isProcessing = false;\r\nvar frame = {\r\n    delta: 0,\r\n    timestamp: 0\r\n};\r\nvar stepsOrder = [\r\n    StepId.Read,\r\n    StepId.Update,\r\n    StepId.Render,\r\n    StepId.PostRender\r\n];\r\nvar setWillRunNextFrame = function (willRun) { return (willRunNextFrame = willRun); };\r\nvar _a = stepsOrder.reduce(function (acc, key) {\r\n    var step = createStep(setWillRunNextFrame);\r\n    acc.sync[key] = function (process, keepAlive, immediate) {\r\n        if (keepAlive === void 0) { keepAlive = false; }\r\n        if (immediate === void 0) { immediate = false; }\r\n        if (!willRunNextFrame)\r\n            startLoop();\r\n        step.schedule(process, keepAlive, immediate);\r\n        return process;\r\n    };\r\n    acc.cancelSync[key] = function (process) { return step.cancel(process); };\r\n    acc.steps[key] = step;\r\n    return acc;\r\n}, {\r\n    steps: {},\r\n    sync: {},\r\n    cancelSync: {}\r\n}), steps = _a.steps, sync = _a.sync, cancelSync = _a.cancelSync;\r\nvar processStep = function (stepId) { return steps[stepId].process(frame); };\r\nvar processFrame = function (timestamp) {\r\n    willRunNextFrame = false;\r\n    frame.delta = useDefaultElapsed\r\n        ? defaultElapsed\r\n        : Math.max(Math.min(timestamp - frame.timestamp, maxElapsed), 1);\r\n    if (!useDefaultElapsed)\r\n        defaultElapsed = frame.delta;\r\n    frame.timestamp = timestamp;\r\n    isProcessing = true;\r\n    stepsOrder.forEach(processStep);\r\n    isProcessing = false;\r\n    if (willRunNextFrame) {\r\n        useDefaultElapsed = false;\r\n        onNextFrame(processFrame);\r\n    }\r\n};\r\nvar startLoop = function () {\r\n    willRunNextFrame = true;\r\n    useDefaultElapsed = true;\r\n    if (!isProcessing)\r\n        onNextFrame(processFrame);\r\n};\r\nvar getFrameData = function () { return frame; };\n\nexport default sync;\nexport { cancelSync, getFrameData };\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***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0)\r\n            t[p[i]] = s[p[i]];\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\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;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator], i = 0;\r\n    if (m) return m.call(o);\r\n    return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\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 () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\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***************************************************************************** */\r\n\r\nvar __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    };\r\n    return __assign.apply(this, arguments);\r\n};\n\nvar clamp = function (min, max) { return function (v) {\r\n    return Math.max(Math.min(v, max), min);\r\n}; };\r\nvar isFirstChars = function (term) { return function (v) {\r\n    return typeof v === 'string' && v.indexOf(term) === 0;\r\n}; };\r\nvar getValueFromFunctionString = function (value) {\r\n    return value.substring(value.indexOf('(') + 1, value.lastIndexOf(')'));\r\n};\r\nvar splitCommaDelimited = function (value) {\r\n    return typeof value === 'string' ? value.split(/,\\s*/) : [value];\r\n};\r\nvar sanitize = function (v) { return (v % 1 ? Number(v.toFixed(5)) : v); };\n\nvar number = {\r\n    test: function (v) { return typeof v === 'number'; },\r\n    parse: parseFloat,\r\n    transform: function (v) { return v; }\r\n};\r\nvar alpha = __assign({}, number, { transform: clamp(0, 1) });\r\nvar scale = __assign({}, number, { default: 1 });\n\nvar createUnitType = function (unit) { return ({\r\n    test: function (v) {\r\n        return typeof v === 'string' && v.endsWith(unit) && v.split(' ').length === 1;\r\n    },\r\n    parse: parseFloat,\r\n    transform: function (v) { return \"\" + v + unit; }\r\n}); };\r\nvar degrees = createUnitType('deg');\r\nvar percent = createUnitType('%');\r\nvar px = createUnitType('px');\r\nvar vh = createUnitType('vh');\r\nvar vw = createUnitType('vw');\n\nvar clampRgbUnit = clamp(0, 255);\r\nvar onlyColorRegex = /^(#[0-9a-f]{3}|#(?:[0-9a-f]{2}){2,4}|(rgb|hsl)a?\\((-?\\d+%?[,\\s]+){2,3}\\s*[\\d\\.]+%?\\))$/i;\r\nvar isRgba = function (v) { return v.red !== undefined; };\r\nvar isHsla = function (v) { return v.hue !== undefined; };\r\nvar splitColorValues = function (terms) {\r\n    var numTerms = terms.length;\r\n    return function (v) {\r\n        if (typeof v !== 'string')\r\n            return v;\r\n        var values = {};\r\n        var valuesArray = splitCommaDelimited(getValueFromFunctionString(v));\r\n        for (var i = 0; i < numTerms; i++) {\r\n            values[terms[i]] =\r\n                valuesArray[i] !== undefined ? parseFloat(valuesArray[i]) : 1;\r\n        }\r\n        return values;\r\n    };\r\n};\r\nvar rgbaTemplate = function (_a) {\r\n    var red = _a.red, green = _a.green, blue = _a.blue, _b = _a.alpha, alpha$$1 = _b === void 0 ? 1 : _b;\r\n    return \"rgba(\" + red + \", \" + green + \", \" + blue + \", \" + alpha$$1 + \")\";\r\n};\r\nvar hslaTemplate = function (_a) {\r\n    var hue = _a.hue, saturation = _a.saturation, lightness = _a.lightness, _b = _a.alpha, alpha$$1 = _b === void 0 ? 1 : _b;\r\n    return \"hsla(\" + hue + \", \" + saturation + \", \" + lightness + \", \" + alpha$$1 + \")\";\r\n};\r\nvar rgbUnit = __assign({}, number, { transform: function (v) { return Math.round(clampRgbUnit(v)); } });\r\nvar testRgbaString = isFirstChars('rgb');\r\nvar rgba = {\r\n    test: function (v) { return (typeof v === 'string' ? testRgbaString(v) : isRgba(v)); },\r\n    parse: splitColorValues(['red', 'green', 'blue', 'alpha']),\r\n    transform: function (_a) {\r\n        var red = _a.red, green = _a.green, blue = _a.blue, alpha$$1 = _a.alpha;\r\n        return rgbaTemplate({\r\n            red: rgbUnit.transform(red),\r\n            green: rgbUnit.transform(green),\r\n            blue: rgbUnit.transform(blue),\r\n            alpha: sanitize(alpha$$1)\r\n        });\r\n    }\r\n};\r\nvar testHslaString = isFirstChars('hsl');\r\nvar hsla = {\r\n    test: function (v) { return (typeof v === 'string' ? testHslaString(v) : isHsla(v)); },\r\n    parse: splitColorValues(['hue', 'saturation', 'lightness', 'alpha']),\r\n    transform: function (_a) {\r\n        var hue = _a.hue, saturation = _a.saturation, lightness = _a.lightness, alpha$$1 = _a.alpha;\r\n        return hslaTemplate({\r\n            hue: Math.round(hue),\r\n            saturation: percent.transform(sanitize(saturation)),\r\n            lightness: percent.transform(sanitize(lightness)),\r\n            alpha: sanitize(alpha$$1)\r\n        });\r\n    }\r\n};\r\nvar hex = __assign({}, rgba, { test: isFirstChars('#'), parse: function (v) {\r\n        var r = '';\r\n        var g = '';\r\n        var b = '';\r\n        if (v.length > 4) {\r\n            r = v.substr(1, 2);\r\n            g = v.substr(3, 2);\r\n            b = v.substr(5, 2);\r\n        }\r\n        else {\r\n            r = v.substr(1, 1);\r\n            g = v.substr(2, 1);\r\n            b = v.substr(3, 1);\r\n            r += r;\r\n            g += g;\r\n            b += b;\r\n        }\r\n        return {\r\n            red: parseInt(r, 16),\r\n            green: parseInt(g, 16),\r\n            blue: parseInt(b, 16),\r\n            alpha: 1\r\n        };\r\n    } });\r\nvar color = {\r\n    test: function (v) {\r\n        return (typeof v === 'string' && onlyColorRegex.test(v)) ||\r\n            rgba.test(v) ||\r\n            hsla.test(v) ||\r\n            hex.test(v);\r\n    },\r\n    parse: function (v) {\r\n        if (rgba.test(v)) {\r\n            return rgba.parse(v);\r\n        }\r\n        else if (hsla.test(v)) {\r\n            return hsla.parse(v);\r\n        }\r\n        else if (hex.test(v)) {\r\n            return hex.parse(v);\r\n        }\r\n        return v;\r\n    },\r\n    transform: function (v) {\r\n        if (isRgba(v)) {\r\n            return rgba.transform(v);\r\n        }\r\n        else if (isHsla(v)) {\r\n            return hsla.transform(v);\r\n        }\r\n        return v;\r\n    }\r\n};\n\nvar floatRegex = /(-)?(\\d[\\d\\.]*)/g;\r\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;\r\nvar COLOR_TOKEN = '${c}';\r\nvar NUMBER_TOKEN = '${n}';\r\nvar complex = {\r\n    test: function (v) {\r\n        if (typeof v !== 'string' || !isNaN(v))\r\n            return false;\r\n        var numValues = 0;\r\n        var foundNumbers = v.match(floatRegex);\r\n        var foundColors = v.match(colorRegex);\r\n        if (foundNumbers)\r\n            numValues += foundNumbers.length;\r\n        if (foundColors)\r\n            numValues += foundColors.length;\r\n        return numValues > 0;\r\n    },\r\n    parse: function (v) {\r\n        var input = v;\r\n        var parsed = [];\r\n        var foundColors = input.match(colorRegex);\r\n        if (foundColors) {\r\n            input = input.replace(colorRegex, COLOR_TOKEN);\r\n            parsed.push.apply(parsed, foundColors.map(color.parse));\r\n        }\r\n        var foundNumbers = input.match(floatRegex);\r\n        if (foundNumbers) {\r\n            parsed.push.apply(parsed, foundNumbers.map(number.parse));\r\n        }\r\n        return parsed;\r\n    },\r\n    createTransformer: function (prop) {\r\n        var template = prop;\r\n        var token = 0;\r\n        var foundColors = prop.match(colorRegex);\r\n        var numColors = foundColors ? foundColors.length : 0;\r\n        if (foundColors) {\r\n            for (var i = 0; i < numColors; i++) {\r\n                template = template.replace(foundColors[i], COLOR_TOKEN);\r\n                token++;\r\n            }\r\n        }\r\n        var foundNumbers = template.match(floatRegex);\r\n        var numNumbers = foundNumbers ? foundNumbers.length : 0;\r\n        if (foundNumbers) {\r\n            for (var i = 0; i < numNumbers; i++) {\r\n                template = template.replace(foundNumbers[i], NUMBER_TOKEN);\r\n                token++;\r\n            }\r\n        }\r\n        return function (v) {\r\n            var output = template;\r\n            for (var i = 0; i < token; i++) {\r\n                output = output.replace(i < numColors ? COLOR_TOKEN : NUMBER_TOKEN, i < numColors ? color.transform(v[i]) : sanitize(v[i]));\r\n            }\r\n            return output;\r\n        };\r\n    }\r\n};\n\nexport { number, scale, alpha, degrees, percent, px, vw, vh, rgba, rgbUnit, hex, hsla, color, complex };\n","import { 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';\n\nvar zeroPoint = {\r\n    x: 0,\r\n    y: 0,\r\n    z: 0\r\n};\r\nvar isNum = function (v) { return typeof v === 'number'; };\n\nvar radiansToDegrees = (function (radians) { return (radians * 180) / Math.PI; });\n\nvar angle = (function (a, b) {\r\n    if (b === void 0) { b = zeroPoint; }\r\n    return radiansToDegrees(Math.atan2(b.y - a.y, b.x - a.x));\r\n});\n\nvar applyOffset = (function (from, to) {\r\n    var hasReceivedFrom = true;\r\n    if (to === undefined) {\r\n        to = from;\r\n        hasReceivedFrom = false;\r\n    }\r\n    return function (v) {\r\n        if (hasReceivedFrom) {\r\n            return v - from + to;\r\n        }\r\n        else {\r\n            from = v;\r\n            hasReceivedFrom = true;\r\n            return to;\r\n        }\r\n    };\r\n});\n\nvar curryRange = (function (func) { return function (min, max, v) { return (v !== undefined ? func(min, max, v) : function (cv) { return func(min, max, cv); }); }; });\n\nvar clamp = function (min, max, v) {\r\n    return Math.min(Math.max(v, min), max);\r\n};\r\nvar clamp$1 = curryRange(clamp);\n\nvar conditional = (function (check, apply) { return function (v) {\r\n    return check(v) ? apply(v) : v;\r\n}; });\n\nvar degreesToRadians = (function (degrees) { return (degrees * Math.PI) / 180; });\n\nvar isPoint = (function (point) {\r\n    return point.hasOwnProperty('x') && point.hasOwnProperty('y');\r\n});\n\nvar isPoint3D = (function (point) {\r\n    return isPoint(point) && point.hasOwnProperty('z');\r\n});\n\nvar distance1D = function (a, b) { return Math.abs(a - b); };\r\nvar distance = (function (a, b) {\r\n    if (b === void 0) { b = zeroPoint; }\r\n    if (isNum(a) && isNum(b)) {\r\n        return distance1D(a, b);\r\n    }\r\n    else if (isPoint(a) && isPoint(b)) {\r\n        var xDelta = distance1D(a.x, b.x);\r\n        var yDelta = distance1D(a.y, b.y);\r\n        var zDelta = isPoint3D(a) && isPoint3D(b) ? distance1D(a.z, b.z) : 0;\r\n        return Math.sqrt(Math.pow(xDelta, 2) + Math.pow(yDelta, 2) + Math.pow(zDelta, 2));\r\n    }\r\n    return 0;\r\n});\n\nvar progress = (function (from, to, value) {\r\n    var toFromDifference = to - from;\r\n    return toFromDifference === 0 ? 1 : (value - from) / toFromDifference;\r\n});\n\nvar mix = (function (from, to, progress) {\r\n    return -progress * from + progress * to + from;\r\n});\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***************************************************************************** */\r\n\r\nvar __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    };\r\n    return __assign.apply(this, arguments);\r\n};\n\nvar mixLinearColor = function (from, to, v) {\r\n    var fromExpo = from * from;\r\n    var toExpo = to * to;\r\n    return Math.sqrt(v * (toExpo - fromExpo) + fromExpo);\r\n};\r\nvar colorTypes = [hex, rgba, hsla];\r\nvar getColorType = function (v) {\r\n    return colorTypes.find(function (type) { return type.test(v); });\r\n};\r\nvar mixColor = (function (from, to) {\r\n    var fromColorType = getColorType(from);\r\n    var toColorType = getColorType(to);\r\n    invariant(fromColorType.transform === toColorType.transform, 'Both colors must be Hex and/or RGBA, or both must be HSLA');\r\n    var fromColor = fromColorType.parse(from);\r\n    var toColor = toColorType.parse(to);\r\n    var blended = __assign({}, fromColor);\r\n    var mixFunc = fromColorType === hsla ? mix : mixLinearColor;\r\n    return function (v) {\r\n        for (var key in blended) {\r\n            if (key !== 'alpha') {\r\n                blended[key] = mixFunc(fromColor[key], toColor[key], v);\r\n            }\r\n        }\r\n        blended.alpha = mix(fromColor.alpha, toColor.alpha, v);\r\n        return fromColorType.transform(blended);\r\n    };\r\n});\n\nvar combineFunctions = function (a, b) { return function (v) { return b(a(v)); }; };\r\nvar pipe = (function () {\r\n    var transformers = [];\r\n    for (var _i = 0; _i < arguments.length; _i++) {\r\n        transformers[_i] = arguments[_i];\r\n    }\r\n    return transformers.reduce(combineFunctions);\r\n});\n\nvar mixArray = function (from, to) {\r\n    var output = from.slice();\r\n    var numValues = output.length;\r\n    var blendValue = from.map(function (fromThis, i) {\r\n        var toThis = to[i];\r\n        if (isNum(fromThis)) {\r\n            return function (v) { return mix(fromThis, toThis, v); };\r\n        }\r\n        else if (color.test(fromThis)) {\r\n            return mixColor(fromThis, toThis);\r\n        }\r\n        else {\r\n            return mixComplex(fromThis, toThis);\r\n        }\r\n    });\r\n    return function (v) {\r\n        for (var i = 0; i < numValues; i++) {\r\n            output[i] = blendValue[i](v);\r\n        }\r\n        return output;\r\n    };\r\n};\r\nvar mixComplex = function (from, to) {\r\n    var valueTemplate = complex.createTransformer(from);\r\n    invariant(valueTemplate(from) === complex.createTransformer(to)(from), \"Values '\" + from + \"' and '\" + to + \"' are of different format, or a value might have changed value type.\");\r\n    return pipe(mixArray(complex.parse(from), complex.parse(to)), valueTemplate);\r\n};\n\nvar mixNumber = curryRange(mix);\r\nvar getMixer = function (v) {\r\n    return typeof v === 'number'\r\n        ? mixNumber\r\n        : color.test(v)\r\n            ? mixColor\r\n            : mixComplex;\r\n};\r\nvar createMixers = function (output, ease) {\r\n    return Array(output.length - 1)\r\n        .fill(getMixer(output[0]))\r\n        .map(function (factory, i) {\r\n        var mixer = factory(output[i], output[i + 1]);\r\n        if (ease) {\r\n            var easingFunction = Array.isArray(ease) ? ease[i] : ease;\r\n            return pipe(easingFunction, mixer);\r\n        }\r\n        else {\r\n            return mixer;\r\n        }\r\n    });\r\n};\r\nvar fastInterpolate = function (_a, _b) {\r\n    var from = _a[0], to = _a[1];\r\n    var mixer = _b[0];\r\n    return function (v) { return mixer(progress(from, to, v)); };\r\n};\r\nvar slowInterpolate = function (input, mixers) {\r\n    var inputLength = input.length;\r\n    var lastInputIndex = inputLength - 1;\r\n    return function (v) {\r\n        var mixerIndex = 0;\r\n        var foundMixerIndex = false;\r\n        if (v <= input[0]) {\r\n            foundMixerIndex = true;\r\n        }\r\n        else if (v >= input[lastInputIndex]) {\r\n            mixerIndex = lastInputIndex - 1;\r\n            foundMixerIndex = true;\r\n        }\r\n        if (!foundMixerIndex) {\r\n            var i = 1;\r\n            for (; i < inputLength; i++) {\r\n                if (input[i] > v || i === lastInputIndex) {\r\n                    break;\r\n                }\r\n            }\r\n            mixerIndex = i - 1;\r\n        }\r\n        var progressInRange = progress(input[mixerIndex], input[mixerIndex + 1], v);\r\n        return mixers[mixerIndex](progressInRange);\r\n    };\r\n};\r\nvar interpolate = (function (input, output, _a) {\r\n    var _b = _a === void 0 ? {} : _a, _c = _b.clamp, clamp = _c === void 0 ? true : _c, ease = _b.ease;\r\n    var inputLength = input.length;\r\n    invariant(inputLength === output.length, 'Both input and output ranges must be the same length');\r\n    invariant(!ease || !Array.isArray(ease) || ease.length === input.length - 1, 'Array of easing functions must be of length `input.length - 1`, as it applies to the transitions **between** the defined values.');\r\n    if (input[0] > input[inputLength - 1]) {\r\n        input = input.slice();\r\n        output = output.slice();\r\n        input.reverse();\r\n        output.reverse();\r\n    }\r\n    var mixers = createMixers(output, ease);\r\n    var interpolate = inputLength === 2\r\n        ? fastInterpolate(input, mixers)\r\n        : slowInterpolate(input, mixers);\r\n    return clamp\r\n        ? pipe(clamp$1(input[0], input[inputLength - 1]), interpolate)\r\n        : interpolate;\r\n});\n\nvar pointFromVector = (function (origin, angle, distance) {\r\n    angle = degreesToRadians(angle);\r\n    return {\r\n        x: distance * Math.cos(angle) + origin.x,\r\n        y: distance * Math.sin(angle) + origin.y\r\n    };\r\n});\n\nvar toDecimal = (function (num, precision) {\r\n    if (precision === void 0) { precision = 2; }\r\n    precision = Math.pow(10, precision);\r\n    return Math.round(num * precision) / precision;\r\n});\n\nvar smoothFrame = (function (prevValue, nextValue, duration, smoothing) {\r\n    if (smoothing === void 0) { smoothing = 0; }\r\n    return toDecimal(prevValue +\r\n        (duration * (nextValue - prevValue)) / Math.max(smoothing, duration));\r\n});\n\nvar smooth = (function (strength) {\r\n    if (strength === void 0) { strength = 50; }\r\n    var previousValue = 0;\r\n    var lastUpdated = 0;\r\n    return function (v) {\r\n        var currentFramestamp = getFrameData().timestamp;\r\n        var timeDelta = currentFramestamp !== lastUpdated ? currentFramestamp - lastUpdated : 0;\r\n        var newValue = timeDelta\r\n            ? smoothFrame(previousValue, v, timeDelta, strength)\r\n            : previousValue;\r\n        lastUpdated = currentFramestamp;\r\n        previousValue = newValue;\r\n        return newValue;\r\n    };\r\n});\n\nvar snap = (function (points) {\r\n    if (typeof points === 'number') {\r\n        return function (v) { return Math.round(v / points) * points; };\r\n    }\r\n    else {\r\n        var i_1 = 0;\r\n        var numPoints_1 = points.length;\r\n        return function (v) {\r\n            var lastDistance = Math.abs(points[0] - v);\r\n            for (i_1 = 1; i_1 < numPoints_1; i_1++) {\r\n                var point = points[i_1];\r\n                var distance = Math.abs(point - v);\r\n                if (distance === 0)\r\n                    return point;\r\n                if (distance > lastDistance)\r\n                    return points[i_1 - 1];\r\n                if (i_1 === numPoints_1 - 1)\r\n                    return point;\r\n                lastDistance = distance;\r\n            }\r\n        };\r\n    }\r\n});\n\nvar identity = function (v) { return v; };\r\nvar springForce = function (alterDisplacement) {\r\n    if (alterDisplacement === void 0) { alterDisplacement = identity; }\r\n    return curryRange(function (constant, origin, v) {\r\n        var displacement = origin - v;\r\n        var springModifiedDisplacement = -(0 - constant + 1) * (0 - alterDisplacement(Math.abs(displacement)));\r\n        return displacement <= 0\r\n            ? origin + springModifiedDisplacement\r\n            : origin - springModifiedDisplacement;\r\n    });\r\n};\r\nvar springForceLinear = springForce();\r\nvar springForceExpo = springForce(Math.sqrt);\n\nvar velocityPerFrame = (function (xps, frameDuration) {\r\n    return isNum(xps) ? xps / (1000 / frameDuration) : 0;\r\n});\n\nvar velocityPerSecond = (function (velocity, frameDuration) {\r\n    return frameDuration ? velocity * (1000 / frameDuration) : 0;\r\n});\n\nvar wrap = function (min, max, v) {\r\n    var rangeSize = max - min;\r\n    return ((((v - min) % rangeSize) + rangeSize) % rangeSize) + min;\r\n};\r\nvar wrap$1 = curryRange(wrap);\n\nvar clampProgress = clamp$1(0, 1);\r\nvar steps = (function (steps, direction) {\r\n    if (direction === void 0) { direction = 'end'; }\r\n    return function (progress) {\r\n        progress =\r\n            direction === 'end' ? Math.min(progress, 0.999) : Math.max(progress, 0.001);\r\n        var expanded = progress * steps;\r\n        var rounded = direction === 'end' ? Math.floor(expanded) : Math.ceil(expanded);\r\n        return clampProgress(rounded / steps);\r\n    };\r\n});\n\nexport { angle, applyOffset, clamp$1 as clamp, conditional, degreesToRadians, distance, interpolate, isPoint, isPoint3D, mix, mixArray, mixColor, mixComplex, pipe, pointFromVector, progress, radiansToDegrees, smooth, smoothFrame, snap, springForce, springForceExpo, springForceLinear, steps, toDecimal, velocityPerFrame, velocityPerSecond, wrap$1 as wrap };\n","var DEFAULT_OVERSHOOT_STRENGTH = 1.525;\nvar reversed = function (easing) {\n    return function (p) {\n        return 1 - easing(1 - p);\n    };\n};\nvar mirrored = function (easing) {\n    return function (p) {\n        return p <= 0.5 ? easing(2 * p) / 2 : (2 - easing(2 * (1 - p))) / 2;\n    };\n};\nvar createReversedEasing = reversed;\nvar createMirroredEasing = mirrored;\nvar createExpoIn = function (power) {\n    return function (p) {\n        return Math.pow(p, power);\n    };\n};\nvar createBackIn = function (power) {\n    return function (p) {\n        return p * p * ((power + 1) * p - power);\n    };\n};\nvar createAnticipateEasing = function (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};\nvar linear = function (p) {\n    return p;\n};\nvar easeIn = /*#__PURE__*/createExpoIn(2);\nvar easeOut = /*#__PURE__*/reversed(easeIn);\nvar easeInOut = /*#__PURE__*/mirrored(easeIn);\nvar circIn = function (p) {\n    return 1 - Math.sin(Math.acos(p));\n};\nvar circOut = /*#__PURE__*/reversed(circIn);\nvar circInOut = /*#__PURE__*/mirrored(circOut);\nvar backIn = /*#__PURE__*/createBackIn(DEFAULT_OVERSHOOT_STRENGTH);\nvar backOut = /*#__PURE__*/reversed(backIn);\nvar backInOut = /*#__PURE__*/mirrored(backIn);\nvar anticipate = /*#__PURE__*/createAnticipateEasing(DEFAULT_OVERSHOOT_STRENGTH);\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';\nvar a = function (a1, a2) {\n    return 1.0 - 3.0 * a2 + 3.0 * a1;\n};\nvar b = function (a1, a2) {\n    return 3.0 * a2 - 6.0 * a1;\n};\nvar c = function (a1) {\n    return 3.0 * a1;\n};\nvar getSlope = function (t, a1, a2) {\n    return 3.0 * a(a1, a2) * t * t + 2.0 * b(a1, a2) * t + c(a1);\n};\nvar calcBezier = function (t, a1, a2) {\n    return ((a(a1, a2) * t + b(a1, a2)) * t + c(a1)) * t;\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    var binarySubdivide = function (aX, aA, aB) {\n        var i = 0;\n        var currentX;\n        var currentT;\n        do {\n            currentT = aA + (aB - aA) / 2.0;\n            currentX = calcBezier(currentT, mX1, mX2) - aX;\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        return currentT;\n    };\n    var newtonRaphsonIterate = function (aX, aGuessT) {\n        var i = 0;\n        var currentSlope = 0;\n        var currentX;\n        for (; i < NEWTON_ITERATIONS; ++i) {\n            currentSlope = getSlope(aGuessT, mX1, mX2);\n            if (currentSlope === 0.0) {\n                return aGuessT;\n            }\n            currentX = calcBezier(aGuessT, mX1, mX2) - aX;\n            aGuessT -= currentX / currentSlope;\n        }\n        return aGuessT;\n    };\n    var calcSampleValues = function () {\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    var getTForX = function (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        for (; currentSample !== lastSample && sampleValues[currentSample] <= aX; ++currentSample) {\n            intervalStart += K_SAMPLE_STEP_SIZE;\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        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    calcSampleValues();\n    var resolver = function (aX) {\n        var returnValue;\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        return returnValue;\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, cubicBezier };\n","import sync from 'framesync';\nimport { alpha, color, degrees, scale, px, percent } from 'style-value-types';\nimport { invariant } from 'hey-listen';\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\nvar __assign = function () {\n    __assign = Object.assign || function __assign(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\n\nfunction __rest(s, e) {\n    var t = {};\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0) t[p[i]] = s[p[i]];\n    return t;\n}\n\nvar createStyler = function (_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 (props) {\n        var state = {};\n        var changedValues = [];\n        var hasChanged = false;\n        var setValue = function (key, value) {\n            var currentValue = state[key];\n            state[key] = value;\n            if (state[key] !== currentValue) {\n                if (changedValues.indexOf(key) === -1) {\n                    changedValues.push(key);\n                }\n                if (!hasChanged) {\n                    hasChanged = true;\n                    sync.render(render);\n                }\n            }\n        };\n        function render(forceRender) {\n            if (forceRender === void 0) {\n                forceRender = false;\n            }\n            if (forceRender === true || hasChanged) {\n                onRender(state, props, changedValues);\n                hasChanged = false;\n                changedValues.length = 0;\n            }\n            return this;\n        }\n        return {\n            get: function (key) {\n                return key ? useCache && !uncachedValues.has(key) && state[key] !== undefined ? state[key] : onRead(key, props) : state;\n            },\n            set: function (values, value) {\n                if (typeof values === 'string') {\n                    if (value !== undefined) {\n                        setValue(values, value);\n                    } else {\n                        return function (v) {\n                            return setValue(values, v);\n                        };\n                    }\n                } else {\n                    for (var key in values) {\n                        if (values.hasOwnProperty(key)) {\n                            setValue(key, values[key]);\n                        }\n                    }\n                }\n                return this;\n            },\n            render: render\n        };\n    };\n};\n\nvar CAMEL_CASE_PATTERN = /([a-z])([A-Z])/g;\nvar REPLACE_TEMPLATE = '$1-$2';\nvar camelToDash = function (str) {\n    return str.replace(CAMEL_CASE_PATTERN, REPLACE_TEMPLATE).toLowerCase();\n};\nvar setDomAttrs = function (element, attrs) {\n    for (var key in attrs) {\n        if (attrs.hasOwnProperty(key)) {\n            element.setAttribute(key, attrs[key]);\n        }\n    }\n};\n\nvar camelCache = /*#__PURE__*/new Map();\nvar dashCache = /*#__PURE__*/new Map();\nvar prefixes = ['Webkit', 'Moz', 'O', 'ms', ''];\nvar numPrefixes = prefixes.length;\nvar isBrowser = typeof document !== 'undefined';\nvar testElement;\nvar setDashPrefix = function (key, prefixed) {\n    return dashCache.set(key, camelToDash(prefixed));\n};\nvar testPrefix = function (key) {\n    testElement = testElement || document.createElement('div');\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        if (prefixedPropertyName in testElement.style || noPrefix) {\n            camelCache.set(key, prefixedPropertyName);\n            setDashPrefix(key, \"\" + (noPrefix ? '' : '-') + camelToDash(prefixedPropertyName));\n        }\n    }\n};\nvar setServerProperty = function (key) {\n    return setDashPrefix(key, key);\n};\nvar prefixer = function (key, asDashCase) {\n    if (asDashCase === void 0) {\n        asDashCase = false;\n    }\n    var cache = asDashCase ? dashCache : camelCache;\n    if (!cache.has(key)) isBrowser ? testPrefix(key) : setServerProperty(key);\n    return cache.get(key) || key;\n};\n\nvar axes = ['', 'X', 'Y', 'Z'];\nvar order = ['scale', 'rotate', 'skew', 'transformPerspective'];\nvar transformProps = /*#__PURE__*/order.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 = /*#__PURE__*/transformProps.reduce(function (dict, key) {\n    dict[key] = true;\n    return dict;\n}, {});\nvar isTransformProp = function (key) {\n    return transformPropDictionary[key] === true;\n};\nvar sortTransformProps = function (a, b) {\n    return transformProps.indexOf(a) - transformProps.indexOf(b);\n};\nvar isTransformOriginProp = function (key) {\n    return key === 'originX' || key === 'originY';\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    borderTopLeftRadius: px,\n    borderTopRightRadius: px,\n    borderBottomRightRadius: px,\n    borderBottomLeftRadius: px,\n    width: px,\n    maxWidth: px,\n    height: px,\n    maxHeight: 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    x: px,\n    y: px,\n    z: px,\n    perspective: px,\n    opacity: alpha,\n    originX: percent,\n    originY: percent,\n    originZ: px\n};\nvar getValueType = function (key) {\n    return valueTypes[key];\n};\n\nvar SCROLL_LEFT = 'scrollLeft';\nvar SCROLL_TOP = 'scrollTop';\nvar scrollKeys = /*#__PURE__*/new Set([SCROLL_LEFT, SCROLL_TOP]);\n\nvar blacklist = /*#__PURE__*/new Set([SCROLL_LEFT, SCROLL_TOP, 'transform']);\nvar aliasMap = {\n    x: 'translateX',\n    y: 'translateY',\n    z: 'translateZ'\n};\nvar isCustomTemplate = function (v) {\n    return typeof v === 'function';\n};\nvar buildStyleProperty = function (state, enableHardwareAcceleration, styles, transform, transformOrigin, transformKeys) {\n    if (enableHardwareAcceleration === void 0) {\n        enableHardwareAcceleration = true;\n    }\n    if (styles === void 0) {\n        styles = {};\n    }\n    if (transform === void 0) {\n        transform = {};\n    }\n    if (transformOrigin === void 0) {\n        transformOrigin = {};\n    }\n    if (transformKeys === void 0) {\n        transformKeys = [];\n    }\n    var transformIsDefault = true;\n    var hasTransform = false;\n    var hasTransformOrigin = false;\n    for (var key in state) {\n        var value = state[key];\n        var valueType = getValueType(key);\n        var valueAsType = typeof value === 'number' && valueType ? valueType.transform(value) : value;\n        if (isTransformProp(key)) {\n            hasTransform = true;\n            transform[key] = valueAsType;\n            transformKeys.push(key);\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, true)] = valueAsType;\n        }\n    }\n    if (!transformIsDefault) {\n        var transformString = '';\n        if (isCustomTemplate(state.transform)) {\n            transformString = state.transform(transform);\n        } else {\n            var transformHasZ = false;\n            transformKeys.sort(sortTransformProps);\n            var numTransformKeys = transformKeys.length;\n            for (var i = 0; i < numTransformKeys; i++) {\n                var key = transformKeys[i];\n                transformString += (aliasMap[key] || key) + \"(\" + transform[key] + \") \";\n                transformHasZ = key === 'z' ? true : transformHasZ;\n            }\n            if (!transformHasZ && enableHardwareAcceleration) {\n                transformString += 'translateZ(0)';\n            } else {\n                transformString = transformString.trim();\n            }\n        }\n        styles.transform = transformString;\n    } else if (hasTransform) {\n        styles.transform = 'none';\n    }\n    if (hasTransformOrigin) {\n        styles.transformOrigin = (transformOrigin.originX || 0) + \" \" + (transformOrigin.originY || 0) + \" \" + (transformOrigin.originZ || 0);\n    }\n    return styles;\n};\nvar createStyleBuilder = function (enableHardwareAcceleration) {\n    if (enableHardwareAcceleration === void 0) {\n        enableHardwareAcceleration = true;\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);\n        return styles;\n    };\n};\n\nvar cssStyler = /*#__PURE__*/createStyler({\n    onRead: function (key, _a) {\n        var element = _a.element,\n            preparseOutput = _a.preparseOutput;\n        var valueType = getValueType(key);\n        if (isTransformProp(key)) {\n            return valueType ? valueType.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 && valueType && valueType.parse ? valueType.parse(domValue) : domValue;\n        }\n    },\n    onRender: function (state, _a, changedValues) {\n        var element = _a.element,\n            buildStyles = _a.buildStyles;\n        Object.assign(element.style, buildStyles(state));\n        if (changedValues.indexOf(SCROLL_LEFT) !== -1) element.scrollLeft = state.scrollLeft;\n        if (changedValues.indexOf(SCROLL_TOP) !== -1) element.scrollTop = state.scrollTop;\n    },\n    uncachedValues: scrollKeys\n});\nvar css = function (element, _a) {\n    if (_a === void 0) {\n        _a = {};\n    }\n    var enableHardwareAcceleration = _a.enableHardwareAcceleration,\n        props = __rest(_a, [\"enableHardwareAcceleration\"]);\n    return cssStyler(__assign({ element: element, buildStyles: createStyleBuilder(enableHardwareAcceleration), preparseOutput: true }, props));\n};\n\nvar ZERO_NOT_ZERO = 0.0000001;\nvar percentToPixels = function (percent$$1, length) {\n    return percent$$1 / 100 * length + 'px';\n};\nvar build = function (state, dimensions, isPath, pathLength) {\n    var hasTransform = false;\n    var hasDashArray = false;\n    var props = {};\n    var dashArrayStyles = isPath ? {\n        pathLength: '0',\n        pathSpacing: \"\" + pathLength\n    } : undefined;\n    var scale$$1 = state.scale !== undefined ? state.scale || ZERO_NOT_ZERO : state.scaleX || 1;\n    var scaleY = state.scaleY !== undefined ? state.scaleY || ZERO_NOT_ZERO : scale$$1 || 1;\n    var transformOriginX = dimensions.width * ((state.originX || 50) / 100) + dimensions.x;\n    var transformOriginY = dimensions.height * ((state.originY || 50) / 100) + dimensions.y;\n    var scaleTransformX = -transformOriginX * (scale$$1 * 1);\n    var scaleTransformY = -transformOriginY * (scaleY * 1);\n    var scaleReplaceX = transformOriginX / scale$$1;\n    var scaleReplaceY = transformOriginY / scaleY;\n    var transform = {\n        translate: \"translate(\" + state.x + \", \" + state.y + \") \",\n        scale: \"translate(\" + scaleTransformX + \", \" + scaleTransformY + \") scale(\" + scale$$1 + \", \" + scaleY + \") translate(\" + scaleReplaceX + \", \" + scaleReplaceY + \") \",\n        rotate: \"rotate(\" + state.rotate + \", \" + transformOriginX + \", \" + transformOriginY + \") \",\n        skewX: \"skewX(\" + state.skewX + \") \",\n        skewY: \"skewY(\" + state.skewY + \") \"\n    };\n    for (var key in state) {\n        if (state.hasOwnProperty(key)) {\n            var value = state[key];\n            if (isTransformProp(key)) {\n                hasTransform = true;\n            } else if (isPath && (key === 'pathLength' || key === 'pathSpacing') && typeof value === 'number') {\n                hasDashArray = true;\n                dashArrayStyles[key] = percentToPixels(value, pathLength);\n            } else if (isPath && key === 'pathOffset') {\n                props['stroke-dashoffset'] = percentToPixels(-value, pathLength);\n            } else {\n                props[camelToDash(key)] = value;\n            }\n        }\n    }\n    if (hasDashArray) {\n        props['stroke-dasharray'] = dashArrayStyles.pathLength + ' ' + dashArrayStyles.pathSpacing;\n    }\n    if (hasTransform) {\n        props.transform = '';\n        for (var key in transform) {\n            if (transform.hasOwnProperty(key)) {\n                var defaultValue = key === 'scale' ? '1' : '0';\n                props.transform += transform[key].replace(/undefined/g, defaultValue);\n            }\n        }\n    }\n    return props;\n};\n\nvar valueTypes$1 = {\n    fill: color,\n    stroke: color,\n    scale: scale,\n    scaleX: scale,\n    scaleY: scale,\n    opacity: alpha,\n    fillOpacity: alpha,\n    strokeOpacity: alpha\n};\nvar getValueType$1 = function (key) {\n    return valueTypes$1[key];\n};\n\nvar svgStyler = /*#__PURE__*/createStyler({\n    onRead: function (key, _a) {\n        var element = _a.element;\n        if (!isTransformProp(key)) {\n            return element.getAttribute(key);\n        } else {\n            var valueType = getValueType$1(key);\n            return valueType ? valueType.default : 0;\n        }\n    },\n    onRender: function (state, _a) {\n        var dimensions = _a.dimensions,\n            element = _a.element,\n            isPath = _a.isPath,\n            pathLength = _a.pathLength;\n        setDomAttrs(element, build(state, dimensions, isPath, pathLength));\n    }\n});\nvar svg = function (element) {\n    var _a = typeof element.getBBox === 'function' ? element.getBBox() : element.getBoundingClientRect(),\n        x = _a.x,\n        y = _a.y,\n        width = _a.width,\n        height = _a.height;\n    var props = {\n        element: element,\n        dimensions: { x: x, y: y, width: width, height: height },\n        isPath: false\n    };\n    if (element.tagName === 'path') {\n        props.isPath = true;\n        props.pathLength = element.getTotalLength();\n    }\n    return svgStyler(props);\n};\n\nvar viewport = /*#__PURE__*/createStyler({\n    useCache: false,\n    onRead: function (key) {\n        return key === 'scrollTop' ? window.pageYOffset : window.pageXOffset;\n    },\n    onRender: function (_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});\n\nvar cache = /*#__PURE__*/new WeakMap();\nvar createDOMStyler = function (node, props) {\n    var styler;\n    if (node instanceof HTMLElement) {\n        styler = css(node, props);\n    } else if (node instanceof SVGElement) {\n        styler = svg(node);\n    } else if (node === window) {\n        styler = viewport(node);\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};\nvar getStyler = function (node, props) {\n    return cache.has(node) ? cache.get(node) : createDOMStyler(node, props);\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 };\n","import { __rest, __extends, __assign } from 'tslib';\nimport { pipe, angle, degreesToRadians, distance, isPoint3D, isPoint, mix, pointFromVector, progress, radiansToDegrees, smoothFrame, velocityPerFrame, velocityPerSecond, mixArray, mixColor, clamp, applyOffset, conditional, interpolate, smooth, snap, springForce, springForceExpo, springForceLinear, wrap } from '@popmotion/popcorn';\nimport sync, { getFrameData, cancelSync } from 'framesync';\nimport * as styleValueTypes from 'style-value-types';\nimport { color, complex, percent, degrees, vh, vw, px, number } from 'style-value-types';\nexport { styleValueTypes as valueTypes };\nimport { invariant, warning } from 'hey-listen';\nimport * as easing from '@popmotion/easing';\nimport { linear, easeOut, easeInOut } from '@popmotion/easing';\nexport { easing };\nimport styler from 'stylefire';\nexport { default as styler } from 'stylefire';\n\nvar Chainable = /*#__PURE__*/function () {\n    function Chainable(props) {\n        if (props === void 0) {\n            props = {};\n        }\n        this.props = props;\n    }\n    Chainable.prototype.applyMiddleware = function (middleware) {\n        return this.create(__assign({}, this.props, { middleware: this.props.middleware ? [middleware].concat(this.props.middleware) : [middleware] }));\n    };\n    Chainable.prototype.pipe = function () {\n        var funcs = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            funcs[_i] = arguments[_i];\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    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    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    return Chainable;\n}();\n\nvar Observer = /*#__PURE__*/function () {\n    function Observer(_a, observer) {\n        var middleware = _a.middleware,\n            onComplete = _a.onComplete;\n        var _this = this;\n        this.isActive = true;\n        this.update = function (v) {\n            if (_this.observer.update) _this.updateObserver(v);\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        this.error = function (err) {\n            if (_this.observer.error && _this.isActive) _this.observer.error(err);\n            _this.isActive = false;\n        };\n        this.observer = observer;\n        this.updateObserver = function (v) {\n            return observer.update(v);\n        };\n        this.onComplete = onComplete;\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    return Observer;\n}();\nvar createObserver = function (observerCandidate, _a, onComplete) {\n    var middleware = _a.middleware;\n    if (typeof observerCandidate === 'function') {\n        return new Observer({ middleware: middleware, onComplete: onComplete }, { update: observerCandidate });\n    } else {\n        return new Observer({ middleware: middleware, onComplete: onComplete }, observerCandidate);\n    }\n};\n\nvar Action = /*#__PURE__*/function (_super) {\n    __extends(Action, _super);\n    function Action() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    Action.prototype.create = function (props) {\n        return new Action(props);\n    };\n    Action.prototype.start = function (observerCandidate) {\n        if (observerCandidate === void 0) {\n            observerCandidate = {};\n        }\n        var isComplete = false;\n        var subscription = {\n            stop: function () {\n                return undefined;\n            }\n        };\n        var _a = this.props,\n            init = _a.init,\n            observerProps = __rest(_a, [\"init\"]);\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 (observerCandidate.registerParent) {\n            observerCandidate.registerParent(subscription);\n        }\n        if (isComplete) subscription.stop();\n        return subscription;\n    };\n    return Action;\n}(Chainable);\nvar action = function (init) {\n    return new Action({ init: init });\n};\n\nvar BaseMulticast = /*#__PURE__*/function (_super) {\n    __extends(BaseMulticast, _super);\n    function BaseMulticast() {\n        var _this = _super !== null && _super.apply(this, arguments) || this;\n        _this.subscribers = [];\n        return _this;\n    }\n    BaseMulticast.prototype.complete = function () {\n        this.subscribers.forEach(function (subscriber) {\n            return subscriber.complete();\n        });\n    };\n    BaseMulticast.prototype.error = function (err) {\n        this.subscribers.forEach(function (subscriber) {\n            return subscriber.error(err);\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    BaseMulticast.prototype.subscribe = function (observerCandidate) {\n        var _this = this;\n        var observer = createObserver(observerCandidate, this.props);\n        this.subscribers.push(observer);\n        var subscription = {\n            unsubscribe: function () {\n                var index = _this.subscribers.indexOf(observer);\n                if (index !== -1) _this.subscribers.splice(index, 1);\n            }\n        };\n        return subscription;\n    };\n    BaseMulticast.prototype.stop = function () {\n        if (this.parent) this.parent.stop();\n    };\n    BaseMulticast.prototype.registerParent = function (subscription) {\n        this.stop();\n        this.parent = subscription;\n    };\n    return BaseMulticast;\n}(Chainable);\n\nvar Multicast = /*#__PURE__*/function (_super) {\n    __extends(Multicast, _super);\n    function Multicast() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    Multicast.prototype.create = function (props) {\n        return new Multicast(props);\n    };\n    return Multicast;\n}(BaseMulticast);\nvar multicast = function () {\n    return new Multicast();\n};\n\nvar stepProgress = function (steps, progress$$1) {\n    var segment = 1 / (steps - 1);\n    var subsegment = 1 / (2 * (steps - 1));\n    var percentProgressOfTarget = Math.min(progress$$1, 1);\n    var subsegmentProgressOfTarget = percentProgressOfTarget / subsegment;\n    var segmentProgressOfTarget = Math.floor((subsegmentProgressOfTarget + 1) / 2);\n    return segmentProgressOfTarget * segment;\n};\n\nvar calc = /*#__PURE__*/Object.freeze({\n    angle: angle,\n    degreesToRadians: degreesToRadians,\n    distance: distance,\n    isPoint3D: isPoint3D,\n    isPoint: isPoint,\n    dilate: mix,\n    getValueFromProgress: mix,\n    pointFromAngleAndDistance: pointFromVector,\n    getProgressFromValue: progress,\n    radiansToDegrees: radiansToDegrees,\n    smooth: smoothFrame,\n    speedPerFrame: velocityPerFrame,\n    speedPerSecond: velocityPerSecond,\n    stepProgress: stepProgress\n});\n\nvar isValueList = function (v) {\n    return Array.isArray(v);\n};\nvar isSingleValue = function (v) {\n    var typeOfV = typeof v;\n    return typeOfV === 'string' || typeOfV === 'number';\n};\nvar ValueReaction = /*#__PURE__*/function (_super) {\n    __extends(ValueReaction, _super);\n    function ValueReaction(props) {\n        var _this = _super.call(this, props) || this;\n        _this.scheduleVelocityCheck = function () {\n            return sync.postRender(_this.velocityCheck);\n        };\n        _this.velocityCheck = function (_a) {\n            var timestamp = _a.timestamp;\n            if (timestamp !== _this.lastUpdated) {\n                _this.prev = _this.current;\n            }\n        };\n        _this.prev = _this.current = props.value || 0;\n        if (isSingleValue(_this.current)) {\n            _this.updateCurrent = function (v) {\n                return _this.current = v;\n            };\n            _this.getVelocityOfCurrent = function () {\n                return _this.getSingleVelocity(_this.current, _this.prev);\n            };\n        } else if (isValueList(_this.current)) {\n            _this.updateCurrent = function (v) {\n                return _this.current = v.slice();\n            };\n            _this.getVelocityOfCurrent = function () {\n                return _this.getListVelocity();\n            };\n        } else {\n            _this.updateCurrent = function (v) {\n                _this.current = {};\n                for (var key in v) {\n                    if (v.hasOwnProperty(key)) {\n                        _this.current[key] = v[key];\n                    }\n                }\n            };\n            _this.getVelocityOfCurrent = function () {\n                return _this.getMapVelocity();\n            };\n        }\n        if (props.initialSubscription) _this.subscribe(props.initialSubscription);\n        return _this;\n    }\n    ValueReaction.prototype.create = function (props) {\n        return new ValueReaction(props);\n    };\n    ValueReaction.prototype.get = function () {\n        return this.current;\n    };\n    ValueReaction.prototype.getVelocity = function () {\n        return this.getVelocityOfCurrent();\n    };\n    ValueReaction.prototype.update = function (v) {\n        _super.prototype.update.call(this, v);\n        this.prev = this.current;\n        this.updateCurrent(v);\n        var _a = getFrameData(),\n            delta = _a.delta,\n            timestamp = _a.timestamp;\n        this.timeDelta = delta;\n        this.lastUpdated = timestamp;\n        sync.postRender(this.scheduleVelocityCheck);\n    };\n    ValueReaction.prototype.subscribe = function (observerCandidate) {\n        var sub = _super.prototype.subscribe.call(this, observerCandidate);\n        this.subscribers[this.subscribers.length - 1].update(this.current);\n        return sub;\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    ValueReaction.prototype.getListVelocity = function () {\n        var _this = this;\n        return this.current.map(function (c, i) {\n            return _this.getSingleVelocity(c, _this.prev[i]);\n        });\n    };\n    ValueReaction.prototype.getMapVelocity = function () {\n        var velocity = {};\n        for (var key in this.current) {\n            if (this.current.hasOwnProperty(key)) {\n                velocity[key] = this.getSingleVelocity(this.current[key], this.prev[key]);\n            }\n        }\n        return velocity;\n    };\n    return ValueReaction;\n}(BaseMulticast);\nvar value = function (value, initialSubscription) {\n    return new ValueReaction({ value: value, initialSubscription: initialSubscription });\n};\n\nvar multi = function (_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                complete = _a.complete,\n                error = _a.error;\n            var numActions = getCount(actions);\n            var output = getOutput();\n            var updateOutput = function () {\n                return update(output);\n            };\n            var numCompletedActions = 0;\n            var subs = startActions(actions, function (a, name) {\n                var hasCompleted = false;\n                return a.start({\n                    complete: function () {\n                        if (!hasCompleted) {\n                            hasCompleted = true;\n                            numCompletedActions++;\n                            if (numCompletedActions === numActions) sync.update(complete);\n                        }\n                    },\n                    error: error,\n                    update: function (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 = /*#__PURE__*/multi({\n    getOutput: function () {\n        return {};\n    },\n    getCount: function (subs) {\n        return Object.keys(subs).length;\n    },\n    getFirst: function (subs) {\n        return subs[Object.keys(subs)[0]];\n    },\n    mapApi: function (subs, methodName) {\n        return function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            return Object.keys(subs).reduce(function (output, propKey) {\n                var _a;\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                return output;\n            }, {});\n        };\n    },\n    setProp: function (output, name, v) {\n        return output[name] = v;\n    },\n    startActions: function (actions, starter) {\n        return Object.keys(actions).reduce(function (subs, key) {\n            subs[key] = starter(actions[key], key);\n            return subs;\n        }, {});\n    }\n});\n\nvar parallel = /*#__PURE__*/multi({\n    getOutput: function () {\n        return [];\n    },\n    getCount: function (subs) {\n        return subs.length;\n    },\n    getFirst: function (subs) {\n        return subs[0];\n    },\n    mapApi: function (subs, methodName) {\n        return function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\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 (output, name, v) {\n        return output[name] = v;\n    },\n    startActions: function (actions, starter) {\n        return actions.map(function (action, i) {\n            return starter(action, i);\n        });\n    }\n});\nvar parallel$1 = function () {\n    var actions = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        actions[_i] = arguments[_i];\n    }\n    return parallel(actions);\n};\n\nvar createVectorTests = function (typeTests) {\n    var testNames = Object.keys(typeTests);\n    var isVectorProp = function (prop, key) {\n        return prop !== undefined && !typeTests[key](prop);\n    };\n    var getVectorKeys = function (props) {\n        return testNames.reduce(function (vectorKeys, key) {\n            if (isVectorProp(props[key], key)) vectorKeys.push(key);\n            return vectorKeys;\n        }, []);\n    };\n    var testVectorProps = function (props) {\n        return props && testNames.some(function (key) {\n            return isVectorProp(props[key], key);\n        });\n    };\n    return { getVectorKeys: getVectorKeys, testVectorProps: testVectorProps };\n};\nvar unitTypes = [px, percent, degrees, vh, vw];\nvar findUnitType = function (prop) {\n    return unitTypes.find(function (type) {\n        return type.test(prop);\n    });\n};\nvar isUnitProp = function (prop) {\n    return Boolean(findUnitType(prop));\n};\nvar createAction = function (action, props) {\n    return action(props);\n};\nvar reduceArrayValue = function (i) {\n    return function (props, key) {\n        props[key] = props[key][i];\n        return props;\n    };\n};\nvar createArrayAction = function (action, props, vectorKeys) {\n    var firstVectorKey = vectorKeys[0];\n    var actionList = props[firstVectorKey].map(function (v, i) {\n        var childActionProps = vectorKeys.reduce(reduceArrayValue(i), __assign({}, props));\n        return getActionCreator(v)(action, childActionProps);\n    });\n    return parallel$1.apply(void 0, actionList);\n};\nvar reduceObjectValue = function (key) {\n    return function (props, propKey) {\n        props[propKey] = props[propKey][key];\n        return props;\n    };\n};\nvar createObjectAction = function (action, props, vectorKeys) {\n    var firstVectorKey = vectorKeys[0];\n    var actionMap = Object.keys(props[firstVectorKey]).reduce(function (map, key) {\n        var childActionProps = vectorKeys.reduce(reduceObjectValue(key), __assign({}, props));\n        map[key] = getActionCreator(props[firstVectorKey][key])(action, childActionProps);\n        return map;\n    }, {});\n    return composite(actionMap);\n};\nvar createUnitAction = function (action, _a) {\n    var from = _a.from,\n        to = _a.to,\n        props = __rest(_a, [\"from\", \"to\"]);\n    var unitType = findUnitType(from) || findUnitType(to);\n    var transform = unitType.transform,\n        parse = unitType.parse;\n    return action(__assign({}, props, { from: typeof from === 'string' ? parse(from) : from, to: typeof to === 'string' ? parse(to) : to })).pipe(transform);\n};\nvar createColorAction = function (action, _a) {\n    var from = _a.from,\n        to = _a.to,\n        props = __rest(_a, [\"from\", \"to\"]);\n    return action(__assign({}, props, { from: 0, to: 1 })).pipe(mixColor(from, to), color.transform);\n};\nvar createComplexAction = function (action, _a) {\n    var from = _a.from,\n        to = _a.to,\n        props = __rest(_a, [\"from\", \"to\"]);\n    var valueTemplate = complex.createTransformer(from);\n    invariant(valueTemplate(from) === complex.createTransformer(to)(from), \"Values '\" + from + \"' and '\" + to + \"' are of different format, or a value might have changed value type.\");\n    return action(__assign({}, props, { from: 0, to: 1 })).pipe(mixArray(complex.parse(from), complex.parse(to)), valueTemplate);\n};\nvar createVectorAction = function (action, typeTests) {\n    var _a = createVectorTests(typeTests),\n        testVectorProps = _a.testVectorProps,\n        getVectorKeys = _a.getVectorKeys;\n    var vectorAction = function (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    return vectorAction;\n};\nvar getActionCreator = function (prop) {\n    var actionCreator = createAction;\n    if (typeof prop === 'number') {\n        actionCreator = createAction;\n    } else if (Array.isArray(prop)) {\n        actionCreator = createArrayAction;\n    } else if (isUnitProp(prop)) {\n        actionCreator = createUnitAction;\n    } else if (color.test(prop)) {\n        actionCreator = createColorAction;\n    } else if (complex.test(prop)) {\n        actionCreator = createComplexAction;\n    } else if (typeof prop === 'object') {\n        actionCreator = createObjectAction;\n    }\n    return actionCreator;\n};\n\nvar decay = function (props) {\n    if (props === void 0) {\n        props = {};\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            if (!isMoving) {\n                cancelSync.update(process);\n                complete();\n            }\n        }, true);\n        return {\n            stop: function () {\n                return cancelSync.update(process);\n            }\n        };\n    });\n};\nvar vectorDecay = /*#__PURE__*/createVectorAction(decay, {\n    from: number.test,\n    modifyTarget: function (func) {\n        return typeof func === 'function';\n    },\n    velocity: number.test\n});\n\nvar frame = function () {\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 () {\n                return cancelSync.update(process);\n            }\n        };\n    });\n};\n\nvar scrubber = function (_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    return action(function (_a) {\n        var update = _a.update;\n        return {\n            seek: function (progress$$1) {\n                return update(progress$$1);\n            }\n        };\n    }).pipe(ease, function (v) {\n        return mix(from, to, v);\n    });\n};\nvar vectorScrubber = /*#__PURE__*/createVectorAction(scrubber, {\n    ease: function (func) {\n        return typeof func === 'function';\n    },\n    from: number.test,\n    to: number.test\n});\n\nvar clampProgress = /*#__PURE__*/clamp(0, 1);\nvar tween = function (props) {\n    if (props === void 0) {\n        props = {};\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        var _g = props.from,\n            from = _g === void 0 ? 0 : _g,\n            _h = props.to,\n            to = _h === void 0 ? 1 : _h,\n            _j = props.elapsed,\n            elapsed = _j === void 0 ? 0 : _j,\n            _k = props.playDirection,\n            playDirection = _k === void 0 ? 1 : _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({ from: from, to: to, ease: ease }).start(update);\n        var currentProgress = 0;\n        var process;\n        var isActive = false;\n        var reverseTween = function () {\n            return playDirection *= -1;\n        };\n        var isTweenComplete = function () {\n            var _a;\n            var isComplete = playDirection === 1 ? isActive && elapsed >= duration : isActive && elapsed <= 0;\n            if (!isComplete) return false;\n            if (isComplete && !loop && !flip && !yoyo) return true;\n            var isStepTaken = false;\n            if (loop && loopCount < loop) {\n                elapsed = 0;\n                loopCount++;\n                isStepTaken = true;\n            } else if (flip && flipCount < flip) {\n                elapsed = duration - elapsed;\n                _a = [to, from], from = _a[0], to = _a[1];\n                playhead = vectorScrubber({ from: from, to: to, ease: ease }).start(update);\n                flipCount++;\n                isStepTaken = true;\n            } else if (yoyo && yoyoCount < yoyo) {\n                reverseTween();\n                yoyoCount++;\n                isStepTaken = true;\n            }\n            return !isStepTaken;\n        };\n        var updateTween = function () {\n            currentProgress = clampProgress(progress(0, duration, elapsed));\n            playhead.seek(currentProgress);\n        };\n        var startTimer = function () {\n            isActive = true;\n            process = sync.update(function (_a) {\n                var delta = _a.delta;\n                elapsed += delta * playDirection;\n                updateTween();\n                if (isTweenComplete() && complete) {\n                    cancelSync.update(process);\n                    sync.update(complete, false, true);\n                }\n            }, true);\n        };\n        var stopTimer = function () {\n            isActive = false;\n            if (process) cancelSync.update(process);\n        };\n        startTimer();\n        return {\n            isActive: function () {\n                return isActive;\n            },\n            getElapsed: function () {\n                return clamp(0, duration, elapsed);\n            },\n            getProgress: function () {\n                return currentProgress;\n            },\n            stop: function () {\n                stopTimer();\n            },\n            pause: function () {\n                stopTimer();\n                return this;\n            },\n            resume: function () {\n                if (!isActive) startTimer();\n                return this;\n            },\n            seek: function (newProgress) {\n                elapsed = mix(0, duration, newProgress);\n                sync.update(updateTween, false, true);\n                return this;\n            },\n            reverse: function () {\n                reverseTween();\n                return this;\n            }\n        };\n    });\n};\n\nvar clampProgress$1 = /*#__PURE__*/clamp(0, 1);\nvar defaultEasings = function (values, easing$$1) {\n    return values.map(function () {\n        return easing$$1 || easeOut;\n    }).splice(0, values.length - 1);\n};\nvar defaultTimings = function (values) {\n    var numValues = values.length;\n    return values.map(function (value, i) {\n        return i !== 0 ? i / (numValues - 1) : 0;\n    });\n};\nvar interpolateScrubbers = function (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        if (v >= input[finalInputIndex]) {\n            subs[finalScrubberIndex].seek(1);\n        }\n        var i = 1;\n        for (; i < rangeLength; i++) {\n            if (input[i] > v || i === finalInputIndex) break;\n        }\n        var progressInRange = progress(input[i - 1], input[i], v);\n        subs[i - 1].seek(clampProgress$1(progressInRange));\n    };\n};\nvar keyframes = function (_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    easings = Array.isArray(easings) ? easings : defaultEasings(values, easings);\n    times = times || defaultTimings(values);\n    var scrubbers = easings.map(function (easing$$1, i) {\n        return vectorScrubber({\n            from: values[i],\n            to: values[i + 1],\n            ease: easing$$1\n        });\n    });\n    return tween(__assign({}, tweenProps, { ease: ease })).applyMiddleware(function (update) {\n        return interpolateScrubbers(times, scrubbers, update);\n    });\n};\n\nvar physics = function (props) {\n    if (props === void 0) {\n        props = {};\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            if (springStrength !== undefined && to !== undefined) {\n                var distanceToTarget = to - current;\n                velocity += distanceToTarget * velocityPerFrame(springStrength, elapsed);\n            }\n            current += velocityPerFrame(velocity, elapsed);\n            update(current);\n            var isComplete = restSpeed !== false && (!velocity || Math.abs(velocity) <= restSpeed);\n            if (isComplete) {\n                cancelSync.update(process);\n                complete();\n            }\n        }, true);\n        return {\n            set: function (v) {\n                current = v;\n                return this;\n            },\n            setAcceleration: function (v) {\n                acceleration = v;\n                return this;\n            },\n            setFriction: function (v) {\n                friction = v;\n                return this;\n            },\n            setSpringStrength: function (v) {\n                springStrength = v;\n                return this;\n            },\n            setSpringTarget: function (v) {\n                to = v;\n                return this;\n            },\n            setVelocity: function (v) {\n                velocity = v;\n                return this;\n            },\n            stop: function () {\n                return cancelSync.update(process);\n            }\n        };\n    });\n};\nvar vectorPhysics = /*#__PURE__*/createVectorAction(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 spring = function (props) {\n    if (props === void 0) {\n        props = {};\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            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            velocity = velocityPerSecond(position - prevPosition, timeDelta);\n            var isBelowVelocityThreshold = Math.abs(velocity) <= restSpeed;\n            var isBelowDisplacementThreshold = Math.abs(to - position) <= restDelta;\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 () {\n                return cancelSync.update(process);\n            }\n        };\n    });\n};\nvar vectorSpring = /*#__PURE__*/createVectorAction(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 DEFAULT_DURATION = 300;\nvar flattenTimings = function (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        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};\nvar flattenArrayInstructions = function (instructions, instruction) {\n    Array.isArray(instruction) ? instructions.push.apply(instructions, flattenTimings(instruction)) : instructions.push(instruction);\n    return instructions;\n};\nvar convertDefToProps = function (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    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            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    values.push(def.to);\n    times.push(timeTo);\n    easings.push(def.ease || easeInOut);\n    return props;\n};\nvar timeline = function (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    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, { at: playhead });\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    for (var i = 0; i < numDefs; i++) {\n        var def = animationDefs[i];\n        var track = def.track;\n        if (track === undefined) {\n            throw new Error('No track defined');\n        }\n        if (!tracks.hasOwnProperty(track)) tracks[track] = [];\n        tracks[track].push(def);\n    }\n    var trackKeyframes = {};\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, { duration: duration || calculatedDuration, ease: ease,\n                elapsed: elapsed,\n                loop: loop,\n                yoyo: yoyo,\n                flip: flip }));\n        }\n    }\n    return composite(trackKeyframes);\n};\n\nvar listen = function (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 () {\n                return eventNames.forEach(function (eventName) {\n                    return element.removeEventListener(eventName, update, options);\n                });\n            }\n        };\n    });\n};\n\nvar defaultPointerPos = function () {\n    return {\n        clientX: 0,\n        clientY: 0,\n        pageX: 0,\n        pageY: 0,\n        x: 0,\n        y: 0\n    };\n};\nvar eventToPoint = function (e, point) {\n    if (point === void 0) {\n        point = defaultPointerPos();\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 = [/*#__PURE__*/defaultPointerPos()];\nvar isTouchDevice = false;\nif (typeof document !== 'undefined') {\n    var updatePointsLocation = function (_a) {\n        var touches = _a.touches;\n        isTouchDevice = true;\n        var numTouches = touches.length;\n        points.length = 0;\n        for (var i = 0; i < numTouches; i++) {\n            var thisTouch = touches[i];\n            points.push(eventToPoint(thisTouch));\n        }\n    };\n    listen(document, 'touchstart touchmove', {\n        passive: true,\n        capture: true\n    }).start(updatePointsLocation);\n}\nvar multitouch = function (_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    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        if (isGesture) {\n            var firstTouch = points[0],\n                secondTouch = points[1];\n            initialDistance = distance(firstTouch, secondTouch);\n            initialRotation = angle(firstTouch, secondTouch);\n        }\n        var updatePoint = function () {\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            update(output);\n        };\n        var onMove = function (e) {\n            if (preventDefault || e.touches.length > 1) e.preventDefault();\n            sync.update(updatePoint);\n        };\n        var updateOnMove = listen(document, 'touchmove', {\n            passive: !preventDefault\n        }).start(onMove);\n        if (isTouchDevice) sync.update(updatePoint);\n        return {\n            stop: function () {\n                cancelSync.update(updatePoint);\n                updateOnMove.stop();\n            }\n        };\n    });\n};\nvar getIsTouchDevice = function () {\n    return isTouchDevice;\n};\n\nvar point = /*#__PURE__*/defaultPointerPos();\nvar isMouseDevice = false;\nif (typeof document !== 'undefined') {\n    var updatePointLocation = function (e) {\n        isMouseDevice = true;\n        eventToPoint(e, point);\n    };\n    listen(document, 'mousedown mousemove', true).start(updatePointLocation);\n}\nvar mouse = function (_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        var updatePoint = function () {\n            return update(point);\n        };\n        var onMove = function (e) {\n            if (preventDefault) e.preventDefault();\n            sync.update(updatePoint);\n        };\n        var updateOnMove = listen(document, 'mousemove').start(onMove);\n        if (isMouseDevice) sync.update(updatePoint);\n        return {\n            stop: function () {\n                cancelSync.update(updatePoint);\n                updateOnMove.stop();\n            }\n        };\n    });\n};\n\nvar getFirstTouch = function (_a) {\n    var firstTouch = _a[0];\n    return firstTouch;\n};\nvar pointer = function (props) {\n    if (props === void 0) {\n        props = {};\n    }\n    return getIsTouchDevice() ? multitouch(props).pipe(function (_a) {\n        var touches = _a.touches;\n        return touches;\n    }, getFirstTouch) : mouse(props);\n};\nvar index = function (_a) {\n    if (_a === void 0) {\n        _a = {};\n    }\n    var x = _a.x,\n        y = _a.y,\n        props = __rest(_a, [\"x\", \"y\"]);\n    if (x !== undefined || y !== undefined) {\n        var applyXOffset_1 = applyOffset(x || 0);\n        var applyYOffset_1 = applyOffset(y || 0);\n        var delta_1 = { x: 0, y: 0 };\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 () {\n    var actions = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        actions[_i] = arguments[_i];\n    }\n    return action(function (_a) {\n        var update = _a.update,\n            complete = _a.complete;\n        var i = 0;\n        var current;\n        var playCurrent = function () {\n            current = actions[i].start({\n                complete: function () {\n                    i++;\n                    i >= actions.length ? complete() : playCurrent();\n                },\n                update: update\n            });\n        };\n        playCurrent();\n        return {\n            stop: function () {\n                return current && current.stop();\n            }\n        };\n    });\n};\n\nvar crossfade = function (a, b) {\n    return action(function (observer) {\n        var balance = 0;\n        var fadable = parallel$1(a, b).start(__assign({}, observer, { update: function (_a) {\n                var va = _a[0],\n                    vb = _a[1];\n                observer.update(mix(va, vb, balance));\n            } }));\n        return {\n            setBalance: function (v) {\n                return balance = v;\n            },\n            stop: function () {\n                return fadable.stop();\n            }\n        };\n    });\n};\n\nvar delay = function (timeToDelay) {\n    return action(function (_a) {\n        var complete = _a.complete;\n        var timeout = setTimeout(complete, timeToDelay);\n        return {\n            stop: function () {\n                return clearTimeout(timeout);\n            }\n        };\n    });\n};\n\nvar merge = function () {\n    var actions = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        actions[_i] = arguments[_i];\n    }\n    return action(function (observer) {\n        var subs = actions.map(function (thisAction) {\n            return thisAction.start(observer);\n        });\n        return {\n            stop: function () {\n                return subs.forEach(function (sub) {\n                    return sub.stop();\n                });\n            }\n        };\n    });\n};\n\nvar schedule = function (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 () {\n                return latest !== undefined && update(latest);\n            },\n            complete: complete\n        });\n        var scheduleeSub = schedulee.start({\n            update: function (v) {\n                return latest = v;\n            },\n            complete: complete\n        });\n        return {\n            stop: function () {\n                schedulerSub.stop();\n                scheduleeSub.stop();\n            }\n        };\n    });\n};\n\nvar stagger = function (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 appendUnit = function (unit) {\n    return function (v) {\n        return \"\" + v + unit;\n    };\n};\nvar steps = function (st, min, max) {\n    if (min === void 0) {\n        min = 0;\n    }\n    if (max === void 0) {\n        max = 1;\n    }\n    return function (v) {\n        var current = progress(min, max, v);\n        return mix(min, max, stepProgress(st, current));\n    };\n};\nvar transformMap = function (childTransformers) {\n    return function (v) {\n        var output = __assign({}, v);\n        for (var key in childTransformers) {\n            if (childTransformers.hasOwnProperty(key)) {\n                var childTransformer = childTransformers[key];\n                output[key] = childTransformer(v[key]);\n            }\n        }\n        return output;\n    };\n};\n\nvar transformers = /*#__PURE__*/Object.freeze({\n    applyOffset: applyOffset,\n    clamp: clamp,\n    conditional: conditional,\n    interpolate: interpolate,\n    blendArray: mixArray,\n    blendColor: mixColor,\n    pipe: pipe,\n    smooth: smooth,\n    snap: snap,\n    generateStaticSpring: springForce,\n    nonlinearSpring: springForceExpo,\n    linearSpring: springForceLinear,\n    wrap: wrap,\n    appendUnit: appendUnit,\n    steps: steps,\n    transformMap: transformMap\n});\n\nvar css = function (element, props) {\n    warning(false, 'css() is deprecated, use styler instead');\n    return styler(element, props);\n};\nvar svg = function (element, props) {\n    warning(false, 'svg() is deprecated, use styler instead');\n    return styler(element, props);\n};\n\nexport { action, multicast, value, vectorDecay as decay, keyframes, frame as everyFrame, vectorPhysics as physics, vectorSpring as spring, timeline, tween, listen, index as pointer, mouse, multitouch, chain, composite, crossfade, delay, merge, parallel$1 as parallel, schedule, stagger, calc, transformers as transform, css, svg, Action, ValueReaction };\n","import {\n  anticipate,\n  backIn,\n  backInOut,\n  backOut,\n  circIn,\n  circInOut,\n  circOut,\n  easeIn,\n  easeInOut,\n  easeOut,\n  linear,\n} from '@popmotion/easing';\nimport sync from 'framesync';\n// @ts-ignore\nimport throttle from 'lodash/throttle';\nimport { tween } from 'popmotion';\nimport {\n  BoundingClientRect,\n  CachedPositionData,\n  ChildBoundingClientRect,\n  Coords,\n  ItemPosition,\n  PopmotionEasing,\n  WrapGridArguments,\n} from './types';\n\nconst popmotionEasing: PopmotionEasing = {\n  anticipate,\n  backIn,\n  backInOut,\n  backOut,\n  circIn,\n  circInOut,\n  circOut,\n  easeIn,\n  easeInOut,\n  easeOut,\n  linear,\n};\n\nconst DATASET_KEY = 'animateGridId';\n\nconst toArray = (arrLike: ArrayLike<any>): any[] => {\n  if (!arrLike) return [];\n  return Array.prototype.slice.call(arrLike);\n};\n\n// in order to account for scroll, (which we're not listening for)\n// always cache the item's position relative\n// to the top and left of the grid container\nconst getGridAwareBoundingClientRect = (\n  gridBoundingClientRect: BoundingClientRect,\n  el: HTMLElement\n): BoundingClientRect => {\n  const { top, left, width, height } = el.getBoundingClientRect();\n  const rect = { top, left, width, height };\n  rect.top -= gridBoundingClientRect.top;\n  rect.left -= gridBoundingClientRect.left;\n  // if an element is display:none it will return top: 0 and left:0\n  // rather than saying it's still in the containing element\n  // so we need to use Math.max to make sure the coordinates stay\n  // within the container\n  rect.top = Math.max(rect.top, 0);\n  rect.left = Math.max(rect.left, 0);\n  return rect;\n};\n\n// the function used during the tweening\nconst applyCoordTransform = (\n  el: HTMLElement,\n  { translateX, translateY, scaleX, scaleY }: Coords,\n  { immediate }: { immediate?: boolean } = {}\n): void => {\n  const isFinished =\n    translateX === 0 && translateY === 0 && scaleX === 1 && scaleY === 1;\n  const styleEl = () => {\n    el.style.transform = isFinished\n      ? ''\n      : `translateX(${translateX}px) translateY(${translateY}px) scaleX(${scaleX}) scaleY(${scaleY})`;\n  };\n  if (immediate) {\n    styleEl();\n  } else {\n    sync.render(styleEl);\n  }\n  const firstChild = el.children[0] as HTMLElement;\n  if (firstChild) {\n    const styleChild = () => {\n      firstChild.style.transform = isFinished\n        ? ''\n        : `scaleX(${1 / scaleX}) scaleY(${1 / scaleY})`;\n    };\n    if (immediate) {\n      styleChild();\n    } else {\n      sync.render(styleChild);\n    }\n  }\n};\n\n// return a function that take a reference to a grid dom node and optional config\nexport const wrapGrid = (\n  container: HTMLElement,\n  {\n    duration = 250,\n    stagger = 0,\n    easing = 'easeInOut',\n    onStart = () => {},\n    onEnd = () => {},\n  }: WrapGridArguments = {}\n) => {\n  if (!popmotionEasing[easing]) {\n    throw new Error(`${easing} is not a valid easing name`);\n  }\n\n  let mutationsDisabled: boolean = false;\n\n  const disableMutationsWhileFunctionRuns = (func: () => void) => {\n    mutationsDisabled = true;\n    func();\n    setTimeout(() => {\n      mutationsDisabled = false;\n    }, 0);\n  };\n\n  // all cached position data, and in-progress tween data, is stored here\n  const cachedPositionData: CachedPositionData = {};\n  // initially and after every transition, record element positions\n  const recordPositions = (\n    elements: HTMLCollectionOf<HTMLElement> | HTMLElement[]\n  ) => {\n    const gridBoundingClientRect = container.getBoundingClientRect();\n    toArray(elements).forEach(el => {\n      if (typeof el.getBoundingClientRect !== 'function') {\n        return;\n      }\n      if (!el.dataset[DATASET_KEY]) {\n        const newId = `${Math.random()}`;\n        el.dataset[DATASET_KEY] = newId;\n      }\n      const animateGridId = el.dataset[DATASET_KEY] as string;\n\n      if (!cachedPositionData[animateGridId]) {\n        cachedPositionData[animateGridId] = {} as ItemPosition;\n      }\n\n      const rect = getGridAwareBoundingClientRect(gridBoundingClientRect, el);\n      cachedPositionData[animateGridId].rect = rect;\n      cachedPositionData[\n        animateGridId\n      ].gridBoundingClientRect = gridBoundingClientRect;\n    });\n  };\n  recordPositions(container.children as HTMLCollectionOf<HTMLElement>);\n\n  const throttledResizeListener = throttle(() => {\n    const bodyElement = document.querySelector('body');\n    const containerIsNoLongerInPage =\n      bodyElement && !bodyElement.contains(container);\n    if (!container || containerIsNoLongerInPage) {\n      window.removeEventListener('resize', throttledResizeListener);\n    }\n    recordPositions(container.children as HTMLCollectionOf<HTMLElement>);\n  }, 250);\n  window.addEventListener('resize', throttledResizeListener);\n\n  const throttledScrollListener = throttle(() => {\n    recordPositions(container.children as HTMLCollectionOf<HTMLElement>);\n  }, 20);\n  container.addEventListener('scroll', throttledScrollListener);\n\n  const mutationCallback = (\n    mutationsList: MutationRecord[] | 'forceGridAnimation'\n  ) => {\n    if (mutationsList !== 'forceGridAnimation') {\n      // check if we care about the mutation\n      const relevantMutationHappened = mutationsList.filter(\n        (m: MutationRecord) =>\n          m.attributeName === 'class' ||\n          m.addedNodes.length ||\n          m.removedNodes.length\n      ).length;\n      if (!relevantMutationHappened) {\n        return;\n      }\n      if (mutationsDisabled) return;\n    }\n    const gridBoundingClientRect = container.getBoundingClientRect();\n    const childrenElements = toArray(container.children) as HTMLElement[];\n    // stop current transitions and remove transforms on transitioning elements\n    childrenElements\n      .filter(el => {\n        const itemPosition =\n          cachedPositionData[el.dataset[DATASET_KEY] as string];\n        if (itemPosition && itemPosition.stopTween) {\n          itemPosition.stopTween();\n          delete itemPosition.stopTween;\n          return true;\n        }\n      })\n      .forEach(el => {\n        el.style.transform = '';\n        const firstChild = el.children[0] as HTMLElement;\n        if (firstChild) {\n          firstChild.style.transform = '';\n        }\n      });\n    const animatedGridChildren = childrenElements\n      .map(el => ({\n        childCoords: {} as ChildBoundingClientRect,\n        el,\n        boundingClientRect: getGridAwareBoundingClientRect(\n          gridBoundingClientRect,\n          el\n        ),\n      }))\n      .filter(({ el, boundingClientRect }) => {\n        const itemPosition =\n          cachedPositionData[el.dataset[DATASET_KEY] as string];\n        // don't animate the initial appearance of elements,\n        // just cache their position so they can be animated later\n        if (!itemPosition) {\n          recordPositions([el]);\n          return false;\n        } else if (\n          boundingClientRect.top === itemPosition.rect.top &&\n          boundingClientRect.left === itemPosition.rect.left &&\n          boundingClientRect.width === itemPosition.rect.width &&\n          boundingClientRect.height === itemPosition.rect.height\n        ) {\n          // if it hasn't moved, dont animate it\n          return false;\n        }\n        return true;\n      });\n\n    // having more than one child in the animated item is not supported\n    animatedGridChildren.forEach(({ el }) => {\n      if (toArray(el.children).length > 1) {\n        throw new Error(\n          'Make sure every grid item has a single container element surrounding its children'\n        );\n      }\n    });\n\n    if (!animatedGridChildren.length) {\n      return;\n    }\n\n    const animatedElements = animatedGridChildren.map(({ el }) => el);\n    disableMutationsWhileFunctionRuns(() => onStart(animatedElements));\n\n    const completionPromises: Array<Promise<any>> = [];\n\n    animatedGridChildren\n      // do this measurement first so as not to cause layout thrashing\n      .map(data => {\n        const firstChild = data.el.children[0] as HTMLElement;\n        // different transform origins give different effects. \"50% 50%\" is default\n        if (firstChild) {\n          data.childCoords = getGridAwareBoundingClientRect(\n            gridBoundingClientRect,\n            firstChild\n          );\n        }\n        return data;\n      })\n      .forEach(\n        (\n          {\n            el,\n            boundingClientRect: { top, left, width, height },\n            childCoords: { top: childTop, left: childLeft },\n          },\n          i\n        ) => {\n          const firstChild = el.children[0] as HTMLElement;\n          const itemPosition =\n            cachedPositionData[el.dataset[DATASET_KEY] as string];\n          const coords: Coords = {\n            scaleX: itemPosition.rect.width / width,\n            scaleY: itemPosition.rect.height / height,\n            translateX: itemPosition.rect.left - left,\n            translateY: itemPosition.rect.top - top,\n          };\n\n          el.style.transformOrigin = '0 0';\n          if (firstChild && childLeft === left && childTop === top) {\n            firstChild.style.transformOrigin = '0 0';\n          }\n\n          let cachedResolve = () => {};\n\n          const completionPromise = new Promise(resolve => {\n            cachedResolve = resolve;\n          });\n\n          completionPromises.push(completionPromise);\n\n          applyCoordTransform(el, coords, { immediate: true });\n          // now start the animation\n          const startAnimation = () => {\n            const { stop } = tween({\n              from: coords,\n              to: { translateX: 0, translateY: 0, scaleX: 1, scaleY: 1 },\n              duration,\n              ease: popmotionEasing[easing],\n            }).start({\n              update: (transforms: Coords) => {\n                applyCoordTransform(el, transforms);\n                // this helps prevent layout thrashing\n                sync.postRender(() => recordPositions([el]));\n              },\n              complete: cachedResolve,\n            });\n            itemPosition.stopTween = stop;\n          };\n\n          if (typeof stagger !== 'number') {\n            startAnimation();\n          } else {\n            const timeoutId = setTimeout(() => {\n              sync.update(startAnimation);\n            }, stagger * i);\n            itemPosition.stopTween = () => clearTimeout(timeoutId);\n          }\n        }\n      );\n\n    Promise.all(completionPromises).then(() => {\n      onEnd(animatedElements);\n    });\n  };\n\n  const observer = new MutationObserver(mutationCallback);\n  observer.observe(container, {\n    childList: true,\n    attributes: true,\n    subtree: true,\n    attributeFilter: ['class'],\n  });\n  const unwrapGrid = () => {\n    window.removeEventListener('resize', throttledResizeListener);\n    container.removeEventListener('scroll', throttledScrollListener);\n    observer.disconnect();\n  };\n  const forceGridAnimation = () => mutationCallback('forceGridAnimation');\n  return { unwrapGrid, forceGridAnimation };\n};\n"],"sourceRoot":""}