{"version":3,"file":"static/chunks/9468-e0eb621af4ec45d4.js","mappings":"mIAGA,IAAAA,EAAA,IAAAC,IAAA,CACA,UACA,WACA,SACA,YAIA,0GCXA,IAAAC,EAAA,CACAC,QAAA,EACA,iBCkBA,IAAAC,EAAA,CAAAC,EAAAC,EAAAC,IAAA,OAAAA,EAAA,EAAAD,CAAA,EAAAD,EAAA,GAAAE,EAAA,EAAAD,CAAA,GAAAD,EAAA,EAAAC,CAAA,EACAD,EAoBA,SAAAG,EAAAC,CAAA,CAAAC,CAAA,CAAAC,CAAA,CAAAC,CAAA,EAEA,GAAAH,IAAAC,GAAAC,IAAAC,EACA,OAAeC,EAAAC,CAAI,CACnB,IAAAC,EAAA,GAAAC,CArBA,SAAAC,CAAA,CAAAC,CAAA,CAAAC,CAAA,CAAAV,CAAA,CAAAE,CAAA,MACAS,EACAC,EACA,IAAAC,EAAA,EACA,EAGAF,CADAA,EAAAhB,EADAiB,EAAAH,EAAA,CAAAC,EAAAD,CAAA,IACAT,EAAAE,GAAAM,CAAAA,EACA,EACAE,EAAAE,EAGAH,EAAAG,QAEME,KAAAC,GAAA,CAAAJ,GAfN,MAgBA,EAAAE,EAfA,GAeA,CACA,OAAAD,CACA,GAKAI,EAAA,IAAAhB,EAAAE,GAEA,UAAAN,IAAAA,GAAAA,IAAAA,EAAAA,EAAAD,EAAAW,EAAAV,GAAAK,EAAAE,EACA,2BC5CA,IAAAc,EAA8BlB,EAAW,kBACzCmB,EAA6B,GAAAC,EAAAC,CAAA,EAAaH,GAC1CI,EAAgC,GAAAC,EAAAC,CAAA,EAAYL,GCJ5CM,EAAA,IAAAC,GAAA,QAA+CP,EAAMO,GAAA,MAAAX,KAAAY,GAAA,OAAAD,CAAAA,EAAA,2ECSrD,IAAAE,EAAA,CAAAC,EAAAC,IAEA,WAAAA,MAKA,iBAAAD,GAAAE,MAAAC,OAAA,CAAAH,IAEA,iBAAAA,GACSI,CAAAA,EAAAC,CAAO,CAAAC,IAAA,CAAAN,IAAAA,MAAAA,CAAA,GAChB,CAAAA,EAAAO,UAAA,UEtBAC,EAAA,GAAAR,OAAAA,EACA,SAAAS,EAAAC,CAAA,EAAuCC,OAAAA,CAAA,CAAAC,WAAAA,EAAA,OAA6B,CAAAC,CAAA,EACpE,IAAAC,EAAAJ,EAAAK,MAAA,CAAAP,GACAQ,EAAAL,GAAAC,SAAAA,GAAAD,EAAA,KACA,EACAG,EAAAG,MAAA,GACA,UAAAJ,KAAAK,IAAAL,EAEAA,EADAC,CAAA,CAAAE,EAAA,CCQA,MAAAG,EACAC,YAAA,CAAkBC,SAAAA,EAAA,GAAAC,MAAAA,EAAA,EAAAC,KAAAA,EAAA,YAAAZ,OAAAA,EAAA,EAAAa,YAAAA,EAAA,EAAAZ,WAAAA,EAAA,UAAAa,EAA8G,EAEhI,KAAAC,SAAA,IACA,KAAAC,mBAAA,IACA,KAAAC,SAAA,CAAyBC,EAAAC,CAAI,CAAAC,GAAA,GAC7B,KAAAN,OAAA,EACAJ,SAAAA,EACAC,MAAAA,EACAC,KAAAA,EACAZ,OAAAA,EACAa,YAAAA,EACAZ,WAAAA,EACA,GAAAa,CAAA,EAEA,KAAAO,qBAAA,EACA,CAWAC,eAAA,QACA,KAAAC,UAAA,EAEA,KAAAA,UAAA,MAAAN,SAAA,CA/BA,GAgCA,KAAAM,UAAA,CACA,KAAAN,SAAA,CAOA,IAAAO,UAAA,CAIA,OAHA,KAAAC,SAAA,OAAAT,mBAAA,EACY,GAAAU,EAAAC,CAAA,IAEZ,KAAAF,SAAA,CAOAG,oBAAA7B,CAAA,CAAAG,CAAA,EACA,KAAAqB,UAAA,CAA0BL,EAAAC,CAAI,CAAAC,GAAA,GAC9B,KAAAJ,mBAAA,IACA,IAAgB1B,KAAAA,CAAA,CAAAsB,KAAAA,CAAA,CAAAiB,SAAAA,CAAA,CAAAlB,MAAAA,CAAA,CAAAmB,WAAAA,CAAA,CAAAC,SAAAA,CAAA,CAAAC,YAAAA,CAAA,EAAkE,KAAAlB,OAAA,CAKlF,IAAAkB,GAAA,CAA6BC,SF5D7BlC,CAAA,CAAAT,CAAA,CAAAsB,CAAA,CAAAiB,CAAA,EAMA,IAAAK,EAAAnC,CAAA,IACA,GAAAmC,OAAAA,EACA,SAMA,GAAA5C,YAAAA,GAAAA,eAAAA,EACA,SACA,IAAA6C,EAAApC,CAAA,CAAAA,EAAAO,MAAA,IACA8B,EAA+BhD,EAAY8C,EAAA5C,GAC3C+C,EAA+BjD,EAAY+C,EAAA7C,SAG3C,CAFI,EAAAgD,EAAAC,CAAA,EAAOH,IAAAC,EAAA,6BAAyE/C,EAAA,OAAM,EAAQ4C,EAAe,QAAQC,EAAe,KAAKD,EAAA,2DAAgB,EAA4DA,EAAA,0BAAgB,EAA2BC,EAAA,4BAAgB,KAEpRC,KAAAC,GAGAG,CAAAA,SAjCAzC,CAAA,EACA,IAAA5C,EAAA4C,CAAA,IACA,GAAAA,IAAAA,EAAAO,MAAA,CACA,SACA,QAAAhC,EAAA,EAAoBA,EAAAyB,EAAAO,MAAA,CAAsBhC,IAC1C,GAAAyB,CAAA,CAAAzB,EAAA,GAAAnB,EACA,QAEA,EAyBA4C,IACA,CAAAa,WAAAA,GAA+B,GAAA6B,EAAAC,EAAA,EAAW9B,EAAA,GAAAiB,CAAA,CAC1C,EEkCuC9B,EAAAT,EAAAsB,EAAAiB,GAAA,CAEvC,GAAgB3E,EAAqBC,OAAA,GAAAwD,EAAA,CACrCoB,GACAA,EAA6BjC,EAAgBC,EAAA,KAAAe,OAAA,CAAAZ,IAC7C4B,GAAAA,IACA,KAAAa,sBAAA,GACA,MACA,CAGA,KAAA7B,OAAA,CAAA8B,QAAA,EAEA,CACA,IAAAC,EAAA,KAAAC,YAAA,CAAA/C,EAAAG,EACA,MAAA2C,IAEA,KAAApB,SAAA,EACA1B,UAAAA,EACAG,cAAAA,EACA,GAAA2C,CAAA,EAEA,KAAAE,cAAA,GACA,CACAA,gBAAA,EAMAC,KAAAC,CAAA,CAAAC,CAAA,EACA,YAAAC,sBAAA,CAAAH,IAAA,CAAAC,EAAAC,EACA,CACAE,SAAA,CACA,KAAAtC,OAAA,CAAAF,IAAA,aACA,KAAAE,OAAA,CAAAuC,IAAA,SACA,CACAhC,uBAAA,CACA,KAAA8B,sBAAA,KAAAG,QAAA,IACA,KAAAX,sBAAA,CAAAM,CACA,EACA,CACA,2BClHA,SAAAM,EAAArE,CAAA,CAAAsE,CAAA,CAAAnG,CAAA,QAKA,CAJAA,EAAA,GACAA,CAAAA,GAAA,GACAA,EAAA,GACAA,CAAAA,GAAA,GACAA,EAAA,KACA6B,EAAA,CAAAsE,EAAAtE,CAAAA,EAAA,EAAA7B,EACAA,EAAA,GACAmG,EACAnG,EAAA,IACA6B,EAAA,CAAAsE,EAAAtE,CAAAA,EAAA,KAAA7B,CAAAA,EAAA,EACA6B,CACA,sCCbA,SAAAuE,EAAAC,CAAA,CAAAC,CAAA,EACA,UAAAzE,EAAA,EAAAyE,EAAAD,CACA,CCSA,IAAAE,EAAA,CAAAC,EAAAC,EAAAC,KACA,IAAAC,EAAAH,EAAAA,EACAI,EAAAF,EAAAD,CAAAA,EAAAA,EAAAE,CAAA,EAAAA,EACA,OAAAC,EAAA,IAAA1F,KAAA2F,IAAA,CAAAD,EACA,EACAE,EAAA,CAAoBC,EAAAC,CAAG,CAAEC,EAAA3C,CAAI,CAAE4C,EAAAC,CAAI,EACnCC,EAAA,GAAAN,EAAAO,IAAA,IAAA9D,EAAAjB,IAAA,CAAAoE,IACA,SAAAY,EAAAC,CAAA,EACA,IAAAhE,EAAA6D,EAAAG,GAEA,GADI,GAAAtC,EAAAC,CAAA,EAAOsC,CAAAA,CAAAjE,EAAA,IAAoBgE,EAAM,uEACrC,CAAAhE,EACA,SACA,IAAAkE,EAAAlE,EAAAmE,KAAA,CAAAH,GAKA,OAJAhE,IAAiB2D,EAAAC,CAAI,EAErBM,CAAAA,EAAgBE,SFZhB,CAAsBC,IAAAA,CAAA,CAAAC,WAAAA,CAAA,CAAAC,UAAAA,CAAA,CAAAC,MAAAA,CAAA,CAAmC,EACzDH,GAAA,IAEAE,GAAA,IACA,IAAAE,EAAA,EACAC,EAAA,EACAC,EAAA,EACA,GALAL,GAAA,IAQA,CACA,IAAA1B,EAAA2B,EAAA,GACAA,EAAA,GAAAD,CAAA,EACAC,EAAAD,EAAAC,EAAAD,EACAhG,EAAA,EAAAiG,EAAA3B,EACA6B,EAAA9B,EAAArE,EAAAsE,EAAAyB,EAAA,KACAK,EAAA/B,EAAArE,EAAAsE,EAAAyB,GACAM,EAAAhC,EAAArE,EAAAsE,EAAAyB,EAAA,IACA,MAVAI,EAAAC,EAAAC,EAAAJ,EAWA,OACAE,IAAA9G,KAAAiH,KAAA,CAAAH,IAAAA,GACAC,MAAA/G,KAAAiH,KAAA,CAAAF,IAAAA,GACAC,KAAAhH,KAAAiH,KAAA,CAAAD,IAAAA,GACAH,MAAAA,CACA,CACA,EEb0BN,EAAA,EAE1BA,CACA,CACA,IAAAW,EAAA,CAAA5B,EAAAC,KACA,IAAA4B,EAAAf,EAAAd,GACA8B,EAAAhB,EAAAb,GACA,IAAA4B,GAAA,CAAAC,EACA,OAAelC,EAAYI,EAAAC,GAE3B,IAAA8B,EAAA,CAAsB,GAAAF,CAAA,EACtB,WACAE,EAAAP,GAAA,CAAAzB,EAAA8B,EAAAL,GAAA,CAAAM,EAAAN,GAAA,CAAAtB,GACA6B,EAAAN,KAAA,CAAA1B,EAAA8B,EAAAJ,KAAA,CAAAK,EAAAL,KAAA,CAAAvB,GACA6B,EAAAL,IAAA,CAAA3B,EAAA8B,EAAAH,IAAA,CAAAI,EAAAJ,IAAA,CAAAxB,GACA6B,EAAAR,KAAA,CAAwB,GAAAS,EAAAxI,CAAA,EAASqI,EAAAN,KAAA,CAAAO,EAAAP,KAAA,CAAArB,GAClBO,EAAA3C,CAAI,CAAAmE,SAAA,CAAAF,GAEnB,uCC5CA,IAAAG,EAAA,IAAA9I,IAAA,mBCUA,SAAA+I,EAAAtC,CAAA,CAAAC,CAAA,EACA,UAAkB,GAAAkC,EAAAxI,CAAA,EAAWqG,EAAAC,EAAAzE,EAC7B,CACA,SAAA+G,EAAAvC,CAAA,QACA,iBAAAA,EACAsC,EAEA,iBAAAtC,EACe,GAAAwC,EAAA7I,CAAA,EAAkBqG,GACnBD,EACAmB,EAAAP,CAAK,CAAA1E,IAAA,CAAA+D,GACD+B,EAClBU,EAEA5G,MAAAC,OAAA,CAAAkE,GACA0C,EAEA,iBAAA1C,EACekB,EAAAP,CAAK,CAAA1E,IAAA,CAAA+D,GAAW+B,EAAQY,EAE5B5C,CACX,CACA,SAAA2C,EAAA1C,CAAA,CAAAC,CAAA,EACA,IAAA2C,EAAA,IAAA5C,EAAA,CACA6C,EAAAD,EAAAhG,MAAA,CACAkG,EAAA9C,EAAA+C,GAAA,EAAA1C,EAAAzF,IAAA2H,EAAAlC,GAAAA,EAAAJ,CAAA,CAAArF,EAAA,GACA,WACA,QAAAA,EAAA,EAAwBA,EAAAiI,EAAejI,IACvCgI,CAAA,CAAAhI,EAAA,CAAAkI,CAAA,CAAAlI,EAAA,CAAAY,GAEA,OAAAoH,CACA,CACA,CACA,SAAAD,EAAA3C,CAAA,CAAAC,CAAA,EACA,IAAA2C,EAAA,CAAqB,GAAA5C,CAAA,IAAAC,CAAA,EACrB6C,EAAA,GACA,QAAAE,KAAAJ,EACA/F,KAAAA,IAAAmD,CAAA,CAAAgD,EAAA,EAAA/C,KAAApD,IAAAoD,CAAA,CAAA+C,EAAA,EACAF,CAAAA,CAAA,CAAAE,EAAA,CAAAT,EAAAvC,CAAA,CAAAgD,EAAA,EAAAhD,CAAA,CAAAgD,EAAA,CAAA/C,CAAA,CAAA+C,EAAA,GAGA,WACA,QAAAA,KAAAF,EACAF,CAAA,CAAAI,EAAA,CAAAF,CAAA,CAAAE,EAAA,CAAA3C,GAEA,OAAAuC,CACA,CACA,CAcA,IAAAH,EAAA,CAAAQ,EAAAC,KACA,IAAAC,EAAqBpH,EAAAC,CAAO,CAAAoH,iBAAA,CAAAF,GAC5BG,EAAwB,GAAAtH,EAAAuH,CAAA,EAAmBL,GAC3CM,EAAwB,GAAAxH,EAAAuH,CAAA,EAAmBJ,UAI3C,EAHAM,OAAA,CAAAC,GAAA,CAAA7G,MAAA,GAAA2G,EAAAC,OAAA,CAAAC,GAAA,CAAA7G,MAAA,EACAyG,EAAAG,OAAA,CAAAtC,KAAA,CAAAtE,MAAA,GAAA2G,EAAAC,OAAA,CAAAtC,KAAA,CAAAtE,MAAA,EACAyG,EAAAG,OAAA,CAAArB,MAAA,CAAAvF,MAAA,EAAA2G,EAAAC,OAAA,CAAArB,MAAA,CAAAvF,MAAA,CAEA,EAA4B8G,GAAA,CAAAT,IAC5B,CAAAM,EAAAI,MAAA,CAAA/G,MAAA,EACayF,EAAeqB,GAAA,CAAAR,IAC5B,CAAAG,EAAAM,MAAA,CAAA/G,MAAA,CD3EA,EAAA8G,GAAA,CC4EgCT,GD3EhC,GAAAzH,GAAA,EC2EgCyH,EAAAC,EDxEhC,GAAA1H,GAAA,ECwEgC0H,EAAAD,EAEjB,GAAAW,EAAAC,CAAA,EAAInB,EAAAoB,SA3BnBb,CAAA,CAAAC,CAAA,EACA,IAAAa,EACA,IAAAC,EAAA,GACAC,EAAA,CAAuB/C,MAAA,EAAAuC,IAAA,EAAAtB,OAAA,GACvB,QAAAvH,EAAA,EAAoBA,EAAAsI,EAAAS,MAAA,CAAA/G,MAAA,CAA0BhC,IAAA,CAC9C,IAAAsC,EAAAgG,EAAAgB,KAAA,CAAAtJ,EAAA,CACAuJ,EAAAlB,EAAAO,OAAA,CAAAtG,EAAA,CAAA+G,CAAA,CAAA/G,EAAA,EACAkH,EAAA,OAAAL,CAAAA,EAAAd,EAAAU,MAAA,CAAAQ,EAAA,GAAAJ,KAAA,IAAAA,EAAAA,EAAA,CACAC,CAAAA,CAAA,CAAApJ,EAAA,CAAAwJ,EACAH,CAAA,CAAA/G,EAAA,EACA,CACA,OAAA8G,CACA,EAemBX,EAAAE,GAAAA,EAAAI,MAAA,EAAAR,IAGX,GAAAvE,EAAAC,CAAA,EAAO,sBAA0BoE,EAAO,SAASC,EAAO,2KACjDnD,EAAYkD,EAAAC,GAE3B,ECxFA,SAAAmB,EAAAlE,CAAA,CAAAC,CAAA,CAAA5E,CAAA,QACA,iBAAA2E,GACA,iBAAAC,GACA,iBAAA5E,EACe,GAAA2G,EAAAxI,CAAA,EAASwG,EAAAC,EAAA5E,GAGxB8I,EAD0BnE,GAC1BA,EAAAC,EACA,gBCRA,SAAAmE,EAAAC,CAAA,CAAA7K,CAAA,CAAAF,CAAA,EACA,IAAAgL,EAAA5J,KAAA6J,GAAA,CAAA/K,EAFA,EAEA,GACA,MAAW,GAAAgL,EAAAC,CAAA,EAAiBnL,EAAA+K,EAAAC,GAAA9K,EAAA8K,EAC5B,CCNA,IAAAI,EAAA,CAEAC,UAAA,IACAC,QAAA,GACAC,KAAA,EACA7G,SAAA,EAEAe,SAAA,IACA+F,OAAA,GACAC,eAAA,GAEAC,UAAA,CACAC,SAAA,IACAC,QAAA,CACA,EACAC,UAAA,CACAF,SAAA,KACAC,QAAA,EACA,EAEAE,YAAA,IACAC,YAAA,GACAC,WAAA,IACAC,WAAA,CACA,ECwDA,SAAAC,EAAAC,CAAA,CAAAC,CAAA,EACA,OAAAD,EAAA/K,KAAA2F,IAAA,GAAAqF,EAAAA,EACA,CC3EA,IAAAC,EAAA,sBACAC,GAAA,+BACA,SAAAC,GAAA5I,CAAA,CAAA6I,CAAA,EACA,OAAAA,EAAAC,IAAA,IAAA9I,KAAAP,IAAAO,CAAA,CAAA4F,EAAA,CACA,CAuCA,SAAAmD,GAAAC,EAA0CvB,EAAcK,cAAA,CAAAD,EAA0BJ,EAAcI,MAAA,MAsChGoB,EArCA,IAAAjJ,EAAA,iBAAAgJ,EACA,CACAlB,eAAAkB,EACA/J,UAAA,MACA4I,OAAAA,CACA,EACAmB,EACA,CAAUjB,UAAAA,CAAA,CAAAG,UAAAA,CAAA,EAAuBlI,EACjC6F,EAAA7F,EAAAf,SAAA,IACA6G,EAAA9F,EAAAf,SAAA,CAAAe,EAAAf,SAAA,CAAAO,MAAA,IAKA0J,EAAA,CAAoBC,KAAA,GAAA5K,MAAAsH,CAAA,EACpB,CAAY6B,UAAAA,CAAA,CAAAC,QAAAA,CAAA,CAAAC,KAAAA,CAAA,CAAA9F,SAAAA,CAAA,CAAAf,SAAAA,CAAA,CAAAqI,uBAAAA,CAAA,EAAwEC,SAtDpFrJ,CAAA,EACA,IAAAsJ,EAAA,CACAvI,SAAkB0G,EAAc1G,QAAA,CAChC2G,UAAmBD,EAAcC,SAAA,CACjCC,QAAiBF,EAAcE,OAAA,CAC/BC,KAAcH,EAAcG,IAAA,CAC5BwB,uBAAA,GACA,GAAApJ,CAAA,EAGA,IAAA4I,GAAA5I,EAAA2I,KACAC,GAAA5I,EAAA0I,IACA,GAAA1I,EAAA8H,cAAA,EAEA,IAAAyB,EAAA,EAAA9L,KAAA+L,EAAA,CAAA1B,CAAAA,IADA9H,EAAA8H,cAAA,EAEAJ,EAAA6B,EAAAA,EACA5B,EAAA,EACgB,GAAA8B,EAAAC,CAAA,EAAK,QAAA1J,CAAAA,EAAA6H,MAAA,MACrBpK,KAAA2F,IAAA,CAAAsE,GACA4B,EAAA,CACA,GAAAA,CAAA,CACA1B,KAAsBH,EAAcG,IAAA,CACpCF,UAAAA,EACAC,QAAAA,CACA,CACA,KACA,CACA,IAAAgC,EAA4BC,SDlC5B,CAAsB9H,SAAAA,EAAW2F,EAAc3F,QAAA,CAAA+F,OAAAA,EAAoBJ,EAAcI,MAAA,CAAA9G,SAAAA,EAAoB0G,EAAc1G,QAAA,CAAA6G,KAAAA,EAAkBH,EAAcG,IAAA,CAAQ,MAC3JiC,EACAC,EACI,GAAAtI,EAAAC,CAAA,EAAOK,GAAa,GAAAiI,EAAAC,CAAA,EAAsBvC,EAAcW,WAAA,gDAC5D,IAAAK,EAAA,EAAAZ,EAIAY,EAAmB,GAAAgB,EAAAC,CAAA,EAAMjC,EAAcY,UAAA,CAAaZ,EAAca,UAAA,CAAAG,GAClE3G,EAAe,GAAA2H,EAAAC,CAAA,EAAMjC,EAAcU,WAAA,CAAcV,EAAcW,WAAA,CAAc,GAAA2B,EAAA1J,CAAA,EAAqByB,IAClG2G,EAAA,GAIAoB,EAAA,IACA,IAAAI,EAAAzB,EAAAC,EACAyB,EAAAD,EAAAnI,EAIA,OAAAqI,KAAA,CAHAF,EAAAlJ,CAAA,EACAwH,EAAAC,EAAAC,GACAhL,KAAA2M,GAAA,EAAAF,EAEA,EACAJ,EAAA,IAEA,IAAAI,EAAAD,EADAxB,EACA3G,EAEAuI,EAAA5M,KAAAY,GAAA,CAAAoK,EAAA,GAAAhL,KAAAY,GAAA,CAAAmK,EAAA,GAAA1G,EAEAwI,EAAA/B,EAAA9K,KAAAY,GAAA,CAAAmK,EAAA,GAAAC,GAEA,OAAA8B,EALAxJ,EAAAA,EAKAsJ,CAAAA,EAHA5M,KAAA2M,GAAA,EAAAF,GAEA,EAAAL,EAAArB,GA9BA,KA8BA,QACA8B,CACA,IAMAT,EAAA,GAGA,MAAAjH,KAFAwH,GAAA,EAAA5B,EAAA1G,GACA,EAAA0G,EAAAzH,CAAA,EAAAe,EAAA,GAGAgI,EAAA,GAGAlH,EADAd,EAAAf,CAAAA,EAAAyH,CAAA,EADA/K,KAAA2M,GAAA,EAAA5B,EAAA1G,IAMA,IAAA0G,EAAAgC,SAmBAX,CAAA,CAAAC,CAAA,CAAAW,CAAA,EACA,IAAAC,EAAAD,EACA,QAAAjN,EAAA,EAAoBA,EAHpB,GAGwCA,IACxCkN,GAAAb,EAAAa,GAAAZ,EAAAY,GAEA,OAAAA,CACA,EAzBAb,EAAAC,EADA,EAAAhI,GAGA,GADAA,EAAe,GAAAiI,EAAAC,CAAA,EAAqBlI,GACpC6I,MAAAnC,GACA,OACAd,UAAuBD,EAAcC,SAAA,CACrCC,QAAqBF,EAAcE,OAAA,CACnC7F,SAAAA,CACA,CAEA,EACA,IAAA4F,EAAAjK,KAAAY,GAAA,CAAAmK,EAAA,GAAAZ,EACA,OACAF,UAAAA,EACAC,QAAAc,EAAAA,EAAAhL,KAAA2F,IAAA,CAAAwE,EAAAF,GACA5F,SAAAA,CACA,CACA,CACA,EChCsC9B,EAMtCsJ,CALAA,CAAAA,EAAA,CACA,GAAAA,CAAA,CACA,GAAAK,CAAA,CACA/B,KAAsBH,EAAcG,IAAA,CACpC,EACAwB,sBAAA,GACA,EAEA,OAAAE,CACA,EAiBoF,CACpF,GAAAtJ,CAAA,CACAe,SAAA,CAAmB,GAAAgJ,EAAA1J,CAAA,EAAqBL,EAAAe,QAAA,IACxC,GACA6J,EAAA7J,GAAA,EACA0H,EAAAd,EAAA,GAAAlK,KAAA2F,IAAA,CAAAsE,EAAAE,EAAA,EACAiD,EAAA/E,EAAAD,EACAiF,EAAgC,GAAAf,EAAA1J,CAAA,EAAqB5C,KAAA2F,IAAA,CAAAsE,EAAAE,IAQrDmD,EAAAtN,EAAAA,KAAAC,GAAA,CAAAmN,GAQA,GAPA9C,GAAAA,CAAAA,EAAAgD,EACUtD,EAAcM,SAAA,CAAAC,QAAA,CACdP,EAAcM,SAAA,CAAAE,OAAA,EACxBC,GAAAA,CAAAA,EAAA6C,EACUtD,EAAcS,SAAA,CAAAF,QAAA,CACdP,EAAcS,SAAA,CAAAD,OAAA,EAExBQ,EAAA,GACA,IAAAuC,EAA4BzC,EAAeuC,EAAArC,GAE3CQ,EAAA,GAEAnD,EACA+D,KAFAO,GAAA,EAAA3B,EAAAqC,EAAAvO,GAGA,EAAAqO,EACAnC,EAAAqC,EAAAD,CAAA,EACAG,EACAvN,KAAAwN,GAAA,CAAAD,EAAAzO,GACAsO,EAAApN,KAAAyN,GAAA,CAAAF,EAAAzO,EAAA,CAEA,MACA,GAAAkM,IAAAA,EAEAQ,EAAA,GAAAnD,EACArI,KAAA2M,GAAA,EAAAU,EAAAvO,GACAsO,CAAAA,EACA,CAAAD,EAAAE,EAAAD,CAAA,EAAAtO,CAAAA,MAEA,CAEA,IAAA4O,EAAAL,EAAArN,KAAA2F,IAAA,CAAAqF,EAAAA,EAAA,GACAQ,EAAA,IACA,IAAAY,EAAApM,KAAA2M,GAAA,EAAA3B,EAAAqC,EAAAvO,GAEA6O,EAAA3N,KAAA4N,GAAA,CAAAF,EAAA5O,EAAA,KACA,OAAAuJ,EACA,EACA,EAAA8E,EACAnC,EAAAqC,EAAAD,CAAA,EACApN,KAAA6N,IAAA,CAAAF,GACAD,EACAN,EACApN,KAAA8N,IAAA,CAAAH,EAAA,EACAD,CACA,CACA,CACA,IAAAK,EAAA,CACAC,mBAAArC,GAAAtH,GAAA,KACA4J,KAAA,IACA,IAAArP,EAAA4M,EAAA1M,GACA,GAAA6M,EAmBAF,EAAAC,IAAA,CAAA5M,GAAAuF,MAnBA,CACA,IAAA6J,EAAA,EAMAlD,EAAA,GACAkD,CAAAA,EACApP,IAAAA,EAC8B,GAAAwN,EAAAC,CAAA,EAAqBY,GACrBzD,EAAqB8B,EAAA1M,EAAAF,EAAA,EAEnD,IAAAuP,EAAAnO,KAAAC,GAAA,CAAAiO,IAAA5D,EACA8D,EAAApO,KAAAC,GAAA,CAAAoI,EAAAzJ,IAAA6L,CACAgB,CAAAA,EAAAC,IAAA,CACAyC,GAAAC,CACA,CAKA,OADA3C,EAAA3K,KAAA,CAAA2K,EAAAC,IAAA,CAAArD,EAAAzJ,EACA6M,CACA,EACA4C,SAAA,KACA,IAAAL,EAAAhO,KAAA4N,GAAA,CAAgD,GAAA1J,EAAAoK,EAAA,EAAqBP,GAAa7J,EAAAqK,EAAoB,EACtGC,EAA2B,GAAAtK,EAAAuK,EAAA,EAAoB,GAAAV,EAAAE,IAAA,CAAAD,EAAAU,GAAA5N,KAAA,CAAAkN,EAAA,IAC/C,OAAAA,EAAA,MAAAQ,CACA,CACA,EACA,OAAAT,CACA,CChKA,SAAAY,GAAA,CAAmBnN,UAAAA,CAAA,CAAA8B,SAAAA,EAAA,EAAAsL,MAAAA,EAAA,GAAAC,aAAAA,EAAA,IAAAC,cAAAA,EAAA,GAAAC,gBAAAA,EAAA,IAAAC,aAAAA,CAAA,CAAApB,IAAAA,CAAA,CAAA/D,IAAAA,CAAA,CAAAY,UAAAA,EAAA,GAAAH,UAAAA,CAAA,CAA4J,MAqC/K2E,EACAC,EArCA,IAAA9G,EAAA5G,CAAA,IACAiK,EAAA,CACAC,KAAA,GACA5K,MAAAsH,CACA,EACA+G,EAAA,QAAAnN,IAAA4L,GAAApI,EAAAoI,GAAA/D,KAAA7H,IAAA6H,GAAArE,EAAAqE,EACAuF,EAAA,GACA,KAAApN,IAAA4L,EACA/D,EACAA,KAAA7H,IAAA6H,EACA+D,EACA5N,KAAAC,GAAA,CAAA2N,EAAApI,GAAAxF,KAAAC,GAAA,CAAA4J,EAAArE,GAAAoI,EAAA/D,EAEAwF,EAAAT,EAAAtL,EACAgM,EAAAlH,EAAAiH,EACAhH,EAAA2G,KAAAhN,IAAAgN,EAAAM,EAAAN,EAAAM,GAKAjH,IAAAiH,GACAD,CAAAA,EAAAhH,EAAAD,CAAA,EACA,IAAAmH,EAAA,IAAAF,EAAArP,KAAA2M,GAAA,EAAA7N,EAAA+P,GACAW,EAAA,GAAAnH,EAAAkH,EAAAzQ,GACA2Q,EAAA,IACA,IAAAhD,EAAA8C,EAAAzQ,GACA4Q,EAAAF,EAAA1Q,EACA2M,CAAAA,EAAAC,IAAA,CAAA1L,KAAAC,GAAA,CAAAwM,IAAAhC,EACAgB,EAAA3K,KAAA,CAAA2K,EAAAC,IAAA,CAAArD,EAAAqH,CACA,EASAC,EAAA,IACAR,EAAA1D,EAAA3K,KAAA,IAEAmO,EAAAnQ,EACAoQ,EAAmB5D,GAAM,CACzB9J,UAAA,CAAAiK,EAAA3K,KAAA,CAAAsO,EAAA3D,EAAA3K,KAAA,GACAwC,SAAsBoG,EAAqB8F,EAAA1Q,EAAA2M,EAAA3K,KAAA,EAC3CoJ,QAAA4E,EACA7E,UAAA8E,EACAtE,UAAAA,EACAH,UAAAA,CACA,GACA,EAEA,OADAqF,EAAA,GACA,CACA3B,mBAAA,KACAC,KAAA,IAOA,IAAA2B,EAAA,SAUA,CATAV,GAAAD,KAAAjN,IAAAiN,IACAW,EAAA,GACAH,EAAA3Q,GACA6Q,EAAA7Q,IAMAmQ,KAAAjN,IAAAiN,GAAAnQ,GAAAmQ,GACAC,EAAAjB,IAAA,CAAAnP,EAAAmQ,IAGA,GAAAQ,EAAA3Q,GACA2M,EAEA,CACA,CACA,CClFA,IAAAoE,GAA6B5Q,EAAW,WACxC6Q,GAA8B7Q,EAAW,WACzC8Q,GAAgC9Q,EAAW,aCJ3C+Q,GAAA,GACAhP,MAAAC,OAAA,CAAA6D,IAAA,iBAAAA,CAAA,ICOAmL,GAAA,CACAC,OAAY5Q,EAAAC,CAAI,CAChBsQ,OAAUA,GACVE,UAAaA,GACbD,QAAWA,GACXK,OAAUC,EAAAC,EAAA,CACVC,UAAaF,EAAAG,EAAA,CACbC,QAAWJ,EAAAK,EAAA,CACXrQ,OAAUA,EACVG,UAAaA,EACbJ,QAAWA,EACXO,WAAcA,CACd,EACAgQ,GAAA,IACA,GAAQ,GAAAxM,EAAAyM,EAAA,EAAkBC,GAAA,CAElB,GAAA7M,EAAA8M,CAAA,EAASD,IAAAA,EAAA7O,MAAA,4DACjB,IAAA+O,EAAAC,EAAAC,EAAAC,EAAA,CAAAL,EACA,OAAe3R,EAAW6R,EAAAC,EAAAC,EAAAC,EAC1B,OACA,iBAAAL,GAEQ,GAAA7M,EAAA8M,CAAA,EAASZ,KAAAjO,IAAAiO,EAAA,CAAAW,EAAA,yBAAiEA,EAAW,IAC7FX,EAAA,CAAAW,EAAA,EAEAA,CACA,kBKxBA,SAAApP,GAAA,CAAqB6C,SAAAA,EAAA,IAAA7C,UAAA0P,CAAA,CAAAC,MAAAA,CAAA,CAAArM,KAAAA,EAAA,YAAuE,EAK5F,IAAAsM,EAA4BpB,GAAalL,GACzCA,EAAAoD,GAAA,CAAmBwI,IACTA,GAA0B5L,GAKpC2G,EAAA,CACAC,KAAA,GACA5K,MAAAoQ,CAAA,KAWAG,EAA8BC,SJG9BC,CAAA,CAAAxJ,CAAA,EAAsCiE,MAAAwF,EAAA,GAAA1M,KAAAA,CAAA,CAAA2E,MAAAA,CAAA,EAAqC,EAAI,EAC/E,IAAAgI,EAAAF,EAAAxP,MAAA,CAMA,GALI,GAAAgC,EAAA8M,CAAA,EAASY,IAAA1J,EAAAhG,MAAA,yDAKb0P,IAAAA,EACA,UAAA1J,CAAA,IACA,GAAA0J,IAAAA,GAAA1J,CAAA,MAAAA,CAAA,IACA,UAAAA,CAAA,IACA,IAAA2J,EAAAH,CAAA,MAAAA,CAAA,IAEAA,CAAA,IAAAA,CAAA,CAAAE,EAAA,KACAF,EAAA,IAAAA,EAAA,CAAAlR,OAAA,GACA0H,EAAA,IAAAA,EAAA,CAAA1H,OAAA,IAEA,IAAAsR,EAAAC,SAlDA7J,CAAA,CAAAjD,CAAA,CAAA+M,CAAA,EACA,IAAAF,EAAA,GACAG,EAAAD,GAAwCrI,EACxCuI,EAAAhK,EAAAhG,MAAA,GACA,QAAAhC,EAAA,EAAoBA,EAAAgS,EAAehS,IAAA,CACnC,IAAA0J,EAAAqI,EAAA/J,CAAA,CAAAhI,EAAA,CAAAgI,CAAA,CAAAhI,EAAA,IACA,GAAA+E,EAAA,CACA,IAAAkN,EAAAhR,MAAAC,OAAA,CAAA6D,GAAAA,CAAA,CAAA/E,EAAA,EAAoET,EAAAC,CAAI,CAAAuF,EACxE2E,EAAoB,GAAAV,EAAAC,CAAA,EAAIgJ,EAAAvI,EACxB,CACAkI,EAAAM,IAAA,CAAAxI,EACA,CACA,OAAAkI,CACA,EAqCA5J,EAAAjD,EAAA2E,GACAsI,EAAAJ,EAAA5P,MAAA,CACAmQ,EAAA,IACA,GAAAR,GAAAlM,EAAA+L,CAAA,IACA,OAAAxJ,CAAA,IACA,IAAAhI,EAAA,EACA,GAAAgS,EAAA,EACA,KACA,EADmBR,EAAAxP,MAAA,KACnByD,CAAAA,EAAA+L,CAAA,CAAAxR,EAAA,IADyCA,KAKzC,IAAAoS,EAAgC,GAAAzD,GAAA0D,CAAA,EAAQb,CAAA,CAAAxR,EAAA,CAAAwR,CAAA,CAAAxR,EAAA,GAAAyF,GACxC,OAAAmM,CAAA,CAAA5R,EAAA,CAAAoS,EACA,EACA,OAAAX,EACA,GAAAU,EAA8B,GAAAlG,EAAAC,CAAA,EAAKsF,CAAA,IAAAA,CAAA,CAAAE,EAAA,GAAAjM,IACnC0M,CACA,EGxEAG,CC+BAlB,GAAAA,EAAApP,MAAA,GAAAmP,EAAAnP,MAAA,CACAoP,EACUmB,SFhCVC,CAAA,EACA,IAAAF,EAAA,IAEA,OADIG,SDDJH,CAAA,CAAAI,CAAA,EACA,IAAA7E,EAAAyE,CAAA,CAAAA,EAAAtQ,MAAA,IACA,QAAAhC,EAAA,EAAoBA,GAAA0S,EAAgB1S,IAAA,CACpC,IAAA2S,EAA+B,GAAAhE,GAAA0D,CAAA,EAAQ,EAAAK,EAAA1S,GACvCsS,EAAAJ,IAAA,CAAoB,GAAA3K,EAAAxI,CAAA,EAAS8O,EAAA,EAAA8E,GAC7B,CACA,ECLcL,EAAAE,EAAAxQ,MAAA,IACdsQ,CACA,EE4BuBnB,EAAA,EDjCvBhJ,GAAA,IAAAzH,ECiCuB4D,GACkB6M,EAAA,CACzCpM,KAAA9D,MAAAC,OAAA,CAAAmQ,GACAA,EA7BAtI,EAAAZ,GAAA,KAAAsG,GAAsCuB,IAAS4C,MAAA,GAAA7J,EAAA/G,MAAA,GA+B/C,GACA,OACAiM,mBAAA3J,EACA4J,KAAA,IACAxC,EAAA3K,KAAA,CAAAuQ,EAAAvS,GACA2M,EAAAC,IAAA,CAAA5M,GAAAuF,EACAoH,EAEA,CACA,CC7CA,IAAAmH,GAAA,IACA,IAAAC,EAAA,EAA6BC,UAAAA,CAAA,CAAW,GAAAC,EAAAD,GACxC,OACAE,MAAA,IAAqBC,EAAAC,EAAK,CAAAH,MAAA,CAAAF,EAAA,IAC1BM,KAAA,IAAoB,GAAAF,EAAAG,EAAA,EAAWP,GAK/BhQ,IAAA,IAAoBoQ,EAAAI,SAAS,CAAAC,YAAA,CAAgBL,EAAAI,SAAS,CAAAP,SAAA,CAAanQ,EAAAC,CAAI,CAAAC,GAAA,EACvE,CACA,ECDA0Q,GAAA,CACAC,MAAW7E,GACXA,QAAWA,GACX8E,MAAWjS,GACXA,UAAeA,GACf8J,OAAUA,EACV,EACAoI,GAAA,GAAAC,EAAA,GAMA,OAAAC,WAAkC3R,EAClCC,YAAAK,CAAA,EACA,MAAAA,GAIA,KAAAsR,QAAA,MAIA,KAAAC,UAAA,MAIA,KAAAC,WAAA,GAIA,KAAAC,aAAA,GAMA,KAAAC,gBAAA,WAIA,KAAAC,SAAA,MACA,KAAAzI,KAAA,QAKA,KAAA0H,IAAA,MAGA,GAFA,KAAAgB,QAAA,CAAAC,MAAA,GACA,KAAA5R,SAAA,IACA,cAAAiJ,KAAA,CACA,OACA,KAAA4I,QAAA,GACA,IAAoBC,OAAAA,CAAA,EAAS,KAAA/R,OAAA,CAC7B+R,GAAAA,GACA,EACA,IAAgBvT,KAAAA,CAAA,CAAAwT,YAAAA,CAAA,CAAAC,QAAAA,CAAA,CAAAhT,UAAAA,CAAA,EAAwC,KAAAe,OAAA,CACxDkS,EAAA,CAAAD,MAAAA,EAAA,OAAAA,EAAAE,gBAAA,GAAmHvR,EAAAyJ,CAAgB,CAEnI,KAAAuH,QAAA,KAAAM,EAAAjT,EADA,CAAAI,EAAAD,IAAA,KAAA0B,mBAAA,CAAAzB,EAAAD,GACAZ,EAAAwT,EAAAC,GACA,KAAAL,QAAA,CAAAQ,eAAA,EACA,CACA9P,SAAA,CACA,MAAAA,UAEA,KAAA3B,SAAA,EACA0R,OAAAC,MAAA,MAAA3R,SAAA,MAAAqB,YAAA,MAAArB,SAAA,CAAA1B,SAAA,EAEA,CACA+C,aAAAuQ,CAAA,MAWAC,EACAC,EAXA,IAAgB3S,KAAAA,EAAA,YAAAZ,OAAAA,EAAA,EAAAa,YAAAA,EAAA,EAAAZ,WAAAA,CAAA,CAAA4B,SAAAA,EAAA,GAA6E,KAAAf,OAAA,CAC7F0S,EAAiC,GAAA/Q,EAAAC,EAAA,EAAW9B,GAC5CA,EACAkR,EAAA,CAAAlR,EAAA,EAAkCb,GASlCyT,IAAiCzT,IACjC,iBAAAsT,CAAA,MAIAC,EAAoC,GAAAhM,EAAAC,CAAA,EAAI0K,GAAoBlK,EAAGsL,CAAA,IAAAA,CAAA,MAC/DA,EAAA,SAEA,IAAA/G,EAAAkH,EAAA,CAA6C,QAAA1S,OAAA,CAAAf,UAAAsT,CAAA,EAK7C,YAAApT,GACAsT,CAAAA,EAAAC,EAAA,CACA,QAAA1S,OAAA,CACAf,UAAA,IAAAsT,EAAA,CAAAzU,OAAA,GACAiD,SAAA,CAAAA,CACA,EAAa,EAUb,OAAAyK,EAAAC,kBAAA,EACAD,CAAAA,EAAAC,kBAAA,CAA2C,GAAA9J,EAAAoK,EAAA,EAAqBP,EAAA,EAEhE,IAAgBC,mBAAAA,CAAA,EAAqBD,EACrCmH,EAAAlH,EAAA1L,EAEA,OACAyL,UAAAA,EACAiH,kBAAAA,EACAD,sBAAAA,EACA/G,mBAAAA,EACAkH,iBAAAA,EACAC,cAPAD,EAAAzT,CAAAA,EAAA,GAAAa,CAQA,CACA,CACAkC,gBAAA,CACA,IAAgBrC,SAAAA,EAAA,IAAkB,KAAAI,OAAA,CAClC,KAAA6S,IAAA,GACA,gBAAAnB,gBAAA,EAAA9R,EAIA,KAAAsJ,KAAA,MAAAwI,gBAAA,CAHA,KAAAoB,KAAA,EAKA,CACAC,KAAAxC,CAAA,CAAAyC,EAAA,IACA,IAAgBtS,SAAAA,CAAA,EAAW,KAE3B,IAAAA,EAAA,CACA,IAAoBzB,UAAAA,CAAA,EAAY,KAAAe,OAAA,CAChC,OAAqBmJ,KAAA,GAAA5K,MAAAU,CAAA,CAAAA,EAAAO,MAAA,IACrB,CACA,IAAgBJ,cAAAA,CAAA,CAAAoM,UAAAA,CAAA,CAAAiH,kBAAAA,CAAA,CAAAD,sBAAAA,CAAA,CAAAvT,UAAAA,CAAA,CAAAwM,mBAAAA,CAAA,CAAAmH,cAAAA,CAAA,CAAAD,iBAAAA,CAAA,EAAsIjS,EACtJ,eAAAiR,SAAA,CACA,OAAAnG,EAAAE,IAAA,IACA,IAAgB7L,MAAAA,CAAA,CAAAX,OAAAA,CAAA,CAAAC,WAAAA,CAAA,CAAAY,YAAAA,CAAA,CAAAkB,SAAAA,CAAA,EAAmD,KAAAjB,OAAA,CAOnE,KAAAiT,KAAA,GACA,KAAAtB,SAAA,CAAAlU,KAAA4N,GAAA,MAAAsG,SAAA,CAAApB,GAEA,KAAA0C,KAAA,IACA,MAAAtB,SAAA,CAAAlU,KAAA4N,GAAA,CAAAkF,EAAAqC,EAAA,KAAAK,KAAA,MAAAtB,SAAA,GAGAqB,EACA,KAAAxB,WAAA,CAAAjB,EAEA,YAAAe,QAAA,CACA,KAAAE,WAAA,MAAAF,QAAA,CAMA,KAAAE,WAAA,CACA/T,KAAAiH,KAAA,CAAA6L,EAAA,KAAAoB,SAAA,OAAAsB,KAAA,CAGA,IAAAC,EAAA,KAAA1B,WAAA,CAAA3R,EAAA,MAAAoT,KAAA,UACAE,EAAA,KAAAF,KAAA,IACAC,EAAA,EACAA,EAAAN,CACA,MAAApB,WAAA,CAAA/T,KAAA6J,GAAA,CAAA4L,EAAA,GAEA,kBAAAhK,KAAA,cAAAoI,QAAA,EACA,MAAAE,WAAA,CAAAoB,CAAA,EAEA,IAAAQ,EAAA,KAAA5B,WAAA,CACA6B,EAAA7H,EACA,GAAAtM,EAAA,CAMA,IAAAiN,EAAA1O,KAAA4N,GAAA,MAAAmG,WAAA,CAAAoB,GAAAD,EAKAW,EAAA7V,KAAA8V,KAAA,CAAApH,GAKAqH,EAAArH,EAAA,CAKA,EAAAqH,GAAArH,GAAA,GACAqH,CAAAA,EAAA,GAEAA,IAAAA,GAAAF,IACAA,CAAAA,EAAA7V,KAAA4N,GAAA,CAAAiI,EAAApU,EAAA,IAIA,IAEAC,YAAAA,GACAqU,EAAA,EAAAA,EACAzT,GACAyT,CAAAA,GAAAzT,EAAA4S,CAAA,GAGA,WAAAxT,GACAkU,CAAAA,EAAAZ,CAAA,GAGAW,EAAsB,GAAA3J,EAAAC,CAAA,EAAK,IAAA8J,GAAAb,CAC3B,CAMA,IAAAzJ,EAAAiK,EACA,CAAgBhK,KAAA,GAAA5K,MAAAU,CAAA,KAChBoU,EAAA3H,IAAA,CAAA0H,GACAZ,GACAtJ,CAAAA,EAAA3K,KAAA,CAAAiU,EAAAtJ,EAAA3K,KAAA,GAEA,IAAc4K,KAAAA,CAAA,EAAOD,EACrBiK,GAAA1H,OAAAA,GACAtC,CAAAA,EACA,KAAA8J,KAAA,IACA,KAAAzB,WAAA,EAAAoB,EACA,KAAApB,WAAA,KAEA,IAAAiC,EAAA,YAAAnC,QAAA,EACA,mBAAApI,KAAA,mBAAAA,KAAA,EAAAC,CAAA,EAUA,OATAsK,GAAArU,KAAAK,IAAAL,GACA8J,CAAAA,EAAA3K,KAAA,CAA0BS,EAAgBC,EAAA,KAAAe,OAAA,CAAAZ,EAAA,EAE1C6B,GACAA,EAAAiI,EAAA3K,KAAA,EAEAkV,GACA,KAAAC,MAAA,GAEAxK,CACA,CACA,IAAApH,UAAA,CACA,IAAgBpB,SAAAA,CAAA,EAAW,KAC3B,OAAAA,EAA0B,GAAAqJ,EAAA1J,CAAA,EAAqBK,EAAA+K,kBAAA,GAC/C,CACA,IAAAkI,MAAA,CACA,MAAe,GAAA5J,EAAA1J,CAAA,EAAqB,KAAAmR,WAAA,CACpC,CACA,IAAAmC,KAAAC,CAAA,EACAA,EAAkB,GAAA7J,EAAAC,CAAA,EAAqB4J,GACvC,KAAApC,WAAA,CAAAoC,EACA,YAAAtC,QAAA,WAAA2B,KAAA,CACA,KAAA3B,QAAA,CAAAsC,EAEA,KAAAC,MAAA,EACA,MAAAlC,SAAA,MAAAkC,MAAA,CAAAvT,GAAA,GAAAsT,EAAA,KAAAX,KAAA,CAEA,CACA,IAAAA,OAAA,CACA,YAAAxB,aAAA,CAEA,IAAAwB,MAAAa,CAAA,EACA,IAAAC,EAAA,KAAAtC,aAAA,GAAAqC,CACA,MAAArC,aAAA,CAAAqC,EACAC,GACA,MAAAJ,IAAA,CAAwB,GAAA5J,EAAA1J,CAAA,EAAqB,KAAAmR,WAAA,EAE7C,CACAqB,MAAA,CAIA,GAHA,KAAAjB,QAAA,CAAAoC,WAAA,EACA,KAAApC,QAAA,CAAAqC,MAAA,GAEA,MAAAtT,SAAA,EACA,KAAA+Q,gBAAA,WACA,MACA,CACA,QAAAzR,SAAA,CACA,OACA,IAAgB4T,OAAAA,EAASxD,EAAe,CAAA6D,OAAAA,CAAA,CAAAvC,UAAAA,CAAA,EAAsB,KAAA3R,OAAA,CAC9D,KAAA6T,MAAA,EACA,MAAAA,MAAA,CAAAA,EAAA,QAAAd,IAAA,CAAAxC,GAAA,EAEA2D,GAAAA,IACA,IAAA5T,EAAA,KAAAuT,MAAA,CAAAvT,GAAA,EACA,aAAAgR,QAAA,CACA,KAAAK,SAAA,CAAArR,EAAA,KAAAgR,QAAA,CAEA,KAAAK,SAAA,CAGA,kBAAAzI,KAAA,EACA,MAAAyI,SAAA,CAAArR,CAAA,EAHA,KAAAqR,SAAA,CAAAA,MAAAA,EAAAA,EAAA,KAAAnR,aAAA,GAKA,kBAAA0I,KAAA,EACA,KAAA3I,qBAAA,GAEA,KAAAgR,UAAA,MAAAI,SAAA,CACA,KAAAL,QAAA,MAKA,KAAApI,KAAA,WACA,KAAA2K,MAAA,CAAApD,KAAA,EACA,CACAqC,OAAA,CACA,IAAAnM,EACA,SAAAhG,SAAA,EACA,KAAA+Q,gBAAA,UACA,MACA,CACA,KAAAxI,KAAA,UACA,KAAAoI,QAAA,QAAA3K,CAAAA,EAAA,KAAA6K,WAAA,GAAA7K,KAAA,IAAAA,EAAAA,EAAA,CACA,CACAwN,UAAA,CACA,iBAAAjL,KAAA,EACA,KAAA2J,IAAA,GAEA,KAAAnB,gBAAA,MAAAxI,KAAA,YACA,KAAAoI,QAAA,KACA,CACAoC,QAAA,CACA,KAAA5B,QAAA,GACA,KAAA5I,KAAA,YACA,IAAgBlI,WAAAA,CAAA,EAAa,KAAAhB,OAAA,CAC7BgB,GAAAA,GACA,CACA6Q,QAAA,CACA,YAAAN,UAAA,EACA,KAAAwB,IAAA,MAAAxB,UAAA,EAEA,KAAAO,QAAA,GACA,KAAAvR,qBAAA,EACA,CACAuR,UAAA,CACA,KAAA5I,KAAA,QACA,KAAAkL,UAAA,GACA,KAAAvS,sBAAA,GACA,KAAAtB,qBAAA,GACA,KAAAoR,SAAA,MAAAJ,UAAA,MACA,KAAAK,QAAA,CAAAC,MAAA,EACA,CACAuC,YAAA,CACA,KAAAP,MAAA,GAEA,KAAAA,MAAA,CAAAjD,IAAA,GACA,KAAAiD,MAAA,CAAApU,KAAAA,EACA,CACAuT,OAAAW,CAAA,EAEA,OADA,KAAAhC,SAAA,GACA,KAAAoB,IAAA,CAAAY,EAAA,GACA,CACA,iBE5XA,IAAAU,GAAoC,GAAAC,SAAAjU,CAAA,EAAI,IAAAgS,OAAAkC,cAAA,CAAAC,IAAA,CAAAC,QAAAC,SAAA,aCgExCC,GAAA,CACAxW,WAAcA,EACdH,UAAaA,EACb+P,UAAaF,EAAAG,EAAA,CAKb,OAAA4G,WAAmClV,EACnCC,YAAAK,CAAA,EACA,MAAAA,GACA,IAAgBxB,KAAAA,CAAA,CAAAwT,YAAAA,CAAA,CAAAC,QAAAA,CAAA,CAAAhT,UAAAA,CAAA,EAAwC,KAAAe,OAAA,CACxD,KAAA4R,QAAA,KAA4BiD,EAAAC,CAAoB,CAAA7V,EAAA,CAAAI,EAAAD,IAAA,KAAA0B,mBAAA,CAAAzB,EAAAD,GAAAZ,EAAAwT,EAAAC,GAChD,KAAAL,QAAA,CAAAQ,eAAA,EACA,CACApQ,aAAA/C,CAAA,CAAAG,CAAA,MApDAY,EAqDA,IAAc8B,SAAAA,EAAA,IAAA8M,MAAAA,CAAA,CAAArM,KAAAA,CAAA,CAAAzC,KAAAA,CAAA,CAAAkS,YAAAA,CAAA,CAAAxT,KAAAA,CAAA,CAAAmT,UAAAA,CAAA,EAAmE,KAAA3R,OAAA,CAKjF,IAAAgS,EAAA+C,KAAA,GAAA/C,EAAA+C,KAAA,CAAA1Y,OAAA,CACA,SAeA,GARA,iBAAAkG,GACY,GAAAZ,EAAAqT,EAAA,KAxBZpP,KAAA+O,IA0BApS,CAAAA,EAAAoS,EAAA,CAAApS,EAAA,EArEAvC,EA0EA,KAAAA,OAAA,CAzEY,GAAA2B,EAAAC,EAAA,EAAW5B,EAAAF,IAAA,GACvBE,WAAAA,EAAAF,IAAA,EACA,CAAS,GAAA6B,EAAAsT,EAAA,EAAsBjV,EAAAuC,IAAA,EAuE/B,CACA,IAAoBvB,WAAAA,CAAA,CAAAC,SAAAA,CAAA,CAAA+Q,YAAAA,CAAA,CAAAC,QAAAA,CAAA,IAAAjS,EAAA,CAAyD,KAAAA,OAAA,CAC7EkV,EAAAC,SAvEAlW,CAAA,CAAAe,CAAA,EAMA,IAAAoV,EAAA,IAAgC/D,GAAmB,CACnD,GAAArR,CAAA,CACAf,UAAAA,EACAC,OAAA,EACAW,MAAA,EACAqB,YAAA,EACA,GACAgI,EAAA,CAAkBC,KAAA,GAAA5K,MAAAU,CAAA,KAClBoW,EAAA,GAKA9Y,EAAA,EACA,MAAA2M,EAAAC,IAAA,EAAA5M,EA/BA,KAiCA8Y,EAAA3F,IAAA,CAAAxG,CADAA,EAAAkM,EAAApC,MAAA,CAAAzW,EAAA,EACAgC,KAAA,EACAhC,GAvCA,GAyCA,OACAqS,MAAAnP,KAAAA,EACAR,UAAAoW,EACAvT,SAAAvF,EA5CA,GA6CAgG,KAAA,QACA,CACA,EAwCAtD,EAAAe,EAKA,KAAAf,CAJAA,EAAAiW,EAAAjW,SAAA,EAIAO,MAAA,EACAP,CAAAA,CAAA,IAAAA,CAAA,KAEA6C,EAAAoT,EAAApT,QAAA,CACA8M,EAAAsG,EAAAtG,KAAA,CACArM,EAAA2S,EAAA3S,IAAA,CACAzC,EAAA,WACA,CACA,IAAAwV,EAA0BC,SFpH1BtD,CAAA,CAAAuD,CAAA,CAAAvW,CAAA,EAA8DY,MAAAA,EAAA,EAAAiC,SAAAA,EAAA,IAAA5C,OAAAA,EAAA,EAAAC,WAAAA,EAAA,OAAAoD,KAAAA,EAAA,YAAAqM,MAAAA,CAAA,EAAyF,EAAI,EAC3J,IAAA6G,EAAA,CAA8B,CAAAD,EAAA,CAAAvW,CAAA,EAC9B2P,GACA6G,CAAAA,EAAA3F,MAAA,CAAAlB,CAAA,EACA,IAAA3C,EAAmB,GAAAtK,EAAA+T,EAAA,EAAuBnT,EAAAT,GAM1C,OAFArD,MAAAC,OAAA,CAAAuN,IACAwJ,CAAAA,EAAAxJ,MAAA,CAAAA,CAAA,EACAgG,EAAA0D,OAAA,CAAAF,EAAA,CACA5V,MAAAA,EACAiC,SAAAA,EACAmK,OAAA,MAAAvN,OAAA,CAAAuN,GAAA,SAAAA,EACA2J,KAAA,OACAC,WAAA3W,EAAA,EACA4W,UAAA3W,YAAAA,EAAA,oBACA,EACA,EEkG6C6S,EAAA+C,KAAA,CAAA1Y,OAAA,CAAAmC,EAAAS,EAAA,CAA+C,QAAAe,OAAA,CAAA8B,SAAAA,EAAA8M,MAAAA,EAAArM,KAAAA,CAAA,GAyB5F,OAtBA+S,EAAA3D,SAAA,CAAAA,MAAAA,EAAAA,EAAA,KAAAnR,aAAA,GACA,KAAAuV,eAAA,EACY,GAAApU,EAAAqU,EAAA,EAAcV,EAAA,KAAAS,eAAA,EAC1B,KAAAA,eAAA,CAAAtW,KAAAA,GAWA6V,EAAAW,QAAA,MACA,IAAwBjV,WAAAA,CAAA,EAAa,KAAAhB,OAAA,CACrCgS,EAAAkE,GAAA,CAAgClX,EAAgBC,EAAA,KAAAe,OAAA,CAAAZ,IAChD4B,GAAAA,IACA,KAAA6Q,MAAA,GACA,KAAAhQ,sBAAA,EACA,EAEA,CACAyT,UAAAA,EACAxT,SAAAA,EACA8M,MAAAA,EACA9O,KAAAA,EACAyC,KAAAA,EACAtD,UAAAA,CACA,CACA,CACA,IAAA6C,UAAA,CACA,IAAgBpB,SAAAA,CAAA,EAAW,KAC3B,IAAAA,EACA,SACA,IAAgBoB,SAAAA,CAAA,EAAWpB,EAC3B,MAAe,GAAAqJ,EAAA1J,CAAA,EAAqByB,EACpC,CACA,IAAA6R,MAAA,CACA,IAAgBjT,SAAAA,CAAA,EAAW,KAC3B,IAAAA,EACA,SACA,IAAgB4U,UAAAA,CAAA,EAAY5U,EAC5B,MAAe,GAAAqJ,EAAA1J,CAAA,EAAqBiV,EAAA9D,WAAA,IACpC,CACA,IAAAmC,KAAAC,CAAA,EACA,IAAgBlT,SAAAA,CAAA,EAAW,KAC3B,IAAAA,EACA,OACA,IAAgB4U,UAAAA,CAAA,EAAY5U,CAC5B4U,CAAAA,EAAA9D,WAAA,CAAgC,GAAAzH,EAAAC,CAAA,EAAqB4J,EACrD,CACA,IAAAX,OAAA,CACA,IAAgBvS,SAAAA,CAAA,EAAW,KAC3B,IAAAA,EACA,SACA,IAAgB4U,UAAAA,CAAA,EAAY5U,EAC5B,OAAA4U,EAAAa,YAAA,CAEA,IAAAlD,MAAAa,CAAA,EACA,IAAgBpT,SAAAA,CAAA,EAAW,KAC3B,IAAAA,EACA,OACA,IAAgB4U,UAAAA,CAAA,EAAY5U,CAC5B4U,CAAAA,EAAAa,YAAA,CAAArC,CACA,CACA,IAAA5K,OAAA,CACA,IAAgBxI,SAAAA,CAAA,EAAW,KAC3B,IAAAA,EACA,aACA,IAAgB4U,UAAAA,CAAA,EAAY5U,EAC5B,OAAA4U,EAAAc,SAAA,CAEA,IAAAzE,WAAA,CACA,IAAgBjR,SAAAA,CAAA,EAAW,KAC3B,IAAAA,EACA,YACA,IAAgB4U,UAAAA,CAAA,EAAY5U,EAG5B,OAAA4U,EAAA3D,SAAA,CAMA0E,eAAAC,CAAA,EACA,QAAA3V,SAAA,CAGA,CACA,IAAoBD,SAAAA,CAAA,EAAW,KAC/B,IAAAA,EACA,OAAuB3D,EAAAC,CAAI,CAC3B,IAAoBsY,UAAAA,CAAA,EAAY5U,EACpB,GAAAiB,EAAAqU,EAAA,EAAcV,EAAAgB,EAC1B,MARA,KAAAP,eAAA,CAAAO,EASA,OAAevZ,EAAAC,CAAI,CAEnB6V,MAAA,CACA,QAAA5S,SAAA,CACA,OACA,IAAgBS,SAAAA,CAAA,EAAW,KAC3B,IAAAA,EACA,OACA,IAAgB4U,UAAAA,CAAA,EAAY5U,CAC5B,cAAA4U,EAAAc,SAAA,EACA,KAAA7V,qBAAA,GAEA+U,EAAAzC,IAAA,EACA,CACAC,OAAA,CACA,IAAgBpS,SAAAA,CAAA,EAAW,KAC3B,IAAAA,EACA,OACA,IAAgB4U,UAAAA,CAAA,EAAY5U,EAC5B4U,EAAAxC,KAAA,EACA,CACAlC,MAAA,CAGA,GAFA,KAAAgB,QAAA,CAAAC,MAAA,GACA,KAAA5R,SAAA,IACA,cAAAiJ,KAAA,CACA,OACA,KAAArH,sBAAA,GACA,KAAAtB,qBAAA,GACA,IAAgBG,SAAAA,CAAA,EAAW,KAC3B,IAAAA,EACA,OACA,IAAgB4U,UAAAA,CAAA,CAAArW,UAAAA,CAAA,CAAA6C,SAAAA,CAAA,CAAAhC,KAAAA,CAAA,CAAAyC,KAAAA,CAAA,CAAAqM,MAAAA,CAAA,EAAoDlO,EACpE,GAAA4U,SAAAA,EAAAc,SAAA,EACAd,aAAAA,EAAAc,SAAA,CACA,OAUA,QAAAzC,IAAA,EACA,IAAoB3B,YAAAA,CAAA,CAAA/Q,SAAAA,CAAA,CAAAD,WAAAA,CAAA,CAAAiR,QAAAA,CAAA,IAAAjS,EAAA,CAAyD,KAAAA,OAAA,CAC7EoV,EAAA,IAAwC/D,GAAmB,CAC3D,GAAArR,CAAA,CACAf,UAAAA,EACA6C,SAAAA,EACAhC,KAAAA,EACAyC,KAAAA,EACAqM,MAAAA,EACA1N,YAAA,EACA,GACAqV,EAA+B,GAAAxM,EAAAC,CAAA,EAAqB,KAAA2J,IAAA,EACpD3B,EAAAwE,eAAA,CAAApB,EAAApC,MAAA,CAAAuD,EAhQA,IAgQAhY,KAAA,CAAA6W,EAAApC,MAAA,CAAAuD,GAAAhY,KAAA,CAhQA,GAiQA,CACA,IAAgBwT,OAAAA,CAAA,EAAS,KAAA/R,OAAA,CACzB+R,GAAAA,IACA,KAAAF,MAAA,EACA,CACAsC,UAAA,CACA,IAAgBzT,SAAAA,CAAA,EAAW,KAC3BA,GAEAA,EAAA4U,SAAA,CAAA5B,MAAA,EACA,CACA7B,QAAA,CACA,IAAgBnR,SAAAA,CAAA,EAAW,KAC3BA,GAEAA,EAAA4U,SAAA,CAAAzD,MAAA,EACA,CACA,OAAA4E,SAAAzW,CAAA,EACA,IAAgBgS,YAAAA,CAAA,CAAAxT,KAAAA,CAAA,CAAAuB,YAAAA,CAAA,CAAAZ,WAAAA,CAAA,CAAAwI,QAAAA,CAAA,CAAA7H,KAAAA,CAAA,EAA4DE,EAC5E,IAAAgS,GACA,CAAAA,EAAA+C,KAAA,EACA,CAAA/C,CAAAA,EAAA+C,KAAA,CAAA1Y,OAAA,YAAAqa,WAAA,EACA,SAEA,IAAgBzV,SAAAA,CAAA,CAAA0V,kBAAAA,CAAA,EAA8B3E,EAAA+C,KAAA,CAAA6B,QAAA,GAC9C,OAAgBvC,MAChB7V,GACYqY,GAAAta,CAAiB,CAAA+J,GAAA,CAAA9H,IAK7B,CAAAyC,GACA,CAAA0V,GACA,CAAA5W,GACAZ,WAAAA,GACAwI,IAAAA,GACA7H,YAAAA,CACA,CACA,iBCxTA,IAAAgX,GAAA,CACAhX,KAAA,SACA4H,UAAA,IACAC,QAAA,GACAI,UAAA,EACA,EACAgP,GAAA,KACAjX,KAAA,SACA4H,UAAA,IACAC,QAAA7B,IAAAA,EAAA,EAAArI,KAAA2F,IAAA,SACA2E,UAAA,EACA,GACAiP,GAAA,CACAlX,KAAA,YACAgC,SAAA,EACA,EAKAS,GAAA,CACAzC,KAAA,YACAyC,KAAA,eACAT,SAAA,EACA,EACAmV,GAAA,CAAAC,EAAA,CAA0CjY,UAAAA,CAAA,CAAW,GACrD,EAAAO,MAAA,GACAwX,GAEaG,GAAAC,CAAc,CAAA9Q,GAAA,CAAA4Q,GAC3BA,EAAApY,UAAA,UACAiY,GAAA9X,CAAA,KACA6X,GAEAvU,GEzBA8U,GAAA,CAAA7Y,EAAAD,EAAAuH,EAAAwR,EAAA,EAAgE,CAAArF,EAAAsF,IAAA,IAChE,IAAAC,EAA4B,GAAA7V,EAAA8V,EAAA,EAAkBH,EAAA9Y,IAAA,GAM9CqB,EAAA2X,EAAA3X,KAAA,EAAAyX,EAAAzX,KAAA,IAKA,CAAUuT,QAAAA,EAAA,GAAckE,EACxBlE,GAAwB,GAAArJ,EAAAC,CAAA,EAAqBnK,GAC7C,IAAAG,EAAA,CACAf,UAAAR,MAAAC,OAAA,CAAAoH,GAAAA,EAAA,MAAAA,EAAA,CACAvD,KAAA,UACAxB,SAAAxC,EAAAmZ,WAAA,GACA,GAAAF,CAAA,CACA3X,MAAA,CAAAuT,EACAnS,SAAA,IACA1C,EAAA2X,GAAA,CAAAjT,GACAuU,EAAAvW,QAAA,EAAAuW,EAAAvW,QAAA,CAAAgC,EACA,EACAjC,WAAA,KACAA,IACAwW,EAAAxW,UAAA,EAAAwW,EAAAxW,UAAA,EACA,EACAxC,KAAAA,EACAwT,YAAAzT,EACA0T,QAAAsF,EAAA9X,KAAAA,EAAAwS,CACA,CAKA,EAAS0F,SD1CT,CAA+BC,KAAAA,CAAA,CAAA/X,MAAAgY,CAAA,CAAAC,cAAAA,CAAA,CAAAC,gBAAAA,CAAA,CAAAC,iBAAAA,CAAA,CAAA9Y,OAAAA,CAAA,CAAAC,WAAAA,CAAA,CAAAY,YAAAA,CAAA,CAAAgD,KAAAA,CAAA,CAAAqQ,QAAAA,CAAA,IAAAkE,EAAsI,EACrK,QAAAjF,OAAAxJ,IAAA,CAAAyO,GAAA9X,MAAA,ECyC4BgY,IAC5BxX,CAAAA,EAAA,CACA,GAAAA,CAAA,CACA,GAAeiX,GAAoBzY,EAAAwB,EAAA,CACnC,EAOAA,EAAA8B,QAAA,EACA9B,CAAAA,EAAA8B,QAAA,CAA2B,GAAAiI,EAAAC,CAAA,EAAqBhK,EAAA8B,QAAA,GAEhD9B,EAAAD,WAAA,EACAC,CAAAA,EAAAD,WAAA,CAA8B,GAAAgK,EAAAC,CAAA,EAAqBhK,EAAAD,WAAA,GAEnDN,KAAAA,IAAAO,EAAA+C,IAAA,EACA/C,CAAAA,EAAAf,SAAA,IAAAe,EAAA+C,IAAA,EAEA,IAAAkV,EAAA,GAmBA,GAlBA,KAAAjY,EAAAF,IAAA,EACAE,CAAAA,IAAAA,EAAA8B,QAAA,EAAA9B,EAAAD,WAAA,IACAC,EAAA8B,QAAA,GACA,IAAA9B,EAAAH,KAAA,EACAoY,CAAAA,EAAA,KAGQ7b,CAAAA,EAAqBC,OAAA,EACrB6b,EAAAC,CAAkB,CAAAC,cAAA,IAC1BH,EAAA,GACAjY,EAAA8B,QAAA,GACA9B,EAAAH,KAAA,IAOAoY,GAAA,CAAAV,GAAAhZ,KAAAkB,IAAAlB,EAAA8Z,GAAA,IACA,IAAAjZ,EAA8BJ,EAAgBgB,EAAAf,SAAA,CAAAuY,GAC9C,GAAApY,KAAAK,IAAAL,EAOA,OANYsR,EAAAC,EAAK,CAAAH,MAAA,MACjBxQ,EAAAiB,QAAA,CAAA7B,GACAY,EAAAgB,UAAA,EACA,GAGA,IAAuBW,EAAA2W,EAAqB,IAE5C,OAMA,CAAAf,GAAsB3C,GAAoB6B,QAAA,CAAAzW,GAC1C,IAAmB4U,GAAoB5U,GAGvC,IAAmBqR,GAAmBrR,EAEtC,wEC3GA,SAAAuY,EAAAC,CAAA,EACA,OAAAA,EAAAC,KAAA,CAA+BC,EAAA3a,CAA4B,qICA3D,IAAA6P,EAAA,KAAAnQ,KAAAwN,GAAA,CAAAxN,KAAAkb,IAAA,CAAAva,IACA6P,EAAgB,GAAA2K,EAAA7a,CAAA,EAAa6P,GAC7BG,EAAkB,GAAA8K,EAAA3a,CAAA,EAAY0P,0DCH9B,IAAAkL,EAAA,MAAA1a,GAAA,GAAA6N,EAAA,EAAA7N,GAAA,KAAA6N,EAAA,KAAA7N,CAAAA,EAAA,2DCAA,IAAA2a,EAAA,QAAA9M,EAAA,EAAA7N,0DCFA,SAAA4a,EAAAlT,CAAA,CAAAmT,CAAA,CAAAC,CAAA,CAAAlZ,EAAA,CAA6DmZ,QAAA,GAAe,EAE5E,OADArT,EAAAsT,gBAAA,CAAAH,EAAAC,EAAAlZ,GACA,IAAA8F,EAAAuT,mBAAA,CAAAJ,EAAAC,EACA,+FCDA,SAAAI,EAAAC,CAAA,EACA,OACAC,MAAA,CACArc,EAAAoc,EAAAE,KAAA,CACAC,EAAAH,EAAAI,KAAA,CAEA,CACA,CACA,IAAAC,EAAA,GACA,GAAsB,GAAAC,EAAAC,EAAA,EAAgBP,IAAAL,EAAAK,EAAAD,EAAAC,+BCRtCjZ,4DACA,SAAAyZ,IACAzZ,EAAAb,KAAAA,CACA,CASA,IAAAkU,EAAA,CACArT,IAAA,KACAb,KAAAA,IAAAa,GACAqT,EAAAuC,GAAA,CAAqB8D,EAAAlJ,SAAS,CAAAC,YAAA,EAAiBkJ,EAAA9B,CAAkB,CAAA+B,eAAA,CAC/CF,EAAAlJ,SAAS,CAAAP,SAAA,CAC3B4J,YAAA7Z,GAAA,IAEAA,GAEA4V,IAAA,IACA5V,EAAAsT,EACAwG,eAAAL,EACA,CACA,wDC5BA,OAAAM,EACA1a,YAAA2a,CAAA,EACA,KAAAC,SAAA,IACA,KAAAD,IAAA,CAAAA,CACA,CACA9J,QAAA,EACA,yBCDA,SAAAgK,EAAA,CAAmCC,IAAAA,CAAA,CAAAC,KAAAA,CAAA,CAAAC,MAAAA,CAAA,CAAAC,OAAAA,CAAA,CAA2B,EAC9D,OACAzd,EAAA,CAAakO,IAAAqP,EAAApT,IAAAqT,CAAA,EACbjB,EAAA,CAAarO,IAAAoP,EAAAnT,IAAAsT,CAAA,CACb,CACA,CACA,SAAAC,EAAA,CAAmC1d,EAAAA,CAAA,CAAAuc,EAAAA,CAAA,CAAM,EACzC,OAAae,IAAAf,EAAArO,GAAA,CAAAsP,MAAAxd,EAAAmK,GAAA,CAAAsT,OAAAlB,EAAApS,GAAA,CAAAoT,KAAAvd,EAAAkO,GAAA,CACb,CAMA,SAAAyP,EAAAtB,CAAA,CAAAuB,CAAA,EACA,IAAAA,EACA,OAAAvB,EACA,IAAAwB,EAAAD,EAAA,CAAqC5d,EAAAqc,EAAAkB,IAAA,CAAAhB,EAAAF,EAAAiB,GAAA,GACrCQ,EAAAF,EAAA,CAAyC5d,EAAAqc,EAAAmB,KAAA,CAAAjB,EAAAF,EAAAoB,MAAA,GACzC,OACAH,IAAAO,EAAAtB,CAAA,CACAgB,KAAAM,EAAA7d,CAAA,CACAyd,OAAAK,EAAAvB,CAAA,CACAiB,MAAAM,EAAA9d,CAAA,CAEA,oQCxBA,SAAA+d,EAAA1B,CAAA,CAAA2B,CAAA,CAAAC,CAAA,EAGA,OAAAA,EADAD,EADA3B,CAAAA,EAAA4B,CAAA,CAGA,CAIA,SAAAC,EAAA7B,CAAA,CAAA8B,CAAA,CAAAH,CAAA,CAAAC,CAAA,CAAAG,CAAA,EAIA,OAHA9b,KAAAA,IAAA8b,GACA/B,CAAAA,EAPA4B,EADAD,EADA3B,CAAAA,EASA4B,CATA,CASA,EAEAA,EAVAD,EADA3B,CAAAA,EAWA4B,CAXA,EAWAE,CACA,CAIA,SAAAE,EAAAC,CAAA,CAAAH,EAAA,EAAAH,EAAA,EAAAC,CAAA,CAAAG,CAAA,EACAE,EAAApQ,GAAA,CAAAgQ,EAAAI,EAAApQ,GAAA,CAAAiQ,EAAAH,EAAAC,EAAAG,GACAE,EAAAnU,GAAA,CAAA+T,EAAAI,EAAAnU,GAAA,CAAAgU,EAAAH,EAAAC,EAAAG,EACA,CAIA,SAAAG,EAAAC,CAAA,EAA8Bxe,EAAAA,CAAA,CAAAuc,EAAAA,CAAA,CAAM,EACpC8B,EAAAG,EAAAxe,CAAA,CAAAA,EAAAme,SAAA,CAAAne,EAAAge,KAAA,CAAAhe,EAAAie,WAAA,EACAI,EAAAG,EAAAjC,CAAA,CAAAA,EAAA4B,SAAA,CAAA5B,EAAAyB,KAAA,CAAAzB,EAAA0B,WAAA,CACA,CASA,SAAAQ,EAAAD,CAAA,CAAAE,CAAA,CAAAC,CAAA,CAAAC,EAAA,QAMAzB,EACApQ,EANA,IAAA8R,EAAAF,EAAAtc,MAAA,CACA,GAAAwc,GAGAH,EAAA1e,CAAA,CAAA0e,EAAAnC,CAAA,GAGA,QAAAlc,EAAA,EAAoBA,EAAAwe,EAAgBxe,IAAA,CAEpC0M,EAAAoQ,CADAA,EAAAwB,CAAA,CAAAte,EAAA,EACAye,eAAA,CAKA,IAAgBzD,cAAAA,CAAA,EAAgB8B,EAAAta,OAAA,CAChCwY,CAAAA,CAAAA,IACAA,EAAAC,KAAA,CAAAyD,KAAA,EACA1D,aAAAA,EAAAC,KAAA,CAAAyD,KAAA,CAAAC,OAAA,IAGAJ,GACAzB,EAAAta,OAAA,CAAAoc,YAAA,EACA9B,EAAA+B,MAAA,EACA/B,IAAAA,EAAA/Q,IAAA,EACA+S,EAAAX,EAAA,CACAxe,EAAA,CAAAmd,EAAA+B,MAAA,CAAAvM,MAAA,CAAA3S,CAAA,CACAuc,EAAA,CAAAY,EAAA+B,MAAA,CAAAvM,MAAA,CAAA4J,CAAA,GAGAxP,IAEA2R,EAAA1e,CAAA,EAAA+M,EAAA/M,CAAA,CAAAge,KAAA,CACAU,EAAAnC,CAAA,EAAAxP,EAAAwP,CAAA,CAAAyB,KAAA,CAEAO,EAAAC,EAAAzR,IAEA6R,GAAkC,GAAAQ,EAAAC,EAAA,EAAYlC,EAAAmC,YAAA,GAC9CH,EAAAX,EAAArB,EAAAmC,YAAA,EAEA,CAKAZ,EAAA1e,CAAA,CApDA,iBAqDA0e,EAAA1e,CAAA,CAtDA,eAuDA0e,CAAAA,EAAA1e,CAAA,IAEA0e,EAAAnC,CAAA,CAxDA,iBAyDAmC,EAAAnC,CAAA,CA1DA,eA2DAmC,CAAAA,EAAAnC,CAAA,IAEA,CACA,SAAAgD,EAAAjB,CAAA,CAAAkB,CAAA,EACAlB,EAAApQ,GAAA,CAAAoQ,EAAApQ,GAAA,CAAAsR,EACAlB,EAAAnU,GAAA,CAAAmU,EAAAnU,GAAA,CAAAqV,CACA,CAMA,SAAAC,EAAAnB,CAAA,CAAAoB,CAAA,CAAAC,CAAA,CAAAvB,CAAA,CAAAwB,EAAA,IACA,IAAA3B,EAAwB,GAAA4B,EAAAzgB,CAAA,EAASkf,EAAApQ,GAAA,CAAAoQ,EAAAnU,GAAA,CAAAyV,GAEjCvB,EAAAC,EAAAoB,EAAAC,EAAA1B,EAAAG,EACA,CAIA,SAAAe,EAAAX,CAAA,CAAA3W,CAAA,EACA4X,EAAAjB,EAAAxe,CAAA,CAAA6H,EAAA7H,CAAA,CAAA6H,EAAAiY,MAAA,CAAAjY,EAAAmW,KAAA,CAAAnW,EAAAkY,OAAA,EACAN,EAAAjB,EAAAjC,CAAA,CAAA1U,EAAA0U,CAAA,CAAA1U,EAAAmY,MAAA,CAAAnY,EAAAmW,KAAA,CAAAnW,EAAAoY,OAAA,CACA,kFCpHA,IAAAC,EAAA,MACA/B,UAAA,EACAH,MAAA,EACAtV,OAAA,EACAuV,YAAA,CACA,GACAkC,EAAA,MACAngB,EAAAkgB,IACA3D,EAAA2D,GACA,GACAE,EAAA,MAA4BlS,IAAA,EAAA/D,IAAA,IAC5BkW,EAAA,MACArgB,EAAAogB,IACA7D,EAAA6D,GACA,0BCdA,SAAAE,EAAAtC,CAAA,EACA,OAAAA,KAAA1b,IAAA0b,GAAAA,IAAAA,CACA,CACA,SAAAuC,EAAA,CAAoBvC,MAAAA,CAAA,CAAA8B,OAAAA,CAAA,CAAAE,OAAAA,CAAA,CAAuB,EAC3C,OAAAM,EAAAtC,IACA,CAAAsC,EAAAR,IACA,CAAAQ,EAAAN,EACA,CACA,SAAAQ,EAAApX,CAAA,EACA,OAAAmX,EAAAnX,IACAqX,EAAArX,IACAA,EAAAE,CAAA,EACAF,EAAAsX,MAAA,EACAtX,EAAAuX,OAAA,EACAvX,EAAAwX,OAAA,EACAxX,EAAAyX,KAAA,EACAzX,EAAA0X,KAAA,CAEA,SAAAL,EAAArX,CAAA,MAGAhI,EAAAA,EAFA,MAAA2f,CAEA3f,EAFAgI,EAAApJ,CAAA,GAGAoB,OAAAA,GAAAA,CADAA,EAFAgI,EAAAmT,CAAA,GAGAnb,OAAAA,CAFA,0LCjBA,SAAA4f,EAAAC,CAAA,CAAArD,CAAA,EACA,MAAW,GAAAsD,EAAAC,EAAA,EAAwB,GAAAD,EAAAE,EAAA,EAAkBH,EAAAI,qBAAA,GAAAzD,GACrD,CACA,SAAA0D,EAAAxM,CAAA,CAAAyM,CAAA,CAAAC,CAAA,EACA,IAAAC,EAAAT,EAAAlM,EAAA0M,GACA,CAAYtC,OAAAA,CAAA,EAASqC,EAKrB,OAJArC,IACQ,GAAAwC,EAAAC,EAAA,EAAaF,EAAAzhB,CAAA,CAAAkf,EAAAvM,MAAA,CAAA3S,CAAA,EACb,GAAA0hB,EAAAC,EAAA,EAAaF,EAAAlF,CAAA,CAAA2C,EAAAvM,MAAA,CAAA4J,CAAA,GAErBkF,CACA,yGELA,IAAAG,EAAA,IAAA5iB,IAAA,oECIA,IAAA6iB,EAEA,oFCNA,OAAAnK,UAAmCjU,EAAAyJ,CAAgB,CACnD1K,YAAAsf,CAAA,CAAAje,CAAA,CAAAxC,CAAA,CAAAwT,CAAA,CAAAC,CAAA,EACA,MAAAgN,EAAAje,EAAAxC,EAAAwT,EAAAC,EAAA,GACA,CACAiN,eAAA,CACA,IAAgBD,oBAAAA,CAAA,CAAAhN,QAAAA,CAAA,CAAAzT,KAAAA,CAAA,EAAqC,KACrD,IAAAyT,GAAA,CAAAA,EAAA5V,OAAA,CACA,OACA,MAAA6iB,gBAIA,QAAA1hB,EAAA,EAAwBA,EAAAyhB,EAAAzf,MAAA,CAAgChC,IAAA,CACxD,IAAA2hB,EAAAF,CAAA,CAAAzhB,EAAA,CACA,oBAAA2hB,IACAA,EAAAA,EAAAC,IAAA,GACoB,GAAAha,EAAA7I,CAAA,EAAkB4iB,IAAA,CACtC,IAAAze,EAAqC2e,SDFrCA,EAAAhjB,CAAA,CAAA4V,CAAA,CAAAqN,EAAA,GACI,GAAA9d,EAAA8M,CAAA,EAASgR,GAFb,EAEa,yDAA6EjjB,EAAQ,uDAClG,IAAAkjB,EAAAC,EAAA,CAAAC,SAVApjB,CAAA,EACA,IAAAqjB,EAAAV,EAAAW,IAAA,CAAAtjB,GACA,IAAAqjB,EACA,UACA,KAAAE,EAAAC,EAAAL,EAAA,CAAAE,EACA,YAAiBE,MAAAA,EAAAA,EAAAC,EAAuD,EAAAL,EAAA,EAKxEnjB,GAEA,IAAAkjB,EACA,OAEA,IAAA7e,EAAAof,OAAAC,gBAAA,CAAA9N,GAAA+N,gBAAA,CAAAT,GACA,GAAA7e,EAAA,CACA,IAAAuf,EAAAvf,EAAA0e,IAAA,GACA,MAAe,GAAAc,EAAAthB,CAAA,EAAiBqhB,GAAAE,WAAAF,GAAAA,CAChC,CACA,MAAW,GAAA7a,EAAA7I,CAAA,EAAkBijB,GAC7BH,EAAAG,EAAAvN,EAAAqN,EAAA,GACAE,CACA,ECbqDL,EAAAlN,EAAA5V,OAAA,CACrDoD,MAAAA,IAAAiB,GACAue,CAAAA,CAAA,CAAAzhB,EAAA,CAAAkD,CAAA,EAEAlD,IAAAyhB,EAAAzf,MAAA,IACA,MAAAJ,aAAA,CAAA+f,CAAA,CAEA,CAEA,CAaA,GAPA,KAAAiB,oBAAA,GAOA,CAAaC,EAAA5Z,CAAc,CAAAH,GAAA,CAAA9H,IAAAygB,IAAAA,EAAAzf,MAAA,CAC3B,OAEA,IAAAqG,EAAAC,EAAA,CAAAmZ,EACAqB,EAA2B,GAAAC,EAAAC,CAAA,EAAsB3a,GACjD4a,EAA2B,GAAAF,EAAAC,CAAA,EAAsB1a,GAIjD,GAAAwa,IAAAG,GAMA,GAAY,GAAAC,EAAAC,EAAA,EAAaL,IAAgB,GAAAI,EAAAC,EAAA,EAAaF,GACtD,QAAAjjB,EAAA,EAA4BA,EAAAyhB,EAAAzf,MAAA,CAAgChC,IAAA,CAC5D,IAAAe,EAAA0gB,CAAA,CAAAzhB,EAAA,CACA,iBAAAe,GACA0gB,CAAAA,CAAA,CAAAzhB,EAAA,CAAA2iB,WAAA5hB,EAAA,CAEA,MAMA,KAAAqiB,gBAAA,IAEA,CACAR,sBAAA,CACA,IAAgBnB,oBAAAA,CAAA,CAAAzgB,KAAAA,CAAA,EAA4B,KAC5CqiB,EAAA,GACA,QAAArjB,EAAA,EAAwBA,EAAAyhB,EAAAzf,MAAA,CAAgChC,IAAA,KH/ExDe,EACA,kBADAA,EGgFsB0gB,CAAA,CAAAzhB,EAAA,EH9EtBe,IAAAA,EAEA,OAAAA,GACAA,SAAAA,GAAAA,MAAAA,GAAoD,GAAAuiB,EAAAC,CAAA,EAAiBxiB,EAIrE,GGwEAsiB,EAAAnR,IAAA,CAAAlS,EAEA,CACAqjB,EAAArhB,MAAA,EACYwhB,SF7EZ/B,CAAA,CAAA4B,CAAA,CAAAriB,CAAA,EACA,IACAyiB,EADAzjB,EAAA,EAEA,KAAAA,EAAAyhB,EAAAzf,MAAA,GAAAyhB,GAAA,CACA,IAAA9B,EAAAF,CAAA,CAAAzhB,EAAA,CACA,iBAAA2hB,GACA,CAAAJ,EAAAzY,GAAA,CAAA6Y,IACY,GAAAxgB,EAAAuH,CAAA,EAAmBiZ,GAAA5Y,MAAA,CAAA/G,MAAA,EAC/ByhB,CAAAA,EAAAhC,CAAA,CAAAzhB,EAAA,EAEAA,GACA,CACA,GAAAyjB,GAAAziB,EACA,QAAA0iB,KAAAL,EACA5B,CAAA,CAAAiC,EAAA,CAA6C,GAAAC,EAAAC,CAAA,EAAiB5iB,EAAAyiB,EAG9D,EE4DuChC,EAAA4B,EAAAriB,EAEvC,CACA6iB,qBAAA,CACA,IAAgBpP,QAAAA,CAAA,CAAAgN,oBAAAA,CAAA,CAAAzgB,KAAAA,CAAA,EAAqC,KACrD,IAAAyT,GAAA,CAAAA,EAAA5V,OAAA,CACA,MACA,YAAAmC,GACA,MAAA8iB,gBAAA,CAAAxB,OAAAyB,WAAA,EAEA,KAAAC,cAAA,CAA8Bd,EAAAe,EAAgB,CAAAjjB,EAAA,CAAAyT,EAAAkM,kBAAA,GAAA2B,OAAAC,gBAAA,CAAA9N,EAAA5V,OAAA,GAC9C4iB,CAAA,SAAAuC,cAAA,CAEA,IAAAE,EAAAzC,CAAA,CAAAA,EAAAzf,MAAA,SACAC,IAAAiiB,GACAzP,EAAA0P,QAAA,CAAAnjB,EAAAkjB,GAAAE,IAAA,CAAAF,EAAA,GAEA,CACAG,iBAAA,CACA,IAAAlb,EACA,IAAgBsL,QAAAA,CAAA,CAAAzT,KAAAA,CAAA,CAAAygB,oBAAAA,CAAA,EAAqC,KACrD,IAAAhN,GAAA,CAAAA,EAAA5V,OAAA,CACA,OACA,IAAAkC,EAAA0T,EAAA0P,QAAA,CAAAnjB,EACAD,CAAAA,GAAAA,EAAAqjB,IAAA,MAAAJ,cAAA,KACA,IAAAM,EAAA7C,EAAAzf,MAAA,GACAJ,EAAA6f,CAAA,CAAA6C,EAAA,CACA7C,CAAA,CAAA6C,EAAA,CAAkDpB,EAAAe,EAAgB,CAAAjjB,EAAA,CAAAyT,EAAAkM,kBAAA,GAAA2B,OAAAC,gBAAA,CAAA9N,EAAA5V,OAAA,GAClE,OAAA+C,GAAA,KAAAK,IAAA,KAAAL,aAAA,EACA,MAAAA,aAAA,CAAAA,CAAA,EAGA,QAAAuH,CAAAA,EAAA,KAAAob,iBAAA,GAAApb,KAAA,IAAAA,EAAA,OAAAA,EAAAnH,MAAA,GACA,KAAAuiB,iBAAA,CAAAC,OAAA,GAAAC,EAAAC,EAAA,IACAjQ,EACA0P,QAAA,CAAAM,GACA/L,GAAA,CAAAgM,EACA,GAEA,KAAA9B,oBAAA,EACA,CACA,oFChIA,SAAA+B,EAAAzW,CAAA,CAAA0W,CAAA,EACA,IAAA3jB,MAAAC,OAAA,CAAA0jB,GACA,SACA,IAAAC,EAAAD,EAAA5iB,MAAA,CACA,GAAA6iB,IAAA3W,EAAAlM,MAAA,CACA,SACA,QAAAhC,EAAA,EAAoBA,EAAA6kB,EAAgB7kB,IACpC,GAAA4kB,CAAA,CAAA5kB,EAAA,GAAAkO,CAAA,CAAAlO,EAAA,CACA,SAEA,QACA,2BCTA,SAAA8kB,EAAA9J,CAAA,CAAAnK,CAAA,CAAAkU,CAAA,EACA,IAAA9J,EAAAD,EAAA5B,QAAA,GACA,MAAW,GAAA4L,EAAAtkB,CAAA,EAAuBua,EAAApK,EAAAkU,KAAA9iB,IAAA8iB,EAAAA,EAAA9J,EAAA8J,MAAA,CAAA/J,EAClC,qGEcA,SAAAiK,EAAAjK,CAAA,CAAAkK,CAAA,EAA6D7iB,MAAAA,EAAA,EAAA8iB,mBAAAA,CAAA,CAAA7iB,KAAAA,CAAA,EAAsC,EAAI,EACvG,IAAA6G,EACA,IAAU2Q,WAAAA,EAAAkB,EAAAvB,oBAAA,GAAA2L,cAAAA,CAAA,IAAA9c,EAAA,CAA8E4c,EACxFC,GACArL,CAAAA,EAAAqL,CAAA,EACA,IAAAE,EAAA,GACAC,EAAAhjB,GACA0Y,EAAAuK,cAAA,EACAvK,EAAAuK,cAAA,CAAAC,QAAA,GAAAljB,EAAA,CACA,QAAA8F,KAAAE,EAAA,CACA,IAAAvH,EAAAia,EAAAmJ,QAAA,CAAA/b,EAAA,OAAAe,CAAAA,EAAA6R,EAAAiE,YAAA,CAAA7W,EAAA,GAAAe,KAAA,IAAAA,EAAAA,EAAA,MACAsc,EAAAnd,CAAA,CAAAF,EAAA,CACA,GAAAqd,KAAAxjB,IAAAwjB,GACAH,GACAI,SAnBA,CAAgCC,cAAAA,CAAA,CAAAC,eAAAA,CAAA,CAA+B,CAAAxd,CAAA,EAC/D,IAAAyd,EAAAF,EAAA5O,cAAA,CAAA3O,IAAAwd,CAAA,IAAAA,CAAA,CAAAxd,EAAA,CAEA,OADAwd,CAAA,CAAAxd,EAAA,IACAyd,CACA,EAeAP,EAAAld,GACA,SAEA,IAAA4R,EAAA,CACA3X,MAAAA,EACA,GAAe,GAAA8B,EAAA8V,EAAA,EAAkBH,GAAA,GAAiB1R,EAAA,EAMlD2R,EAAA,GACA,GAAAuI,OAAAwD,sBAAA,EACA,IAAAC,EAA6B,GAAAC,EAAA1O,CAAA,EAAoB0D,GACjD,GAAA+K,EAAA,CACA,IAAA5R,EAAAmO,OAAAwD,sBAAA,CAAAC,EAAA3d,EAA+E8K,EAAAC,EAAK,CACpF,QAAAgB,IACA6F,EAAA7F,SAAA,CAAAA,EACA4F,EAAA,GAEA,CACA,CACQ,GAAAkM,EAAAhiB,CAAA,EAAoB+W,EAAA5S,GAC5BrH,EAAAkS,KAAA,CAAoB,GAAAiT,EAAAzgB,CAAA,EAAkB2C,EAAArH,EAAA0kB,EAAAzK,EAAAmL,kBAAA,EAA8DtD,EAAA5Z,CAAc,CAAAH,GAAA,CAAAV,GAClH,CAAgB9F,KAAA,IAChB0X,EAAAgB,EAAAjB,IACA,IAAAjC,EAAA/W,EAAA+W,SAAA,CACAA,GACAuN,EAAAnT,IAAA,CAAA4F,EAEA,CAQA,OAPAsN,GACApgB,QAAAohB,GAAA,CAAAf,GAAA3gB,IAAA,MACYwO,EAAAC,EAAK,CAAAH,MAAA,MACjBoS,GAAiCiB,SDnDjCrL,CAAA,CAAAnK,CAAA,EAEA,IAAUuU,cAAAA,EAAA,EAAkB,CAAAtL,WAAAA,EAAA,EAAiB,IAAAxR,EAAA,CAAcpF,EADxB8X,EAAAnK,IACwB,GAE3D,QAAAzI,KADAE,EAAA,CAAe,GAAAA,CAAA,IAAA8c,CAAA,EACf,CACA,IAAArkB,EAAsB,GAAAulB,EAAAjU,CAAA,EAA4B/J,CAAA,CAAAF,EAAA,EAZlD4S,EAAAuL,QAAA,CAaAne,GAZA4S,EAAAmJ,QAAA,CAYA/b,GAZAsQ,GAAA,CAYA3X,GATAia,EAAAwL,QAAA,CASApe,EAToC,GAAAqe,EAAAC,EAAA,EASpC3lB,GACA,CACA,EC2C0Cia,EAAAoK,EAC1C,EACA,GAEAC,CACA,CCrEA,SAAAsB,EAAA3L,CAAA,CAAA4L,CAAA,CAAApkB,EAAA,EAA4D,EAC5D,IAAA2G,EACA,IAAAjG,EAAqB4hB,EAAc9J,EAAA4L,EAAApkB,SAAAA,EAAAF,IAAA,CACnC,OAAA6G,CAAAA,EAAA6R,EAAA6L,eAAA,GAAA1d,KAAA,IAAAA,EAAA,OAAAA,EAAA4b,MAAA,CACA9iB,KAAAA,GACA,CAAU6X,WAAAA,EAAAkB,EAAAvB,oBAAA,QAA0DvW,GAAA,EACpEV,CAAAA,EAAA2iB,kBAAA,EACArL,CAAAA,EAAAtX,EAAA2iB,kBAAA,EAMA,IAAA2B,EAAA5jB,EACA,IAAA8B,QAAAohB,GAAA,CAA4BnB,EAAajK,EAAA9X,EAAAV,IACzC,IAAAwC,QAAAL,OAAA,GAKAoiB,EAAA/L,EAAAgM,eAAA,EAAAhM,EAAAgM,eAAA,CAAAC,IAAA,CACA,CAAAC,EAAA,KACA,IAAoB5M,cAAAA,EAAA,EAAAC,gBAAAA,CAAA,CAAAC,iBAAAA,CAAA,EAAwDV,EAC5E,OAAAqN,SAkBAnM,CAAA,CAAA4L,CAAA,CAAAtM,EAAA,EAAAC,EAAA,EAAAC,EAAA,EAAAhY,CAAA,EACA,IAAA6iB,EAAA,GACA+B,EAAA,CAAApM,EAAAgM,eAAA,CAAAC,IAAA,IAAA1M,EACA8M,EAAA7M,IAAAA,EACA,CAAAxa,EAAA,IAAAA,EAAAua,EACA,CAAAva,EAAA,IAAAonB,EAAApnB,EAAAua,EAUA,OATAtZ,MAAAsE,IAAA,CAAAyV,EAAAgM,eAAA,EACAM,IAAA,CAAAC,GACA/C,OAAA,EAAAgD,EAAAxnB,KACAwnB,EAAAC,MAAA,kBAAAb,GACAvB,EAAAnT,IAAA,CAAAyU,EAAAa,EAAAZ,EAAA,CACA,GAAApkB,CAAA,CACAH,MAAAiY,EAAA+M,EAAArnB,EACA,GAAS0E,IAAA,KAAA8iB,EAAAC,MAAA,qBAAAb,IACT,GACA5hB,QAAAohB,GAAA,CAAAf,EACA,EAlCArK,EAAA4L,EAAAtM,EAAA4M,EAAA3M,EAAAC,EAAAhY,EACA,EACA,IAAAwC,QAAAL,OAAA,GAKA,CAAYyV,KAAAA,CAAA,EAAON,EACnB,IAAAM,EAOA,OAAApV,QAAAohB,GAAA,EAAAU,IAAAC,EAAAvkB,EAAAH,KAAA,GAPA,EACA,IAAAqlB,EAAAC,EAAA,CAAAvN,mBAAAA,EACA,CAAA0M,EAAAC,EAAA,CACA,CAAAA,EAAAD,EAAA,CACA,OAAAY,IAAAhjB,IAAA,KAAAijB,IACA,CAIA,CAkBA,SAAAJ,EAAAniB,CAAA,CAAAC,CAAA,EACA,OAAAD,EAAAwiB,gBAAA,CAAAviB,EACA,CE5DA,IAAAwiB,EAAwBC,EAAApf,CAAY,CAAA1G,MAAA,CCMpC+lB,EAAA,IAAiCD,EAAAjb,CAAoB,EAAAvM,OAAA,GACrD0nB,EAA0BF,EAAAjb,CAAoB,CAAA7K,MAAA,CA6S9C,SAAAimB,EAAAC,EAAA,IACA,OACAA,SAAAA,EACAvC,cAAA,GACAC,eAAA,GACAuC,mBAAA,EACA,CACA,CACA,SAAAC,IACA,OACAjQ,QAAA8P,EAAA,IACAI,YAAAJ,IACAK,WAAAL,IACAM,SAAAN,IACAO,UAAAP,IACAQ,WAAAR,IACAS,KAAAT,GACA,CACA,eCrUA,OAAAU,UAA+B9L,EAAA+L,CAAO,CAMtCzmB,YAAA2a,CAAA,EACA,MAAAA,GACAA,EAAAyI,cAAA,EAAAzI,CAAAA,EAAAyI,cAAA,CAAsDsD,SDEtD7N,CAAA,EACA,IAAA7C,EAHA,GAAAnT,QAAAohB,GAAA,CAAAf,EAAAld,GAAA,GAAyD2P,UAAAA,CAAA,CAAAtV,QAAAA,CAAA,CAAoB,GAAKsmB,CFRlF,SAAA9N,CAAA,CAAAnK,CAAA,CAAArO,EAAA,EAAqE,MAErEsV,EACA,GAFAkD,EAAAyM,MAAA,kBAAA5W,GAEA5P,MAAAC,OAAA,CAAA2P,GAEAiH,EAAA9S,QAAAohB,GAAA,CADAvV,EAAA1I,GAAA,IAAuDwe,EAAc3L,EAAA4L,EAAApkB,UAGrE,oBAAAqO,EACAiH,EAAoB6O,EAAc3L,EAAAnK,EAAArO,OAElC,CACA,IAAAumB,EAAA,mBAAAlY,EACciU,EAAc9J,EAAAnK,EAAArO,EAAAuiB,MAAA,EAC5BlU,EACAiH,EAAA9S,QAAAohB,GAAA,CAAgCnB,EAAajK,EAAA+N,EAAAvmB,GAC7C,CACA,OAAAsV,EAAApT,IAAA,MACAsW,EAAAyM,MAAA,qBAAA5W,EACA,EACA,GERAmK,EAHsGlD,EAAAtV,KAItGkJ,EAAA0c,IACAY,EAAA,GAKAC,EAAA,IAAAC,EAAArY,KACA,IAAA1H,EACA,IAAAjG,EAAyB4hB,EAAc9J,EAAAnK,EAAAvO,SAAAA,EACvC,OAAA6G,CAAAA,EAAA6R,EAAA6L,eAAA,GAAA1d,KAAA,IAAAA,EAAA,OAAAA,EAAA4b,MAAA,CACA9iB,KAAAA,GACA,GAAAiB,EAAA,CACA,IAAoB4W,WAAAA,CAAA,CAAAsL,cAAAA,CAAA,IAAA9c,EAAA,CAAuCpF,EAC3DgmB,EAAA,CAAoB,GAAAA,CAAA,IAAA5gB,CAAA,IAAA8c,CAAA,CACpB,CACA,OAAA8D,CACA,EAkBA,SAAAC,EAAAC,CAAA,EACA,IAAgBnO,MAAAA,CAAA,EAAQD,EACxBqO,EAAwBC,SDhDxBA,EAAAtO,CAAA,EACA,IAAAA,EACA,OACA,IAAAA,EAAAuO,qBAAA,EACA,IAAAF,EAAArO,EAAAwO,MAAA,EACAF,EAAAtO,EAAAwO,MAAA,MAKA,OAHAvnB,KAAAA,IAAA+Y,EAAAC,KAAA,CAAAwO,OAAA,EACAJ,CAAAA,EAAAI,OAAA,CAAAzO,EAAAC,KAAA,CAAAwO,OAAA,EAEAJ,CACA,CACA,IAAAA,EAAA,GACA,QAAArpB,EAAA,EAAoBA,EAAA6nB,EAAqB7nB,IAAA,CACzC,IAAAgB,EAAqB8mB,EAAApf,CAAY,CAAA1I,EAAA,CACjC0pB,EAAA1O,EAAAC,KAAA,CAAAja,EAAA,CACY,IAAA2oB,EAAA5jB,CAAA,EAAc2jB,IAAAA,CAAA,IAAAA,CAAA,GAC1BL,CAAAA,CAAA,CAAAroB,EAAA,CAAA0oB,CAAA,CAEA,CACA,OAAAL,CACA,EC2ByCrO,EAAAwO,MAAA,MAKzCnE,EAAA,GAKAuE,EAAA,IAAAjrB,IAMAkrB,EAAA,GAKAC,EAAAC,IAOA,QAAA/pB,EAAA,EAAwBA,EAAAgoB,EAAuBhoB,IAAA,KA8N/C4kB,EA7NA,IAAAtiB,EAAAylB,CAAA,CAAA/nB,EAAA,CACAgqB,EAAAte,CAAA,CAAApJ,EAAA,CACAonB,EAAAzO,KAAAhZ,IAAAgZ,CAAA,CAAA3Y,EAAA,CACA2Y,CAAA,CAAA3Y,EAAA,CACA+mB,CAAA,CAAA/mB,EAAA,CACA2nB,EAAkC,GAAAN,EAAA5jB,CAAA,EAAc2jB,GAKhDQ,EAAA5nB,IAAA8mB,EAAAY,EAAA9B,QAAA,KACA,MAAAgC,GACAJ,CAAAA,EAAA9pB,CAAAA,EAOA,IAAAmqB,EAAAT,IAAAL,CAAA,CAAA/mB,EAAA,EACAonB,IAAAzO,CAAA,CAAA3Y,EAAA,EACA2nB,EAeA,GAXAE,GACAnB,GACAhO,EAAAoP,sBAAA,EACAD,CAAAA,EAAA,IAMAH,EAAArE,aAAA,EAAwC,GAAAkE,CAAA,EAIxC,CAAAG,EAAA9B,QAAA,EAAAgC,OAAAA,GAEA,CAAAR,GAAA,CAAAM,EAAAK,QAAA,EAEgB,GAAAC,EAAAC,CAAA,EAAmBb,IACnC,kBAAAA,EACA,SAOA,IAAAc,GA0KA5F,EA1KAoF,EAAAK,QAAA,CA2KA,iBA3KAX,EA4KAxb,IAAA0W,IAEA3jB,MAAAC,OAAA,CA9KAwoB,IA+KA,CAAgB/E,EA/KhB+E,EA+K8B9E,IA9K9B6F,EAAAD,GAEAloB,IAAA8mB,GACAY,EAAA9B,QAAA,EACA,CAAAiC,GACAF,GAEAjqB,EAAA8pB,GAAAG,EACAS,EAAA,GAKAC,EAAA1pB,MAAAC,OAAA,CAAAwoB,GAAAA,EAAA,CAAAA,EAAA,CAKAkB,EAAAD,EAAAE,MAAA,CAAA5B,EAAA3mB,GAAA,GACA,MAAA4nB,GACAU,CAAAA,EAAA,IAUA,IAAoBzC,mBAAAA,EAAA,IAA0B6B,EAC9Cc,EAAA,CACA,GAAA3C,CAAA,CACA,GAAAyC,CAAA,EAEAG,EAAA,IACAN,EAAA,GACAb,EAAA9gB,GAAA,CAAAV,KACAsiB,EAAA,GACAd,EAAAoB,MAAA,CAAA5iB,IAEA4hB,EAAApE,cAAA,CAAAxd,EAAA,IACA,IAAAoM,EAAAwG,EAAAmJ,QAAA,CAAA/b,GACAoM,GACAA,CAAAA,EAAAyW,SAAA,IACA,EACA,QAAA7iB,KAAA0iB,EAAA,CACA,IAAA5c,EAAA0c,CAAA,CAAAxiB,EAAA,CACAwc,EAAAuD,CAAA,CAAA/f,EAAA,CAEA,IAAAyhB,EAAA9S,cAAA,CAAA3O,IAMoB,GAAA8iB,EAAAlI,CAAA,EAAiB9U,IAAU,GAAAgd,EAAAlI,CAAA,EAAiB4B,GACzBD,EAAczW,EAAA0W,GAGrD1W,IAAA0W,GAYA1W,KAAAjM,IAAAiM,GAAA0b,EAAA9gB,GAAA,CAAAV,GAKA2iB,EAAA3iB,GAOA4hB,EAAArE,aAAA,CAAAvd,EAAA,IArBA8F,MAAAA,EAEA6c,EAAA3iB,GAIAwhB,EAAAuB,GAAA,CAAA/iB,EAiBA,CAKA4hB,EAAAK,QAAA,CAAAX,EACAM,EAAA7B,kBAAA,CAAAyC,EAIAZ,EAAA9B,QAAA,EACA2B,CAAAA,EAAA,CAAoC,GAAAA,CAAA,IAAAe,CAAA,GAEpC5B,GAAAhO,EAAAoQ,qBAAA,EACAX,CAAAA,EAAA,IAOA,IAAA7E,EAAA,CADAuE,CAAAA,GAAAK,CAAA,GACAE,EACAD,GAAA7E,GACAP,EAAAnT,IAAA,IAAAyY,EAAAxiB,GAAA,MACA2P,UAAAA,EACAtV,QAAA,CAA+BF,KAAAA,CAAA,CAC/B,IAEA,CAMA,GAAAsnB,EAAA3C,IAAA,EACA,IAAAoE,EAAA,GACAzB,EAAApF,OAAA,KACA,IAAA8G,EAAAtQ,EAAAuQ,aAAA,CAAAnjB,GACAoM,EAAAwG,EAAAmJ,QAAA,CAAA/b,GACAoM,GACAA,CAAAA,EAAAyW,SAAA,KAEAI,CAAA,CAAAjjB,EAAA,CAAAkjB,MAAAA,EAAAA,EAAA,IACA,GACAjG,EAAAnT,IAAA,EAA8B4F,UAAAuT,CAAA,EAC9B,CACA,IAAAG,EAAAjlB,CAAAA,CAAA8e,EAAArjB,MAAA,CAOA,OANAgnB,GACA/N,CAAAA,CAAA,IAAAA,EAAAwO,OAAA,EAAAxO,EAAAwO,OAAA,GAAAxO,EAAA9C,OAAA,GACA,CAAA6C,EAAAoP,sBAAA,EACAoB,CAAAA,EAAA,IAEAxC,EAAA,GACAwC,EAAArT,EAAAkN,GAAArgB,QAAAL,OAAA,EACA,CAkBA,OACAwkB,eAAAA,EACAsC,UAhBA,SAAAnpB,CAAA,CAAA4lB,CAAA,EACA,IAAA/e,EAEA,GAAAuC,CAAA,CAAApJ,EAAA,CAAA4lB,QAAA,GAAAA,EACA,OAAAljB,QAAAL,OAAA,EAEA,QAAAwE,CAAAA,EAAA6R,EAAAgM,eAAA,GAAA7d,KAAA,IAAAA,GAAAA,EAAAqb,OAAA,KAA0G,IAAArb,EAAQ,cAAAA,CAAAA,EAAAqe,EAAAjC,cAAA,GAAApc,KAAA,IAAAA,EAAA,OAAAA,EAAAsiB,SAAA,CAAAnpB,EAAA4lB,EAAA,GAClHxc,CAAA,CAAApJ,EAAA,CAAA4lB,QAAA,CAAAA,EACA,IAAA7C,EAAA8D,EAAA7mB,GACA,QAAA8F,KAAAsD,EACAA,CAAA,CAAAtD,EAAA,CAAAud,aAAA,IAEA,OAAAN,CACA,EAIAqG,mBAjQA,SAAAC,CAAA,EACAxT,EAAAwT,EAAA3Q,EACA,EAgQAwK,SAAA,IAAA9Z,EACAkgB,MAAA,KACAlgB,EAAA0c,IACAY,EAAA,EACA,CACA,CACA,ECjS0ElM,EAAA,CAC1E,CACA+O,qCAAA,CACA,IAAgB1T,QAAAA,CAAA,EAAU,KAAA2E,IAAA,CAAA1D,QAAA,GACd,GAAAkR,EAAAC,CAAA,EAAmBpS,IAC/B,MAAA2T,eAAA,CAAA3T,EAAA4T,SAAA,MAAAjP,IAAA,EAEA,CAIAkP,OAAA,CACA,KAAAH,mCAAA,EACA,CACA7Y,QAAA,CACA,IAAgBmF,QAAAA,CAAA,EAAU,KAAA2E,IAAA,CAAA1D,QAAA,GAC1B,CAAgBjB,QAAA8T,CAAA,EAAuB,KAAAnP,IAAA,CAAAoP,SAAA,KACvC/T,IAAA8T,GACA,KAAAJ,mCAAA,EAEA,CACAM,SAAA,CACA,IAAAhjB,EACA,KAAA2T,IAAA,CAAAyI,cAAA,CAAAqG,KAAA,GACA,OAAAziB,CAAAA,EAAA,KAAA2iB,eAAA,GAAA3iB,KAAA,IAAAA,GAAAA,EAAA6N,IAAA,MACA,CACA,CCpCA,IAAAoV,EAAA,CACA,OAAAC,UAAmCxP,EAAA+L,CAAO,CAC1CzmB,aAAA,CACA,SAAAmqB,WACA,KAAAF,EAAA,CAAAA,GACA,CACApZ,QAAA,CACA,SAAA8J,IAAA,CAAA+J,eAAA,CACA,OACA,IAAgB0F,UAAAA,CAAA,CAAAC,eAAAA,CAAA,EAA4B,KAAA1P,IAAA,CAAA+J,eAAA,CAC5C,CAAgB0F,UAAAE,CAAA,EAA2B,KAAA3P,IAAA,CAAA4P,mBAAA,KAC3C,SAAA5P,IAAA,CAAAyI,cAAA,EAAAgH,IAAAE,EACA,OAEA,IAAAE,EAAA,KAAA7P,IAAA,CAAAyI,cAAA,CAAAkG,SAAA,SAAAc,GACAC,GAAA,CAAAD,GACAI,EAAAjoB,IAAA,KAAA8nB,EAAA,KAAAJ,EAAA,EAEA,CACAJ,OAAA,CACA,IAAgBY,SAAAA,CAAA,EAAW,KAAA9P,IAAA,CAAA+J,eAAA,KAC3B+F,GACA,MAAAT,OAAA,CAAAS,EAAA,KAAAR,EAAA,EAEA,CACAD,SAAA,EACA,gBEvBA,SAAAU,EAAA/P,CAAA,CAAAf,CAAA,CAAA+Q,CAAA,EACA,IAAY7R,MAAAA,CAAA,EAAQ6B,CACpBA,CAAAA,EAAAyI,cAAA,EAAAtK,EAAAqN,UAAA,EACAxL,EAAAyI,cAAA,CAAAkG,SAAA,cAAAqB,UAAAA,GAGA,IAAAC,EAAA9R,CAAA,CADA,UAAA6R,EACA,CACAC,GACQ7Z,EAAAC,EAAK,CAAA6Z,UAAA,KAAAD,EAAAhR,EAAkC,GAAAkR,EAAAC,CAAA,EAAgBnR,IAE/D,CACA,MAAAoR,UAA2BtQ,EAAA+L,CAAO,CAClCoD,OAAA,CACA,IAAgBntB,QAAAA,CAAA,EAAU,KAAAie,IAAA,CAC1Bje,GAEA,MAAAstB,OAAA,CAAuB,GAAAhoB,EAAAipB,EAAA,EAAKvuB,EAAA,IAC5BguB,EAAA,KAAA/P,IAAA,CAAAuQ,EAAA,SACA,GAAAR,EAAA,KAAA/P,IAAA,CAAAwQ,EAAA,QACS,CACT,CACAnB,SAAA,EACA,0BCvBA,OAAAoB,UAA2B1Q,EAAA+L,CAAO,CAClCzmB,aAAA,CACA,SAAAmqB,WACA,KAAApE,QAAA,GACA,CACAsF,SAAA,CACA,IAAAC,EAAA,GAOA,IACAA,EAAA,KAAA3Q,IAAA,CAAAje,OAAA,CAAA6uB,OAAA,kBACA,CACA,MAAA7gB,EAAA,CACA4gB,EAAA,EACA,CACAA,GAAA,KAAA3Q,IAAA,CAAAyI,cAAA,GAEA,KAAAzI,IAAA,CAAAyI,cAAA,CAAAkG,SAAA,kBACA,KAAAvD,QAAA,IACA,CACAyF,QAAA,CACA,KAAAzF,QAAA,OAAApL,IAAA,CAAAyI,cAAA,GAEA,KAAAzI,IAAA,CAAAyI,cAAA,CAAAkG,SAAA,kBACA,KAAAvD,QAAA,IACA,CACA8D,OAAA,CACA,KAAAG,OAAA,CAAuB,GAAAnjB,EAAAC,CAAA,EAAK,GAAA2kB,EAAAC,CAAA,EAAW,KAAA/Q,IAAA,CAAAje,OAAA,kBAAA2uB,OAAA,IAAoD,GAAAI,EAAAC,CAAA,EAAW,KAAA/Q,IAAA,CAAAje,OAAA,iBAAA8uB,MAAA,IACtG,CACAxB,SAAA,EACA,CCjCA,SAAA2B,EAAAhR,CAAA,CAAAf,CAAA,CAAA+Q,CAAA,EACA,IAAY7R,MAAAA,CAAA,EAAQ6B,CACpBA,CAAAA,EAAAyI,cAAA,EAAAtK,EAAAsN,QAAA,EACAzL,EAAAyI,cAAA,CAAAkG,SAAA,YAAAqB,UAAAA,GAGA,IAAAC,EAAA9R,CAAA,CADA,QAAA6R,CAAAA,QAAAA,EAAA,GAAAA,CAAA,EACA,CACAC,GACQ7Z,EAAAC,EAAK,CAAA6Z,UAAA,KAAAD,EAAAhR,EAAkC,GAAAkR,EAAAC,CAAA,EAAgBnR,IAE/D,CACA,MAAAgS,UAA2BlR,EAAA+L,CAAO,CAClCoD,OAAA,CACA,IAAgBntB,QAAAA,CAAA,EAAU,KAAAie,IAAA,CAC1Bje,GAEA,MAAAstB,OAAA,CAAuB,GAAAhoB,EAAA6pB,EAAA,EAAKnvB,EAAA,IAC5BivB,EAAA,KAAAhR,IAAA,CAAAuQ,EAAA,SACA,CAAAC,EAAA,CAAgCW,QAAAA,CAAA,CAAS,GAAAH,EAAA,KAAAhR,IAAA,CAAAwQ,EAAAW,EAAA,iBAChC,CAAIC,gBAAA,KAAApR,IAAA,CAAA7B,KAAA,CAAAkT,eAAA,EAAkD,CAC/D,CACAhC,SAAA,EACA,CCtBA,IAAAiC,EAAA,IAAAC,QAMAC,EAAA,IAAAD,QACAE,EAAA,IACA,IAAAxB,EAAAqB,EAAAvT,GAAA,CAAA2T,EAAAlmB,MAAA,CACAykB,CAAAA,GAAAA,EAAAyB,EACA,EACAC,EAAA,IACAC,EAAAlK,OAAA,CAAA+J,EACA,ECfAI,EAAA,CACArjB,KAAA,EACA8a,IAAA,CACA,CACA,OAAAwI,UAA4B/R,EAAA+L,CAAO,CACnCzmB,aAAA,CACA,SAAAmqB,WACA,KAAAuC,cAAA,IACA,KAAAC,QAAA,GACA,CACAC,eAAA,CACA,KAAA5C,OAAA,GACA,IAAgB6C,SAAAA,EAAA,IAAgB,KAAAlS,IAAA,CAAA1D,QAAA,GAChC,CAAgBrN,KAAAA,CAAA,CAAAkjB,OAAAC,CAAA,CAAAC,OAAAA,EAAA,OAAAC,KAAAA,CAAA,EAAkDJ,EAClExsB,EAAA,CACAuJ,KAAAA,EAAAA,EAAAlN,OAAA,CAAAoD,KAAAA,EACAitB,WAAAA,EACAG,UAAA,iBAAAF,EAAAA,EAAAR,CAAA,CAAAQ,EAAA,EA+BA,OAAeG,SDbf7a,CAAA,CAAAjS,CAAA,CAAAuqB,CAAA,EACA,IAAAwC,EAAAC,SApBA,CAAoCzjB,KAAAA,CAAA,IAAAvJ,EAAkB,EACtD,IAAAitB,EAAA1jB,GAAA2jB,SAIApB,EAAAxlB,GAAA,CAAA2mB,IACAnB,EAAA5V,GAAA,CAAA+W,EAAA,IAEA,IAAAE,EAAArB,EAAAzT,GAAA,CAAA4U,GACArnB,EAAAwnB,KAAAC,SAAA,CAAArtB,GAQA,OAHAmtB,CAAA,CAAAvnB,EAAA,EACAunB,CAAAA,CAAA,CAAAvnB,EAAA,KAAA0nB,qBAAArB,EAAA,CAAkF1iB,KAAAA,EAAA,GAAAvJ,CAAA,EAAkB,EAEpGmtB,CAAA,CAAAvnB,EAAA,EAGA5F,GAGA,OAFA4rB,EAAA1V,GAAA,CAAAjE,EAAAsY,GACAwC,EAAAQ,OAAA,CAAAtb,GACA,KACA2Z,EAAApD,MAAA,CAAAvW,GACA8a,EAAAS,SAAA,CAAAvb,EACA,CACA,ECKkC,KAAAqI,IAAA,CAAAje,OAAA,CAAA2D,EA7BlC,IACA,IAAoBytB,eAAAA,CAAA,EAAiBzB,EAIrC,QAAAM,QAAA,GAAAmB,IAEA,KAAAnB,QAAA,CAAAmB,EAKAb,GAAA,CAAAa,GAAA,KAAApB,cAAA,EANA,OASAoB,GACA,MAAApB,cAAA,KAEA,KAAA/R,IAAA,CAAAyI,cAAA,EACA,KAAAzI,IAAA,CAAAyI,cAAA,CAAAkG,SAAA,eAAAwE,GAMA,IAAoBC,gBAAAA,CAAA,CAAAC,gBAAAA,CAAA,EAAmC,KAAArT,IAAA,CAAA1D,QAAA,GACvD2T,EAAAkD,EAAAC,EAAAC,CACApD,CAAAA,GAAAA,EAAAyB,EACA,EAEA,CACAxC,OAAA,CACA,KAAA+C,aAAA,EACA,CACA/b,QAAA,CACA,uBAAA8c,qBACA,OACA,IAAgB7U,MAAAA,CAAA,CAAAiR,UAAAA,CAAA,EAAmB,KAAApP,IAAA,CACnC,2BAAAxR,IAAA,CAAA8kB,SAOA,CAAoCpB,SAAAA,EAAA,GAAe,EAAIA,SAAAqB,EAAA,IAA8B,EAAI,EACzF,UAAArB,CAAA,CAAAhuB,EAAA,GAAAqvB,CAAA,CAAArvB,EAAA,EARAia,EAAAiR,KAEA,KAAA6C,aAAA,EAEA,CACA5C,SAAA,EACA,2FEjEA,IAAAmE,EAAA,CAA+BzxB,QAAA,MAC/B0xB,EAAA,CAAmC1xB,QAAA,4FEMnC,IAAA2xB,GAAA,IAAuBzN,GAAAhd,CAAmB,CAAEO,GAAAP,CAAK,CAAE5E,GAAAC,CAAO,EAI1DqvB,GAAA,GAAAD,GAAApqB,IAAA,CAA6C,GAAA/E,GAAAqvB,CAAA,EAAajrB,oBCZ1D,IAAAkrB,GAAA,IAAAtC,oCEsBA,IAAAuC,GAAA,CACA,iBACA,oBACA,SACA,sBACA,gBACA,uBACA,0BACA,OAKAC,GAQAC,4BAAAC,CAAA,CAAAC,CAAA,CAAAC,CAAA,EACA,QACA,CACA9uB,YAAA,CAAkBqnB,OAAAA,CAAA,CAAAvO,MAAAA,CAAA,CAAA4L,gBAAAA,CAAA,CAAAqK,oBAAAA,CAAA,CAAA9F,sBAAAA,CAAA,CAAA+F,YAAAA,CAAA,CAA0F,CAAA3uB,EAAA,EAAc,EAK1H,KAAA3D,OAAA,MAIA,KAAAuyB,QAAA,KAAAzyB,IAIA,KAAA0yB,aAAA,IACA,KAAA9H,qBAAA,IAQA,KAAApD,kBAAA,MAMA,KAAApd,MAAA,KAAAuoB,IACA,KAAA3c,gBAAA,CAAgCvR,GAAAyJ,CAAgB,CAIhD,KAAA0kB,QAAA,IAKA,KAAAC,kBAAA,KAAAF,IAMA,KAAAG,gBAAA,IAIA,KAAAC,MAAA,IAMA,KAAAC,sBAAA,IACA,KAAAC,YAAA,UAAAnK,MAAA,eAAAxI,YAAA,EACA,KAAA4S,MAAA,MACA,KAAAhzB,OAAA,GAEA,KAAAizB,YAAA,GACA,KAAAC,cAAA,MAAAlzB,OAAA,MAAAmzB,WAAA,MAAA/W,KAAA,CAAAyD,KAAA,MAAAuT,UAAA,EACA,EACA,KAAAC,iBAAA,GACA,KAAAC,cAAA,MACA,IAAArvB,EAAwBF,EAAAC,CAAI,CAAAC,GAAA,EAC5B,MAAAovB,iBAAA,CAAApvB,IACA,KAAAovB,iBAAA,CAAApvB,EACgBoQ,EAAAC,EAAK,CAAA0e,MAAA,MAAAA,MAAA,QAErB,EACA,IAAgB5S,aAAAA,CAAA,CAAA+S,YAAAA,CAAA,CAAAvuB,SAAAA,CAAA,EAAsC0tB,CACtD,MAAA1tB,QAAA,CAAAA,EACA,KAAAwb,YAAA,CAAAA,EACA,KAAAmT,UAAA,EAA4B,GAAAnT,CAAA,EAC5B,KAAAoT,aAAA,CAAApX,EAAAwO,OAAA,EAA+C,GAAAxK,CAAA,EAAkB,GACjE,KAAA+S,WAAA,CAAAA,EACA,KAAAxI,MAAA,CAAAA,EACA,KAAAvO,KAAA,CAAAA,EACA,KAAA4L,eAAA,CAAAA,EACA,KAAA/E,KAAA,CAAA0H,EAAAA,EAAA1H,KAAA,KACA,KAAAoP,mBAAA,CAAAA,EACA,KAAA1uB,OAAA,CAAAA,EACA,KAAA4oB,qBAAA,CAAA7kB,CAAAA,CAAA6kB,EACA,KAAA7B,qBAAA,CAAqC,GAAA+I,GAAA1Y,CAAA,EAAqBqB,GAC1D,KAAAoW,aAAA,CAA6B,GAAAiB,GAAA/xB,CAAA,EAAa0a,GAC1C,KAAAoW,aAAA,EACA,MAAArK,eAAA,KAAAroB,GAAA,EAEA,KAAAyrB,sBAAA,CAAA7jB,CAAAA,CAAAijB,CAAAA,GAAAA,EAAA3qB,OAAA,EAWA,IAAgB0zB,WAAAA,CAAA,IAAAC,EAAA,CAAqC,KAAA1B,2BAAA,CAAA7V,EAAA,GAA4C,MACjG,QAAA7S,KAAAoqB,EAAA,CACA,IAAAzxB,EAAAyxB,CAAA,CAAApqB,EAAA,MACAnG,IAAAgd,CAAA,CAAA7W,EAAA,EAAmD,GAAAqqB,GAAAzyB,CAAA,EAAae,IAChEA,EAAA2X,GAAA,CAAAuG,CAAA,CAAA7W,EAAA,IAEA,CACA,CACA4jB,MAAApL,CAAA,EACA,KAAA/hB,OAAA,CAAA+hB,EACQ+P,GAAkBjY,GAAA,CAAAkI,EAAA,MAC1B,KAAAqR,UAAA,QAAAA,UAAA,CAAArR,QAAA,EACA,KAAAqR,UAAA,CAAAjG,KAAA,CAAApL,GAEA,KAAA4I,MAAA,OAAA6H,aAAA,QAAA9H,qBAAA,EACA,MAAAmJ,qBAAA,MAAAlJ,MAAA,CAAAmJ,eAAA,QAEA,KAAA5pB,MAAA,CAAAyb,OAAA,EAAAzjB,EAAAqH,IAAA,KAAAwqB,iBAAA,CAAAxqB,EAAArH,IACawvB,EAAwB1xB,OAAA,EACzBg0B,WJ/JZ,GADItC,EAAwB1xB,OAAA,IACnBi0B,EAAAC,CAAS,EAElB,GAAAzQ,OAAA0Q,UAAA,EACA,IAAAC,EAAA3Q,OAAA0Q,UAAA,6BACAE,EAAA,IAAmD5C,EAAoBzxB,OAAA,CAAAo0B,EAAAvF,OAAA,CACvEuF,EAAAE,WAAA,CAAAD,GACAA,GACA,MAEQ5C,EAAoBzxB,OAAA,IAE5B,IIsJA,KAAAsnB,kBAAA,CACA,eAAA+K,mBAAA,EAEA,iBAAAA,mBAAA,EAEsBZ,EAAoBzxB,OAAA,EAI1C,KAAA2qB,MAAA,EACA,KAAAA,MAAA,CAAA4H,QAAA,CAAAjG,GAAA,OACA,KAAAnY,MAAA,MAAAiI,KAAA,MAAA4L,eAAA,CACA,CACAsF,SAAA,CASA,QAAA/jB,KARQuoB,GAAkB3F,MAAA,MAAAnsB,OAAA,EAC1B,KAAAozB,UAAA,OAAAA,UAAA,CAAA9F,OAAA,GACQ,GAAAjZ,EAAAG,EAAA,EAAW,KAAAue,YAAA,EACX,GAAA1e,EAAAG,EAAA,EAAW,KAAAwe,MAAA,EACnB,KAAAL,kBAAA,CAAAhN,OAAA,IAAA4O,KACA,KAAA5B,kBAAA,CAAA6B,KAAA,GACA,KAAAX,qBAAA,OAAAA,qBAAA,GACA,KAAAlJ,MAAA,OAAAA,MAAA,CAAA4H,QAAA,CAAApG,MAAA,OACA,KAAA0G,MAAA,CACA,KAAAA,MAAA,CAAAtpB,EAAA,CAAAirB,KAAA,GAEA,QAAAjrB,KAAA,KAAAmpB,QAAA,EACA,IAAA+B,EAAA,KAAA/B,QAAA,CAAAnpB,EAAA,CACAkrB,IACAA,EAAAnH,OAAA,GACAmH,EAAAvW,SAAA,IAEA,CACA,KAAAle,OAAA,KACA,CACA+zB,kBAAAxqB,CAAA,CAAArH,CAAA,MAaAwyB,EAZA,KAAA/B,kBAAA,CAAA1oB,GAAA,CAAAV,IACA,KAAAopB,kBAAA,CAAA3W,GAAA,CAAAzS,KAEA,IAAAorB,EAAiC7Z,GAAAC,CAAc,CAAA9Q,GAAA,CAAAV,GAC/CqrB,EAAA1yB,EAAA2yB,EAAA,cACA,KAAAzU,YAAA,CAAA7W,EAAA,CAAAurB,EACA,KAAA1Y,KAAA,CAAAxX,QAAA,EAAmCyP,EAAAC,EAAK,CAAAygB,SAAA,MAAAhC,YAAA,EACxC4B,GAAA,KAAAvB,UAAA,EACA,MAAAA,UAAA,CAAA4B,gBAAA,IAEA,GACAC,EAAA/yB,EAAA2yB,EAAA,sBAAAvB,cAAA,CAEA7P,CAAAA,OAAAyR,qBAAA,EACAR,CAAAA,EAAAjR,OAAAyR,qBAAA,MAAA3rB,EAAArH,EAAA,EAEA,KAAAywB,kBAAA,CAAA9Y,GAAA,CAAAtQ,EAAA,KACAqrB,IACAK,IACAP,GACAA,IACAxyB,EAAAwW,KAAA,EACAxW,EAAAqS,IAAA,EACA,EACA,CACAwU,iBAAAoM,CAAA,SAIA,KAAAn1B,OAAA,EACA,KAAAo1B,wBAAA,EACA,KAAA3xB,IAAA,GAAA0xB,EAAA1xB,IAAA,CAGA,KAAA2xB,wBAAA,MAAAp1B,OAAA,CAAAm1B,EAAAn1B,OAAA,EAFA,CAGA,CACAq1B,gBAAA,CACA,IAAA9rB,EAAA,YACA,IAAAA,KAAoB+rB,EAAAC,kBAAkB,EACtC,IAAAC,EAAsCF,EAAAC,kBAAkB,CAAAhsB,EAAA,CACxD,IAAAisB,EACA,SACA,IAAoBC,UAAAA,CAAA,CAAAzX,QAAA0X,CAAA,EAAyCF,EAY7D,GARA,MAAA9C,QAAA,CAAAnpB,EAAA,EACAmsB,GACAD,EAAA,KAAArZ,KAAA,GACA,MAAAsW,QAAA,CAAAnpB,EAAA,KAAAmsB,EAAA,OAKA,KAAAhD,QAAA,CAAAnpB,EAAA,EACA,IAAAkrB,EAAA,KAAA/B,QAAA,CAAAnpB,EAAA,CACAkrB,EAAAvW,SAAA,CACAuW,EAAAtgB,MAAA,IAGAsgB,EAAAtH,KAAA,GACAsH,EAAAvW,SAAA,IAEA,CACA,CACA,CACA+U,cAAA,CACA,KAAA0C,KAAA,MAAAxC,WAAA,MAAA/S,YAAA,MAAAhE,KAAA,CACA,CAMA0F,oBAAA,CACA,YAAA9hB,OAAA,CACA,KAAA41B,0BAAA,MAAA51B,OAAA,MAAAoc,KAAA,EACc,GAAAyZ,EAAAC,EAAA,GACd,CACAC,eAAAxsB,CAAA,EACA,YAAA6W,YAAA,CAAA7W,EAAA,CAEAysB,eAAAzsB,CAAA,CAAArH,CAAA,EACA,KAAAke,YAAA,CAAA7W,EAAA,CAAArH,CACA,CAKAiS,OAAAiI,CAAA,CAAA4L,CAAA,EACA5L,CAAAA,EAAA9B,iBAAA,OAAA8B,KAAA,CAAA9B,iBAAA,GACA,KAAAgZ,cAAA,GAEA,KAAAjG,SAAA,MAAAjR,KAAA,CACA,KAAAA,KAAA,CAAAA,EACA,KAAAyR,mBAAA,MAAA7F,eAAA,CACA,KAAAA,eAAA,CAAAA,EAIA,QAAA7mB,EAAA,EAAwBA,EAAA4wB,GAAA5uB,MAAA,CAA8BhC,IAAA,CACtD,IAAAoI,EAAAwoB,EAAA,CAAA5wB,EAAA,CACA,KAAA2xB,sBAAA,CAAAvpB,EAAA,GACA,KAAAupB,sBAAA,CAAAvpB,EAAA,GACA,YAAAupB,sBAAA,CAAAvpB,EAAA,EAGA,IAAA0sB,EAAA7Z,CAAA,CADA,KAAA7S,EACA,CACA0sB,GACA,MAAAnD,sBAAA,CAAAvpB,EAAA,MAAAsrB,EAAA,CAAAtrB,EAAA0sB,EAAA,CAEA,CACA,KAAArD,gBAAA,CAAgCsD,SDrThCtgB,CAAA,CAAAvG,CAAA,CAAA0W,CAAA,EACA,QAAAxc,KAAA8F,EAAA,CACA,IAAA8mB,EAAA9mB,CAAA,CAAA9F,EAAA,CACA6sB,EAAArQ,CAAA,CAAAxc,EAAA,CACA,GAAY,GAAAqqB,GAAAzyB,CAAA,EAAag1B,GAKzBvgB,EAAA+R,QAAA,CAAApe,EAAA4sB,QASA,GAAiB,GAAAvC,GAAAzyB,CAAA,EAAai1B,GAK9BxgB,EAAA+R,QAAA,CAAApe,EAAkC,GAAAqe,EAAAC,EAAA,EAAWsO,EAAA,CAAczd,MAAA9C,CAAA,SAE3D,GAAAwgB,IAAAD,GAMA,GAAAvgB,EAAA8R,QAAA,CAAAne,GAAA,CACA,IAAA8sB,EAAAzgB,EAAA0P,QAAA,CAAA/b,EACA8sB,EAAA,IAAAA,EAAAjK,SAAA,CACAiK,EAAA9Q,IAAA,CAAA4Q,GAEAE,EAAAC,WAAA,EACAD,EAAAxc,GAAA,CAAAsc,EAEA,KACA,CACA,IAAArB,EAAAlf,EAAAmgB,cAAA,CAAAxsB,GACAqM,EAAA+R,QAAA,CAAApe,EAAsC,GAAAqe,EAAAC,EAAA,EAAWiN,KAAA1xB,IAAA0xB,EAAAA,EAAAqB,EAAA,CAAwDzd,MAAA9C,CAAA,GACzG,EAEA,CAEA,QAAArM,KAAAwc,EACA3iB,KAAAA,IAAAiM,CAAA,CAAA9F,EAAA,EACAqM,EAAA2gB,WAAA,CAAAhtB,GAEA,OAAA8F,CACA,ECiQ2D,UAAA4iB,2BAAA,CAAA7V,EAAA,KAAAiR,SAAA,YAAAuF,gBAAA,EAC3D,KAAA4D,sBAAA,EACA,KAAAA,sBAAA,GAEA,KAAA5xB,QAAA,OAAAA,QAAA,MACA,CACA2V,UAAA,CACA,YAAA6B,KAAA,CAKAqa,WAAAt0B,CAAA,EACA,YAAAia,KAAA,CAAAsa,QAAA,MAAAta,KAAA,CAAAsa,QAAA,CAAAv0B,EAAA,CAAAiB,KAAAA,CACA,CAIAwX,sBAAA,CACA,YAAAwB,KAAA,CAAAnB,UAAA,CAEA0b,uBAAA,CACA,YAAAva,KAAA,CAAAkG,kBAAA,CAEAsU,uBAAA,CACA,YAAApE,aAAA,CACA,KACA,KAAA7H,MAAA,CACA,KAAAA,MAAA,CAAAiM,qBAAA,GACAxzB,KAAAA,CACA,CAIA0wB,gBAAAnL,CAAA,EACA,IAAAkO,EAAA,KAAAD,qBAAA,GACA,GAAAC,EAGA,OAFAA,EAAA1O,eAAA,EACA0O,EAAA1O,eAAA,CAAAmE,GAAA,CAAA3D,GACA,IAAAkO,EAAA1O,eAAA,CAAAgE,MAAA,CAAAxD,EAEA,CAIAhB,SAAApe,CAAA,CAAArH,CAAA,EAEA,IAAAm0B,EAAA,KAAAnsB,MAAA,CAAA8R,GAAA,CAAAzS,GACArH,IAAAm0B,IACAA,GACA,KAAAE,WAAA,CAAAhtB,GACA,KAAAwqB,iBAAA,CAAAxqB,EAAArH,GACA,KAAAgI,MAAA,CAAA2P,GAAA,CAAAtQ,EAAArH,GACA,KAAAke,YAAA,CAAA7W,EAAA,CAAArH,EAAA8Z,GAAA,GAEA,CAIAua,YAAAhtB,CAAA,EACA,KAAAW,MAAA,CAAAiiB,MAAA,CAAA5iB,GACA,IAAAutB,EAAA,KAAAnE,kBAAA,CAAA3W,GAAA,CAAAzS,GACAutB,IACAA,IACA,KAAAnE,kBAAA,CAAAxG,MAAA,CAAA5iB,IAEA,YAAA6W,YAAA,CAAA7W,EAAA,CACA,KAAAwtB,0BAAA,CAAAxtB,EAAA,KAAA4pB,WAAA,CACA,CAIAzL,SAAAne,CAAA,EACA,YAAAW,MAAA,CAAAD,GAAA,CAAAV,EACA,CACA+b,SAAA/b,CAAA,CAAAytB,CAAA,EACA,QAAA5a,KAAA,CAAAlS,MAAA,OAAAkS,KAAA,CAAAlS,MAAA,CAAAX,EAAA,CACA,YAAA6S,KAAA,CAAAlS,MAAA,CAAAX,EAAA,CAEA,IAAArH,EAAA,KAAAgI,MAAA,CAAA8R,GAAA,CAAAzS,GAKA,OAJAnG,KAAAA,IAAAlB,GAAA80B,KAAA5zB,IAAA4zB,IACA90B,EAAoB,GAAA0lB,EAAAC,EAAA,EAAWmP,OAAAA,EAAA5zB,KAAAA,EAAA4zB,EAAA,CAAqDte,MAAA,OACpF,KAAAiP,QAAA,CAAApe,EAAArH,IAEAA,CACA,CAMA+0B,UAAA1tB,CAAA,CAAAE,CAAA,EACA,IAAAa,EACA,IAAApI,EAAA,KAAAkB,IAAA,KAAAgd,YAAA,CAAA7W,EAAA,OAAAvJ,OAAA,CAEA,OAAAsK,CAAAA,EAAA,KAAA4sB,sBAAA,MAAA9a,KAAA,CAAA7S,EAAA,GAAAe,KAAA,IAAAA,EAAAA,EAAA,KAAA6sB,qBAAA,MAAAn3B,OAAA,CAAAuJ,EAAA,KAAA5F,OAAA,EADA,KAAAyc,YAAA,CAAA7W,EAAA,CAaA,aAXArH,IACA,iBAAAA,GACiB,IAAA2hB,EAAAthB,CAAA,EAAiBL,IAAW,GAAAuiB,EAAAC,CAAA,EAAiBxiB,EAAA,EAE9DA,EAAA4hB,WAAA5hB,GAEA,CAAsB0vB,GAAa1vB,IAAWI,GAAAC,CAAO,CAAAC,IAAA,CAAAiH,IACrDvH,CAAAA,EAAwB,GAAA4iB,GAAAC,CAAA,EAAiBxb,EAAAE,EAAA,EAEzC,KAAA2tB,aAAA,CAAA7tB,EAAoC,GAAAqqB,GAAAzyB,CAAA,EAAae,GAAAA,EAAA8Z,GAAA,GAAA9Z,IAElC,GAAA0xB,GAAAzyB,CAAA,EAAae,GAAAA,EAAA8Z,GAAA,GAAA9Z,CAC5B,CAKAk1B,cAAA7tB,CAAA,CAAArH,CAAA,EACA,KAAAqxB,UAAA,CAAAhqB,EAAA,CAAArH,CACA,CAKAwqB,cAAAnjB,CAAA,MACAe,MAEA+sB,EADA,IAAgBzM,QAAAA,CAAA,EAAU,KAAAxO,KAAA,CAE1B,oBAAAwO,GAAA,iBAAAA,EAAA,CACA,IAAA7C,EAA4B,GAAA5B,EAAAtkB,CAAA,EAAuB,KAAAua,KAAA,CAAAwO,EAAA,OAAAtgB,CAAAA,EAAA,KAAA0d,eAAA,GAAA1d,KAAA,IAAAA,EAAA,OAAAA,EAAA4b,MAAA,EACnD6B,GACAsP,CAAAA,EAAAtP,CAAA,CAAAxe,EAAA,CAEA,CAIA,GAAAqhB,GAAAyM,KAAAj0B,IAAAi0B,EACA,OAAAA,EAMA,IAAA5tB,EAAA,KAAAytB,sBAAA,MAAA9a,KAAA,CAAA7S,UACA,KAAAnG,IAAAqG,GAAqC,GAAAmqB,GAAAzyB,CAAA,EAAasI,GAMlD,KAAArG,IAAA,KAAAowB,aAAA,CAAAjqB,EAAA,EACA8tB,KAAAj0B,IAAAi0B,EACAj0B,KAAAA,EACA,KAAAmwB,UAAA,CAAAhqB,EAAA,CARAE,CASA,CACAorB,GAAAjY,CAAA,CAAAsR,CAAA,EAIA,OAHA,KAAA2E,MAAA,CAAAjW,EAAA,EACA,MAAAiW,MAAA,CAAAjW,EAAA,KAAyC0a,GAAAvN,CAAmB,EAE5D,KAAA8I,MAAA,CAAAjW,EAAA,CAAA0P,GAAA,CAAA4B,EACA,CACAtF,OAAAhM,CAAA,IAAA2a,CAAA,EACA,KAAA1E,MAAA,CAAAjW,EAAA,EACA,KAAAiW,MAAA,CAAAjW,EAAA,CAAAgM,MAAA,IAAA2O,EAEA,CACA,gBCxdA,OAAAC,WAA+BxF,GAC/B1uB,aAAA,CACA,SAAAmqB,WACA,KAAA3X,gBAAA,CAAgC0C,GAAAC,CAAoB,CAEpD2c,yBAAA7uB,CAAA,CAAAC,CAAA,EAMA,OAAAD,EAAAA,EAAAkxB,uBAAA,CAAAjxB,GAAA,IACA,CACA0wB,uBAAA9a,CAAA,CAAA7S,CAAA,EACA,OAAA6S,EAAAyD,KAAA,CACAzD,EAAAyD,KAAA,CAAAtW,EAAA,CACAnG,KAAAA,CACA,CACA2zB,2BAAAxtB,CAAA,EAAsCmuB,KAAAA,CAAA,CAAA7X,MAAAA,CAAA,CAAa,EACnD,OAAA6X,CAAA,CAAAnuB,EAAA,CACA,OAAAsW,CAAA,CAAAtW,EAAA,CAEAitB,wBAAA,CACA,KAAAmB,iBAAA,GACA,KAAAA,iBAAA,GACA,YAAAA,iBAAA,EAEA,IAAgBpF,SAAAA,CAAA,EAAW,KAAAnW,KAAA,CACf,GAAAwX,GAAAzyB,CAAA,EAAaoxB,IACzB,MAAAoF,iBAAA,CAAApF,EAAAsC,EAAA,cACA,KAAA70B,OAAA,EACA,MAAAA,OAAA,CAAA43B,WAAA,IAAkD9mB,EAAO,EAEzD,EAAa,CAEb,CACA,8DC5BA,OAAA+mB,WAAgCL,GAChCl0B,aAAA,CACA,SAAAmqB,WACA,KAAAhqB,IAAA,QACA,KAAAyvB,cAAA,CAA8BF,GAAA8E,CAAU,CAExCX,sBAAApV,CAAA,CAAAxY,CAAA,EACA,GAAYuR,GAAAC,CAAc,CAAA9Q,GAAA,CAAAV,GAAA,CAC1B,IAAAwuB,EAAgC,GAAAC,GAAAC,CAAA,EAAmB1uB,GACnD,OAAAwuB,GAAAA,EAAAnsB,OAAA,GACA,CACA,CACA,IAAAssB,EAdAzU,OAAAC,gBAAA,CAcA3B,GACA7f,EAAA,CAA2B,GAAA6G,GAAAovB,CAAA,EAAiB5uB,GAC5C2uB,EAAAvU,gBAAA,CAAApa,GACA2uB,CAAA,CAAA3uB,EAAA,KACA,uBAAArH,EAAAA,EAAA6gB,IAAA,GAAA7gB,CACA,CACA,CACA0zB,2BAAA7T,CAAA,EAA2CO,mBAAAA,CAAA,CAAoB,EAC/D,MAAe,GAAA8V,EAAA/wB,CAAA,EAAkB0a,EAAAO,EACjC,CACAqT,MAAAxC,CAAA,CAAA/S,CAAA,CAAAhE,CAAA,EACQ,GAAAic,GAAAC,CAAA,EAAenF,EAAA/S,EAAAhE,EAAA9B,iBAAA,CACvB,CACA2X,4BAAA7V,CAAA,CAAAiR,CAAA,CAAAlR,CAAA,EACA,MAAe,GAAAoc,GAAAC,CAAA,EAA2Bpc,EAAAiR,EAAAlR,EAC1C,CACA,4EC7BA,OAAAsc,WAA+BjB,GAC/Bl0B,aAAA,CACA,SAAAmqB,WACA,KAAAhqB,IAAA,OACA,KAAAi1B,QAAA,IACA,KAAA9C,0BAAA,CAA0CC,EAAAC,EAAS,CAEnDoB,uBAAA9a,CAAA,CAAA7S,CAAA,EACA,OAAA6S,CAAA,CAAA7S,EAAA,CAEA4tB,sBAAApV,CAAA,CAAAxY,CAAA,EACA,GAAYuR,GAAAC,CAAc,CAAA9Q,GAAA,CAAAV,GAAA,CAC1B,IAAAwuB,EAAgC,GAAAC,GAAAC,CAAA,EAAmB1uB,GACnD,OAAAwuB,GAAAA,EAAAnsB,OAAA,GACA,CAEA,OADArC,EAAA,GAAekP,CAAmB,CAAAxO,GAAA,CAAAV,GAAuBA,EAAX,GAAAovB,GAAAC,CAAA,EAAWrvB,GACzDwY,EAAA8W,YAAA,CAAAtvB,EACA,CACA0oB,4BAAA7V,CAAA,CAAAiR,CAAA,CAAAlR,CAAA,EACA,MAAe,GAAA2c,GAAAN,CAAA,EAA2Bpc,EAAAiR,EAAAlR,EAC1C,CACAwZ,MAAAxC,CAAA,CAAA/S,CAAA,CAAAhE,CAAA,EACQ,GAAA2c,GAAA53B,CAAA,EAAagyB,EAAA/S,EAAA,KAAAsY,QAAA,CAAAtc,EAAA9B,iBAAA,CACrB,CACA4Y,eAAAnR,CAAA,CAAAoR,CAAA,CAAA6F,CAAA,CAAA5F,CAAA,EACQ,GAAA6F,GAAA7zB,CAAA,EAAS2c,EAAAoR,EAAA6F,EAAA5F,EACjB,CACAjG,MAAApL,CAAA,EACA,KAAA2W,QAAA,CAAwB,GAAAQ,GAAA3yB,CAAA,EAAQwb,EAAAoX,OAAA,EAChC,MAAAhM,MAAApL,EACA,CACA,iBEnCA,IAAAqX,GAAA,CACAC,SDHA,CAAAC,EAAA31B,IACW,GAAA41B,GAAAlzB,CAAA,EAAcizB,GACzB,IAAcb,GAAgB90B,GAC9B,IAAck0B,GAAiBl0B,EAAA,CAC/B61B,gBAAAF,IAA2CG,EAAAC,QAAQ,GhBLnDzgB,UAAA,CACA+E,QAAiB8L,CACjB,EACAD,KAAA,CACA7L,QAAiBwP,CACjB,EMHAmM,OAAA,CACA3b,QAAiB+R,CACjB,EACA6J,IAAA,CACA5b,QAAiBkR,CACjB,EACA2K,MAAA,CACA7b,QAAiB0Q,CACjB,EACAoL,MAAA,CACA9b,QAAiBsQ,CACjB,CWNA,+ICPA,IAAAyL,EAAA,GAAAnzB,IAAmCozB,EAAAC,EAAM,EAAArzB,IAAUszB,EAAAC,EAAE,CACrDC,EAAA,CAAAC,EAAAC,IAAAxW,WAAAuW,EAAAE,KAAA,OAAAD,EAAA,EACAE,EAAA,CAAAC,EAAAC,IAAA,CAAAC,EAAA,CAAyDhyB,UAAAA,CAAA,CAAW,IACpE,GAAAA,SAAAA,GAAA,CAAAA,EACA,SACA,IAAAiyB,EAAAjyB,EAAA0a,KAAA,wBACA,GAAAuX,EACA,OAAAR,EAAAQ,CAAA,IAAAF,EAEA,EACA,IAAAL,EAAA1xB,EAAA0a,KAAA,6BACA,EACA+W,EAAAC,CAAA,IAAAI,GAGA,CAEA,CACA,EACAI,EAAA,IAAA/6B,IAAA,eACAg7B,EAAsCC,EAAAC,CAAkB,CAAA/3B,MAAA,KAAA43B,EAAA5wB,GAAA,CAAAV,IACxD,SAAA0xB,EAAA9e,CAAA,EACA,IAAAuJ,EAAA,GAQA,OAPAoV,EAAAnV,OAAA,KACA,IAAAzjB,EAAAia,EAAAmJ,QAAA,CAAA/b,EACAnG,MAAAA,IAAAlB,IACAwjB,EAAArS,IAAA,EAAA9J,EAAArH,EAAA8Z,GAAA,KACA9Z,EAAA2X,GAAA,CAAAtQ,EAAA9G,UAAA,eAEA,GACAijB,CACA,CACA,IAAAwV,EAAA,CAEAC,MAAA,EAAcr6B,EAAAA,CAAA,CAAG,EAAIs6B,YAAAA,EAAA,IAAAC,aAAAA,EAAA,IAAuC,GAAAv6B,EAAAmK,GAAA,CAAAnK,EAAAkO,GAAA,CAAA8U,WAAAsX,GAAAtX,WAAAuX,GAC5DC,OAAA,EAAeje,EAAAA,CAAA,CAAG,EAAIke,WAAAA,EAAA,IAAAC,cAAAA,EAAA,IAAuC,GAAAne,EAAApS,GAAA,CAAAoS,EAAArO,GAAA,CAAA8U,WAAAyX,GAAAzX,WAAA0X,GAC7Dpd,IAAA,CAAAuc,EAAA,CAAmBvc,IAAAA,CAAA,CAAK,GAAA0F,WAAA1F,GACxBC,KAAA,CAAAsc,EAAA,CAAoBtc,KAAAA,CAAA,CAAM,GAAAyF,WAAAzF,GAC1BE,OAAA,EAAelB,EAAAA,CAAA,CAAG,EAAIe,IAAAA,CAAA,CAAK,GAAA0F,WAAA1F,GAAAf,CAAAA,EAAApS,GAAA,CAAAoS,EAAArO,GAAA,EAC3BsP,MAAA,EAAcxd,EAAAA,CAAA,CAAG,EAAIud,KAAAA,CAAA,CAAM,GAAAyF,WAAAzF,GAAAvd,CAAAA,EAAAmK,GAAA,CAAAnK,EAAAkO,GAAA,EAE3BlO,EAAA05B,EAAA,MACAnd,EAAAmd,EAAA,KACA,CAEAU,CAAAA,EAAAO,UAAA,CAAAP,EAAAp6B,CAAA,CACAo6B,EAAAQ,UAAA,CAAAR,EAAA7d,CAAA,6FC9CA,SAAAse,EAAApyB,CAAA,CAAArH,CAAA,EACA,IAAA05B,EAA2B,GAAAC,EAAA5D,CAAA,EAAmB1uB,GAI9C,OAHAqyB,IAA6BE,EAAAC,CAAM,EACnCH,CAAAA,EAA2BI,EAAAz5B,CAAO,EAElCq5B,EAAAD,iBAAA,CACAC,EAAAD,iBAAA,CAAAz5B,GACAkB,KAAAA,CACA,mFCLA,IAAA64B,EAAA,CACA,GAAOC,SAAAhI,CAAgB,CAEvBzsB,MAAS00B,EAAAj1B,CAAA,CACTk1B,gBAAqBD,EAAAj1B,CAAK,CAC1Bm1B,aAAkBF,EAAAj1B,CAAK,CACvBqS,KAAU4iB,EAAAj1B,CAAK,CACfo1B,OAAYH,EAAAj1B,CAAK,CAEjBq1B,YAAiBJ,EAAAj1B,CAAK,CACtBs1B,eAAoBL,EAAAj1B,CAAK,CACzBu1B,iBAAsBN,EAAAj1B,CAAK,CAC3Bw1B,kBAAuBP,EAAAj1B,CAAK,CAC5By1B,gBAAqBR,EAAAj1B,CAAK,CAC1BjE,OAAU25B,EAAAb,CAAA,CACVc,aAAkBD,EAAAb,CAAM,EAKxBe,EAAA,GAAAb,CAAA,CAAA1yB,EAAA,oHEnBA,IAAAwzB,EAAA,CAA6BC,EAAA/C,EAAM,CAAEgD,EAAA9C,EAAE,CAAE8C,EAAAC,EAAO,CAAED,EAAAE,EAAO,CAAEF,EAAAG,EAAE,CAAEH,EAAAI,EAAE,CDLjE,CACA76B,KAAA,GAAAoE,SAAAA,EACAgB,MAAA,GAAAhB,CACA,ECEuE,CAIvE02B,EAAA,GAAAP,EAAAx1B,IAAA,CAA+D,GAAA/E,EAAAqvB,CAAA,EAAajrB,2DCT5E,IAAA22B,EAAA,MAAA95B,EAAAjB,IAAA,CAAAoE,0DCDA,IAAA42B,EAAA,IAAA19B,IAAA,CACA,QACA,SACA,MACA,OACA,QACA,YACO29B,SAAAzC,CAAkB,CACzB,0GCPA,IAAA0C,EAAA,IAAA59B,IACA6X,EAAA,GACAgmB,EAAA,GACA,SAAAC,IACA,GAAAD,EAAA,CACA,IAAAE,EAAAz7B,MAAAsE,IAAA,CAAAg3B,GAAAz6B,MAAA,IAAAsS,EAAAgP,gBAAA,EACAuZ,EAAA,IAAAh+B,IAAA+9B,EAAAv0B,GAAA,IAAAiM,EAAAK,OAAA,GACAmoB,EAAA,IAAAtL,IAKAqL,EAAAnY,OAAA,KACA,IAAAD,EAAsC,GAAAsY,EAAAC,EAAA,EAA+BroB,EACrE8P,CAAAA,EAAAviB,MAAA,GAEA46B,EAAAlkB,GAAA,CAAAjE,EAAA8P,GACA9P,EAAAod,MAAA,GACA,GAEA6K,EAAAlY,OAAA,IAAApQ,EAAAyP,mBAAA,IAEA8Y,EAAAnY,OAAA,KACA/P,EAAAod,MAAA,GACA,IAAAkL,EAAAH,EAAA/hB,GAAA,CAAApG,GACAsoB,GACAA,EAAAvY,OAAA,GAAApc,EAAArH,EAAA,IACA,IAAAoI,CACA,QAAAA,CAAAA,EAAAsL,EAAA0P,QAAA,CAAA/b,EAAA,GAAAe,KAAA,IAAAA,GAAAA,EAAAuP,GAAA,CAAA3X,EACA,EAEA,GAEA27B,EAAAlY,OAAA,IAAApQ,EAAAiQ,eAAA,IAEAqY,EAAAlY,OAAA,KACAviB,KAAAA,IAAAmS,EAAA0P,gBAAA,EACAxB,OAAA0a,QAAA,GAAA5oB,EAAA0P,gBAAA,CAEA,EACA,CACA0Y,EAAA,GACAhmB,EAAA,GACA+lB,EAAA/X,OAAA,IAAApQ,EAAAuC,QAAA,IACA4lB,EAAAlJ,KAAA,EACA,CACA,SAAA4J,IACAV,EAAA/X,OAAA,KACApQ,EAAAsN,aAAA,GACAtN,EAAAgP,gBAAA,EACAoZ,CAAAA,EAAA,GAEA,EACA,CACA,SAAAU,IACAD,IACAR,GACA,CACA,MAAA9nB,EACAxS,YAAAsf,CAAA,CAAAje,CAAA,CAAAxC,CAAA,CAAAwT,CAAA,CAAAC,CAAA,CAAA0oB,EAAA,IAKA,KAAAC,UAAA,IAMA,KAAAD,OAAA,IAKA,KAAA/Z,gBAAA,IAKA,KAAA5M,WAAA,IACA,KAAAiL,mBAAA,KAAAA,EAAA,CACA,KAAAje,UAAA,CAAAA,EACA,KAAAxC,IAAA,CAAAA,EACA,KAAAwT,WAAA,CAAAA,EACA,KAAAC,OAAA,CAAAA,EACA,KAAA0oB,OAAA,CAAAA,CACA,CACAvoB,iBAAA,CACA,KAAA4B,WAAA,IACA,KAAA2mB,OAAA,EACAZ,EAAApR,GAAA,OACA3U,IACAA,EAAA,GACgB6mB,EAAAlqB,EAAK,CAAAmqB,IAAA,CAAAL,GACLI,EAAAlqB,EAAK,CAAAoqB,gBAAA,CAAAd,MAIrB,KAAA/a,aAAA,GACA,KAAA/K,QAAA,GAEA,CACA+K,eAAA,CACA,IAAgBD,oBAAAA,CAAA,CAAAzgB,KAAAA,CAAA,CAAAyT,QAAAA,CAAA,CAAAD,YAAAA,CAAA,EAAkD,KAKlE,QAAAxU,EAAA,EAAwBA,EAAAyhB,EAAAzf,MAAA,CAAgChC,IACxD,GAAAyhB,OAAAA,CAAA,CAAAzhB,EAAA,EAIA,GAAAA,IAAAA,EAAA,CACA,IAAAw9B,EAAAhpB,MAAAA,EAAA,OAAAA,EAAAqG,GAAA,GACAjZ,EAAA6f,CAAA,CAAAA,EAAAzf,MAAA,IACA,GAAAw7B,KAAAv7B,IAAAu7B,EACA/b,CAAA,IAAA+b,OAEA,GAAA/oB,GAAAzT,EAAA,CACA,IAAAy8B,EAAAhpB,EAAAqhB,SAAA,CAAA90B,EAAAY,SACA67B,GACAhc,CAAAA,CAAA,IAAAgc,CAAA,CAEA,CACAx7B,KAAAA,IAAAwf,CAAA,KACAA,CAAAA,CAAA,IAAA7f,CAAA,EAEA4S,GAAAgpB,KAAAv7B,IAAAu7B,GACAhpB,EAAAkE,GAAA,CAAA+I,CAAA,IAEA,MAEAA,CAAA,CAAAzhB,EAAA,CAAAyhB,CAAA,CAAAzhB,EAAA,GAIA,CACA09B,kBAAA,EACA7Z,qBAAA,EACA8Z,iBAAA,EACAtZ,iBAAA,EACA1N,UAAA,CACA,KAAAymB,UAAA,IACA,KAAA55B,UAAA,MAAAie,mBAAA,MAAA7f,aAAA,EACA26B,EAAAvR,MAAA,MACA,CACA3W,QAAA,CACA,KAAA+oB,UAAA,GACA,KAAA5mB,WAAA,IACA+lB,EAAAvR,MAAA,OAEA,CACAvU,QAAA,CACA,KAAA2mB,UAAA,EACA,KAAAxoB,eAAA,EACA,CACA,yBCjKA,SAAAgpB,EAAAprB,CAAA,CAAAqrB,CAAA,EACA,KAAArrB,EAAAsrB,OAAA,CAAAD,IACArrB,EAAAN,IAAA,CAAA2rB,EACA,CACA,SAAAE,EAAAvrB,CAAA,CAAAqrB,CAAA,EACA,IAAA97B,EAAAyQ,EAAAsrB,OAAA,CAAAD,GACA97B,EAAA,IACAyQ,EAAAI,MAAA,CAAA7Q,EAAA,EACA,gHCLA,IAAAi8B,EAAA,kCAAA38B,IAAA,CAAAoE,0DCAA,IAAAw4B,EAAA,iBAAA58B,IAAA,CAAAoE,0DCkBA,IAAAiC,EAAA,CAAAnC,EAAAC,EAAAmJ,IACApJ,EAAA,CAAAC,EAAAD,CAAA,EAAAoJ,yDCfA,IAAAuvB,EAAA,CAAA94B,EAAAC,IAAA,GAAAA,EAAAD,EAAAK,IACAuD,EAAA,IAAAm1B,IAAAA,EAAAtT,MAAA,CAAAqT,wECNA,OAAAE,EACAj8B,aAAA,CACA,KAAAk8B,aAAA,IAEAlT,IAAAzP,CAAA,EAEA,MADQ,GAAA4iB,EAAAC,EAAA,EAAa,KAAAF,aAAA,CAAA3iB,GACrB,IAAqB,GAAA4iB,EAAAE,EAAA,EAAU,KAAAH,aAAA,CAAA3iB,EAC/B,CACA+L,OAAAriB,CAAA,CAAAC,CAAA,CAAAsV,CAAA,EACA,IAAA8jB,EAAA,KAAAJ,aAAA,CAAAr8B,MAAA,CACA,GAAAy8B,GAEA,GAAAA,IAAAA,EAIA,KAAAJ,aAAA,IAAAj5B,EAAAC,EAAAsV,QAGA,QAAA3a,EAAA,EAA4BA,EAAAy+B,EAAsBz+B,IAAA,CAKlD,IAAA0b,EAAA,KAAA2iB,aAAA,CAAAr+B,EAAA,CACA0b,GAAAA,EAAAtW,EAAAC,EAAAsV,EACA,EAEA,CACA+jB,SAAA,CACA,YAAAL,aAAA,CAAAr8B,MAAA,CAEAqxB,OAAA,CACA,KAAAgL,aAAA,CAAAr8B,MAAA,EACA,CACA,yDC/BA,SAAA28B,EAAAp7B,CAAA,CAAAq7B,CAAA,EACA,OAAAA,EAAAr7B,IAAAq7B,EAAAr7B,EAAA,CACA,iICGA,IAAAs7B,EAAA,GACA,CAAA1xB,MAAAwV,WAAA5hB,IAEA+9B,EAAA,CACAjgC,QAAAoD,KAAAA,CACA,CAMA,OAAA88B,EASA58B,YAAA68B,CAAA,CAAAx8B,EAAA,EAAkC,EAKlC,KAAAy8B,OAAA,WAQA,KAAAC,gBAAA,MAIA,KAAAxN,MAAA,IACA,KAAAyN,eAAA,EAAA15B,EAAAosB,EAAA,MACA,IAAA7d,EAAgCorB,EAAAv8B,CAAI,CAAAC,GAAA,EAMpC,MAAAu8B,SAAA,GAAArrB,GACA,KAAAsrB,iBAAA,GAEA,KAAA1a,IAAA,MAAA/lB,OAAA,CACA,KAAA0gC,UAAA,CAAA95B,GAEA,KAAA5G,OAAA,QAAA+lB,IAAA,OAAA8M,MAAA,CAAA8N,MAAA,EACA,KAAA9N,MAAA,CAAA8N,MAAA,CAAA/X,MAAA,MAAA5oB,OAAA,EAGAgzB,GAAA,KAAAH,MAAA,CAAA+N,aAAA,EACA,KAAA/N,MAAA,CAAA+N,aAAA,CAAAhY,MAAA,MAAA5oB,OAAA,CAEA,EACA,KAAAs2B,WAAA,IACA,KAAAoK,UAAA,CAAAP,GACA,KAAAznB,KAAA,CAAA/U,EAAA+U,KAAA,CAEAgoB,WAAA1gC,CAAA,EACA,KAAAA,OAAA,CAAAA,EACA,KAAAwgC,SAAA,CAAyBD,EAAAv8B,CAAI,CAAAC,GAAA,GAC7B,YAAAo8B,gBAAA,EAAArgC,KAAAoD,IAAApD,GACA,MAAAqgC,gBAAA,CAAAL,EAAA,KAAAhgC,OAAA,EAEA,CACAygC,kBAAAI,EAAA,KAAA7gC,OAAA,EACA,KAAA6gC,cAAA,CAAAA,EACA,KAAAC,aAAA,MAAAN,SAAA,CA0CAO,SAAAC,CAAA,EAIA,YAAAnM,EAAA,UAAAmM,EACA,CACAnM,GAAAjY,CAAA,CAAAsR,CAAA,EACA,KAAA2E,MAAA,CAAAjW,EAAA,EACA,MAAAiW,MAAA,CAAAjW,EAAA,KAAyCqkB,EAAAlX,CAAmB,EAE5D,IAAA+M,EAAA,KAAAjE,MAAA,CAAAjW,EAAA,CAAA0P,GAAA,CAAA4B,SACA,WAAAtR,EACA,KACAka,IAKgBoK,EAAA5sB,EAAK,CAAAmqB,IAAA,MACrB,KAAA5L,MAAA,CAAA8N,MAAA,CAAAd,OAAA,IACA,KAAAtrB,IAAA,EAEA,EACA,EAEAuiB,CACA,CACAqK,gBAAA,CACA,QAAAC,KAAA,KAAAvO,MAAA,CACA,KAAAA,MAAA,CAAAuO,EAAA,CAAA5M,KAAA,EAEA,CAMA6M,OAAAC,CAAA,CAAAC,CAAA,EACA,KAAAD,aAAA,CAAAA,EACA,KAAAC,iBAAA,CAAAA,CACA,CAgBA1nB,IAAAjT,CAAA,CAAAosB,EAAA,IACA,QAAAsO,aAAA,CAIA,KAAAA,aAAA,CAAA16B,EAAA,KAAA05B,eAAA,EAHA,KAAAA,eAAA,CAAA15B,EAAAosB,EAKA,CACA7Y,gBAAA4L,CAAA,CAAA/lB,CAAA,CAAA6N,CAAA,EACA,KAAAgM,GAAA,CAAA7Z,GACA,KAAA+lB,IAAA,CAAA3iB,KAAAA,EACA,KAAAy9B,cAAA,CAAA9a,EACA,KAAA+a,aAAA,MAAAN,SAAA,CAAA3yB,CACA,CAKA0X,KAAA3e,CAAA,CAAA46B,EAAA,IACA,KAAAlB,eAAA,CAAA15B,GACA,KAAAmf,IAAA,CAAAnf,EACA,KAAAk6B,aAAA,MAAAD,cAAA,CAAAz9B,KAAAA,EACAo+B,GAAA,KAAAjtB,IAAA,GACA,KAAAgtB,iBAAA,EACA,KAAAA,iBAAA,EACA,CAQAvlB,KAAA,CAIA,OAHAikB,EAAAjgC,OAAA,EACAigC,EAAAjgC,OAAA,CAAAqT,IAAA,OAEA,KAAArT,OAAA,CAKAyhC,aAAA,CACA,YAAA1b,IAAA,CASA1K,aAAA,CACA,IAAAlG,EAA4BorB,EAAAv8B,CAAI,CAAAC,GAAA,GAChC,SAAAo8B,gBAAA,EACA,KAAAj9B,IAAA,KAAAy9B,cAAA,EACA1rB,EAAA,KAAAqrB,SAAA,CAnOA,GAoOA,SAEA,IAAA3yB,EAAAzM,KAAA4N,GAAA,MAAAwxB,SAAA,MAAAM,aAAA,CAtOA,IAwOA,MAAe,GAAAY,EAAAv2B,CAAA,EAAiB2Y,WAAA,KAAA9jB,OAAA,EAChC8jB,WAAA,KAAA+c,cAAA,EAAAhzB,EACA,CAaAuG,MAAAutB,CAAA,EAEA,OADA,KAAAptB,IAAA,GACA,IAAApO,QAAA,IACA,KAAAmwB,WAAA,IACA,KAAArd,SAAA,CAAA0oB,EAAA77B,GACA,KAAA+sB,MAAA,CAAA+O,cAAA,EACA,KAAA/O,MAAA,CAAA+O,cAAA,CAAAhZ,MAAA,EAEA,GAAS/iB,IAAA,MACT,KAAAgtB,MAAA,CAAAgP,iBAAA,EACA,KAAAhP,MAAA,CAAAgP,iBAAA,CAAAjZ,MAAA,GAEA,KAAAkZ,cAAA,EACA,EACA,CAMAvtB,MAAA,CACA,KAAA0E,SAAA,GACA,KAAAA,SAAA,CAAA1E,IAAA,GACA,KAAAse,MAAA,CAAAkP,eAAA,EACA,KAAAlP,MAAA,CAAAkP,eAAA,CAAAnZ,MAAA,IAGA,KAAAkZ,cAAA,EACA,CAMAE,aAAA,CACA,aAAA/oB,SAAA,CAEA6oB,gBAAA,CACA,YAAA7oB,SAAA,CAWAgpB,SAAA,CACA,KAAAd,cAAA,GACA,KAAA5sB,IAAA,GACA,KAAAgtB,iBAAA,EACA,KAAAA,iBAAA,EAEA,CACA,CACA,SAAA5rB,EAAAwqB,CAAA,CAAAx8B,CAAA,EACA,WAAAu8B,EAAAC,EAAAx8B,EACA,wEC3RA,IAAAsD,EAAA,CACAzE,KAAwB,GAAA0/B,SAAA/gC,CAAA,EAAa,KACrCyG,MAhCA,SAAAhB,CAAA,EACA,IAAA0xB,EAAA,GACArqB,EAAA,GACAzH,EAAA,GACAD,EAAA,GAmBA,OAjBAK,EAAAzD,MAAA,IACAm1B,EAAA1xB,EAAAu7B,SAAA,MACAl0B,EAAArH,EAAAu7B,SAAA,MACA37B,EAAAI,EAAAu7B,SAAA,MACA57B,EAAAK,EAAAu7B,SAAA,QAIA7J,EAAA1xB,EAAAu7B,SAAA,MACAl0B,EAAArH,EAAAu7B,SAAA,MACA37B,EAAAI,EAAAu7B,SAAA,MACA57B,EAAAK,EAAAu7B,SAAA,MACA7J,GAAAA,EACArqB,GAAAA,EACAzH,GAAAA,EACAD,GAAAA,GAEA,CACA2B,IAAAk6B,SAAA9J,EAAA,IACAnwB,MAAAi6B,SAAAn0B,EAAA,IACA7F,KAAAg6B,SAAA57B,EAAA,IACAyB,MAAA1B,EAAA67B,SAAA77B,EAAA,SACA,CACA,EAIAoC,UAAe05B,EAAA79B,CAAI,CAAAmE,SAAA,yGC/BnB,IAAAvB,EAAA,CACA5E,KAAwB,GAAA0/B,EAAA/gC,CAAA,EAAa,aACrCyG,MAAyB,GAAAs6B,EAAAh0B,CAAA,EAAU,gCACnCvF,UAAA,EAAkBb,IAAAA,CAAA,CAAAC,WAAAA,CAAA,CAAAC,UAAAA,CAAA,CAAAC,MAAAq6B,EAAA,EAAgD,GAClE,QACAlhC,KAAAiH,KAAA,CAAAP,GACA,KACYy6B,EAAArF,EAAO,CAAAv0B,SAAA,CAAW,GAAA65B,EAAA1K,CAAA,EAAQ/vB,IACtC,KACYw6B,EAAArF,EAAO,CAAAv0B,SAAA,CAAW,GAAA65B,EAAA1K,CAAA,EAAQ9vB,IACtC,KACY,GAAAw6B,EAAA1K,CAAA,EAAS2K,EAAAC,EAAK,CAAA/5B,SAAA,CAAA25B,IAC1B,GAEA,8FCfA,IAAA76B,EAAA,CACAjF,KAAA,GAAiBmgC,EAAAn+B,CAAI,CAAAhC,IAAA,CAAAoE,IAAYg8B,EAAA17B,CAAG,CAAA1E,IAAA,CAAAoE,IAAYi8B,EAAAx7B,CAAI,CAAA7E,IAAA,CAAAoE,GACpDgB,MAAA,GACA,EAAYpD,CAAI,CAAAhC,IAAA,CAAAoE,GACG+7B,EAAAn+B,CAAI,CAAAoD,KAAA,CAAAhB,GAENi8B,EAAAx7B,CAAI,CAAA7E,IAAA,CAAAoE,GACFi8B,EAAAx7B,CAAI,CAAAO,KAAA,CAAAhB,GAGJg8B,EAAA17B,CAAG,CAAAU,KAAA,CAAAhB,GAGtB+B,UAAA,GACA,iBAAA/B,EACAA,EACAA,EAAAsR,cAAA,QACkByqB,EAAAn+B,CAAI,CAAAmE,SAAA,CAAA/B,GACJi8B,EAAAx7B,CAAI,CAAAsB,SAAA,CAAA/B,EAEtB,yGCnBA,IAAAk8B,EAAA,GAA4B,GAAAC,EAAA11B,CAAA,EAAK,MAAAzG,GACjCo8B,EAAA,CACA,GAAOC,EAAAhJ,EAAM,CACbtxB,UAAA,GAAAvH,KAAAiH,KAAA,CAAAy6B,EAAAl8B,GACA,EACAO,EAAA,CACA3E,KAAwB,GAAA0gC,EAAA/hC,CAAA,EAAa,aACrCyG,MAAyB,GAAAs7B,EAAAh1B,CAAA,EAAU,sBACnCvF,UAAA,EAAkBT,IAAAA,CAAA,CAAAC,MAAAA,CAAA,CAAAC,KAAAA,CAAA,CAAAH,MAAAq6B,EAAA,EAAsC,WACxDU,EAAAr6B,SAAA,CAAAT,GACA,KACA86B,EAAAr6B,SAAA,CAAAR,GACA,KACA66B,EAAAr6B,SAAA,CAAAP,GACA,KACQ,GAAA+6B,EAAArL,CAAA,EAASmL,EAAAP,EAAK,CAAA/5B,SAAA,CAAA25B,IACtB,GACA,+FEtBA,IAAAc,EAAA,sHCQAC,EAAA,CAAA5/B,EAAA6/B,IAAA,GACA57B,CAAAA,CAAA,kBAAAd,GACQw8B,EAAgB5gC,IAAA,CAAAoE,IACxBA,EAAAnE,UAAA,CAAAgB,IACA6/B,GACA,MAAsB18B,GACtBoP,OAAAqC,SAAA,CAAAH,cAAA,CAAAC,IAAA,CAAAvR,EAAA08B,EAAA,EAEAC,EAAA,CAAAC,EAAAC,EAAAC,IAAA,IACA,oBAAA98B,EACA,OAAAA,EACA,IAAAL,EAAAC,EAAAsV,EAAA7T,EAAA,CAAArB,EAAAyc,KAAA,CAAqCsgB,EAAAv+B,CAAU,EAC/C,OACA,CAAAo+B,EAAA,CAAA1f,WAAAvd,GACA,CAAAk9B,EAAA,CAAA3f,WAAAtd,GACA,CAAAk9B,EAAA,CAAA5f,WAAAhI,GACA7T,MAAAA,KAAA7E,IAAA6E,EAAA6b,WAAA7b,GAAA,CACA,CACA,mFCpBA,IAAA27B,EAAA,IAAA9jC,IAAA,gDACA,SAAA+jC,EAAAj9B,CAAA,EACA,IAAAzE,EAAAD,EAAA,CAAA0E,EAAAk9B,KAAA,OAAAvJ,KAAA,MACA,GAAAp4B,gBAAAA,EACA,OAAAyE,EACA,IAAA8B,EAAA,CAAAxG,EAAAmhB,KAAA,CAAiC0gB,EAAA3+B,CAAU,MAC3C,IAAAsD,EACA,OAAA9B,EACA,IAAAo9B,EAAA9hC,EAAA+hC,OAAA,CAAAv7B,EAAA,IACAsuB,EAAA4M,EAAA35B,GAAA,CAAA9H,GAAA,IAGA,OAFAuG,IAAAxG,GACA80B,CAAAA,GAAA,KACA70B,EAAA,IAAA60B,EAAAgN,EAAA,GACA,CACA,IAAAE,EAAA,uBACAjhC,EAAA,CACA,GAAOkhC,EAAA5hC,CAAO,CACdo5B,kBAAA,IACA,IAAAyI,EAAAx9B,EAAAyc,KAAA,CAAA6gB,GACA,OAAAE,EAAAA,EAAA96B,GAAA,CAAAu6B,GAAAQ,IAAA,MAAAz9B,CACA,CACA,+FC3BA,IAAA09B,EAAA,+ICaA,IAAAC,EAAA,SACAC,EAAA,QAKAC,EAAA,kOACA,SAAAC,EAAAxiC,CAAA,EACA,IAAAyiC,EAAAziC,EAAAuN,QAAA,GACAvF,EAAA,GACAH,EAAA,CACAtC,MAAA,GACAiB,OAAA,GACAsB,IAAA,IAEAS,EAAA,GACAtJ,EAAA,EAoBAo5B,EAAAqK,EAnBAX,OAAA,CAAAQ,EAAA,IACYh9B,EAAAP,CAAK,CAAA1E,IAAA,CAAAqiC,IACjB96B,EAAAtC,KAAA,CAAA4L,IAAA,CAAAlS,GACAsJ,EAAA4I,IAAA,CAAAmxB,GACAt6B,EAAAmJ,IAAA,CAAwB5L,EAAAP,CAAK,CAAAU,KAAA,CAAAi9B,KAE7BA,EAAApiC,UAAA,CApBA,SAqBAsH,EAAAC,GAAA,CAAAqJ,IAAA,CAAAlS,GACAsJ,EAAA4I,IAAA,CAvBA,OAwBAnJ,EAAAmJ,IAAA,CAAAwxB,KAGA96B,EAAArB,MAAA,CAAA2K,IAAA,CAAAlS,GACAsJ,EAAA4I,IAAA,CAAAkxB,GACAr6B,EAAAmJ,IAAA,CAAAyQ,WAAA+gB,KAEA,EAAA1jC,EA7BA,QAgCAo5B,KAAA,CAhCA,OAiCA,OAAarwB,OAAAA,EAAAqwB,MAAAA,EAAAxwB,QAAAA,EAAAU,MAAAA,CAAA,CACb,CACA,SAAAq6B,EAAAl+B,CAAA,EACA,OAAA89B,EAAA99B,GAAAsD,MAAA,CAEA,SAAAP,EAAAo7B,CAAA,EACA,IAAYxK,MAAAA,CAAA,CAAA9vB,MAAAA,CAAA,EAAei6B,EAAAK,GAC3BC,EAAAzK,EAAAp3B,MAAA,CACA,WACA,IAAAgG,EAAA,GACA,QAAAhI,EAAA,EAAwBA,EAAA6jC,EAAiB7jC,IAEzC,GADAgI,GAAAoxB,CAAA,CAAAp5B,EAAA,CACAyF,KAAAxD,IAAAwD,CAAA,CAAAzF,EAAA,EACA,IAAAsC,EAAAgH,CAAA,CAAAtJ,EAAA,CACAsC,IAAA8gC,EACAp7B,GAA8B,GAAA87B,EAAAnN,CAAA,EAAQlxB,CAAA,CAAAzF,EAAA,EAEtCsC,IAAA+gC,EACAr7B,GAA8B1B,EAAAP,CAAK,CAAAyB,SAAA,CAAA/B,CAAA,CAAAzF,EAAA,EAGnCgI,GAAAvC,CAAA,CAAAzF,EAAA,CAIA,OAAAgI,CACA,CACA,CACA,IAAA+7B,EAAA,oBAAAt+B,EAAA,EAAAA,EAMAtE,EAAA,CACAE,KAhFA,SAAAoE,CAAA,EACA,IAAA0D,EAAA66B,EACA,OAAA72B,MAAA1H,IACA,iBAAAA,GACA,SAAA0D,CAAAA,EAAA1D,EAAAyc,KAAA,CAAwBsgB,EAAAv+B,CAAU,IAAAkF,KAAA,IAAAA,EAAA,OAAAA,EAAAnH,MAAA,MAClC,SAAAgiC,CAAAA,EAAAv+B,EAAAyc,KAAA,CAA4BihB,EAAU,GAAAa,KAAA,IAAAA,EAAA,OAAAA,EAAAhiC,MAAA,MACtC,CACA,EA0EAyE,MAAAk9B,EACAn7B,kBAAAA,EACAgyB,kBATA,SAAA/0B,CAAA,EACA,IAAAw+B,EAAAN,EAAAl+B,GAEA,OAAAy+B,EADAz+B,GACAw+B,EAAA97B,GAAA,CAAA47B,GACA,CAMA,yDCzFA,IAAAI,EAAA,qFCEA,IAAAL,EAAA,GAAA7jC,KAAAiH,KAAA,CAAAzB,IAAAA,GAAA,yEEAA,SAAA2+B,EAAAppB,CAAA,CAAA5S,CAAA,EACA,IAAAmqB,EAAAvX,EAAAmJ,QAAA,eAKA,GDLmB,GAAAsO,EAAAzyB,CAAA,ECKYuyB,IDLCxxB,EAAAoqB,GAAA,CCMhC,OAAAoH,EAAApH,GAAA,CAAA/iB,EAEA,qSaaA,SAASi8B,EAAuB51B,CAAA,CAAAnK,CAAA,EAChC,GAAAmK,QAGA,mBAAAA,GAA6C61B,IAC9BC,EAAoB91B,EAAAnK,GAEtBkgC,EAAkB/1B,GAC/Bg2B,EAAAh2B,GAEAxN,MAAAC,OAAA,CAAAuN,GACAA,EAAAtG,GAAA,IAA6Ck8B,EAAuBK,EAAApgC,IACpEqgC,EAAA50B,OAAA,EAGA40B,CAAA,CAAAl2B,EAAA,oHZrCA,IAAAm2B,EAA+B,GAAA9tB,EAAAjU,CAAA,EAAI,IAAAyf,KAAArgB,IAAAqgB,OAAAuiB,cAAA,CCAnC,OAAMC,EACN3iC,YAAAkjB,CAAA,EAEA,KAAAjS,IAAA,UAAA2xB,MAAA,SACA,KAAA1f,UAAA,CAAAA,EAAAvjB,MAAA,CAAAyE,QACA,CACA,IAAAy+B,UAAA,CAEA,OAAAhgC,QAAAohB,GAAA,MAAAf,UAAA,CAAAld,GAAA,iBAAA2P,EAAAA,EAAAktB,QAAA,CAAAltB,GACA,CAIAmtB,OAAAC,CAAA,EACA,YAAA7f,UAAA,IAAA6f,EAAA,CAEAC,OAAAD,CAAA,CAAAE,CAAA,EACA,QAAAplC,EAAA,EAAwBA,EAAA,KAAAqlB,UAAA,CAAArjB,MAAA,CAA4BhC,IACpD,KAAAqlB,UAAA,CAAArlB,EAAA,CAAAklC,EAAA,CAAAE,CAEA,CACAvsB,eAAAC,CAAA,CAAAkJ,CAAA,EACA,IAAAqc,EAAA,KAAAhZ,UAAA,CAAAld,GAAA,IACA,KAAsC2P,EAAAe,cAAA,CACtCf,EAAAe,cAAA,CAAAC,GAEA,mBAAAkJ,EACAA,EAAAlK,WAGA,WACAumB,EAAA7Z,OAAA,EAAAnQ,EAAArU,KACAqU,GAAAA,IACA,KAAAgR,UAAA,CAAArlB,EAAA,CAAAoT,IAAA,EACA,EACA,CACA,CACA,IAAA+C,MAAA,CACA,YAAA8uB,MAAA,QACA,CACA,IAAA9uB,KAAAA,CAAA,EACA,KAAAgvB,MAAA,QAAAhvB,EACA,CACA,IAAAV,OAAA,CACA,YAAAwvB,MAAA,SACA,CACA,IAAAxvB,MAAAA,CAAA,EACA,KAAA0vB,MAAA,SAAA1vB,EACA,CACA,IAAAtB,WAAA,CACA,YAAA8wB,MAAA,aACA,CACA,IAAA3gC,UAAA,CACA,IAAAwF,EAAA,EACA,QAAA9J,EAAA,EAAwBA,EAAA,KAAAqlB,UAAA,CAAArjB,MAAA,CAA4BhC,IACpD8J,EAAA7J,KAAA6J,GAAA,CAAAA,EAAA,KAAAub,UAAA,CAAArlB,EAAA,CAAAsE,QAAA,EAEA,OAAAwF,CACA,CACAi7B,OAAAM,CAAA,EACA,KAAAhgB,UAAA,CAAAb,OAAA,IAAA8gB,CAAA,CAAAD,EAAA,GACA,CACAvgC,SAAA,CACA,KAAAigC,MAAA,WACA,CACA1vB,MAAA,CACA,KAAA0vB,MAAA,QACA,CACAzvB,OAAA,CACA,KAAAyvB,MAAA,SACA,CACA1wB,QAAA,CACA,KAAA0wB,MAAA,UACA,CACApuB,UAAA,CACA,KAAAouB,MAAA,YACA,CACA,CCzEA,MAAAQ,UAAoCT,EACpCpgC,KAAA8gC,CAAA,CAAAC,CAAA,EACA,OAAAzgC,QAAAohB,GAAA,MAAAf,UAAA,EAAA3gB,IAAA,CAAA8gC,GAAAE,KAAA,CAAAD,EACA,CACA,CCVA,SAASE,EAAkB7rB,CAAA,CAAA1R,CAAA,EAC3B,OAAA0R,EACAA,CAAA,CAAA1R,EAAA,EACA0R,EAAA,SACAA,EACA7X,KAAAA,CACA,CCFA,IAAA2jC,EAAA,IACA,SAAAC,EAAA73B,CAAA,EACA,IAAA1J,EAAA,EAEAoH,EAAAsC,EAAAE,IAAA,CAAA5J,GACA,MAAAoH,EAAAC,IAAA,EAAArH,EAAAshC,GACAthC,GAHA,GAIAoH,EAAAsC,EAAAE,IAAA,CAAA5J,GAEA,OAAAA,GAAAshC,EAAA7b,IAAAzlB,CACA,CCdA,SAAAZ,EAAApB,CAAA,EACA,yBAAAA,CACA,CCFA,SAAAuW,EAAAf,CAAA,CAAAgB,CAAA,EACAhB,EAAAgB,QAAA,CAAAA,EACAhB,EAAAW,QAAA,KACA,CCHA,IAAA+rB,EAAA,GAAAvjC,MAAAC,OAAA,CAAAuN,IAAA,iBAAAA,CAAA,ICIAq3B,EAAA,CACAC,aAAA9jC,KAAAA,CACA,EEJAqiC,EAA2C0B,SDC3CjZ,CAAA,CAAAkZ,CAAA,EACA,IAAAC,EAAqB,GAAApvB,EAAAjU,CAAA,EAAIkqB,GACzB,WAAmB,IAAA5jB,EAAQ,cAAAA,CAAAA,EAAa28B,CAAa,CAAAG,EAAA,GAAA98B,KAAA,IAAAA,EAAAA,EAAA+8B,GAAA,CACrD,ECJuD,KACvD,IACAxW,SACAyW,aAAA,QACAhuB,OAAA,EAAuBiuB,QAAA,GAAY,CAAI33B,OAAA,gBACvC,CACA,MAAA5B,EAAA,CACA,QACA,CACA,QACA,EAAC,+BCVD,IAAA03B,EAAA,CAAA91B,EAAAnK,EACA+hC,EAAA,MAEA,IAAAC,EAAA,GACAC,EAAAtmC,KAAA6J,GAAA,CAAA7J,KAAAiH,KAAA,CAAA5C,EAAA+hC,GAAA,GACA,QAAArmC,EAAA,EAAoBA,EAAAumC,EAAevmC,IACnCsmC,GAAA73B,EAAyB,GAAAE,EAAA0D,CAAA,EAAQ,EAAAk0B,EAAA,EAAAvmC,IAAA,KAEjC,gBAAqBsmC,EAAAtF,SAAA,GAAAsF,EAAAtkC,MAAA,IAAuC,ICN5D,SAAAwkC,EAAA/3B,CAAA,EACA,MAAAlI,CAAAA,CAAA,oBAAAkI,GAAoD61B,KACpD,CAAA71B,GACA,iBAAAA,GACAA,CAAAA,KAAAk2B,GAA+CL,GAAoB,GAC3DE,EAAkB/1B,IAC1BxN,MAAAC,OAAA,CAAAuN,IAAAA,EAAAg4B,KAAA,CAAAD,EAAA,CACA,CACA,IAAA/B,EAAA,EAAAr/B,EAAAC,EAAAsV,EAAA5N,EAAA,mBAA8D3H,EAAE,IAAIC,EAAE,IAAIsV,EAAE,IAAI5N,EAAE,GAClF43B,EAAA,CACAx0B,OAAA,SACApL,KAAA,OACA+K,OAAA,UACAC,QAAA,WACAC,UAAA,cACAI,OAAAq0B,EAAA,eACAh0B,QAAAg0B,EAAA,eACApkC,OAAAokC,EAAA,oBACArkC,QAAAqkC,EAAA,mBACA,ECvBAiC,EAAA,CACA/mC,EAAA,GACAuc,EAAA,EACA,EEDA,SAAAyqB,EAAAC,CAAA,CAAApkC,CAAA,EACA,IAAAqkC,EAAqBC,SDHrBF,CAAA,CAAAG,CAAA,CAAAC,CAAA,EAEA,GAAAJ,aAAA3vB,QACA,OAAA2vB,EAAA,CAEA,oBAAAA,EAAA,CAUA,IAAAC,EAAA96B,SAAAk7B,gBAAA,CAAAL,GACA,OAAAC,EAAA5lC,MAAAsE,IAAA,CAAAshC,GAAA,GAEA,OAAA5lC,MAAAsE,IAAA,CAAAqhC,EACA,EChBoCA,GACpCM,EAAA,IAAAC,gBAOA,OAAAN,EANA,CACAlrB,QAAA,GACA,GAAAnZ,CAAA,CACA4kC,OAAAF,EAAAE,MAAA,EAEA,IAAAF,EAAAG,KAAA,GACA,CCJA,SAAAC,EAAAva,CAAA,EACA,WACA,UAAAhR,EAAAwrB,WAAA,EHJAb,EAAA/mC,CAAA,EAAA+mC,EAAAxqB,CAAA,EGMA6Q,EAAAhR,EACA,CACA,CAQA,SAAA4c,EAAAiO,CAAA,CAAAY,CAAA,CAAAhlC,EAAA,EAA4D,EAC5D,IAAAqkC,EAAAY,EAAApzB,EAAA,CAA6CsyB,EAAYC,EAAApkC,GACzDklC,EAAAJ,EAAA,IACA,IAAgBh/B,OAAAA,CAAA,EAASq/B,EACzBC,EAAAJ,EAAAG,GACA,sBAAAC,GAAA,CAAAt/B,EACA,OACA,IAAAu/B,EAAAP,EAAA,IACAM,EAAAE,GACAx/B,EAAAuT,mBAAA,gBAAAgsB,EACA,GACAv/B,EAAAsT,gBAAA,gBAAAisB,EAAAJ,EACA,GAIA,OAHAZ,EAAAriB,OAAA,KACA/P,EAAAmH,gBAAA,gBAAA8rB,EAAAD,EACA,GACApzB,CACA,CC/BA,IAAA0zB,EAAA,CAAAve,EAAAhC,IACA,EAAAA,IAGAgC,IAAAhC,GAIAugB,EAAAve,EAAAhC,EAAAwgB,aAAA,GCfAC,EAAA,GACA,UAAAlsB,EAAAwrB,WAAA,CACA,iBAAAxrB,EAAAmsB,MAAA,EAAAnsB,EAAAmsB,MAAA,IAWAnsB,CAAA,IAAAA,EAAAosB,SAAA,CCbAC,EAAA,IAAAzpC,IAAA,CACA,SACA,QACA,SACA,WACA,IACA,ECNA0pC,EAAA,IAAAC,QCKA,SAASC,EAAYxb,CAAA,EACrB,WACA,UAAAhR,EAAA3T,GAAA,EAEA2kB,EAAAhR,EACA,CACA,CACA,SAAAysB,EAAAlgC,CAAA,CAAAhG,CAAA,EACAgG,EAAAmgC,aAAA,KAAAC,aAAA,UAAApmC,EAAA,CAA8D6lC,UAAA,GAAAQ,QAAA,KAC9D,CACA,IAAAC,EAAA,CAAAC,EAAApB,KACA,IAAAhzB,EAAAo0B,EAAAC,aAAA,CACA,IAAAr0B,EACA,OACA,IAAAs0B,EAA0BR,EAAY,KACtC,GAAYF,EAAUv/B,GAAA,CAAA2L,GACtB,OACA+zB,EAAA/zB,EAAA,QACA,IAAAu0B,EAA4BT,EAAY,KACxCC,EAAA/zB,EAAA,KACA,GAEAA,EAAAmH,gBAAA,SAAAotB,EAAAvB,GACAhzB,EAAAmH,gBAAA,QAFA,IAAA4sB,EAAA/zB,EAAA,UAEAgzB,EACA,GACAhzB,EAAAmH,gBAAA,WAAAmtB,EAAAtB,GAIAhzB,EAAAmH,gBAAA,YAAAnH,EAAAoH,mBAAA,WAAAktB,GAAAtB,EACA,ECvBA,SAAAwB,EAAAltB,CAAA,EACA,OAAWksB,EAAgBlsB,IAAA,CTR3B2qB,CAAAA,EAAA/mC,CAAA,EAAA+mC,EAAAxqB,CAAA,CSSA,CAoBA,SAAAgtB,EAAAtC,CAAA,CAAAuC,CAAA,CAAA3mC,EAAA,EAA4D,EAC5D,IAAAqkC,EAAAY,EAAA2B,EAAA,CAAmDzC,EAAYC,EAAApkC,GAC/D6mC,EAAA,IACA,IAAA50B,EAAA4Y,EAAAyb,aAAA,CACA,IAAAG,EAAA5b,IAA8Cgb,EAAUv/B,GAAA,CAAA2L,GACxD,OACQ4zB,EAAUld,GAAA,CAAA1W,GAClB,IAAA60B,EAAAH,EAAA9b,GACAkc,EAAA,CAAAjc,EAAAW,KACA3L,OAAAzG,mBAAA,aAAA2tB,GACAlnB,OAAAzG,mBAAA,iBAAA4tB,GACAR,EAAA3b,IAAiD+a,EAAUv/B,GAAA,CAAA2L,KAG/C4zB,EAAUrd,MAAA,CAAAvW,GACtB,mBAAA60B,GACAA,EAAAhc,EAAA,CAAuCW,QAAAA,CAAA,GAEvC,EACAub,EAAA,IACAD,EAAAG,EAAAlnC,EAAA0rB,eAAA,EACgB6Z,EAAatzB,EAAAi1B,EAAAphC,MAAA,EAC7B,EACAmhC,EAAA,IACAF,EAAAI,EAAA,GACA,EACArnB,OAAA1G,gBAAA,aAAA4tB,EAAA/B,GACAnlB,OAAA1G,gBAAA,iBAAA6tB,EAAAhC,EACA,EAUA,OATAZ,EAAAriB,OAAA,KHvDA4jB,EAAAt/B,GAAA,CAAA2L,EAAAujB,OAAA,GACAvjB,KAAAA,EAAAm1B,QAAA,EGwDAn1B,OAAAA,EAAAijB,YAAA,cACAjjB,CAAAA,EAAAm1B,QAAA,IAGAthC,CADA9F,EAAA0rB,eAAA,CAAA5L,OAAA7N,CAAA,EACAmH,gBAAA,eAAAytB,EAAA5B,GACAhzB,EAAAmH,gBAAA,YAAqDgtB,EAAmB7sB,EAAA0rB,GAAAA,EACxE,GACA2B,CACA,CQvEA,SAAAS,EAAA5rB,CAAA,QACA,MAAAA,GAAAA,MAAAA,EACA,CAAsB,CAAAA,EAAA,CACtB,MAGYyoB,CAAU,CAAAzoB,EAAA,IACtB,KACgByoB,CAAU,CAAAzoB,EAAA,GAC1B,GAIA,EAAsBte,CAAA,EAAM+mC,EAAUxqB,CAAA,CACtC,MAGYwqB,EAAU/mC,CAAA,CAAK+mC,EAAUxqB,CAAA,IACrC,KACgBwqB,EAAU/mC,CAAA,CAAK+mC,EAAUxqB,CAAA,GACzC,EAGA,gHEvBA,IAAA4tB,EAAcC,EAAAvqC,CAAI,CAClBwqC,EAAgBD,EAAAvqC,CAAI,wDCFpB,SAAAsX,EAAAiW,CAAA,EACA,IAAA7f,EACA,WACAjL,KAAAA,IAAAiL,GACAA,CAAAA,EAAA6f,GAAA,EACA7f,EAEA,yDCKA,IAAAyB,EAAA,CAAApJ,EAAAC,EAAAzE,KACA,IAAAkpC,EAAAzkC,EAAAD,EACA,OAAA0kC,IAAAA,EAAA,GAAAlpC,EAAAwE,CAAA,EAAA0kC,CACA,gFCTA,IAAAC,EAAA,GAAAC,IAAAA,EAEAC,EAAA,GAAAC,EAAA","sources":["webpack://_N_E/./node_modules/framer-motion/dist/es/animation/animators/utils/accelerated-values.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/use-instant-transition-state.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/easing/cubic-bezier.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/easing/back.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/easing/anticipate.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/utils/is-animatable.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/animators/utils/can-animate.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/animators/waapi/utils/get-final-keyframe.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/animators/BaseAnimation.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/hsla-to-rgba.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/mix/immediate.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/mix/color.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/mix/visibility.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/mix/complex.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/mix/index.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/generators/utils/velocity.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/generators/spring/defaults.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/generators/spring/find.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/generators/spring/index.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/generators/inertia.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/easing/ease.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/easing/utils/is-easing-array.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/easing/utils/map.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/interpolate.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/offsets/fill.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/offsets/default.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/offsets/time.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/generators/keyframes.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/animators/drivers/driver-frameloop.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/animators/MainThreadAnimation.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/animators/waapi/index.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/animators/waapi/utils/supports-waapi.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/animators/AcceleratedAnimation.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/utils/default-transitions.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/utils/is-transition-defined.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/interfaces/motion-value.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/optimized-appear/get-appear-id.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/easing/circ.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/easing/modifiers/mirror.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/easing/modifiers/reverse.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/events/add-dom-event.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/events/event-info.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/frameloop/sync-time.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/motion/features/Feature.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/projection/geometry/conversion.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/projection/geometry/delta-apply.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/projection/geometry/models.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/projection/utils/has-transform.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/projection/utils/measure.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/utils/is-none.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/html/utils/make-none-animatable.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/dom/utils/css-variables-conversion.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/dom/DOMKeyframesResolver.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/shallow-compare.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/utils/resolve-dynamic-variants.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/utils/setters.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/interfaces/visual-element-target.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/interfaces/visual-element-variant.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/animation/interfaces/visual-element.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/utils/get-variant-context.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/utils/animation-state.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/motion/features/animation/index.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/motion/features/animation/exit.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/motion/features/animations.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/gestures/hover.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/gestures/focus.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/gestures/press.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/motion/features/viewport/observers.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/motion/features/viewport/index.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/motion/features/gestures.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/reduced-motion/state.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/reduced-motion/index.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/dom/value-types/find.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/store.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/utils/motion-values.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/VisualElement.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/dom/DOMVisualElement.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/html/HTMLVisualElement.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/svg/SVGVisualElement.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/dom/create-visual-element.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/dom/features-animation.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/dom/utils/unit-conversion.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/dom/value-types/animatable-none.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/dom/value-types/defaults.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/dom/value-types/type-auto.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/dom/value-types/dimensions.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/dom/value-types/test.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/html/utils/keys-position.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/render/utils/KeyframesResolver.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/array.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/is-numerical-string.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/is-zero-value-string.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/mix/number.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/pipe.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/subscription-manager.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/utils/velocity-per-second.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/value/index.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/value/types/color/hex.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/value/types/color/hsla.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/value/types/color/index.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/value/types/color/rgba.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/value/types/utils/is-nullish.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/value/types/utils/single-color-regex.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/value/types/color/utils.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/value/types/complex/filter.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/value/types/utils/color-regex.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/value/types/complex/index.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/value/types/utils/float-regex.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/value/types/utils/sanitize.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/value/use-will-change/is.mjs","webpack://_N_E/./node_modules/framer-motion/dist/es/value/use-will-change/add-will-change.mjs","webpack://_N_E/./node_modules/motion-dom/dist/es/utils/supports/scroll-timeline.mjs","webpack://_N_E/./node_modules/motion-dom/dist/es/animation/controls/BaseGroup.mjs","webpack://_N_E/./node_modules/motion-dom/dist/es/animation/controls/Group.mjs","webpack://_N_E/./node_modules/motion-dom/dist/es/animation/utils/get-value-transition.mjs","webpack://_N_E/./node_modules/motion-dom/dist/es/animation/generators/utils/calc-duration.mjs","webpack://_N_E/./node_modules/motion-dom/dist/es/animation/generators/utils/is-generator.mjs","webpack://_N_E/./node_modules/motion-dom/dist/es/animation/waapi/utils/attach-timeline.mjs","webpack://_N_E/./node_modules/motion-dom/dist/es/utils/is-bezier-definition.mjs","webpack://_N_E/./node_modules/motion-dom/dist/es/utils/supports/flags.mjs","webpack://_N_E/./node_modules/motion-dom/dist/es/utils/supports/memo.mjs","webpack://_N_E/./node_modules/motion-dom/dist/es/utils/supports/linear-easing.mjs","webpack://_N_E/./node_modules/motion-dom/dist/es/animation/waapi/utils/linear.mjs","webpack://_N_E/./node_modules/motion-dom/dist/es/animation/waapi/utils/easing.mjs","webpack://_N_E/./node_modules/motion-dom/dist/es/gestures/drag/state/is-active.mjs","webpack://_N_E/./node_modules/motion-dom/dist/es/utils/resolve-elements.mjs","webpack://_N_E/./node_modules/motion-dom/dist/es/gestures/utils/setup.mjs","webpack://_N_E/./node_modules/motion-dom/dist/es/gestures/hover.mjs","webpack://_N_E/./node_modules/motion-dom/dist/es/gestures/utils/is-node-or-child.mjs","webpack://_N_E/./node_modules/motion-dom/dist/es/gestures/utils/is-primary-pointer.mjs","webpack://_N_E/./node_modules/motion-dom/dist/es/gestures/press/utils/is-keyboard-accessible.mjs","webpack://_N_E/./node_modules/motion-dom/dist/es/gestures/press/utils/state.mjs","webpack://_N_E/./node_modules/motion-dom/dist/es/gestures/press/utils/keyboard.mjs","webpack://_N_E/./node_modules/motion-dom/dist/es/gestures/press/index.mjs","webpack://_N_E/./node_modules/motion-dom/dist/es/animation/waapi/NativeAnimationControls.mjs","webpack://_N_E/./node_modules/motion-dom/dist/es/animation/generators/utils/create-generator-easing.mjs","webpack://_N_E/./node_modules/motion-dom/dist/es/animation/waapi/utils/convert-options.mjs","webpack://_N_E/./node_modules/motion-dom/dist/es/animation/waapi/PseudoAnimation.mjs","webpack://_N_E/./node_modules/motion-dom/dist/es/view/utils/css.mjs","webpack://_N_E/./node_modules/motion-dom/dist/es/view/start.mjs","webpack://_N_E/./node_modules/motion-dom/dist/es/view/index.mjs","webpack://_N_E/./node_modules/motion-dom/dist/es/gestures/drag/state/set-active.mjs","webpack://_N_E/./node_modules/motion-dom/dist/es/index.mjs","webpack://_N_E/./node_modules/motion-utils/dist/es/errors.mjs","webpack://_N_E/./node_modules/motion-utils/dist/es/memo.mjs","webpack://_N_E/./node_modules/motion-utils/dist/es/progress.mjs","webpack://_N_E/./node_modules/motion-utils/dist/es/time-conversion.mjs"],"sourcesContent":["/**\n * A list of values that can be hardware-accelerated.\n */\nconst acceleratedValues = new Set([\n    \"opacity\",\n    \"clipPath\",\n    \"filter\",\n    \"transform\",\n    // TODO: Can be accelerated but currently disabled until https://issues.chromium.org/issues/41491098 is resolved\n    // or until we implement support for linear() easing.\n    // \"background-color\"\n]);\n\nexport { acceleratedValues };\n","const instantAnimationState = {\n    current: false,\n};\n\nexport { instantAnimationState };\n","import { noop } from 'motion-utils';\n\n/*\n  Bezier function generator\n  This has been modified from Gaëtan Renaudeau's BezierEasing\n  https://github.com/gre/bezier-easing/blob/master/src/index.js\n  https://github.com/gre/bezier-easing/blob/master/LICENSE\n  \n  I've removed the newtonRaphsonIterate algo because in benchmarking it\n  wasn't noticiably faster than binarySubdivision, indeed removing it\n  usually improved times, depending on the curve.\n  I also removed the lookup table, as for the added bundle size and loop we're\n  only cutting ~4 or so subdivision iterations. I bumped the max iterations up\n  to 12 to compensate and this still tended to be faster for no perceivable\n  loss in accuracy.\n  Usage\n    const easeOut = cubicBezier(.17,.67,.83,.67);\n    const x = easeOut(0.5); // returns 0.627...\n*/\n// Returns x(t) given t, x1, and x2, or y(t) given t, y1, and y2.\nconst calcBezier = (t, a1, a2) => (((1.0 - 3.0 * a2 + 3.0 * a1) * t + (3.0 * a2 - 6.0 * a1)) * t + 3.0 * a1) *\n    t;\nconst subdivisionPrecision = 0.0000001;\nconst subdivisionMaxIterations = 12;\nfunction binarySubdivide(x, lowerBound, upperBound, mX1, mX2) {\n    let currentX;\n    let currentT;\n    let i = 0;\n    do {\n        currentT = lowerBound + (upperBound - lowerBound) / 2.0;\n        currentX = calcBezier(currentT, mX1, mX2) - x;\n        if (currentX > 0.0) {\n            upperBound = currentT;\n        }\n        else {\n            lowerBound = currentT;\n        }\n    } while (Math.abs(currentX) > subdivisionPrecision &&\n        ++i < subdivisionMaxIterations);\n    return currentT;\n}\nfunction cubicBezier(mX1, mY1, mX2, mY2) {\n    // If this is a linear gradient, return linear easing\n    if (mX1 === mY1 && mX2 === mY2)\n        return noop;\n    const getTForX = (aX) => binarySubdivide(aX, 0, 1, mX1, mX2);\n    // If animation is at start/end, return t without easing\n    return (t) => t === 0 || t === 1 ? t : calcBezier(getTForX(t), mY1, mY2);\n}\n\nexport { cubicBezier };\n","import { cubicBezier } from './cubic-bezier.mjs';\nimport { mirrorEasing } from './modifiers/mirror.mjs';\nimport { reverseEasing } from './modifiers/reverse.mjs';\n\nconst backOut = /*@__PURE__*/ cubicBezier(0.33, 1.53, 0.69, 0.99);\nconst backIn = /*@__PURE__*/ reverseEasing(backOut);\nconst backInOut = /*@__PURE__*/ mirrorEasing(backIn);\n\nexport { backIn, backInOut, backOut };\n","import { backIn } from './back.mjs';\n\nconst anticipate = (p) => (p *= 2) < 1 ? 0.5 * backIn(p) : 0.5 * (2 - Math.pow(2, -10 * (p - 1)));\n\nexport { anticipate };\n","import { complex } from '../../value/types/complex/index.mjs';\n\n/**\n * Check if a value is animatable. Examples:\n *\n * ✅: 100, \"100px\", \"#fff\"\n * ❌: \"block\", \"url(2.jpg)\"\n * @param value\n *\n * @internal\n */\nconst isAnimatable = (value, name) => {\n    // If the list of keys tat might be non-animatable grows, replace with Set\n    if (name === \"zIndex\")\n        return false;\n    // If it's a number or a keyframes array, we can animate it. We might at some point\n    // need to do a deep isAnimatable check of keyframes, or let Popmotion handle this,\n    // but for now lets leave it like this for performance reasons\n    if (typeof value === \"number\" || Array.isArray(value))\n        return true;\n    if (typeof value === \"string\" && // It's animatable if we have a string\n        (complex.test(value) || value === \"0\") && // And it contains numbers and/or colors\n        !value.startsWith(\"url(\") // Unless it starts with \"url(\"\n    ) {\n        return true;\n    }\n    return false;\n};\n\nexport { isAnimatable };\n","import { isGenerator } from 'motion-dom';\nimport { warning } from 'motion-utils';\nimport { isAnimatable } from '../../utils/is-animatable.mjs';\n\nfunction hasKeyframesChanged(keyframes) {\n    const current = keyframes[0];\n    if (keyframes.length === 1)\n        return true;\n    for (let i = 0; i < keyframes.length; i++) {\n        if (keyframes[i] !== current)\n            return true;\n    }\n}\nfunction canAnimate(keyframes, name, type, velocity) {\n    /**\n     * Check if we're able to animate between the start and end keyframes,\n     * and throw a warning if we're attempting to animate between one that's\n     * animatable and another that isn't.\n     */\n    const originKeyframe = keyframes[0];\n    if (originKeyframe === null)\n        return false;\n    /**\n     * These aren't traditionally animatable but we do support them.\n     * In future we could look into making this more generic or replacing\n     * this function with mix() === mixImmediate\n     */\n    if (name === \"display\" || name === \"visibility\")\n        return true;\n    const targetKeyframe = keyframes[keyframes.length - 1];\n    const isOriginAnimatable = isAnimatable(originKeyframe, name);\n    const isTargetAnimatable = isAnimatable(targetKeyframe, name);\n    warning(isOriginAnimatable === isTargetAnimatable, `You are trying to animate ${name} from \"${originKeyframe}\" to \"${targetKeyframe}\". ${originKeyframe} is not an animatable value - to enable this animation set ${originKeyframe} to a value animatable to ${targetKeyframe} via the \\`style\\` property.`);\n    // Always skip if any of these are true\n    if (!isOriginAnimatable || !isTargetAnimatable) {\n        return false;\n    }\n    return (hasKeyframesChanged(keyframes) ||\n        ((type === \"spring\" || isGenerator(type)) && velocity));\n}\n\nexport { canAnimate };\n","const isNotNull = (value) => value !== null;\nfunction getFinalKeyframe(keyframes, { repeat, repeatType = \"loop\" }, finalKeyframe) {\n    const resolvedKeyframes = keyframes.filter(isNotNull);\n    const index = repeat && repeatType !== \"loop\" && repeat % 2 === 1\n        ? 0\n        : resolvedKeyframes.length - 1;\n    return !index || finalKeyframe === undefined\n        ? resolvedKeyframes[index]\n        : finalKeyframe;\n}\n\nexport { getFinalKeyframe };\n","import { time } from '../../frameloop/sync-time.mjs';\nimport { flushKeyframeResolvers } from '../../render/utils/KeyframesResolver.mjs';\nimport { instantAnimationState } from '../../utils/use-instant-transition-state.mjs';\nimport { canAnimate } from './utils/can-animate.mjs';\nimport { getFinalKeyframe } from './waapi/utils/get-final-keyframe.mjs';\n\n/**\n * Maximum time allowed between an animation being created and it being\n * resolved for us to use the latter as the start time.\n *\n * This is to ensure that while we prefer to \"start\" an animation as soon\n * as it's triggered, we also want to avoid a visual jump if there's a big delay\n * between these two moments.\n */\nconst MAX_RESOLVE_DELAY = 40;\nclass BaseAnimation {\n    constructor({ autoplay = true, delay = 0, type = \"keyframes\", repeat = 0, repeatDelay = 0, repeatType = \"loop\", ...options }) {\n        // Track whether the animation has been stopped. Stopped animations won't restart.\n        this.isStopped = false;\n        this.hasAttemptedResolve = false;\n        this.createdAt = time.now();\n        this.options = {\n            autoplay,\n            delay,\n            type,\n            repeat,\n            repeatDelay,\n            repeatType,\n            ...options,\n        };\n        this.updateFinishedPromise();\n    }\n    /**\n     * This method uses the createdAt and resolvedAt to calculate the\n     * animation startTime. *Ideally*, we would use the createdAt time as t=0\n     * as the following frame would then be the first frame of the animation in\n     * progress, which would feel snappier.\n     *\n     * However, if there's a delay (main thread work) between the creation of\n     * the animation and the first commited frame, we prefer to use resolvedAt\n     * to avoid a sudden jump into the animation.\n     */\n    calcStartTime() {\n        if (!this.resolvedAt)\n            return this.createdAt;\n        return this.resolvedAt - this.createdAt > MAX_RESOLVE_DELAY\n            ? this.resolvedAt\n            : this.createdAt;\n    }\n    /**\n     * A getter for resolved data. If keyframes are not yet resolved, accessing\n     * this.resolved will synchronously flush all pending keyframe resolvers.\n     * This is a deoptimisation, but at its worst still batches read/writes.\n     */\n    get resolved() {\n        if (!this._resolved && !this.hasAttemptedResolve) {\n            flushKeyframeResolvers();\n        }\n        return this._resolved;\n    }\n    /**\n     * A method to be called when the keyframes resolver completes. This method\n     * will check if its possible to run the animation and, if not, skip it.\n     * Otherwise, it will call initPlayback on the implementing class.\n     */\n    onKeyframesResolved(keyframes, finalKeyframe) {\n        this.resolvedAt = time.now();\n        this.hasAttemptedResolve = true;\n        const { name, type, velocity, delay, onComplete, onUpdate, isGenerator, } = this.options;\n        /**\n         * If we can't animate this value with the resolved keyframes\n         * then we should complete it immediately.\n         */\n        if (!isGenerator && !canAnimate(keyframes, name, type, velocity)) {\n            // Finish immediately\n            if (instantAnimationState.current || !delay) {\n                onUpdate &&\n                    onUpdate(getFinalKeyframe(keyframes, this.options, finalKeyframe));\n                onComplete && onComplete();\n                this.resolveFinishedPromise();\n                return;\n            }\n            // Finish after a delay\n            else {\n                this.options.duration = 0;\n            }\n        }\n        const resolvedAnimation = this.initPlayback(keyframes, finalKeyframe);\n        if (resolvedAnimation === false)\n            return;\n        this._resolved = {\n            keyframes,\n            finalKeyframe,\n            ...resolvedAnimation,\n        };\n        this.onPostResolved();\n    }\n    onPostResolved() { }\n    /**\n     * Allows the returned animation to be awaited or promise-chained. Currently\n     * resolves when the animation finishes at all but in a future update could/should\n     * reject if its cancels.\n     */\n    then(resolve, reject) {\n        return this.currentFinishedPromise.then(resolve, reject);\n    }\n    flatten() {\n        this.options.type = \"keyframes\";\n        this.options.ease = \"linear\";\n    }\n    updateFinishedPromise() {\n        this.currentFinishedPromise = new Promise((resolve) => {\n            this.resolveFinishedPromise = resolve;\n        });\n    }\n}\n\nexport { BaseAnimation };\n","// Adapted from https://gist.github.com/mjackson/5311256\nfunction hueToRgb(p, q, t) {\n    if (t < 0)\n        t += 1;\n    if (t > 1)\n        t -= 1;\n    if (t < 1 / 6)\n        return p + (q - p) * 6 * t;\n    if (t < 1 / 2)\n        return q;\n    if (t < 2 / 3)\n        return p + (q - p) * (2 / 3 - t) * 6;\n    return p;\n}\nfunction hslaToRgba({ hue, saturation, lightness, alpha }) {\n    hue /= 360;\n    saturation /= 100;\n    lightness /= 100;\n    let red = 0;\n    let green = 0;\n    let blue = 0;\n    if (!saturation) {\n        red = green = blue = lightness;\n    }\n    else {\n        const q = lightness < 0.5\n            ? lightness * (1 + saturation)\n            : lightness + saturation - lightness * saturation;\n        const p = 2 * lightness - q;\n        red = hueToRgb(p, q, hue + 1 / 3);\n        green = hueToRgb(p, q, hue);\n        blue = hueToRgb(p, q, hue - 1 / 3);\n    }\n    return {\n        red: Math.round(red * 255),\n        green: Math.round(green * 255),\n        blue: Math.round(blue * 255),\n        alpha,\n    };\n}\n\nexport { hslaToRgba };\n","function mixImmediate(a, b) {\n    return (p) => (p > 0 ? b : a);\n}\n\nexport { mixImmediate };\n","import { mixNumber } from './number.mjs';\nimport { warning } from 'motion-utils';\nimport { hslaToRgba } from '../hsla-to-rgba.mjs';\nimport { hex } from '../../value/types/color/hex.mjs';\nimport { rgba } from '../../value/types/color/rgba.mjs';\nimport { hsla } from '../../value/types/color/hsla.mjs';\nimport { mixImmediate } from './immediate.mjs';\n\n// Linear color space blending\n// Explained https://www.youtube.com/watch?v=LKnqECcg6Gw\n// Demonstrated http://codepen.io/osublake/pen/xGVVaN\nconst mixLinearColor = (from, to, v) => {\n    const fromExpo = from * from;\n    const expo = v * (to * to - fromExpo) + fromExpo;\n    return expo < 0 ? 0 : Math.sqrt(expo);\n};\nconst colorTypes = [hex, rgba, hsla];\nconst getColorType = (v) => colorTypes.find((type) => type.test(v));\nfunction asRGBA(color) {\n    const type = getColorType(color);\n    warning(Boolean(type), `'${color}' is not an animatable color. Use the equivalent color code instead.`);\n    if (!Boolean(type))\n        return false;\n    let model = type.parse(color);\n    if (type === hsla) {\n        // TODO Remove this cast - needed since Motion's stricter typing\n        model = hslaToRgba(model);\n    }\n    return model;\n}\nconst mixColor = (from, to) => {\n    const fromRGBA = asRGBA(from);\n    const toRGBA = asRGBA(to);\n    if (!fromRGBA || !toRGBA) {\n        return mixImmediate(from, to);\n    }\n    const blended = { ...fromRGBA };\n    return (v) => {\n        blended.red = mixLinearColor(fromRGBA.red, toRGBA.red, v);\n        blended.green = mixLinearColor(fromRGBA.green, toRGBA.green, v);\n        blended.blue = mixLinearColor(fromRGBA.blue, toRGBA.blue, v);\n        blended.alpha = mixNumber(fromRGBA.alpha, toRGBA.alpha, v);\n        return rgba.transform(blended);\n    };\n};\n\nexport { mixColor, mixLinearColor };\n","const invisibleValues = new Set([\"none\", \"hidden\"]);\n/**\n * Returns a function that, when provided a progress value between 0 and 1,\n * will return the \"none\" or \"hidden\" string only when the progress is that of\n * the origin or target.\n */\nfunction mixVisibility(origin, target) {\n    if (invisibleValues.has(origin)) {\n        return (p) => (p <= 0 ? origin : target);\n    }\n    else {\n        return (p) => (p >= 1 ? target : origin);\n    }\n}\n\nexport { invisibleValues, mixVisibility };\n","import { mixNumber as mixNumber$1 } from './number.mjs';\nimport { mixColor } from './color.mjs';\nimport { pipe } from '../pipe.mjs';\nimport { warning } from 'motion-utils';\nimport { color } from '../../value/types/color/index.mjs';\nimport { complex, analyseComplexValue } from '../../value/types/complex/index.mjs';\nimport { isCSSVariableToken } from '../../render/dom/utils/is-css-variable.mjs';\nimport { invisibleValues, mixVisibility } from './visibility.mjs';\nimport { mixImmediate } from './immediate.mjs';\n\nfunction mixNumber(a, b) {\n    return (p) => mixNumber$1(a, b, p);\n}\nfunction getMixer(a) {\n    if (typeof a === \"number\") {\n        return mixNumber;\n    }\n    else if (typeof a === \"string\") {\n        return isCSSVariableToken(a)\n            ? mixImmediate\n            : color.test(a)\n                ? mixColor\n                : mixComplex;\n    }\n    else if (Array.isArray(a)) {\n        return mixArray;\n    }\n    else if (typeof a === \"object\") {\n        return color.test(a) ? mixColor : mixObject;\n    }\n    return mixImmediate;\n}\nfunction mixArray(a, b) {\n    const output = [...a];\n    const numValues = output.length;\n    const blendValue = a.map((v, i) => getMixer(v)(v, b[i]));\n    return (p) => {\n        for (let i = 0; i < numValues; i++) {\n            output[i] = blendValue[i](p);\n        }\n        return output;\n    };\n}\nfunction mixObject(a, b) {\n    const output = { ...a, ...b };\n    const blendValue = {};\n    for (const key in output) {\n        if (a[key] !== undefined && b[key] !== undefined) {\n            blendValue[key] = getMixer(a[key])(a[key], b[key]);\n        }\n    }\n    return (v) => {\n        for (const key in blendValue) {\n            output[key] = blendValue[key](v);\n        }\n        return output;\n    };\n}\nfunction matchOrder(origin, target) {\n    var _a;\n    const orderedOrigin = [];\n    const pointers = { color: 0, var: 0, number: 0 };\n    for (let i = 0; i < target.values.length; i++) {\n        const type = target.types[i];\n        const originIndex = origin.indexes[type][pointers[type]];\n        const originValue = (_a = origin.values[originIndex]) !== null && _a !== void 0 ? _a : 0;\n        orderedOrigin[i] = originValue;\n        pointers[type]++;\n    }\n    return orderedOrigin;\n}\nconst mixComplex = (origin, target) => {\n    const template = complex.createTransformer(target);\n    const originStats = analyseComplexValue(origin);\n    const targetStats = analyseComplexValue(target);\n    const canInterpolate = originStats.indexes.var.length === targetStats.indexes.var.length &&\n        originStats.indexes.color.length === targetStats.indexes.color.length &&\n        originStats.indexes.number.length >= targetStats.indexes.number.length;\n    if (canInterpolate) {\n        if ((invisibleValues.has(origin) &&\n            !targetStats.values.length) ||\n            (invisibleValues.has(target) &&\n                !originStats.values.length)) {\n            return mixVisibility(origin, target);\n        }\n        return pipe(mixArray(matchOrder(originStats, targetStats), targetStats.values), template);\n    }\n    else {\n        warning(true, `Complex values '${origin}' and '${target}' too different to mix. Ensure all colors are of the same type, and that each contains the same quantity of number and color values. Falling back to instant transition.`);\n        return mixImmediate(origin, target);\n    }\n};\n\nexport { getMixer, mixArray, mixComplex, mixObject };\n","import { getMixer } from './complex.mjs';\nimport { mixNumber } from './number.mjs';\n\nfunction mix(from, to, p) {\n    if (typeof from === \"number\" &&\n        typeof to === \"number\" &&\n        typeof p === \"number\") {\n        return mixNumber(from, to, p);\n    }\n    const mixer = getMixer(from);\n    return mixer(from, to);\n}\n\nexport { mix };\n","import { velocityPerSecond } from '../../../utils/velocity-per-second.mjs';\n\nconst velocitySampleDuration = 5; // ms\nfunction calcGeneratorVelocity(resolveValue, t, current) {\n    const prevT = Math.max(t - velocitySampleDuration, 0);\n    return velocityPerSecond(current - resolveValue(prevT), t - prevT);\n}\n\nexport { calcGeneratorVelocity };\n","const springDefaults = {\n    // Default spring physics\n    stiffness: 100,\n    damping: 10,\n    mass: 1.0,\n    velocity: 0.0,\n    // Default duration/bounce-based options\n    duration: 800, // in ms\n    bounce: 0.3,\n    visualDuration: 0.3, // in seconds\n    // Rest thresholds\n    restSpeed: {\n        granular: 0.01,\n        default: 2,\n    },\n    restDelta: {\n        granular: 0.005,\n        default: 0.5,\n    },\n    // Limits\n    minDuration: 0.01, // in seconds\n    maxDuration: 10.0, // in seconds\n    minDamping: 0.05,\n    maxDamping: 1,\n};\n\nexport { springDefaults };\n","import { warning, secondsToMilliseconds, millisecondsToSeconds } from 'motion-utils';\nimport { clamp } from '../../../utils/clamp.mjs';\nimport { springDefaults } from './defaults.mjs';\n\nconst safeMin = 0.001;\nfunction findSpring({ duration = springDefaults.duration, bounce = springDefaults.bounce, velocity = springDefaults.velocity, mass = springDefaults.mass, }) {\n    let envelope;\n    let derivative;\n    warning(duration <= secondsToMilliseconds(springDefaults.maxDuration), \"Spring duration must be 10 seconds or less\");\n    let dampingRatio = 1 - bounce;\n    /**\n     * Restrict dampingRatio and duration to within acceptable ranges.\n     */\n    dampingRatio = clamp(springDefaults.minDamping, springDefaults.maxDamping, dampingRatio);\n    duration = clamp(springDefaults.minDuration, springDefaults.maxDuration, millisecondsToSeconds(duration));\n    if (dampingRatio < 1) {\n        /**\n         * Underdamped spring\n         */\n        envelope = (undampedFreq) => {\n            const exponentialDecay = undampedFreq * dampingRatio;\n            const delta = exponentialDecay * duration;\n            const a = exponentialDecay - velocity;\n            const b = calcAngularFreq(undampedFreq, dampingRatio);\n            const c = Math.exp(-delta);\n            return safeMin - (a / b) * c;\n        };\n        derivative = (undampedFreq) => {\n            const exponentialDecay = undampedFreq * dampingRatio;\n            const delta = exponentialDecay * duration;\n            const d = delta * velocity + velocity;\n            const e = Math.pow(dampingRatio, 2) * Math.pow(undampedFreq, 2) * duration;\n            const f = Math.exp(-delta);\n            const g = calcAngularFreq(Math.pow(undampedFreq, 2), dampingRatio);\n            const factor = -envelope(undampedFreq) + safeMin > 0 ? -1 : 1;\n            return (factor * ((d - e) * f)) / g;\n        };\n    }\n    else {\n        /**\n         * Critically-damped spring\n         */\n        envelope = (undampedFreq) => {\n            const a = Math.exp(-undampedFreq * duration);\n            const b = (undampedFreq - velocity) * duration + 1;\n            return -safeMin + a * b;\n        };\n        derivative = (undampedFreq) => {\n            const a = Math.exp(-undampedFreq * duration);\n            const b = (velocity - undampedFreq) * (duration * duration);\n            return a * b;\n        };\n    }\n    const initialGuess = 5 / duration;\n    const undampedFreq = approximateRoot(envelope, derivative, initialGuess);\n    duration = secondsToMilliseconds(duration);\n    if (isNaN(undampedFreq)) {\n        return {\n            stiffness: springDefaults.stiffness,\n            damping: springDefaults.damping,\n            duration,\n        };\n    }\n    else {\n        const stiffness = Math.pow(undampedFreq, 2) * mass;\n        return {\n            stiffness,\n            damping: dampingRatio * 2 * Math.sqrt(mass * stiffness),\n            duration,\n        };\n    }\n}\nconst rootIterations = 12;\nfunction approximateRoot(envelope, derivative, initialGuess) {\n    let result = initialGuess;\n    for (let i = 1; i < rootIterations; i++) {\n        result = result - envelope(result) / derivative(result);\n    }\n    return result;\n}\nfunction calcAngularFreq(undampedFreq, dampingRatio) {\n    return undampedFreq * Math.sqrt(1 - dampingRatio * dampingRatio);\n}\n\nexport { calcAngularFreq, findSpring };\n","import { calcGeneratorDuration, maxGeneratorDuration, generateLinearEasing } from 'motion-dom';\nimport { millisecondsToSeconds, secondsToMilliseconds } from 'motion-utils';\nimport { clamp } from '../../../utils/clamp.mjs';\nimport { calcGeneratorVelocity } from '../utils/velocity.mjs';\nimport { springDefaults } from './defaults.mjs';\nimport { findSpring, calcAngularFreq } from './find.mjs';\n\nconst durationKeys = [\"duration\", \"bounce\"];\nconst physicsKeys = [\"stiffness\", \"damping\", \"mass\"];\nfunction isSpringType(options, keys) {\n    return keys.some((key) => options[key] !== undefined);\n}\nfunction getSpringOptions(options) {\n    let springOptions = {\n        velocity: springDefaults.velocity,\n        stiffness: springDefaults.stiffness,\n        damping: springDefaults.damping,\n        mass: springDefaults.mass,\n        isResolvedFromDuration: false,\n        ...options,\n    };\n    // stiffness/damping/mass overrides duration/bounce\n    if (!isSpringType(options, physicsKeys) &&\n        isSpringType(options, durationKeys)) {\n        if (options.visualDuration) {\n            const visualDuration = options.visualDuration;\n            const root = (2 * Math.PI) / (visualDuration * 1.2);\n            const stiffness = root * root;\n            const damping = 2 *\n                clamp(0.05, 1, 1 - (options.bounce || 0)) *\n                Math.sqrt(stiffness);\n            springOptions = {\n                ...springOptions,\n                mass: springDefaults.mass,\n                stiffness,\n                damping,\n            };\n        }\n        else {\n            const derived = findSpring(options);\n            springOptions = {\n                ...springOptions,\n                ...derived,\n                mass: springDefaults.mass,\n            };\n            springOptions.isResolvedFromDuration = true;\n        }\n    }\n    return springOptions;\n}\nfunction spring(optionsOrVisualDuration = springDefaults.visualDuration, bounce = springDefaults.bounce) {\n    const options = typeof optionsOrVisualDuration !== \"object\"\n        ? {\n            visualDuration: optionsOrVisualDuration,\n            keyframes: [0, 1],\n            bounce,\n        }\n        : optionsOrVisualDuration;\n    let { restSpeed, restDelta } = options;\n    const origin = options.keyframes[0];\n    const target = options.keyframes[options.keyframes.length - 1];\n    /**\n     * This is the Iterator-spec return value. We ensure it's mutable rather than using a generator\n     * to reduce GC during animation.\n     */\n    const state = { done: false, value: origin };\n    const { stiffness, damping, mass, duration, velocity, isResolvedFromDuration, } = getSpringOptions({\n        ...options,\n        velocity: -millisecondsToSeconds(options.velocity || 0),\n    });\n    const initialVelocity = velocity || 0.0;\n    const dampingRatio = damping / (2 * Math.sqrt(stiffness * mass));\n    const initialDelta = target - origin;\n    const undampedAngularFreq = millisecondsToSeconds(Math.sqrt(stiffness / mass));\n    /**\n     * If we're working on a granular scale, use smaller defaults for determining\n     * when the spring is finished.\n     *\n     * These defaults have been selected emprically based on what strikes a good\n     * ratio between feeling good and finishing as soon as changes are imperceptible.\n     */\n    const isGranularScale = Math.abs(initialDelta) < 5;\n    restSpeed || (restSpeed = isGranularScale\n        ? springDefaults.restSpeed.granular\n        : springDefaults.restSpeed.default);\n    restDelta || (restDelta = isGranularScale\n        ? springDefaults.restDelta.granular\n        : springDefaults.restDelta.default);\n    let resolveSpring;\n    if (dampingRatio < 1) {\n        const angularFreq = calcAngularFreq(undampedAngularFreq, dampingRatio);\n        // Underdamped spring\n        resolveSpring = (t) => {\n            const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n            return (target -\n                envelope *\n                    (((initialVelocity +\n                        dampingRatio * undampedAngularFreq * initialDelta) /\n                        angularFreq) *\n                        Math.sin(angularFreq * t) +\n                        initialDelta * Math.cos(angularFreq * t)));\n        };\n    }\n    else if (dampingRatio === 1) {\n        // Critically damped spring\n        resolveSpring = (t) => target -\n            Math.exp(-undampedAngularFreq * t) *\n                (initialDelta +\n                    (initialVelocity + undampedAngularFreq * initialDelta) * t);\n    }\n    else {\n        // Overdamped spring\n        const dampedAngularFreq = undampedAngularFreq * Math.sqrt(dampingRatio * dampingRatio - 1);\n        resolveSpring = (t) => {\n            const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n            // When performing sinh or cosh values can hit Infinity so we cap them here\n            const freqForT = Math.min(dampedAngularFreq * t, 300);\n            return (target -\n                (envelope *\n                    ((initialVelocity +\n                        dampingRatio * undampedAngularFreq * initialDelta) *\n                        Math.sinh(freqForT) +\n                        dampedAngularFreq *\n                            initialDelta *\n                            Math.cosh(freqForT))) /\n                    dampedAngularFreq);\n        };\n    }\n    const generator = {\n        calculatedDuration: isResolvedFromDuration ? duration || null : null,\n        next: (t) => {\n            const current = resolveSpring(t);\n            if (!isResolvedFromDuration) {\n                let currentVelocity = 0.0;\n                /**\n                 * We only need to calculate velocity for under-damped springs\n                 * as over- and critically-damped springs can't overshoot, so\n                 * checking only for displacement is enough.\n                 */\n                if (dampingRatio < 1) {\n                    currentVelocity =\n                        t === 0\n                            ? secondsToMilliseconds(initialVelocity)\n                            : calcGeneratorVelocity(resolveSpring, t, current);\n                }\n                const isBelowVelocityThreshold = Math.abs(currentVelocity) <= restSpeed;\n                const isBelowDisplacementThreshold = Math.abs(target - current) <= restDelta;\n                state.done =\n                    isBelowVelocityThreshold && isBelowDisplacementThreshold;\n            }\n            else {\n                state.done = t >= duration;\n            }\n            state.value = state.done ? target : current;\n            return state;\n        },\n        toString: () => {\n            const calculatedDuration = Math.min(calcGeneratorDuration(generator), maxGeneratorDuration);\n            const easing = generateLinearEasing((progress) => generator.next(calculatedDuration * progress).value, calculatedDuration, 30);\n            return calculatedDuration + \"ms \" + easing;\n        },\n    };\n    return generator;\n}\n\nexport { spring };\n","import { spring } from './spring/index.mjs';\nimport { calcGeneratorVelocity } from './utils/velocity.mjs';\n\nfunction inertia({ keyframes, velocity = 0.0, power = 0.8, timeConstant = 325, bounceDamping = 10, bounceStiffness = 500, modifyTarget, min, max, restDelta = 0.5, restSpeed, }) {\n    const origin = keyframes[0];\n    const state = {\n        done: false,\n        value: origin,\n    };\n    const isOutOfBounds = (v) => (min !== undefined && v < min) || (max !== undefined && v > max);\n    const nearestBoundary = (v) => {\n        if (min === undefined)\n            return max;\n        if (max === undefined)\n            return min;\n        return Math.abs(min - v) < Math.abs(max - v) ? min : max;\n    };\n    let amplitude = power * velocity;\n    const ideal = origin + amplitude;\n    const target = modifyTarget === undefined ? ideal : modifyTarget(ideal);\n    /**\n     * If the target has changed we need to re-calculate the amplitude, otherwise\n     * the animation will start from the wrong position.\n     */\n    if (target !== ideal)\n        amplitude = target - origin;\n    const calcDelta = (t) => -amplitude * Math.exp(-t / timeConstant);\n    const calcLatest = (t) => target + calcDelta(t);\n    const applyFriction = (t) => {\n        const delta = calcDelta(t);\n        const latest = calcLatest(t);\n        state.done = Math.abs(delta) <= restDelta;\n        state.value = state.done ? target : latest;\n    };\n    /**\n     * Ideally this would resolve for t in a stateless way, we could\n     * do that by always precalculating the animation but as we know\n     * this will be done anyway we can assume that spring will\n     * be discovered during that.\n     */\n    let timeReachedBoundary;\n    let spring$1;\n    const checkCatchBoundary = (t) => {\n        if (!isOutOfBounds(state.value))\n            return;\n        timeReachedBoundary = t;\n        spring$1 = spring({\n            keyframes: [state.value, nearestBoundary(state.value)],\n            velocity: calcGeneratorVelocity(calcLatest, t, state.value), // TODO: This should be passing * 1000\n            damping: bounceDamping,\n            stiffness: bounceStiffness,\n            restDelta,\n            restSpeed,\n        });\n    };\n    checkCatchBoundary(0);\n    return {\n        calculatedDuration: null,\n        next: (t) => {\n            /**\n             * We need to resolve the friction to figure out if we need a\n             * spring but we don't want to do this twice per frame. So here\n             * we flag if we updated for this frame and later if we did\n             * we can skip doing it again.\n             */\n            let hasUpdatedFrame = false;\n            if (!spring$1 && timeReachedBoundary === undefined) {\n                hasUpdatedFrame = true;\n                applyFriction(t);\n                checkCatchBoundary(t);\n            }\n            /**\n             * If we have a spring and the provided t is beyond the moment the friction\n             * animation crossed the min/max boundary, use the spring.\n             */\n            if (timeReachedBoundary !== undefined && t >= timeReachedBoundary) {\n                return spring$1.next(t - timeReachedBoundary);\n            }\n            else {\n                !hasUpdatedFrame && applyFriction(t);\n                return state;\n            }\n        },\n    };\n}\n\nexport { inertia };\n","import { cubicBezier } from './cubic-bezier.mjs';\n\nconst easeIn = /*@__PURE__*/ cubicBezier(0.42, 0, 1, 1);\nconst easeOut = /*@__PURE__*/ cubicBezier(0, 0, 0.58, 1);\nconst easeInOut = /*@__PURE__*/ cubicBezier(0.42, 0, 0.58, 1);\n\nexport { easeIn, easeInOut, easeOut };\n","const isEasingArray = (ease) => {\n    return Array.isArray(ease) && typeof ease[0] !== \"number\";\n};\n\nexport { isEasingArray };\n","import { isBezierDefinition } from 'motion-dom';\nimport { invariant, noop } from 'motion-utils';\nimport { anticipate } from '../anticipate.mjs';\nimport { backIn, backInOut, backOut } from '../back.mjs';\nimport { circIn, circInOut, circOut } from '../circ.mjs';\nimport { cubicBezier } from '../cubic-bezier.mjs';\nimport { easeIn, easeInOut, easeOut } from '../ease.mjs';\n\nconst easingLookup = {\n    linear: noop,\n    easeIn,\n    easeInOut,\n    easeOut,\n    circIn,\n    circInOut,\n    circOut,\n    backIn,\n    backInOut,\n    backOut,\n    anticipate,\n};\nconst easingDefinitionToFunction = (definition) => {\n    if (isBezierDefinition(definition)) {\n        // If cubic bezier definition, create bezier curve\n        invariant(definition.length === 4, `Cubic bezier arrays must contain four numerical values.`);\n        const [x1, y1, x2, y2] = definition;\n        return cubicBezier(x1, y1, x2, y2);\n    }\n    else if (typeof definition === \"string\") {\n        // Else lookup from table\n        invariant(easingLookup[definition] !== undefined, `Invalid easing type '${definition}'`);\n        return easingLookup[definition];\n    }\n    return definition;\n};\n\nexport { easingDefinitionToFunction };\n","import { invariant, noop, progress } from 'motion-utils';\nimport { clamp } from './clamp.mjs';\nimport { mix } from './mix/index.mjs';\nimport { pipe } from './pipe.mjs';\n\nfunction createMixers(output, ease, customMixer) {\n    const mixers = [];\n    const mixerFactory = customMixer || mix;\n    const numMixers = output.length - 1;\n    for (let i = 0; i < numMixers; i++) {\n        let mixer = mixerFactory(output[i], output[i + 1]);\n        if (ease) {\n            const easingFunction = Array.isArray(ease) ? ease[i] || noop : ease;\n            mixer = pipe(easingFunction, mixer);\n        }\n        mixers.push(mixer);\n    }\n    return mixers;\n}\n/**\n * Create a function that maps from a numerical input array to a generic output array.\n *\n * Accepts:\n *   - Numbers\n *   - Colors (hex, hsl, hsla, rgb, rgba)\n *   - Complex (combinations of one or more numbers or strings)\n *\n * ```jsx\n * const mixColor = interpolate([0, 1], ['#fff', '#000'])\n *\n * mixColor(0.5) // 'rgba(128, 128, 128, 1)'\n * ```\n *\n * TODO Revist this approach once we've moved to data models for values,\n * probably not needed to pregenerate mixer functions.\n *\n * @public\n */\nfunction interpolate(input, output, { clamp: isClamp = true, ease, mixer } = {}) {\n    const inputLength = input.length;\n    invariant(inputLength === output.length, \"Both input and output ranges must be the same length\");\n    /**\n     * If we're only provided a single input, we can just make a function\n     * that returns the output.\n     */\n    if (inputLength === 1)\n        return () => output[0];\n    if (inputLength === 2 && output[0] === output[1])\n        return () => output[1];\n    const isZeroDeltaRange = input[0] === input[1];\n    // If input runs highest -> lowest, reverse both arrays\n    if (input[0] > input[inputLength - 1]) {\n        input = [...input].reverse();\n        output = [...output].reverse();\n    }\n    const mixers = createMixers(output, ease, mixer);\n    const numMixers = mixers.length;\n    const interpolator = (v) => {\n        if (isZeroDeltaRange && v < input[0])\n            return output[0];\n        let i = 0;\n        if (numMixers > 1) {\n            for (; i < input.length - 2; i++) {\n                if (v < input[i + 1])\n                    break;\n            }\n        }\n        const progressInRange = progress(input[i], input[i + 1], v);\n        return mixers[i](progressInRange);\n    };\n    return isClamp\n        ? (v) => interpolator(clamp(input[0], input[inputLength - 1], v))\n        : interpolator;\n}\n\nexport { interpolate };\n","import { progress } from 'motion-utils';\nimport { mixNumber } from '../mix/number.mjs';\n\nfunction fillOffset(offset, remaining) {\n    const min = offset[offset.length - 1];\n    for (let i = 1; i <= remaining; i++) {\n        const offsetProgress = progress(0, remaining, i);\n        offset.push(mixNumber(min, 1, offsetProgress));\n    }\n}\n\nexport { fillOffset };\n","import { fillOffset } from './fill.mjs';\n\nfunction defaultOffset(arr) {\n    const offset = [0];\n    fillOffset(offset, arr.length - 1);\n    return offset;\n}\n\nexport { defaultOffset };\n","function convertOffsetToTimes(offset, duration) {\n    return offset.map((o) => o * duration);\n}\n\nexport { convertOffsetToTimes };\n","import { easeInOut } from '../../easing/ease.mjs';\nimport { isEasingArray } from '../../easing/utils/is-easing-array.mjs';\nimport { easingDefinitionToFunction } from '../../easing/utils/map.mjs';\nimport { interpolate } from '../../utils/interpolate.mjs';\nimport { defaultOffset } from '../../utils/offsets/default.mjs';\nimport { convertOffsetToTimes } from '../../utils/offsets/time.mjs';\n\nfunction defaultEasing(values, easing) {\n    return values.map(() => easing || easeInOut).splice(0, values.length - 1);\n}\nfunction keyframes({ duration = 300, keyframes: keyframeValues, times, ease = \"easeInOut\", }) {\n    /**\n     * Easing functions can be externally defined as strings. Here we convert them\n     * into actual functions.\n     */\n    const easingFunctions = isEasingArray(ease)\n        ? ease.map(easingDefinitionToFunction)\n        : easingDefinitionToFunction(ease);\n    /**\n     * This is the Iterator-spec return value. We ensure it's mutable rather than using a generator\n     * to reduce GC during animation.\n     */\n    const state = {\n        done: false,\n        value: keyframeValues[0],\n    };\n    /**\n     * Create a times array based on the provided 0-1 offsets\n     */\n    const absoluteTimes = convertOffsetToTimes(\n    // Only use the provided offsets if they're the correct length\n    // TODO Maybe we should warn here if there's a length mismatch\n    times && times.length === keyframeValues.length\n        ? times\n        : defaultOffset(keyframeValues), duration);\n    const mapTimeToKeyframe = interpolate(absoluteTimes, keyframeValues, {\n        ease: Array.isArray(easingFunctions)\n            ? easingFunctions\n            : defaultEasing(keyframeValues, easingFunctions),\n    });\n    return {\n        calculatedDuration: duration,\n        next: (t) => {\n            state.value = mapTimeToKeyframe(t);\n            state.done = t >= duration;\n            return state;\n        },\n    };\n}\n\nexport { defaultEasing, keyframes };\n","import { time } from '../../../frameloop/sync-time.mjs';\nimport { frame, cancelFrame, frameData } from '../../../frameloop/frame.mjs';\n\nconst frameloopDriver = (update) => {\n    const passTimestamp = ({ timestamp }) => update(timestamp);\n    return {\n        start: () => frame.update(passTimestamp, true),\n        stop: () => cancelFrame(passTimestamp),\n        /**\n         * If we're processing this frame we can use the\n         * framelocked timestamp to keep things in sync.\n         */\n        now: () => (frameData.isProcessing ? frameData.timestamp : time.now()),\n    };\n};\n\nexport { frameloopDriver };\n","import { isGenerator, calcGeneratorDuration } from 'motion-dom';\nimport { invariant, millisecondsToSeconds, secondsToMilliseconds } from 'motion-utils';\nimport { KeyframeResolver } from '../../render/utils/KeyframesResolver.mjs';\nimport { clamp } from '../../utils/clamp.mjs';\nimport { mix } from '../../utils/mix/index.mjs';\nimport { pipe } from '../../utils/pipe.mjs';\nimport { inertia } from '../generators/inertia.mjs';\nimport { keyframes } from '../generators/keyframes.mjs';\nimport { spring } from '../generators/spring/index.mjs';\nimport { BaseAnimation } from './BaseAnimation.mjs';\nimport { frameloopDriver } from './drivers/driver-frameloop.mjs';\nimport { getFinalKeyframe } from './waapi/utils/get-final-keyframe.mjs';\n\nconst generators = {\n    decay: inertia,\n    inertia,\n    tween: keyframes,\n    keyframes: keyframes,\n    spring,\n};\nconst percentToProgress = (percent) => percent / 100;\n/**\n * Animation that runs on the main thread. Designed to be WAAPI-spec in the subset of\n * features we expose publically. Mostly the compatibility is to ensure visual identity\n * between both WAAPI and main thread animations.\n */\nclass MainThreadAnimation extends BaseAnimation {\n    constructor(options) {\n        super(options);\n        /**\n         * The time at which the animation was paused.\n         */\n        this.holdTime = null;\n        /**\n         * The time at which the animation was cancelled.\n         */\n        this.cancelTime = null;\n        /**\n         * The current time of the animation.\n         */\n        this.currentTime = 0;\n        /**\n         * Playback speed as a factor. 0 would be stopped, -1 reverse and 2 double speed.\n         */\n        this.playbackSpeed = 1;\n        /**\n         * The state of the animation to apply when the animation is resolved. This\n         * allows calls to the public API to control the animation before it is resolved,\n         * without us having to resolve it first.\n         */\n        this.pendingPlayState = \"running\";\n        /**\n         * The time at which the animation was started.\n         */\n        this.startTime = null;\n        this.state = \"idle\";\n        /**\n         * This method is bound to the instance to fix a pattern where\n         * animation.stop is returned as a reference from a useEffect.\n         */\n        this.stop = () => {\n            this.resolver.cancel();\n            this.isStopped = true;\n            if (this.state === \"idle\")\n                return;\n            this.teardown();\n            const { onStop } = this.options;\n            onStop && onStop();\n        };\n        const { name, motionValue, element, keyframes } = this.options;\n        const KeyframeResolver$1 = (element === null || element === void 0 ? void 0 : element.KeyframeResolver) || KeyframeResolver;\n        const onResolved = (resolvedKeyframes, finalKeyframe) => this.onKeyframesResolved(resolvedKeyframes, finalKeyframe);\n        this.resolver = new KeyframeResolver$1(keyframes, onResolved, name, motionValue, element);\n        this.resolver.scheduleResolve();\n    }\n    flatten() {\n        super.flatten();\n        // If we've already resolved the animation, re-initialise it\n        if (this._resolved) {\n            Object.assign(this._resolved, this.initPlayback(this._resolved.keyframes));\n        }\n    }\n    initPlayback(keyframes$1) {\n        const { type = \"keyframes\", repeat = 0, repeatDelay = 0, repeatType, velocity = 0, } = this.options;\n        const generatorFactory = isGenerator(type)\n            ? type\n            : generators[type] || keyframes;\n        /**\n         * If our generator doesn't support mixing numbers, we need to replace keyframes with\n         * [0, 100] and then make a function that maps that to the actual keyframes.\n         *\n         * 100 is chosen instead of 1 as it works nicer with spring animations.\n         */\n        let mapPercentToKeyframes;\n        let mirroredGenerator;\n        if (generatorFactory !== keyframes &&\n            typeof keyframes$1[0] !== \"number\") {\n            if (process.env.NODE_ENV !== \"production\") {\n                invariant(keyframes$1.length === 2, `Only two keyframes currently supported with spring and inertia animations. Trying to animate ${keyframes$1}`);\n            }\n            mapPercentToKeyframes = pipe(percentToProgress, mix(keyframes$1[0], keyframes$1[1]));\n            keyframes$1 = [0, 100];\n        }\n        const generator = generatorFactory({ ...this.options, keyframes: keyframes$1 });\n        /**\n         * If we have a mirror repeat type we need to create a second generator that outputs the\n         * mirrored (not reversed) animation and later ping pong between the two generators.\n         */\n        if (repeatType === \"mirror\") {\n            mirroredGenerator = generatorFactory({\n                ...this.options,\n                keyframes: [...keyframes$1].reverse(),\n                velocity: -velocity,\n            });\n        }\n        /**\n         * If duration is undefined and we have repeat options,\n         * we need to calculate a duration from the generator.\n         *\n         * We set it to the generator itself to cache the duration.\n         * Any timeline resolver will need to have already precalculated\n         * the duration by this step.\n         */\n        if (generator.calculatedDuration === null) {\n            generator.calculatedDuration = calcGeneratorDuration(generator);\n        }\n        const { calculatedDuration } = generator;\n        const resolvedDuration = calculatedDuration + repeatDelay;\n        const totalDuration = resolvedDuration * (repeat + 1) - repeatDelay;\n        return {\n            generator,\n            mirroredGenerator,\n            mapPercentToKeyframes,\n            calculatedDuration,\n            resolvedDuration,\n            totalDuration,\n        };\n    }\n    onPostResolved() {\n        const { autoplay = true } = this.options;\n        this.play();\n        if (this.pendingPlayState === \"paused\" || !autoplay) {\n            this.pause();\n        }\n        else {\n            this.state = this.pendingPlayState;\n        }\n    }\n    tick(timestamp, sample = false) {\n        const { resolved } = this;\n        // If the animations has failed to resolve, return the final keyframe.\n        if (!resolved) {\n            const { keyframes } = this.options;\n            return { done: true, value: keyframes[keyframes.length - 1] };\n        }\n        const { finalKeyframe, generator, mirroredGenerator, mapPercentToKeyframes, keyframes, calculatedDuration, totalDuration, resolvedDuration, } = resolved;\n        if (this.startTime === null)\n            return generator.next(0);\n        const { delay, repeat, repeatType, repeatDelay, onUpdate } = this.options;\n        /**\n         * requestAnimationFrame timestamps can come through as lower than\n         * the startTime as set by performance.now(). Here we prevent this,\n         * though in the future it could be possible to make setting startTime\n         * a pending operation that gets resolved here.\n         */\n        if (this.speed > 0) {\n            this.startTime = Math.min(this.startTime, timestamp);\n        }\n        else if (this.speed < 0) {\n            this.startTime = Math.min(timestamp - totalDuration / this.speed, this.startTime);\n        }\n        // Update currentTime\n        if (sample) {\n            this.currentTime = timestamp;\n        }\n        else if (this.holdTime !== null) {\n            this.currentTime = this.holdTime;\n        }\n        else {\n            // Rounding the time because floating point arithmetic is not always accurate, e.g. 3000.367 - 1000.367 =\n            // 2000.0000000000002. This is a problem when we are comparing the currentTime with the duration, for\n            // example.\n            this.currentTime =\n                Math.round(timestamp - this.startTime) * this.speed;\n        }\n        // Rebase on delay\n        const timeWithoutDelay = this.currentTime - delay * (this.speed >= 0 ? 1 : -1);\n        const isInDelayPhase = this.speed >= 0\n            ? timeWithoutDelay < 0\n            : timeWithoutDelay > totalDuration;\n        this.currentTime = Math.max(timeWithoutDelay, 0);\n        // If this animation has finished, set the current time  to the total duration.\n        if (this.state === \"finished\" && this.holdTime === null) {\n            this.currentTime = totalDuration;\n        }\n        let elapsed = this.currentTime;\n        let frameGenerator = generator;\n        if (repeat) {\n            /**\n             * Get the current progress (0-1) of the animation. If t is >\n             * than duration we'll get values like 2.5 (midway through the\n             * third iteration)\n             */\n            const progress = Math.min(this.currentTime, totalDuration) / resolvedDuration;\n            /**\n             * Get the current iteration (0 indexed). For instance the floor of\n             * 2.5 is 2.\n             */\n            let currentIteration = Math.floor(progress);\n            /**\n             * Get the current progress of the iteration by taking the remainder\n             * so 2.5 is 0.5 through iteration 2\n             */\n            let iterationProgress = progress % 1.0;\n            /**\n             * If iteration progress is 1 we count that as the end\n             * of the previous iteration.\n             */\n            if (!iterationProgress && progress >= 1) {\n                iterationProgress = 1;\n            }\n            iterationProgress === 1 && currentIteration--;\n            currentIteration = Math.min(currentIteration, repeat + 1);\n            /**\n             * Reverse progress if we're not running in \"normal\" direction\n             */\n            const isOddIteration = Boolean(currentIteration % 2);\n            if (isOddIteration) {\n                if (repeatType === \"reverse\") {\n                    iterationProgress = 1 - iterationProgress;\n                    if (repeatDelay) {\n                        iterationProgress -= repeatDelay / resolvedDuration;\n                    }\n                }\n                else if (repeatType === \"mirror\") {\n                    frameGenerator = mirroredGenerator;\n                }\n            }\n            elapsed = clamp(0, 1, iterationProgress) * resolvedDuration;\n        }\n        /**\n         * If we're in negative time, set state as the initial keyframe.\n         * This prevents delay: x, duration: 0 animations from finishing\n         * instantly.\n         */\n        const state = isInDelayPhase\n            ? { done: false, value: keyframes[0] }\n            : frameGenerator.next(elapsed);\n        if (mapPercentToKeyframes) {\n            state.value = mapPercentToKeyframes(state.value);\n        }\n        let { done } = state;\n        if (!isInDelayPhase && calculatedDuration !== null) {\n            done =\n                this.speed >= 0\n                    ? this.currentTime >= totalDuration\n                    : this.currentTime <= 0;\n        }\n        const isAnimationFinished = this.holdTime === null &&\n            (this.state === \"finished\" || (this.state === \"running\" && done));\n        if (isAnimationFinished && finalKeyframe !== undefined) {\n            state.value = getFinalKeyframe(keyframes, this.options, finalKeyframe);\n        }\n        if (onUpdate) {\n            onUpdate(state.value);\n        }\n        if (isAnimationFinished) {\n            this.finish();\n        }\n        return state;\n    }\n    get duration() {\n        const { resolved } = this;\n        return resolved ? millisecondsToSeconds(resolved.calculatedDuration) : 0;\n    }\n    get time() {\n        return millisecondsToSeconds(this.currentTime);\n    }\n    set time(newTime) {\n        newTime = secondsToMilliseconds(newTime);\n        this.currentTime = newTime;\n        if (this.holdTime !== null || this.speed === 0) {\n            this.holdTime = newTime;\n        }\n        else if (this.driver) {\n            this.startTime = this.driver.now() - newTime / this.speed;\n        }\n    }\n    get speed() {\n        return this.playbackSpeed;\n    }\n    set speed(newSpeed) {\n        const hasChanged = this.playbackSpeed !== newSpeed;\n        this.playbackSpeed = newSpeed;\n        if (hasChanged) {\n            this.time = millisecondsToSeconds(this.currentTime);\n        }\n    }\n    play() {\n        if (!this.resolver.isScheduled) {\n            this.resolver.resume();\n        }\n        if (!this._resolved) {\n            this.pendingPlayState = \"running\";\n            return;\n        }\n        if (this.isStopped)\n            return;\n        const { driver = frameloopDriver, onPlay, startTime } = this.options;\n        if (!this.driver) {\n            this.driver = driver((timestamp) => this.tick(timestamp));\n        }\n        onPlay && onPlay();\n        const now = this.driver.now();\n        if (this.holdTime !== null) {\n            this.startTime = now - this.holdTime;\n        }\n        else if (!this.startTime) {\n            this.startTime = startTime !== null && startTime !== void 0 ? startTime : this.calcStartTime();\n        }\n        else if (this.state === \"finished\") {\n            this.startTime = now;\n        }\n        if (this.state === \"finished\") {\n            this.updateFinishedPromise();\n        }\n        this.cancelTime = this.startTime;\n        this.holdTime = null;\n        /**\n         * Set playState to running only after we've used it in\n         * the previous logic.\n         */\n        this.state = \"running\";\n        this.driver.start();\n    }\n    pause() {\n        var _a;\n        if (!this._resolved) {\n            this.pendingPlayState = \"paused\";\n            return;\n        }\n        this.state = \"paused\";\n        this.holdTime = (_a = this.currentTime) !== null && _a !== void 0 ? _a : 0;\n    }\n    complete() {\n        if (this.state !== \"running\") {\n            this.play();\n        }\n        this.pendingPlayState = this.state = \"finished\";\n        this.holdTime = null;\n    }\n    finish() {\n        this.teardown();\n        this.state = \"finished\";\n        const { onComplete } = this.options;\n        onComplete && onComplete();\n    }\n    cancel() {\n        if (this.cancelTime !== null) {\n            this.tick(this.cancelTime);\n        }\n        this.teardown();\n        this.updateFinishedPromise();\n    }\n    teardown() {\n        this.state = \"idle\";\n        this.stopDriver();\n        this.resolveFinishedPromise();\n        this.updateFinishedPromise();\n        this.startTime = this.cancelTime = null;\n        this.resolver.cancel();\n    }\n    stopDriver() {\n        if (!this.driver)\n            return;\n        this.driver.stop();\n        this.driver = undefined;\n    }\n    sample(time) {\n        this.startTime = 0;\n        return this.tick(time, true);\n    }\n}\n// Legacy interface\nfunction animateValue(options) {\n    return new MainThreadAnimation(options);\n}\n\nexport { MainThreadAnimation, animateValue };\n","import { mapEasingToNativeEasing } from 'motion-dom';\n\nfunction startWaapiAnimation(element, valueName, keyframes, { delay = 0, duration = 300, repeat = 0, repeatType = \"loop\", ease = \"easeInOut\", times, } = {}) {\n    const keyframeOptions = { [valueName]: keyframes };\n    if (times)\n        keyframeOptions.offset = times;\n    const easing = mapEasingToNativeEasing(ease, duration);\n    /**\n     * If this is an easing array, apply to keyframes, not animation as a whole\n     */\n    if (Array.isArray(easing))\n        keyframeOptions.easing = easing;\n    return element.animate(keyframeOptions, {\n        delay,\n        duration,\n        easing: !Array.isArray(easing) ? easing : \"linear\",\n        fill: \"both\",\n        iterations: repeat + 1,\n        direction: repeatType === \"reverse\" ? \"alternate\" : \"normal\",\n    });\n}\n\nexport { startWaapiAnimation };\n","import { memo } from 'motion-utils';\n\nconst supportsWaapi = /*@__PURE__*/ memo(() => Object.hasOwnProperty.call(Element.prototype, \"animate\"));\n\nexport { supportsWaapi };\n","import { supportsLinearEasing, attachTimeline, isGenerator, isWaapiSupportedEasing } from 'motion-dom';\nimport { millisecondsToSeconds, secondsToMilliseconds, noop } from 'motion-utils';\nimport { anticipate } from '../../easing/anticipate.mjs';\nimport { backInOut } from '../../easing/back.mjs';\nimport { circInOut } from '../../easing/circ.mjs';\nimport { DOMKeyframesResolver } from '../../render/dom/DOMKeyframesResolver.mjs';\nimport { BaseAnimation } from './BaseAnimation.mjs';\nimport { MainThreadAnimation } from './MainThreadAnimation.mjs';\nimport { acceleratedValues } from './utils/accelerated-values.mjs';\nimport { startWaapiAnimation } from './waapi/index.mjs';\nimport { getFinalKeyframe } from './waapi/utils/get-final-keyframe.mjs';\nimport { supportsWaapi } from './waapi/utils/supports-waapi.mjs';\n\n/**\n * 10ms is chosen here as it strikes a balance between smooth\n * results (more than one keyframe per frame at 60fps) and\n * keyframe quantity.\n */\nconst sampleDelta = 10; //ms\n/**\n * Implement a practical max duration for keyframe generation\n * to prevent infinite loops\n */\nconst maxDuration = 20000;\n/**\n * Check if an animation can run natively via WAAPI or requires pregenerated keyframes.\n * WAAPI doesn't support spring or function easings so we run these as JS animation before\n * handing off.\n */\nfunction requiresPregeneratedKeyframes(options) {\n    return (isGenerator(options.type) ||\n        options.type === \"spring\" ||\n        !isWaapiSupportedEasing(options.ease));\n}\nfunction pregenerateKeyframes(keyframes, options) {\n    /**\n     * Create a main-thread animation to pregenerate keyframes.\n     * We sample this at regular intervals to generate keyframes that we then\n     * linearly interpolate between.\n     */\n    const sampleAnimation = new MainThreadAnimation({\n        ...options,\n        keyframes,\n        repeat: 0,\n        delay: 0,\n        isGenerator: true,\n    });\n    let state = { done: false, value: keyframes[0] };\n    const pregeneratedKeyframes = [];\n    /**\n     * Bail after 20 seconds of pre-generated keyframes as it's likely\n     * we're heading for an infinite loop.\n     */\n    let t = 0;\n    while (!state.done && t < maxDuration) {\n        state = sampleAnimation.sample(t);\n        pregeneratedKeyframes.push(state.value);\n        t += sampleDelta;\n    }\n    return {\n        times: undefined,\n        keyframes: pregeneratedKeyframes,\n        duration: t - sampleDelta,\n        ease: \"linear\",\n    };\n}\nconst unsupportedEasingFunctions = {\n    anticipate,\n    backInOut,\n    circInOut,\n};\nfunction isUnsupportedEase(key) {\n    return key in unsupportedEasingFunctions;\n}\nclass AcceleratedAnimation extends BaseAnimation {\n    constructor(options) {\n        super(options);\n        const { name, motionValue, element, keyframes } = this.options;\n        this.resolver = new DOMKeyframesResolver(keyframes, (resolvedKeyframes, finalKeyframe) => this.onKeyframesResolved(resolvedKeyframes, finalKeyframe), name, motionValue, element);\n        this.resolver.scheduleResolve();\n    }\n    initPlayback(keyframes, finalKeyframe) {\n        let { duration = 300, times, ease, type, motionValue, name, startTime, } = this.options;\n        /**\n         * If element has since been unmounted, return false to indicate\n         * the animation failed to initialised.\n         */\n        if (!motionValue.owner || !motionValue.owner.current) {\n            return false;\n        }\n        /**\n         * If the user has provided an easing function name that isn't supported\n         * by WAAPI (like \"anticipate\"), we need to provide the corressponding\n         * function. This will later get converted to a linear() easing function.\n         */\n        if (typeof ease === \"string\" &&\n            supportsLinearEasing() &&\n            isUnsupportedEase(ease)) {\n            ease = unsupportedEasingFunctions[ease];\n        }\n        /**\n         * If this animation needs pre-generated keyframes then generate.\n         */\n        if (requiresPregeneratedKeyframes(this.options)) {\n            const { onComplete, onUpdate, motionValue, element, ...options } = this.options;\n            const pregeneratedAnimation = pregenerateKeyframes(keyframes, options);\n            keyframes = pregeneratedAnimation.keyframes;\n            // If this is a very short animation, ensure we have\n            // at least two keyframes to animate between as older browsers\n            // can't animate between a single keyframe.\n            if (keyframes.length === 1) {\n                keyframes[1] = keyframes[0];\n            }\n            duration = pregeneratedAnimation.duration;\n            times = pregeneratedAnimation.times;\n            ease = pregeneratedAnimation.ease;\n            type = \"keyframes\";\n        }\n        const animation = startWaapiAnimation(motionValue.owner.current, name, keyframes, { ...this.options, duration, times, ease });\n        // Override the browser calculated startTime with one synchronised to other JS\n        // and WAAPI animations starting this event loop.\n        animation.startTime = startTime !== null && startTime !== void 0 ? startTime : this.calcStartTime();\n        if (this.pendingTimeline) {\n            attachTimeline(animation, this.pendingTimeline);\n            this.pendingTimeline = undefined;\n        }\n        else {\n            /**\n             * Prefer the `onfinish` prop as it's more widely supported than\n             * the `finished` promise.\n             *\n             * Here, we synchronously set the provided MotionValue to the end\n             * keyframe. If we didn't, when the WAAPI animation is finished it would\n             * be removed from the element which would then revert to its old styles.\n             */\n            animation.onfinish = () => {\n                const { onComplete } = this.options;\n                motionValue.set(getFinalKeyframe(keyframes, this.options, finalKeyframe));\n                onComplete && onComplete();\n                this.cancel();\n                this.resolveFinishedPromise();\n            };\n        }\n        return {\n            animation,\n            duration,\n            times,\n            type,\n            ease,\n            keyframes: keyframes,\n        };\n    }\n    get duration() {\n        const { resolved } = this;\n        if (!resolved)\n            return 0;\n        const { duration } = resolved;\n        return millisecondsToSeconds(duration);\n    }\n    get time() {\n        const { resolved } = this;\n        if (!resolved)\n            return 0;\n        const { animation } = resolved;\n        return millisecondsToSeconds(animation.currentTime || 0);\n    }\n    set time(newTime) {\n        const { resolved } = this;\n        if (!resolved)\n            return;\n        const { animation } = resolved;\n        animation.currentTime = secondsToMilliseconds(newTime);\n    }\n    get speed() {\n        const { resolved } = this;\n        if (!resolved)\n            return 1;\n        const { animation } = resolved;\n        return animation.playbackRate;\n    }\n    set speed(newSpeed) {\n        const { resolved } = this;\n        if (!resolved)\n            return;\n        const { animation } = resolved;\n        animation.playbackRate = newSpeed;\n    }\n    get state() {\n        const { resolved } = this;\n        if (!resolved)\n            return \"idle\";\n        const { animation } = resolved;\n        return animation.playState;\n    }\n    get startTime() {\n        const { resolved } = this;\n        if (!resolved)\n            return null;\n        const { animation } = resolved;\n        // Coerce to number as TypeScript incorrectly types this\n        // as CSSNumberish\n        return animation.startTime;\n    }\n    /**\n     * Replace the default DocumentTimeline with another AnimationTimeline.\n     * Currently used for scroll animations.\n     */\n    attachTimeline(timeline) {\n        if (!this._resolved) {\n            this.pendingTimeline = timeline;\n        }\n        else {\n            const { resolved } = this;\n            if (!resolved)\n                return noop;\n            const { animation } = resolved;\n            attachTimeline(animation, timeline);\n        }\n        return noop;\n    }\n    play() {\n        if (this.isStopped)\n            return;\n        const { resolved } = this;\n        if (!resolved)\n            return;\n        const { animation } = resolved;\n        if (animation.playState === \"finished\") {\n            this.updateFinishedPromise();\n        }\n        animation.play();\n    }\n    pause() {\n        const { resolved } = this;\n        if (!resolved)\n            return;\n        const { animation } = resolved;\n        animation.pause();\n    }\n    stop() {\n        this.resolver.cancel();\n        this.isStopped = true;\n        if (this.state === \"idle\")\n            return;\n        this.resolveFinishedPromise();\n        this.updateFinishedPromise();\n        const { resolved } = this;\n        if (!resolved)\n            return;\n        const { animation, keyframes, duration, type, ease, times } = resolved;\n        if (animation.playState === \"idle\" ||\n            animation.playState === \"finished\") {\n            return;\n        }\n        /**\n         * WAAPI doesn't natively have any interruption capabilities.\n         *\n         * Rather than read commited styles back out of the DOM, we can\n         * create a renderless JS animation and sample it twice to calculate\n         * its current value, \"previous\" value, and therefore allow\n         * Motion to calculate velocity for any subsequent animation.\n         */\n        if (this.time) {\n            const { motionValue, onUpdate, onComplete, element, ...options } = this.options;\n            const sampleAnimation = new MainThreadAnimation({\n                ...options,\n                keyframes,\n                duration,\n                type,\n                ease,\n                times,\n                isGenerator: true,\n            });\n            const sampleTime = secondsToMilliseconds(this.time);\n            motionValue.setWithVelocity(sampleAnimation.sample(sampleTime - sampleDelta).value, sampleAnimation.sample(sampleTime).value, sampleDelta);\n        }\n        const { onStop } = this.options;\n        onStop && onStop();\n        this.cancel();\n    }\n    complete() {\n        const { resolved } = this;\n        if (!resolved)\n            return;\n        resolved.animation.finish();\n    }\n    cancel() {\n        const { resolved } = this;\n        if (!resolved)\n            return;\n        resolved.animation.cancel();\n    }\n    static supports(options) {\n        const { motionValue, name, repeatDelay, repeatType, damping, type } = options;\n        if (!motionValue ||\n            !motionValue.owner ||\n            !(motionValue.owner.current instanceof HTMLElement)) {\n            return false;\n        }\n        const { onUpdate, transformTemplate } = motionValue.owner.getProps();\n        return (supportsWaapi() &&\n            name &&\n            acceleratedValues.has(name) &&\n            /**\n             * If we're outputting values to onUpdate then we can't use WAAPI as there's\n             * no way to read the value from WAAPI every frame.\n             */\n            !onUpdate &&\n            !transformTemplate &&\n            !repeatDelay &&\n            repeatType !== \"mirror\" &&\n            damping !== 0 &&\n            type !== \"inertia\");\n    }\n}\n\nexport { AcceleratedAnimation };\n","import { transformProps } from '../../render/html/utils/keys-transform.mjs';\n\nconst underDampedSpring = {\n    type: \"spring\",\n    stiffness: 500,\n    damping: 25,\n    restSpeed: 10,\n};\nconst criticallyDampedSpring = (target) => ({\n    type: \"spring\",\n    stiffness: 550,\n    damping: target === 0 ? 2 * Math.sqrt(550) : 30,\n    restSpeed: 10,\n});\nconst keyframesTransition = {\n    type: \"keyframes\",\n    duration: 0.8,\n};\n/**\n * Default easing curve is a slightly shallower version of\n * the default browser easing curve.\n */\nconst ease = {\n    type: \"keyframes\",\n    ease: [0.25, 0.1, 0.35, 1],\n    duration: 0.3,\n};\nconst getDefaultTransition = (valueKey, { keyframes }) => {\n    if (keyframes.length > 2) {\n        return keyframesTransition;\n    }\n    else if (transformProps.has(valueKey)) {\n        return valueKey.startsWith(\"scale\")\n            ? criticallyDampedSpring(keyframes[1])\n            : underDampedSpring;\n    }\n    return ease;\n};\n\nexport { getDefaultTransition };\n","/**\n * Decide whether a transition is defined on a given Transition.\n * This filters out orchestration options and returns true\n * if any options are left.\n */\nfunction isTransitionDefined({ when, delay: _delay, delayChildren, staggerChildren, staggerDirection, repeat, repeatType, repeatDelay, from, elapsed, ...transition }) {\n    return !!Object.keys(transition).length;\n}\n\nexport { isTransitionDefined };\n","import { getValueTransition, GroupPlaybackControls } from 'motion-dom';\nimport { secondsToMilliseconds } from 'motion-utils';\nimport { frame } from '../../frameloop/frame.mjs';\nimport { MotionGlobalConfig } from '../../utils/GlobalConfig.mjs';\nimport { instantAnimationState } from '../../utils/use-instant-transition-state.mjs';\nimport { AcceleratedAnimation } from '../animators/AcceleratedAnimation.mjs';\nimport { MainThreadAnimation } from '../animators/MainThreadAnimation.mjs';\nimport { getFinalKeyframe } from '../animators/waapi/utils/get-final-keyframe.mjs';\nimport { getDefaultTransition } from '../utils/default-transitions.mjs';\nimport { isTransitionDefined } from '../utils/is-transition-defined.mjs';\n\nconst animateMotionValue = (name, value, target, transition = {}, element, isHandoff) => (onComplete) => {\n    const valueTransition = getValueTransition(transition, name) || {};\n    /**\n     * Most transition values are currently completely overwritten by value-specific\n     * transitions. In the future it'd be nicer to blend these transitions. But for now\n     * delay actually does inherit from the root transition if not value-specific.\n     */\n    const delay = valueTransition.delay || transition.delay || 0;\n    /**\n     * Elapsed isn't a public transition option but can be passed through from\n     * optimized appear effects in milliseconds.\n     */\n    let { elapsed = 0 } = transition;\n    elapsed = elapsed - secondsToMilliseconds(delay);\n    let options = {\n        keyframes: Array.isArray(target) ? target : [null, target],\n        ease: \"easeOut\",\n        velocity: value.getVelocity(),\n        ...valueTransition,\n        delay: -elapsed,\n        onUpdate: (v) => {\n            value.set(v);\n            valueTransition.onUpdate && valueTransition.onUpdate(v);\n        },\n        onComplete: () => {\n            onComplete();\n            valueTransition.onComplete && valueTransition.onComplete();\n        },\n        name,\n        motionValue: value,\n        element: isHandoff ? undefined : element,\n    };\n    /**\n     * If there's no transition defined for this value, we can generate\n     * unqiue transition settings for this value.\n     */\n    if (!isTransitionDefined(valueTransition)) {\n        options = {\n            ...options,\n            ...getDefaultTransition(name, options),\n        };\n    }\n    /**\n     * Both WAAPI and our internal animation functions use durations\n     * as defined by milliseconds, while our external API defines them\n     * as seconds.\n     */\n    if (options.duration) {\n        options.duration = secondsToMilliseconds(options.duration);\n    }\n    if (options.repeatDelay) {\n        options.repeatDelay = secondsToMilliseconds(options.repeatDelay);\n    }\n    if (options.from !== undefined) {\n        options.keyframes[0] = options.from;\n    }\n    let shouldSkip = false;\n    if (options.type === false ||\n        (options.duration === 0 && !options.repeatDelay)) {\n        options.duration = 0;\n        if (options.delay === 0) {\n            shouldSkip = true;\n        }\n    }\n    if (instantAnimationState.current ||\n        MotionGlobalConfig.skipAnimations) {\n        shouldSkip = true;\n        options.duration = 0;\n        options.delay = 0;\n    }\n    /**\n     * If we can or must skip creating the animation, and apply only\n     * the final keyframe, do so. We also check once keyframes are resolved but\n     * this early check prevents the need to create an animation at all.\n     */\n    if (shouldSkip && !isHandoff && value.get() !== undefined) {\n        const finalKeyframe = getFinalKeyframe(options.keyframes, valueTransition);\n        if (finalKeyframe !== undefined) {\n            frame.update(() => {\n                options.onUpdate(finalKeyframe);\n                options.onComplete();\n            });\n            // We still want to return some animation controls here rather\n            // than returning undefined\n            return new GroupPlaybackControls([]);\n        }\n    }\n    /**\n     * Animate via WAAPI if possible. If this is a handoff animation, the optimised animation will be running via\n     * WAAPI. Therefore, this animation must be JS to ensure it runs \"under\" the\n     * optimised animation.\n     */\n    if (!isHandoff && AcceleratedAnimation.supports(options)) {\n        return new AcceleratedAnimation(options);\n    }\n    else {\n        return new MainThreadAnimation(options);\n    }\n};\n\nexport { animateMotionValue };\n","import { optimizedAppearDataAttribute } from './data-id.mjs';\n\nfunction getOptimisedAppearId(visualElement) {\n    return visualElement.props[optimizedAppearDataAttribute];\n}\n\nexport { getOptimisedAppearId };\n","import { mirrorEasing } from './modifiers/mirror.mjs';\nimport { reverseEasing } from './modifiers/reverse.mjs';\n\nconst circIn = (p) => 1 - Math.sin(Math.acos(p));\nconst circOut = reverseEasing(circIn);\nconst circInOut = mirrorEasing(circIn);\n\nexport { circIn, circInOut, circOut };\n","// Accepts an easing function and returns a new one that outputs mirrored values for\n// the second half of the animation. Turns easeIn into easeInOut.\nconst mirrorEasing = (easing) => (p) => p <= 0.5 ? easing(2 * p) / 2 : (2 - easing(2 * (1 - p))) / 2;\n\nexport { mirrorEasing };\n","// Accepts an easing function and returns a new one that outputs reversed values.\n// Turns easeIn into easeOut.\nconst reverseEasing = (easing) => (p) => 1 - easing(1 - p);\n\nexport { reverseEasing };\n","function addDomEvent(target, eventName, handler, options = { passive: true }) {\n    target.addEventListener(eventName, handler, options);\n    return () => target.removeEventListener(eventName, handler);\n}\n\nexport { addDomEvent };\n","import { isPrimaryPointer } from 'motion-dom';\n\nfunction extractEventInfo(event) {\n    return {\n        point: {\n            x: event.pageX,\n            y: event.pageY,\n        },\n    };\n}\nconst addPointerInfo = (handler) => {\n    return (event) => isPrimaryPointer(event) && handler(event, extractEventInfo(event));\n};\n\nexport { addPointerInfo, extractEventInfo };\n","import { MotionGlobalConfig } from '../utils/GlobalConfig.mjs';\nimport { frameData } from './frame.mjs';\n\nlet now;\nfunction clearTime() {\n    now = undefined;\n}\n/**\n * An eventloop-synchronous alternative to performance.now().\n *\n * Ensures that time measurements remain consistent within a synchronous context.\n * Usually calling performance.now() twice within the same synchronous context\n * will return different values which isn't useful for animations when we're usually\n * trying to sync animations to the same frame.\n */\nconst time = {\n    now: () => {\n        if (now === undefined) {\n            time.set(frameData.isProcessing || MotionGlobalConfig.useManualTiming\n                ? frameData.timestamp\n                : performance.now());\n        }\n        return now;\n    },\n    set: (newTime) => {\n        now = newTime;\n        queueMicrotask(clearTime);\n    },\n};\n\nexport { time };\n","class Feature {\n    constructor(node) {\n        this.isMounted = false;\n        this.node = node;\n    }\n    update() { }\n}\n\nexport { Feature };\n","/**\n * Bounding boxes tend to be defined as top, left, right, bottom. For various operations\n * it's easier to consider each axis individually. This function returns a bounding box\n * as a map of single-axis min/max values.\n */\nfunction convertBoundingBoxToBox({ top, left, right, bottom, }) {\n    return {\n        x: { min: left, max: right },\n        y: { min: top, max: bottom },\n    };\n}\nfunction convertBoxToBoundingBox({ x, y }) {\n    return { top: y.min, right: x.max, bottom: y.max, left: x.min };\n}\n/**\n * Applies a TransformPoint function to a bounding box. TransformPoint is usually a function\n * provided by Framer to allow measured points to be corrected for device scaling. This is used\n * when measuring DOM elements and DOM event points.\n */\nfunction transformBoxPoints(point, transformPoint) {\n    if (!transformPoint)\n        return point;\n    const topLeft = transformPoint({ x: point.left, y: point.top });\n    const bottomRight = transformPoint({ x: point.right, y: point.bottom });\n    return {\n        top: topLeft.y,\n        left: topLeft.x,\n        bottom: bottomRight.y,\n        right: bottomRight.x,\n    };\n}\n\nexport { convertBoundingBoxToBox, convertBoxToBoundingBox, transformBoxPoints };\n","import { mixNumber } from '../../utils/mix/number.mjs';\nimport { hasTransform } from '../utils/has-transform.mjs';\n\n/**\n * Scales a point based on a factor and an originPoint\n */\nfunction scalePoint(point, scale, originPoint) {\n    const distanceFromOrigin = point - originPoint;\n    const scaled = scale * distanceFromOrigin;\n    return originPoint + scaled;\n}\n/**\n * Applies a translate/scale delta to a point\n */\nfunction applyPointDelta(point, translate, scale, originPoint, boxScale) {\n    if (boxScale !== undefined) {\n        point = scalePoint(point, boxScale, originPoint);\n    }\n    return scalePoint(point, scale, originPoint) + translate;\n}\n/**\n * Applies a translate/scale delta to an axis\n */\nfunction applyAxisDelta(axis, translate = 0, scale = 1, originPoint, boxScale) {\n    axis.min = applyPointDelta(axis.min, translate, scale, originPoint, boxScale);\n    axis.max = applyPointDelta(axis.max, translate, scale, originPoint, boxScale);\n}\n/**\n * Applies a translate/scale delta to a box\n */\nfunction applyBoxDelta(box, { x, y }) {\n    applyAxisDelta(box.x, x.translate, x.scale, x.originPoint);\n    applyAxisDelta(box.y, y.translate, y.scale, y.originPoint);\n}\nconst TREE_SCALE_SNAP_MIN = 0.999999999999;\nconst TREE_SCALE_SNAP_MAX = 1.0000000000001;\n/**\n * Apply a tree of deltas to a box. We do this to calculate the effect of all the transforms\n * in a tree upon our box before then calculating how to project it into our desired viewport-relative box\n *\n * This is the final nested loop within updateLayoutDelta for future refactoring\n */\nfunction applyTreeDeltas(box, treeScale, treePath, isSharedTransition = false) {\n    const treeLength = treePath.length;\n    if (!treeLength)\n        return;\n    // Reset the treeScale\n    treeScale.x = treeScale.y = 1;\n    let node;\n    let delta;\n    for (let i = 0; i < treeLength; i++) {\n        node = treePath[i];\n        delta = node.projectionDelta;\n        /**\n         * TODO: Prefer to remove this, but currently we have motion components with\n         * display: contents in Framer.\n         */\n        const { visualElement } = node.options;\n        if (visualElement &&\n            visualElement.props.style &&\n            visualElement.props.style.display === \"contents\") {\n            continue;\n        }\n        if (isSharedTransition &&\n            node.options.layoutScroll &&\n            node.scroll &&\n            node !== node.root) {\n            transformBox(box, {\n                x: -node.scroll.offset.x,\n                y: -node.scroll.offset.y,\n            });\n        }\n        if (delta) {\n            // Incoporate each ancestor's scale into a culmulative treeScale for this component\n            treeScale.x *= delta.x.scale;\n            treeScale.y *= delta.y.scale;\n            // Apply each ancestor's calculated delta into this component's recorded layout box\n            applyBoxDelta(box, delta);\n        }\n        if (isSharedTransition && hasTransform(node.latestValues)) {\n            transformBox(box, node.latestValues);\n        }\n    }\n    /**\n     * Snap tree scale back to 1 if it's within a non-perceivable threshold.\n     * This will help reduce useless scales getting rendered.\n     */\n    if (treeScale.x < TREE_SCALE_SNAP_MAX &&\n        treeScale.x > TREE_SCALE_SNAP_MIN) {\n        treeScale.x = 1.0;\n    }\n    if (treeScale.y < TREE_SCALE_SNAP_MAX &&\n        treeScale.y > TREE_SCALE_SNAP_MIN) {\n        treeScale.y = 1.0;\n    }\n}\nfunction translateAxis(axis, distance) {\n    axis.min = axis.min + distance;\n    axis.max = axis.max + distance;\n}\n/**\n * Apply a transform to an axis from the latest resolved motion values.\n * This function basically acts as a bridge between a flat motion value map\n * and applyAxisDelta\n */\nfunction transformAxis(axis, axisTranslate, axisScale, boxScale, axisOrigin = 0.5) {\n    const originPoint = mixNumber(axis.min, axis.max, axisOrigin);\n    // Apply the axis delta to the final axis\n    applyAxisDelta(axis, axisTranslate, axisScale, originPoint, boxScale);\n}\n/**\n * Apply a transform to a box from the latest resolved motion values.\n */\nfunction transformBox(box, transform) {\n    transformAxis(box.x, transform.x, transform.scaleX, transform.scale, transform.originX);\n    transformAxis(box.y, transform.y, transform.scaleY, transform.scale, transform.originY);\n}\n\nexport { applyAxisDelta, applyBoxDelta, applyPointDelta, applyTreeDeltas, scalePoint, transformAxis, transformBox, translateAxis };\n","const createAxisDelta = () => ({\n    translate: 0,\n    scale: 1,\n    origin: 0,\n    originPoint: 0,\n});\nconst createDelta = () => ({\n    x: createAxisDelta(),\n    y: createAxisDelta(),\n});\nconst createAxis = () => ({ min: 0, max: 0 });\nconst createBox = () => ({\n    x: createAxis(),\n    y: createAxis(),\n});\n\nexport { createAxis, createAxisDelta, createBox, createDelta };\n","function isIdentityScale(scale) {\n    return scale === undefined || scale === 1;\n}\nfunction hasScale({ scale, scaleX, scaleY }) {\n    return (!isIdentityScale(scale) ||\n        !isIdentityScale(scaleX) ||\n        !isIdentityScale(scaleY));\n}\nfunction hasTransform(values) {\n    return (hasScale(values) ||\n        has2DTranslate(values) ||\n        values.z ||\n        values.rotate ||\n        values.rotateX ||\n        values.rotateY ||\n        values.skewX ||\n        values.skewY);\n}\nfunction has2DTranslate(values) {\n    return is2DTranslate(values.x) || is2DTranslate(values.y);\n}\nfunction is2DTranslate(value) {\n    return value && value !== \"0%\";\n}\n\nexport { has2DTranslate, hasScale, hasTransform };\n","import { convertBoundingBoxToBox, transformBoxPoints } from '../geometry/conversion.mjs';\nimport { translateAxis } from '../geometry/delta-apply.mjs';\n\nfunction measureViewportBox(instance, transformPoint) {\n    return convertBoundingBoxToBox(transformBoxPoints(instance.getBoundingClientRect(), transformPoint));\n}\nfunction measurePageBox(element, rootProjectionNode, transformPagePoint) {\n    const viewportBox = measureViewportBox(element, transformPagePoint);\n    const { scroll } = rootProjectionNode;\n    if (scroll) {\n        translateAxis(viewportBox.x, scroll.offset.x);\n        translateAxis(viewportBox.y, scroll.offset.y);\n    }\n    return viewportBox;\n}\n\nexport { measurePageBox, measureViewportBox };\n","import { isZeroValueString } from '../../utils/is-zero-value-string.mjs';\n\nfunction isNone(value) {\n    if (typeof value === \"number\") {\n        return value === 0;\n    }\n    else if (value !== null) {\n        return value === \"none\" || value === \"0\" || isZeroValueString(value);\n    }\n    else {\n        return true;\n    }\n}\n\nexport { isNone };\n","import { analyseComplexValue } from '../../../value/types/complex/index.mjs';\nimport { getAnimatableNone } from '../../dom/value-types/animatable-none.mjs';\n\n/**\n * If we encounter keyframes like \"none\" or \"0\" and we also have keyframes like\n * \"#fff\" or \"200px 200px\" we want to find a keyframe to serve as a template for\n * the \"none\" keyframes. In this case \"#fff\" or \"200px 200px\" - then these get turned into\n * zero equivalents, i.e. \"#fff0\" or \"0px 0px\".\n */\nconst invalidTemplates = new Set([\"auto\", \"none\", \"0\"]);\nfunction makeNoneKeyframesAnimatable(unresolvedKeyframes, noneKeyframeIndexes, name) {\n    let i = 0;\n    let animatableTemplate = undefined;\n    while (i < unresolvedKeyframes.length && !animatableTemplate) {\n        const keyframe = unresolvedKeyframes[i];\n        if (typeof keyframe === \"string\" &&\n            !invalidTemplates.has(keyframe) &&\n            analyseComplexValue(keyframe).values.length) {\n            animatableTemplate = unresolvedKeyframes[i];\n        }\n        i++;\n    }\n    if (animatableTemplate && name) {\n        for (const noneIndex of noneKeyframeIndexes) {\n            unresolvedKeyframes[noneIndex] = getAnimatableNone(name, animatableTemplate);\n        }\n    }\n}\n\nexport { makeNoneKeyframesAnimatable };\n","import { invariant } from 'motion-utils';\nimport { isNumericalString } from '../../../utils/is-numerical-string.mjs';\nimport { isCSSVariableToken } from './is-css-variable.mjs';\n\n/**\n * Parse Framer's special CSS variable format into a CSS token and a fallback.\n *\n * ```\n * `var(--foo, #fff)` => [`--foo`, '#fff']\n * ```\n *\n * @param current\n */\nconst splitCSSVariableRegex = \n// eslint-disable-next-line redos-detector/no-unsafe-regex -- false positive, as it can match a lot of words\n/^var\\(--(?:([\\w-]+)|([\\w-]+), ?([a-zA-Z\\d ()%#.,-]+))\\)/u;\nfunction parseCSSVariable(current) {\n    const match = splitCSSVariableRegex.exec(current);\n    if (!match)\n        return [,];\n    const [, token1, token2, fallback] = match;\n    return [`--${token1 !== null && token1 !== void 0 ? token1 : token2}`, fallback];\n}\nconst maxDepth = 4;\nfunction getVariableValue(current, element, depth = 1) {\n    invariant(depth <= maxDepth, `Max CSS variable fallback depth detected in property \"${current}\". This may indicate a circular fallback dependency.`);\n    const [token, fallback] = parseCSSVariable(current);\n    // No CSS variable detected\n    if (!token)\n        return;\n    // Attempt to read this CSS variable off the element\n    const resolved = window.getComputedStyle(element).getPropertyValue(token);\n    if (resolved) {\n        const trimmed = resolved.trim();\n        return isNumericalString(trimmed) ? parseFloat(trimmed) : trimmed;\n    }\n    return isCSSVariableToken(fallback)\n        ? getVariableValue(fallback, element, depth + 1)\n        : fallback;\n}\n\nexport { getVariableValue, parseCSSVariable };\n","import { isNone } from '../../animation/utils/is-none.mjs';\nimport { positionalKeys } from '../html/utils/keys-position.mjs';\nimport { makeNoneKeyframesAnimatable } from '../html/utils/make-none-animatable.mjs';\nimport { KeyframeResolver } from '../utils/KeyframesResolver.mjs';\nimport { getVariableValue } from './utils/css-variables-conversion.mjs';\nimport { isCSSVariableToken } from './utils/is-css-variable.mjs';\nimport { isNumOrPxType, positionalValues } from './utils/unit-conversion.mjs';\nimport { findDimensionValueType } from './value-types/dimensions.mjs';\n\nclass DOMKeyframesResolver extends KeyframeResolver {\n    constructor(unresolvedKeyframes, onComplete, name, motionValue, element) {\n        super(unresolvedKeyframes, onComplete, name, motionValue, element, true);\n    }\n    readKeyframes() {\n        const { unresolvedKeyframes, element, name } = this;\n        if (!element || !element.current)\n            return;\n        super.readKeyframes();\n        /**\n         * If any keyframe is a CSS variable, we need to find its value by sampling the element\n         */\n        for (let i = 0; i < unresolvedKeyframes.length; i++) {\n            let keyframe = unresolvedKeyframes[i];\n            if (typeof keyframe === \"string\") {\n                keyframe = keyframe.trim();\n                if (isCSSVariableToken(keyframe)) {\n                    const resolved = getVariableValue(keyframe, element.current);\n                    if (resolved !== undefined) {\n                        unresolvedKeyframes[i] = resolved;\n                    }\n                    if (i === unresolvedKeyframes.length - 1) {\n                        this.finalKeyframe = keyframe;\n                    }\n                }\n            }\n        }\n        /**\n         * Resolve \"none\" values. We do this potentially twice - once before and once after measuring keyframes.\n         * This could be seen as inefficient but it's a trade-off to avoid measurements in more situations, which\n         * have a far bigger performance impact.\n         */\n        this.resolveNoneKeyframes();\n        /**\n         * Check to see if unit type has changed. If so schedule jobs that will\n         * temporarily set styles to the destination keyframes.\n         * Skip if we have more than two keyframes or this isn't a positional value.\n         * TODO: We can throw if there are multiple keyframes and the value type changes.\n         */\n        if (!positionalKeys.has(name) || unresolvedKeyframes.length !== 2) {\n            return;\n        }\n        const [origin, target] = unresolvedKeyframes;\n        const originType = findDimensionValueType(origin);\n        const targetType = findDimensionValueType(target);\n        /**\n         * Either we don't recognise these value types or we can animate between them.\n         */\n        if (originType === targetType)\n            return;\n        /**\n         * If both values are numbers or pixels, we can animate between them by\n         * converting them to numbers.\n         */\n        if (isNumOrPxType(originType) && isNumOrPxType(targetType)) {\n            for (let i = 0; i < unresolvedKeyframes.length; i++) {\n                const value = unresolvedKeyframes[i];\n                if (typeof value === \"string\") {\n                    unresolvedKeyframes[i] = parseFloat(value);\n                }\n            }\n        }\n        else {\n            /**\n             * Else, the only way to resolve this is by measuring the element.\n             */\n            this.needsMeasurement = true;\n        }\n    }\n    resolveNoneKeyframes() {\n        const { unresolvedKeyframes, name } = this;\n        const noneKeyframeIndexes = [];\n        for (let i = 0; i < unresolvedKeyframes.length; i++) {\n            if (isNone(unresolvedKeyframes[i])) {\n                noneKeyframeIndexes.push(i);\n            }\n        }\n        if (noneKeyframeIndexes.length) {\n            makeNoneKeyframesAnimatable(unresolvedKeyframes, noneKeyframeIndexes, name);\n        }\n    }\n    measureInitialState() {\n        const { element, unresolvedKeyframes, name } = this;\n        if (!element || !element.current)\n            return;\n        if (name === \"height\") {\n            this.suspendedScrollY = window.pageYOffset;\n        }\n        this.measuredOrigin = positionalValues[name](element.measureViewportBox(), window.getComputedStyle(element.current));\n        unresolvedKeyframes[0] = this.measuredOrigin;\n        // Set final key frame to measure after next render\n        const measureKeyframe = unresolvedKeyframes[unresolvedKeyframes.length - 1];\n        if (measureKeyframe !== undefined) {\n            element.getValue(name, measureKeyframe).jump(measureKeyframe, false);\n        }\n    }\n    measureEndState() {\n        var _a;\n        const { element, name, unresolvedKeyframes } = this;\n        if (!element || !element.current)\n            return;\n        const value = element.getValue(name);\n        value && value.jump(this.measuredOrigin, false);\n        const finalKeyframeIndex = unresolvedKeyframes.length - 1;\n        const finalKeyframe = unresolvedKeyframes[finalKeyframeIndex];\n        unresolvedKeyframes[finalKeyframeIndex] = positionalValues[name](element.measureViewportBox(), window.getComputedStyle(element.current));\n        if (finalKeyframe !== null && this.finalKeyframe === undefined) {\n            this.finalKeyframe = finalKeyframe;\n        }\n        // If we removed transform values, reapply them before the next render\n        if ((_a = this.removedTransforms) === null || _a === void 0 ? void 0 : _a.length) {\n            this.removedTransforms.forEach(([unsetTransformName, unsetTransformValue]) => {\n                element\n                    .getValue(unsetTransformName)\n                    .set(unsetTransformValue);\n            });\n        }\n        this.resolveNoneKeyframes();\n    }\n}\n\nexport { DOMKeyframesResolver };\n","function shallowCompare(next, prev) {\n    if (!Array.isArray(prev))\n        return false;\n    const prevLength = prev.length;\n    if (prevLength !== next.length)\n        return false;\n    for (let i = 0; i < prevLength; i++) {\n        if (prev[i] !== next[i])\n            return false;\n    }\n    return true;\n}\n\nexport { shallowCompare };\n","import { resolveVariantFromProps } from './resolve-variants.mjs';\n\nfunction resolveVariant(visualElement, definition, custom) {\n    const props = visualElement.getProps();\n    return resolveVariantFromProps(props, definition, custom !== undefined ? custom : props.custom, visualElement);\n}\n\nexport { resolveVariant };\n","import { resolveFinalValueInKeyframes } from '../../utils/resolve-value.mjs';\nimport { motionValue } from '../../value/index.mjs';\nimport { resolveVariant } from './resolve-dynamic-variants.mjs';\n\n/**\n * Set VisualElement's MotionValue, creating a new MotionValue for it if\n * it doesn't exist.\n */\nfunction setMotionValue(visualElement, key, value) {\n    if (visualElement.hasValue(key)) {\n        visualElement.getValue(key).set(value);\n    }\n    else {\n        visualElement.addValue(key, motionValue(value));\n    }\n}\nfunction setTarget(visualElement, definition) {\n    const resolved = resolveVariant(visualElement, definition);\n    let { transitionEnd = {}, transition = {}, ...target } = resolved || {};\n    target = { ...target, ...transitionEnd };\n    for (const key in target) {\n        const value = resolveFinalValueInKeyframes(target[key]);\n        setMotionValue(visualElement, key, value);\n    }\n}\n\nexport { setTarget };\n","import { getValueTransition } from 'motion-dom';\nimport { positionalKeys } from '../../render/html/utils/keys-position.mjs';\nimport { setTarget } from '../../render/utils/setters.mjs';\nimport { addValueToWillChange } from '../../value/use-will-change/add-will-change.mjs';\nimport { getOptimisedAppearId } from '../optimized-appear/get-appear-id.mjs';\nimport { animateMotionValue } from './motion-value.mjs';\nimport { frame } from '../../frameloop/frame.mjs';\n\n/**\n * Decide whether we should block this animation. Previously, we achieved this\n * just by checking whether the key was listed in protectedKeys, but this\n * posed problems if an animation was triggered by afterChildren and protectedKeys\n * had been set to true in the meantime.\n */\nfunction shouldBlockAnimation({ protectedKeys, needsAnimating }, key) {\n    const shouldBlock = protectedKeys.hasOwnProperty(key) && needsAnimating[key] !== true;\n    needsAnimating[key] = false;\n    return shouldBlock;\n}\nfunction animateTarget(visualElement, targetAndTransition, { delay = 0, transitionOverride, type } = {}) {\n    var _a;\n    let { transition = visualElement.getDefaultTransition(), transitionEnd, ...target } = targetAndTransition;\n    if (transitionOverride)\n        transition = transitionOverride;\n    const animations = [];\n    const animationTypeState = type &&\n        visualElement.animationState &&\n        visualElement.animationState.getState()[type];\n    for (const key in target) {\n        const value = visualElement.getValue(key, (_a = visualElement.latestValues[key]) !== null && _a !== void 0 ? _a : null);\n        const valueTarget = target[key];\n        if (valueTarget === undefined ||\n            (animationTypeState &&\n                shouldBlockAnimation(animationTypeState, key))) {\n            continue;\n        }\n        const valueTransition = {\n            delay,\n            ...getValueTransition(transition || {}, key),\n        };\n        /**\n         * If this is the first time a value is being animated, check\n         * to see if we're handling off from an existing animation.\n         */\n        let isHandoff = false;\n        if (window.MotionHandoffAnimation) {\n            const appearId = getOptimisedAppearId(visualElement);\n            if (appearId) {\n                const startTime = window.MotionHandoffAnimation(appearId, key, frame);\n                if (startTime !== null) {\n                    valueTransition.startTime = startTime;\n                    isHandoff = true;\n                }\n            }\n        }\n        addValueToWillChange(visualElement, key);\n        value.start(animateMotionValue(key, value, valueTarget, visualElement.shouldReduceMotion && positionalKeys.has(key)\n            ? { type: false }\n            : valueTransition, visualElement, isHandoff));\n        const animation = value.animation;\n        if (animation) {\n            animations.push(animation);\n        }\n    }\n    if (transitionEnd) {\n        Promise.all(animations).then(() => {\n            frame.update(() => {\n                transitionEnd && setTarget(visualElement, transitionEnd);\n            });\n        });\n    }\n    return animations;\n}\n\nexport { animateTarget };\n","import { resolveVariant } from '../../render/utils/resolve-dynamic-variants.mjs';\nimport { animateTarget } from './visual-element-target.mjs';\n\nfunction animateVariant(visualElement, variant, options = {}) {\n    var _a;\n    const resolved = resolveVariant(visualElement, variant, options.type === \"exit\"\n        ? (_a = visualElement.presenceContext) === null || _a === void 0 ? void 0 : _a.custom\n        : undefined);\n    let { transition = visualElement.getDefaultTransition() || {} } = resolved || {};\n    if (options.transitionOverride) {\n        transition = options.transitionOverride;\n    }\n    /**\n     * If we have a variant, create a callback that runs it as an animation.\n     * Otherwise, we resolve a Promise immediately for a composable no-op.\n     */\n    const getAnimation = resolved\n        ? () => Promise.all(animateTarget(visualElement, resolved, options))\n        : () => Promise.resolve();\n    /**\n     * If we have children, create a callback that runs all their animations.\n     * Otherwise, we resolve a Promise immediately for a composable no-op.\n     */\n    const getChildAnimations = visualElement.variantChildren && visualElement.variantChildren.size\n        ? (forwardDelay = 0) => {\n            const { delayChildren = 0, staggerChildren, staggerDirection, } = transition;\n            return animateChildren(visualElement, variant, delayChildren + forwardDelay, staggerChildren, staggerDirection, options);\n        }\n        : () => Promise.resolve();\n    /**\n     * If the transition explicitly defines a \"when\" option, we need to resolve either\n     * this animation or all children animations before playing the other.\n     */\n    const { when } = transition;\n    if (when) {\n        const [first, last] = when === \"beforeChildren\"\n            ? [getAnimation, getChildAnimations]\n            : [getChildAnimations, getAnimation];\n        return first().then(() => last());\n    }\n    else {\n        return Promise.all([getAnimation(), getChildAnimations(options.delay)]);\n    }\n}\nfunction animateChildren(visualElement, variant, delayChildren = 0, staggerChildren = 0, staggerDirection = 1, options) {\n    const animations = [];\n    const maxStaggerDuration = (visualElement.variantChildren.size - 1) * staggerChildren;\n    const generateStaggerDuration = staggerDirection === 1\n        ? (i = 0) => i * staggerChildren\n        : (i = 0) => maxStaggerDuration - i * staggerChildren;\n    Array.from(visualElement.variantChildren)\n        .sort(sortByTreeOrder)\n        .forEach((child, i) => {\n        child.notify(\"AnimationStart\", variant);\n        animations.push(animateVariant(child, variant, {\n            ...options,\n            delay: delayChildren + generateStaggerDuration(i),\n        }).then(() => child.notify(\"AnimationComplete\", variant)));\n    });\n    return Promise.all(animations);\n}\nfunction sortByTreeOrder(a, b) {\n    return a.sortNodePosition(b);\n}\n\nexport { animateVariant, sortByTreeOrder };\n","import { resolveVariant } from '../../render/utils/resolve-dynamic-variants.mjs';\nimport { animateTarget } from './visual-element-target.mjs';\nimport { animateVariant } from './visual-element-variant.mjs';\n\nfunction animateVisualElement(visualElement, definition, options = {}) {\n    visualElement.notify(\"AnimationStart\", definition);\n    let animation;\n    if (Array.isArray(definition)) {\n        const animations = definition.map((variant) => animateVariant(visualElement, variant, options));\n        animation = Promise.all(animations);\n    }\n    else if (typeof definition === \"string\") {\n        animation = animateVariant(visualElement, definition, options);\n    }\n    else {\n        const resolvedDefinition = typeof definition === \"function\"\n            ? resolveVariant(visualElement, definition, options.custom)\n            : definition;\n        animation = Promise.all(animateTarget(visualElement, resolvedDefinition, options));\n    }\n    return animation.then(() => {\n        visualElement.notify(\"AnimationComplete\", definition);\n    });\n}\n\nexport { animateVisualElement };\n","import { isVariantLabel } from './is-variant-label.mjs';\nimport { variantProps } from './variant-props.mjs';\n\nconst numVariantProps = variantProps.length;\nfunction getVariantContext(visualElement) {\n    if (!visualElement)\n        return undefined;\n    if (!visualElement.isControllingVariants) {\n        const context = visualElement.parent\n            ? getVariantContext(visualElement.parent) || {}\n            : {};\n        if (visualElement.props.initial !== undefined) {\n            context.initial = visualElement.props.initial;\n        }\n        return context;\n    }\n    const context = {};\n    for (let i = 0; i < numVariantProps; i++) {\n        const name = variantProps[i];\n        const prop = visualElement.props[name];\n        if (isVariantLabel(prop) || prop === false) {\n            context[name] = prop;\n        }\n    }\n    return context;\n}\n\nexport { getVariantContext };\n","import { isAnimationControls } from '../../animation/utils/is-animation-controls.mjs';\nimport { isKeyframesTarget } from '../../animation/utils/is-keyframes-target.mjs';\nimport { shallowCompare } from '../../utils/shallow-compare.mjs';\nimport { isVariantLabel } from './is-variant-label.mjs';\nimport { resolveVariant } from './resolve-dynamic-variants.mjs';\nimport { variantPriorityOrder } from './variant-props.mjs';\nimport { animateVisualElement } from '../../animation/interfaces/visual-element.mjs';\nimport { getVariantContext } from './get-variant-context.mjs';\n\nconst reversePriorityOrder = [...variantPriorityOrder].reverse();\nconst numAnimationTypes = variantPriorityOrder.length;\nfunction animateList(visualElement) {\n    return (animations) => Promise.all(animations.map(({ animation, options }) => animateVisualElement(visualElement, animation, options)));\n}\nfunction createAnimationState(visualElement) {\n    let animate = animateList(visualElement);\n    let state = createState();\n    let isInitialRender = true;\n    /**\n     * This function will be used to reduce the animation definitions for\n     * each active animation type into an object of resolved values for it.\n     */\n    const buildResolvedTypeValues = (type) => (acc, definition) => {\n        var _a;\n        const resolved = resolveVariant(visualElement, definition, type === \"exit\"\n            ? (_a = visualElement.presenceContext) === null || _a === void 0 ? void 0 : _a.custom\n            : undefined);\n        if (resolved) {\n            const { transition, transitionEnd, ...target } = resolved;\n            acc = { ...acc, ...target, ...transitionEnd };\n        }\n        return acc;\n    };\n    /**\n     * This just allows us to inject mocked animation functions\n     * @internal\n     */\n    function setAnimateFunction(makeAnimator) {\n        animate = makeAnimator(visualElement);\n    }\n    /**\n     * When we receive new props, we need to:\n     * 1. Create a list of protected keys for each type. This is a directory of\n     *    value keys that are currently being \"handled\" by types of a higher priority\n     *    so that whenever an animation is played of a given type, these values are\n     *    protected from being animated.\n     * 2. Determine if an animation type needs animating.\n     * 3. Determine if any values have been removed from a type and figure out\n     *    what to animate those to.\n     */\n    function animateChanges(changedActiveType) {\n        const { props } = visualElement;\n        const context = getVariantContext(visualElement.parent) || {};\n        /**\n         * A list of animations that we'll build into as we iterate through the animation\n         * types. This will get executed at the end of the function.\n         */\n        const animations = [];\n        /**\n         * Keep track of which values have been removed. Then, as we hit lower priority\n         * animation types, we can check if they contain removed values and animate to that.\n         */\n        const removedKeys = new Set();\n        /**\n         * A dictionary of all encountered keys. This is an object to let us build into and\n         * copy it without iteration. Each time we hit an animation type we set its protected\n         * keys - the keys its not allowed to animate - to the latest version of this object.\n         */\n        let encounteredKeys = {};\n        /**\n         * If a variant has been removed at a given index, and this component is controlling\n         * variant animations, we want to ensure lower-priority variants are forced to animate.\n         */\n        let removedVariantIndex = Infinity;\n        /**\n         * Iterate through all animation types in reverse priority order. For each, we want to\n         * detect which values it's handling and whether or not they've changed (and therefore\n         * need to be animated). If any values have been removed, we want to detect those in\n         * lower priority props and flag for animation.\n         */\n        for (let i = 0; i < numAnimationTypes; i++) {\n            const type = reversePriorityOrder[i];\n            const typeState = state[type];\n            const prop = props[type] !== undefined\n                ? props[type]\n                : context[type];\n            const propIsVariant = isVariantLabel(prop);\n            /**\n             * If this type has *just* changed isActive status, set activeDelta\n             * to that status. Otherwise set to null.\n             */\n            const activeDelta = type === changedActiveType ? typeState.isActive : null;\n            if (activeDelta === false)\n                removedVariantIndex = i;\n            /**\n             * If this prop is an inherited variant, rather than been set directly on the\n             * component itself, we want to make sure we allow the parent to trigger animations.\n             *\n             * TODO: Can probably change this to a !isControllingVariants check\n             */\n            let isInherited = prop === context[type] &&\n                prop !== props[type] &&\n                propIsVariant;\n            /**\n             *\n             */\n            if (isInherited &&\n                isInitialRender &&\n                visualElement.manuallyAnimateOnMount) {\n                isInherited = false;\n            }\n            /**\n             * Set all encountered keys so far as the protected keys for this type. This will\n             * be any key that has been animated or otherwise handled by active, higher-priortiy types.\n             */\n            typeState.protectedKeys = { ...encounteredKeys };\n            // Check if we can skip analysing this prop early\n            if (\n            // If it isn't active and hasn't *just* been set as inactive\n            (!typeState.isActive && activeDelta === null) ||\n                // If we didn't and don't have any defined prop for this animation type\n                (!prop && !typeState.prevProp) ||\n                // Or if the prop doesn't define an animation\n                isAnimationControls(prop) ||\n                typeof prop === \"boolean\") {\n                continue;\n            }\n            /**\n             * As we go look through the values defined on this type, if we detect\n             * a changed value or a value that was removed in a higher priority, we set\n             * this to true and add this prop to the animation list.\n             */\n            const variantDidChange = checkVariantsDidChange(typeState.prevProp, prop);\n            let shouldAnimateType = variantDidChange ||\n                // If we're making this variant active, we want to always make it active\n                (type === changedActiveType &&\n                    typeState.isActive &&\n                    !isInherited &&\n                    propIsVariant) ||\n                // If we removed a higher-priority variant (i is in reverse order)\n                (i > removedVariantIndex && propIsVariant);\n            let handledRemovedValues = false;\n            /**\n             * As animations can be set as variant lists, variants or target objects, we\n             * coerce everything to an array if it isn't one already\n             */\n            const definitionList = Array.isArray(prop) ? prop : [prop];\n            /**\n             * Build an object of all the resolved values. We'll use this in the subsequent\n             * animateChanges calls to determine whether a value has changed.\n             */\n            let resolvedValues = definitionList.reduce(buildResolvedTypeValues(type), {});\n            if (activeDelta === false)\n                resolvedValues = {};\n            /**\n             * Now we need to loop through all the keys in the prev prop and this prop,\n             * and decide:\n             * 1. If the value has changed, and needs animating\n             * 2. If it has been removed, and needs adding to the removedKeys set\n             * 3. If it has been removed in a higher priority type and needs animating\n             * 4. If it hasn't been removed in a higher priority but hasn't changed, and\n             *    needs adding to the type's protectedKeys list.\n             */\n            const { prevResolvedValues = {} } = typeState;\n            const allKeys = {\n                ...prevResolvedValues,\n                ...resolvedValues,\n            };\n            const markToAnimate = (key) => {\n                shouldAnimateType = true;\n                if (removedKeys.has(key)) {\n                    handledRemovedValues = true;\n                    removedKeys.delete(key);\n                }\n                typeState.needsAnimating[key] = true;\n                const motionValue = visualElement.getValue(key);\n                if (motionValue)\n                    motionValue.liveStyle = false;\n            };\n            for (const key in allKeys) {\n                const next = resolvedValues[key];\n                const prev = prevResolvedValues[key];\n                // If we've already handled this we can just skip ahead\n                if (encounteredKeys.hasOwnProperty(key))\n                    continue;\n                /**\n                 * If the value has changed, we probably want to animate it.\n                 */\n                let valueHasChanged = false;\n                if (isKeyframesTarget(next) && isKeyframesTarget(prev)) {\n                    valueHasChanged = !shallowCompare(next, prev);\n                }\n                else {\n                    valueHasChanged = next !== prev;\n                }\n                if (valueHasChanged) {\n                    if (next !== undefined && next !== null) {\n                        // If next is defined and doesn't equal prev, it needs animating\n                        markToAnimate(key);\n                    }\n                    else {\n                        // If it's undefined, it's been removed.\n                        removedKeys.add(key);\n                    }\n                }\n                else if (next !== undefined && removedKeys.has(key)) {\n                    /**\n                     * If next hasn't changed and it isn't undefined, we want to check if it's\n                     * been removed by a higher priority\n                     */\n                    markToAnimate(key);\n                }\n                else {\n                    /**\n                     * If it hasn't changed, we add it to the list of protected values\n                     * to ensure it doesn't get animated.\n                     */\n                    typeState.protectedKeys[key] = true;\n                }\n            }\n            /**\n             * Update the typeState so next time animateChanges is called we can compare the\n             * latest prop and resolvedValues to these.\n             */\n            typeState.prevProp = prop;\n            typeState.prevResolvedValues = resolvedValues;\n            /**\n             *\n             */\n            if (typeState.isActive) {\n                encounteredKeys = { ...encounteredKeys, ...resolvedValues };\n            }\n            if (isInitialRender && visualElement.blockInitialAnimation) {\n                shouldAnimateType = false;\n            }\n            /**\n             * If this is an inherited prop we want to skip this animation\n             * unless the inherited variants haven't changed on this render.\n             */\n            const willAnimateViaParent = isInherited && variantDidChange;\n            const needsAnimating = !willAnimateViaParent || handledRemovedValues;\n            if (shouldAnimateType && needsAnimating) {\n                animations.push(...definitionList.map((animation) => ({\n                    animation: animation,\n                    options: { type },\n                })));\n            }\n        }\n        /**\n         * If there are some removed value that haven't been dealt with,\n         * we need to create a new animation that falls back either to the value\n         * defined in the style prop, or the last read value.\n         */\n        if (removedKeys.size) {\n            const fallbackAnimation = {};\n            removedKeys.forEach((key) => {\n                const fallbackTarget = visualElement.getBaseTarget(key);\n                const motionValue = visualElement.getValue(key);\n                if (motionValue)\n                    motionValue.liveStyle = true;\n                // @ts-expect-error - @mattgperry to figure if we should do something here\n                fallbackAnimation[key] = fallbackTarget !== null && fallbackTarget !== void 0 ? fallbackTarget : null;\n            });\n            animations.push({ animation: fallbackAnimation });\n        }\n        let shouldAnimate = Boolean(animations.length);\n        if (isInitialRender &&\n            (props.initial === false || props.initial === props.animate) &&\n            !visualElement.manuallyAnimateOnMount) {\n            shouldAnimate = false;\n        }\n        isInitialRender = false;\n        return shouldAnimate ? animate(animations) : Promise.resolve();\n    }\n    /**\n     * Change whether a certain animation type is active.\n     */\n    function setActive(type, isActive) {\n        var _a;\n        // If the active state hasn't changed, we can safely do nothing here\n        if (state[type].isActive === isActive)\n            return Promise.resolve();\n        // Propagate active change to children\n        (_a = visualElement.variantChildren) === null || _a === void 0 ? void 0 : _a.forEach((child) => { var _a; return (_a = child.animationState) === null || _a === void 0 ? void 0 : _a.setActive(type, isActive); });\n        state[type].isActive = isActive;\n        const animations = animateChanges(type);\n        for (const key in state) {\n            state[key].protectedKeys = {};\n        }\n        return animations;\n    }\n    return {\n        animateChanges,\n        setActive,\n        setAnimateFunction,\n        getState: () => state,\n        reset: () => {\n            state = createState();\n            isInitialRender = true;\n        },\n    };\n}\nfunction checkVariantsDidChange(prev, next) {\n    if (typeof next === \"string\") {\n        return next !== prev;\n    }\n    else if (Array.isArray(next)) {\n        return !shallowCompare(next, prev);\n    }\n    return false;\n}\nfunction createTypeState(isActive = false) {\n    return {\n        isActive,\n        protectedKeys: {},\n        needsAnimating: {},\n        prevResolvedValues: {},\n    };\n}\nfunction createState() {\n    return {\n        animate: createTypeState(true),\n        whileInView: createTypeState(),\n        whileHover: createTypeState(),\n        whileTap: createTypeState(),\n        whileDrag: createTypeState(),\n        whileFocus: createTypeState(),\n        exit: createTypeState(),\n    };\n}\n\nexport { checkVariantsDidChange, createAnimationState };\n","import { isAnimationControls } from '../../../animation/utils/is-animation-controls.mjs';\nimport { createAnimationState } from '../../../render/utils/animation-state.mjs';\nimport { Feature } from '../Feature.mjs';\n\nclass AnimationFeature extends Feature {\n    /**\n     * We dynamically generate the AnimationState manager as it contains a reference\n     * to the underlying animation library. We only want to load that if we load this,\n     * so people can optionally code split it out using the `m` component.\n     */\n    constructor(node) {\n        super(node);\n        node.animationState || (node.animationState = createAnimationState(node));\n    }\n    updateAnimationControlsSubscription() {\n        const { animate } = this.node.getProps();\n        if (isAnimationControls(animate)) {\n            this.unmountControls = animate.subscribe(this.node);\n        }\n    }\n    /**\n     * Subscribe any provided AnimationControls to the component's VisualElement\n     */\n    mount() {\n        this.updateAnimationControlsSubscription();\n    }\n    update() {\n        const { animate } = this.node.getProps();\n        const { animate: prevAnimate } = this.node.prevProps || {};\n        if (animate !== prevAnimate) {\n            this.updateAnimationControlsSubscription();\n        }\n    }\n    unmount() {\n        var _a;\n        this.node.animationState.reset();\n        (_a = this.unmountControls) === null || _a === void 0 ? void 0 : _a.call(this);\n    }\n}\n\nexport { AnimationFeature };\n","import { Feature } from '../Feature.mjs';\n\nlet id = 0;\nclass ExitAnimationFeature extends Feature {\n    constructor() {\n        super(...arguments);\n        this.id = id++;\n    }\n    update() {\n        if (!this.node.presenceContext)\n            return;\n        const { isPresent, onExitComplete } = this.node.presenceContext;\n        const { isPresent: prevIsPresent } = this.node.prevPresenceContext || {};\n        if (!this.node.animationState || isPresent === prevIsPresent) {\n            return;\n        }\n        const exitAnimation = this.node.animationState.setActive(\"exit\", !isPresent);\n        if (onExitComplete && !isPresent) {\n            exitAnimation.then(() => onExitComplete(this.id));\n        }\n    }\n    mount() {\n        const { register } = this.node.presenceContext || {};\n        if (register) {\n            this.unmount = register(this.id);\n        }\n    }\n    unmount() { }\n}\n\nexport { ExitAnimationFeature };\n","import { AnimationFeature } from './animation/index.mjs';\nimport { ExitAnimationFeature } from './animation/exit.mjs';\n\nconst animations = {\n    animation: {\n        Feature: AnimationFeature,\n    },\n    exit: {\n        Feature: ExitAnimationFeature,\n    },\n};\n\nexport { animations };\n","import { Feature } from '../motion/features/Feature.mjs';\nimport { hover } from 'motion-dom';\nimport { extractEventInfo } from '../events/event-info.mjs';\nimport { frame } from '../frameloop/frame.mjs';\n\nfunction handleHoverEvent(node, event, lifecycle) {\n    const { props } = node;\n    if (node.animationState && props.whileHover) {\n        node.animationState.setActive(\"whileHover\", lifecycle === \"Start\");\n    }\n    const eventName = (\"onHover\" + lifecycle);\n    const callback = props[eventName];\n    if (callback) {\n        frame.postRender(() => callback(event, extractEventInfo(event)));\n    }\n}\nclass HoverGesture extends Feature {\n    mount() {\n        const { current } = this.node;\n        if (!current)\n            return;\n        this.unmount = hover(current, (startEvent) => {\n            handleHoverEvent(this.node, startEvent, \"Start\");\n            return (endEvent) => handleHoverEvent(this.node, endEvent, \"End\");\n        });\n    }\n    unmount() { }\n}\n\nexport { HoverGesture };\n","import { addDomEvent } from '../events/add-dom-event.mjs';\nimport { Feature } from '../motion/features/Feature.mjs';\nimport { pipe } from '../utils/pipe.mjs';\n\nclass FocusGesture extends Feature {\n    constructor() {\n        super(...arguments);\n        this.isActive = false;\n    }\n    onFocus() {\n        let isFocusVisible = false;\n        /**\n         * If this element doesn't match focus-visible then don't\n         * apply whileHover. But, if matches throws that focus-visible\n         * is not a valid selector then in that browser outline styles will be applied\n         * to the element by default and we want to match that behaviour with whileFocus.\n         */\n        try {\n            isFocusVisible = this.node.current.matches(\":focus-visible\");\n        }\n        catch (e) {\n            isFocusVisible = true;\n        }\n        if (!isFocusVisible || !this.node.animationState)\n            return;\n        this.node.animationState.setActive(\"whileFocus\", true);\n        this.isActive = true;\n    }\n    onBlur() {\n        if (!this.isActive || !this.node.animationState)\n            return;\n        this.node.animationState.setActive(\"whileFocus\", false);\n        this.isActive = false;\n    }\n    mount() {\n        this.unmount = pipe(addDomEvent(this.node.current, \"focus\", () => this.onFocus()), addDomEvent(this.node.current, \"blur\", () => this.onBlur()));\n    }\n    unmount() { }\n}\n\nexport { FocusGesture };\n","import { Feature } from '../motion/features/Feature.mjs';\nimport { press } from 'motion-dom';\nimport { extractEventInfo } from '../events/event-info.mjs';\nimport { frame } from '../frameloop/frame.mjs';\n\nfunction handlePressEvent(node, event, lifecycle) {\n    const { props } = node;\n    if (node.animationState && props.whileTap) {\n        node.animationState.setActive(\"whileTap\", lifecycle === \"Start\");\n    }\n    const eventName = (\"onTap\" + (lifecycle === \"End\" ? \"\" : lifecycle));\n    const callback = props[eventName];\n    if (callback) {\n        frame.postRender(() => callback(event, extractEventInfo(event)));\n    }\n}\nclass PressGesture extends Feature {\n    mount() {\n        const { current } = this.node;\n        if (!current)\n            return;\n        this.unmount = press(current, (startEvent) => {\n            handlePressEvent(this.node, startEvent, \"Start\");\n            return (endEvent, { success }) => handlePressEvent(this.node, endEvent, success ? \"End\" : \"Cancel\");\n        }, { useGlobalTarget: this.node.props.globalTapTarget });\n    }\n    unmount() { }\n}\n\nexport { PressGesture };\n","/**\n * Map an IntersectionHandler callback to an element. We only ever make one handler for one\n * element, so even though these handlers might all be triggered by different\n * observers, we can keep them in the same map.\n */\nconst observerCallbacks = new WeakMap();\n/**\n * Multiple observers can be created for multiple element/document roots. Each with\n * different settings. So here we store dictionaries of observers to each root,\n * using serialised settings (threshold/margin) as lookup keys.\n */\nconst observers = new WeakMap();\nconst fireObserverCallback = (entry) => {\n    const callback = observerCallbacks.get(entry.target);\n    callback && callback(entry);\n};\nconst fireAllObserverCallbacks = (entries) => {\n    entries.forEach(fireObserverCallback);\n};\nfunction initIntersectionObserver({ root, ...options }) {\n    const lookupRoot = root || document;\n    /**\n     * If we don't have an observer lookup map for this root, create one.\n     */\n    if (!observers.has(lookupRoot)) {\n        observers.set(lookupRoot, {});\n    }\n    const rootObservers = observers.get(lookupRoot);\n    const key = JSON.stringify(options);\n    /**\n     * If we don't have an observer for this combination of root and settings,\n     * create one.\n     */\n    if (!rootObservers[key]) {\n        rootObservers[key] = new IntersectionObserver(fireAllObserverCallbacks, { root, ...options });\n    }\n    return rootObservers[key];\n}\nfunction observeIntersection(element, options, callback) {\n    const rootInteresectionObserver = initIntersectionObserver(options);\n    observerCallbacks.set(element, callback);\n    rootInteresectionObserver.observe(element);\n    return () => {\n        observerCallbacks.delete(element);\n        rootInteresectionObserver.unobserve(element);\n    };\n}\n\nexport { observeIntersection };\n","import { Feature } from '../Feature.mjs';\nimport { observeIntersection } from './observers.mjs';\n\nconst thresholdNames = {\n    some: 0,\n    all: 1,\n};\nclass InViewFeature extends Feature {\n    constructor() {\n        super(...arguments);\n        this.hasEnteredView = false;\n        this.isInView = false;\n    }\n    startObserver() {\n        this.unmount();\n        const { viewport = {} } = this.node.getProps();\n        const { root, margin: rootMargin, amount = \"some\", once } = viewport;\n        const options = {\n            root: root ? root.current : undefined,\n            rootMargin,\n            threshold: typeof amount === \"number\" ? amount : thresholdNames[amount],\n        };\n        const onIntersectionUpdate = (entry) => {\n            const { isIntersecting } = entry;\n            /**\n             * If there's been no change in the viewport state, early return.\n             */\n            if (this.isInView === isIntersecting)\n                return;\n            this.isInView = isIntersecting;\n            /**\n             * Handle hasEnteredView. If this is only meant to run once, and\n             * element isn't visible, early return. Otherwise set hasEnteredView to true.\n             */\n            if (once && !isIntersecting && this.hasEnteredView) {\n                return;\n            }\n            else if (isIntersecting) {\n                this.hasEnteredView = true;\n            }\n            if (this.node.animationState) {\n                this.node.animationState.setActive(\"whileInView\", isIntersecting);\n            }\n            /**\n             * Use the latest committed props rather than the ones in scope\n             * when this observer is created\n             */\n            const { onViewportEnter, onViewportLeave } = this.node.getProps();\n            const callback = isIntersecting ? onViewportEnter : onViewportLeave;\n            callback && callback(entry);\n        };\n        return observeIntersection(this.node.current, options, onIntersectionUpdate);\n    }\n    mount() {\n        this.startObserver();\n    }\n    update() {\n        if (typeof IntersectionObserver === \"undefined\")\n            return;\n        const { props, prevProps } = this.node;\n        const hasOptionsChanged = [\"amount\", \"margin\", \"root\"].some(hasViewportOptionChanged(props, prevProps));\n        if (hasOptionsChanged) {\n            this.startObserver();\n        }\n    }\n    unmount() { }\n}\nfunction hasViewportOptionChanged({ viewport = {} }, { viewport: prevViewport = {} } = {}) {\n    return (name) => viewport[name] !== prevViewport[name];\n}\n\nexport { InViewFeature };\n","import { HoverGesture } from '../../gestures/hover.mjs';\nimport { FocusGesture } from '../../gestures/focus.mjs';\nimport { PressGesture } from '../../gestures/press.mjs';\nimport { InViewFeature } from './viewport/index.mjs';\n\nconst gestureAnimations = {\n    inView: {\n        Feature: InViewFeature,\n    },\n    tap: {\n        Feature: PressGesture,\n    },\n    focus: {\n        Feature: FocusGesture,\n    },\n    hover: {\n        Feature: HoverGesture,\n    },\n};\n\nexport { gestureAnimations };\n","// Does this device prefer reduced motion? Returns `null` server-side.\nconst prefersReducedMotion = { current: null };\nconst hasReducedMotionListener = { current: false };\n\nexport { hasReducedMotionListener, prefersReducedMotion };\n","import { isBrowser } from '../is-browser.mjs';\nimport { hasReducedMotionListener, prefersReducedMotion } from './state.mjs';\n\nfunction initPrefersReducedMotion() {\n    hasReducedMotionListener.current = true;\n    if (!isBrowser)\n        return;\n    if (window.matchMedia) {\n        const motionMediaQuery = window.matchMedia(\"(prefers-reduced-motion)\");\n        const setReducedMotionPreferences = () => (prefersReducedMotion.current = motionMediaQuery.matches);\n        motionMediaQuery.addListener(setReducedMotionPreferences);\n        setReducedMotionPreferences();\n    }\n    else {\n        prefersReducedMotion.current = false;\n    }\n}\n\nexport { initPrefersReducedMotion };\n","import { color } from '../../../value/types/color/index.mjs';\nimport { complex } from '../../../value/types/complex/index.mjs';\nimport { dimensionValueTypes } from './dimensions.mjs';\nimport { testValueType } from './test.mjs';\n\n/**\n * A list of all ValueTypes\n */\nconst valueTypes = [...dimensionValueTypes, color, complex];\n/**\n * Tests a value against the list of ValueTypes\n */\nconst findValueType = (v) => valueTypes.find(testValueType(v));\n\nexport { findValueType };\n","const visualElementStore = new WeakMap();\n\nexport { visualElementStore };\n","import { warnOnce } from '../../utils/warn-once.mjs';\nimport { motionValue } from '../../value/index.mjs';\nimport { isMotionValue } from '../../value/utils/is-motion-value.mjs';\n\nfunction updateMotionValuesFromProps(element, next, prev) {\n    for (const key in next) {\n        const nextValue = next[key];\n        const prevValue = prev[key];\n        if (isMotionValue(nextValue)) {\n            /**\n             * If this is a motion value found in props or style, we want to add it\n             * to our visual element's motion value map.\n             */\n            element.addValue(key, nextValue);\n            /**\n             * Check the version of the incoming motion value with this version\n             * and warn against mismatches.\n             */\n            if (process.env.NODE_ENV === \"development\") {\n                warnOnce(nextValue.version === \"11.18.2\", `Attempting to mix Motion versions ${nextValue.version} with 11.18.2 may not work as expected.`);\n            }\n        }\n        else if (isMotionValue(prevValue)) {\n            /**\n             * If we're swapping from a motion value to a static value,\n             * create a new motion value from that\n             */\n            element.addValue(key, motionValue(nextValue, { owner: element }));\n        }\n        else if (prevValue !== nextValue) {\n            /**\n             * If this is a flat value that has changed, update the motion value\n             * or create one if it doesn't exist. We only want to do this if we're\n             * not handling the value with our animation state.\n             */\n            if (element.hasValue(key)) {\n                const existingValue = element.getValue(key);\n                if (existingValue.liveStyle === true) {\n                    existingValue.jump(nextValue);\n                }\n                else if (!existingValue.hasAnimated) {\n                    existingValue.set(nextValue);\n                }\n            }\n            else {\n                const latestValue = element.getStaticValue(key);\n                element.addValue(key, motionValue(latestValue !== undefined ? latestValue : nextValue, { owner: element }));\n            }\n        }\n    }\n    // Handle removed values\n    for (const key in prev) {\n        if (next[key] === undefined)\n            element.removeValue(key);\n    }\n    return next;\n}\n\nexport { updateMotionValuesFromProps };\n","import { time } from '../frameloop/sync-time.mjs';\nimport { featureDefinitions } from '../motion/features/definitions.mjs';\nimport { createBox } from '../projection/geometry/models.mjs';\nimport { isNumericalString } from '../utils/is-numerical-string.mjs';\nimport { isZeroValueString } from '../utils/is-zero-value-string.mjs';\nimport { initPrefersReducedMotion } from '../utils/reduced-motion/index.mjs';\nimport { hasReducedMotionListener, prefersReducedMotion } from '../utils/reduced-motion/state.mjs';\nimport { SubscriptionManager } from '../utils/subscription-manager.mjs';\nimport { warnOnce } from '../utils/warn-once.mjs';\nimport { motionValue } from '../value/index.mjs';\nimport { complex } from '../value/types/complex/index.mjs';\nimport { isMotionValue } from '../value/utils/is-motion-value.mjs';\nimport { getAnimatableNone } from './dom/value-types/animatable-none.mjs';\nimport { findValueType } from './dom/value-types/find.mjs';\nimport { transformProps } from './html/utils/keys-transform.mjs';\nimport { visualElementStore } from './store.mjs';\nimport { isControllingVariants, isVariantNode } from './utils/is-controlling-variants.mjs';\nimport { KeyframeResolver } from './utils/KeyframesResolver.mjs';\nimport { updateMotionValuesFromProps } from './utils/motion-values.mjs';\nimport { resolveVariantFromProps } from './utils/resolve-variants.mjs';\nimport { frame, cancelFrame } from '../frameloop/frame.mjs';\n\nconst propEventHandlers = [\n    \"AnimationStart\",\n    \"AnimationComplete\",\n    \"Update\",\n    \"BeforeLayoutMeasure\",\n    \"LayoutMeasure\",\n    \"LayoutAnimationStart\",\n    \"LayoutAnimationComplete\",\n];\n/**\n * A VisualElement is an imperative abstraction around UI elements such as\n * HTMLElement, SVGElement, Three.Object3D etc.\n */\nclass VisualElement {\n    /**\n     * This method takes React props and returns found MotionValues. For example, HTML\n     * MotionValues will be found within the style prop, whereas for Three.js within attribute arrays.\n     *\n     * This isn't an abstract method as it needs calling in the constructor, but it is\n     * intended to be one.\n     */\n    scrapeMotionValuesFromProps(_props, _prevProps, _visualElement) {\n        return {};\n    }\n    constructor({ parent, props, presenceContext, reducedMotionConfig, blockInitialAnimation, visualState, }, options = {}) {\n        /**\n         * A reference to the current underlying Instance, e.g. a HTMLElement\n         * or Three.Mesh etc.\n         */\n        this.current = null;\n        /**\n         * A set containing references to this VisualElement's children.\n         */\n        this.children = new Set();\n        /**\n         * Determine what role this visual element should take in the variant tree.\n         */\n        this.isVariantNode = false;\n        this.isControllingVariants = false;\n        /**\n         * Decides whether this VisualElement should animate in reduced motion\n         * mode.\n         *\n         * TODO: This is currently set on every individual VisualElement but feels\n         * like it could be set globally.\n         */\n        this.shouldReduceMotion = null;\n        /**\n         * A map of all motion values attached to this visual element. Motion\n         * values are source of truth for any given animated value. A motion\n         * value might be provided externally by the component via props.\n         */\n        this.values = new Map();\n        this.KeyframeResolver = KeyframeResolver;\n        /**\n         * Cleanup functions for active features (hover/tap/exit etc)\n         */\n        this.features = {};\n        /**\n         * A map of every subscription that binds the provided or generated\n         * motion values onChange listeners to this visual element.\n         */\n        this.valueSubscriptions = new Map();\n        /**\n         * A reference to the previously-provided motion values as returned\n         * from scrapeMotionValuesFromProps. We use the keys in here to determine\n         * if any motion values need to be removed after props are updated.\n         */\n        this.prevMotionValues = {};\n        /**\n         * An object containing a SubscriptionManager for each active event.\n         */\n        this.events = {};\n        /**\n         * An object containing an unsubscribe function for each prop event subscription.\n         * For example, every \"Update\" event can have multiple subscribers via\n         * VisualElement.on(), but only one of those can be defined via the onUpdate prop.\n         */\n        this.propEventSubscriptions = {};\n        this.notifyUpdate = () => this.notify(\"Update\", this.latestValues);\n        this.render = () => {\n            if (!this.current)\n                return;\n            this.triggerBuild();\n            this.renderInstance(this.current, this.renderState, this.props.style, this.projection);\n        };\n        this.renderScheduledAt = 0.0;\n        this.scheduleRender = () => {\n            const now = time.now();\n            if (this.renderScheduledAt < now) {\n                this.renderScheduledAt = now;\n                frame.render(this.render, false, true);\n            }\n        };\n        const { latestValues, renderState, onUpdate } = visualState;\n        this.onUpdate = onUpdate;\n        this.latestValues = latestValues;\n        this.baseTarget = { ...latestValues };\n        this.initialValues = props.initial ? { ...latestValues } : {};\n        this.renderState = renderState;\n        this.parent = parent;\n        this.props = props;\n        this.presenceContext = presenceContext;\n        this.depth = parent ? parent.depth + 1 : 0;\n        this.reducedMotionConfig = reducedMotionConfig;\n        this.options = options;\n        this.blockInitialAnimation = Boolean(blockInitialAnimation);\n        this.isControllingVariants = isControllingVariants(props);\n        this.isVariantNode = isVariantNode(props);\n        if (this.isVariantNode) {\n            this.variantChildren = new Set();\n        }\n        this.manuallyAnimateOnMount = Boolean(parent && parent.current);\n        /**\n         * Any motion values that are provided to the element when created\n         * aren't yet bound to the element, as this would technically be impure.\n         * However, we iterate through the motion values and set them to the\n         * initial values for this component.\n         *\n         * TODO: This is impure and we should look at changing this to run on mount.\n         * Doing so will break some tests but this isn't necessarily a breaking change,\n         * more a reflection of the test.\n         */\n        const { willChange, ...initialMotionValues } = this.scrapeMotionValuesFromProps(props, {}, this);\n        for (const key in initialMotionValues) {\n            const value = initialMotionValues[key];\n            if (latestValues[key] !== undefined && isMotionValue(value)) {\n                value.set(latestValues[key], false);\n            }\n        }\n    }\n    mount(instance) {\n        this.current = instance;\n        visualElementStore.set(instance, this);\n        if (this.projection && !this.projection.instance) {\n            this.projection.mount(instance);\n        }\n        if (this.parent && this.isVariantNode && !this.isControllingVariants) {\n            this.removeFromVariantTree = this.parent.addVariantChild(this);\n        }\n        this.values.forEach((value, key) => this.bindToMotionValue(key, value));\n        if (!hasReducedMotionListener.current) {\n            initPrefersReducedMotion();\n        }\n        this.shouldReduceMotion =\n            this.reducedMotionConfig === \"never\"\n                ? false\n                : this.reducedMotionConfig === \"always\"\n                    ? true\n                    : prefersReducedMotion.current;\n        if (process.env.NODE_ENV !== \"production\") {\n            warnOnce(this.shouldReduceMotion !== true, \"You have Reduced Motion enabled on your device. Animations may not appear as expected.\");\n        }\n        if (this.parent)\n            this.parent.children.add(this);\n        this.update(this.props, this.presenceContext);\n    }\n    unmount() {\n        visualElementStore.delete(this.current);\n        this.projection && this.projection.unmount();\n        cancelFrame(this.notifyUpdate);\n        cancelFrame(this.render);\n        this.valueSubscriptions.forEach((remove) => remove());\n        this.valueSubscriptions.clear();\n        this.removeFromVariantTree && this.removeFromVariantTree();\n        this.parent && this.parent.children.delete(this);\n        for (const key in this.events) {\n            this.events[key].clear();\n        }\n        for (const key in this.features) {\n            const feature = this.features[key];\n            if (feature) {\n                feature.unmount();\n                feature.isMounted = false;\n            }\n        }\n        this.current = null;\n    }\n    bindToMotionValue(key, value) {\n        if (this.valueSubscriptions.has(key)) {\n            this.valueSubscriptions.get(key)();\n        }\n        const valueIsTransform = transformProps.has(key);\n        const removeOnChange = value.on(\"change\", (latestValue) => {\n            this.latestValues[key] = latestValue;\n            this.props.onUpdate && frame.preRender(this.notifyUpdate);\n            if (valueIsTransform && this.projection) {\n                this.projection.isTransformDirty = true;\n            }\n        });\n        const removeOnRenderRequest = value.on(\"renderRequest\", this.scheduleRender);\n        let removeSyncCheck;\n        if (window.MotionCheckAppearSync) {\n            removeSyncCheck = window.MotionCheckAppearSync(this, key, value);\n        }\n        this.valueSubscriptions.set(key, () => {\n            removeOnChange();\n            removeOnRenderRequest();\n            if (removeSyncCheck)\n                removeSyncCheck();\n            if (value.owner)\n                value.stop();\n        });\n    }\n    sortNodePosition(other) {\n        /**\n         * If these nodes aren't even of the same type we can't compare their depth.\n         */\n        if (!this.current ||\n            !this.sortInstanceNodePosition ||\n            this.type !== other.type) {\n            return 0;\n        }\n        return this.sortInstanceNodePosition(this.current, other.current);\n    }\n    updateFeatures() {\n        let key = \"animation\";\n        for (key in featureDefinitions) {\n            const featureDefinition = featureDefinitions[key];\n            if (!featureDefinition)\n                continue;\n            const { isEnabled, Feature: FeatureConstructor } = featureDefinition;\n            /**\n             * If this feature is enabled but not active, make a new instance.\n             */\n            if (!this.features[key] &&\n                FeatureConstructor &&\n                isEnabled(this.props)) {\n                this.features[key] = new FeatureConstructor(this);\n            }\n            /**\n             * If we have a feature, mount or update it.\n             */\n            if (this.features[key]) {\n                const feature = this.features[key];\n                if (feature.isMounted) {\n                    feature.update();\n                }\n                else {\n                    feature.mount();\n                    feature.isMounted = true;\n                }\n            }\n        }\n    }\n    triggerBuild() {\n        this.build(this.renderState, this.latestValues, this.props);\n    }\n    /**\n     * Measure the current viewport box with or without transforms.\n     * Only measures axis-aligned boxes, rotate and skew must be manually\n     * removed with a re-render to work.\n     */\n    measureViewportBox() {\n        return this.current\n            ? this.measureInstanceViewportBox(this.current, this.props)\n            : createBox();\n    }\n    getStaticValue(key) {\n        return this.latestValues[key];\n    }\n    setStaticValue(key, value) {\n        this.latestValues[key] = value;\n    }\n    /**\n     * Update the provided props. Ensure any newly-added motion values are\n     * added to our map, old ones removed, and listeners updated.\n     */\n    update(props, presenceContext) {\n        if (props.transformTemplate || this.props.transformTemplate) {\n            this.scheduleRender();\n        }\n        this.prevProps = this.props;\n        this.props = props;\n        this.prevPresenceContext = this.presenceContext;\n        this.presenceContext = presenceContext;\n        /**\n         * Update prop event handlers ie onAnimationStart, onAnimationComplete\n         */\n        for (let i = 0; i < propEventHandlers.length; i++) {\n            const key = propEventHandlers[i];\n            if (this.propEventSubscriptions[key]) {\n                this.propEventSubscriptions[key]();\n                delete this.propEventSubscriptions[key];\n            }\n            const listenerName = (\"on\" + key);\n            const listener = props[listenerName];\n            if (listener) {\n                this.propEventSubscriptions[key] = this.on(key, listener);\n            }\n        }\n        this.prevMotionValues = updateMotionValuesFromProps(this, this.scrapeMotionValuesFromProps(props, this.prevProps, this), this.prevMotionValues);\n        if (this.handleChildMotionValue) {\n            this.handleChildMotionValue();\n        }\n        this.onUpdate && this.onUpdate(this);\n    }\n    getProps() {\n        return this.props;\n    }\n    /**\n     * Returns the variant definition with a given name.\n     */\n    getVariant(name) {\n        return this.props.variants ? this.props.variants[name] : undefined;\n    }\n    /**\n     * Returns the defined default transition on this component.\n     */\n    getDefaultTransition() {\n        return this.props.transition;\n    }\n    getTransformPagePoint() {\n        return this.props.transformPagePoint;\n    }\n    getClosestVariantNode() {\n        return this.isVariantNode\n            ? this\n            : this.parent\n                ? this.parent.getClosestVariantNode()\n                : undefined;\n    }\n    /**\n     * Add a child visual element to our set of children.\n     */\n    addVariantChild(child) {\n        const closestVariantNode = this.getClosestVariantNode();\n        if (closestVariantNode) {\n            closestVariantNode.variantChildren &&\n                closestVariantNode.variantChildren.add(child);\n            return () => closestVariantNode.variantChildren.delete(child);\n        }\n    }\n    /**\n     * Add a motion value and bind it to this visual element.\n     */\n    addValue(key, value) {\n        // Remove existing value if it exists\n        const existingValue = this.values.get(key);\n        if (value !== existingValue) {\n            if (existingValue)\n                this.removeValue(key);\n            this.bindToMotionValue(key, value);\n            this.values.set(key, value);\n            this.latestValues[key] = value.get();\n        }\n    }\n    /**\n     * Remove a motion value and unbind any active subscriptions.\n     */\n    removeValue(key) {\n        this.values.delete(key);\n        const unsubscribe = this.valueSubscriptions.get(key);\n        if (unsubscribe) {\n            unsubscribe();\n            this.valueSubscriptions.delete(key);\n        }\n        delete this.latestValues[key];\n        this.removeValueFromRenderState(key, this.renderState);\n    }\n    /**\n     * Check whether we have a motion value for this key\n     */\n    hasValue(key) {\n        return this.values.has(key);\n    }\n    getValue(key, defaultValue) {\n        if (this.props.values && this.props.values[key]) {\n            return this.props.values[key];\n        }\n        let value = this.values.get(key);\n        if (value === undefined && defaultValue !== undefined) {\n            value = motionValue(defaultValue === null ? undefined : defaultValue, { owner: this });\n            this.addValue(key, value);\n        }\n        return value;\n    }\n    /**\n     * If we're trying to animate to a previously unencountered value,\n     * we need to check for it in our state and as a last resort read it\n     * directly from the instance (which might have performance implications).\n     */\n    readValue(key, target) {\n        var _a;\n        let value = this.latestValues[key] !== undefined || !this.current\n            ? this.latestValues[key]\n            : (_a = this.getBaseTargetFromProps(this.props, key)) !== null && _a !== void 0 ? _a : this.readValueFromInstance(this.current, key, this.options);\n        if (value !== undefined && value !== null) {\n            if (typeof value === \"string\" &&\n                (isNumericalString(value) || isZeroValueString(value))) {\n                // If this is a number read as a string, ie \"0\" or \"200\", convert it to a number\n                value = parseFloat(value);\n            }\n            else if (!findValueType(value) && complex.test(target)) {\n                value = getAnimatableNone(key, target);\n            }\n            this.setBaseTarget(key, isMotionValue(value) ? value.get() : value);\n        }\n        return isMotionValue(value) ? value.get() : value;\n    }\n    /**\n     * Set the base target to later animate back to. This is currently\n     * only hydrated on creation and when we first read a value.\n     */\n    setBaseTarget(key, value) {\n        this.baseTarget[key] = value;\n    }\n    /**\n     * Find the base target for a value thats been removed from all animation\n     * props.\n     */\n    getBaseTarget(key) {\n        var _a;\n        const { initial } = this.props;\n        let valueFromInitial;\n        if (typeof initial === \"string\" || typeof initial === \"object\") {\n            const variant = resolveVariantFromProps(this.props, initial, (_a = this.presenceContext) === null || _a === void 0 ? void 0 : _a.custom);\n            if (variant) {\n                valueFromInitial = variant[key];\n            }\n        }\n        /**\n         * If this value still exists in the current initial variant, read that.\n         */\n        if (initial && valueFromInitial !== undefined) {\n            return valueFromInitial;\n        }\n        /**\n         * Alternatively, if this VisualElement config has defined a getBaseTarget\n         * so we can read the value from an alternative source, try that.\n         */\n        const target = this.getBaseTargetFromProps(this.props, key);\n        if (target !== undefined && !isMotionValue(target))\n            return target;\n        /**\n         * If the value was initially defined on initial, but it doesn't any more,\n         * return undefined. Otherwise return the value as initially read from the DOM.\n         */\n        return this.initialValues[key] !== undefined &&\n            valueFromInitial === undefined\n            ? undefined\n            : this.baseTarget[key];\n    }\n    on(eventName, callback) {\n        if (!this.events[eventName]) {\n            this.events[eventName] = new SubscriptionManager();\n        }\n        return this.events[eventName].add(callback);\n    }\n    notify(eventName, ...args) {\n        if (this.events[eventName]) {\n            this.events[eventName].notify(...args);\n        }\n    }\n}\n\nexport { VisualElement };\n","import { VisualElement } from '../VisualElement.mjs';\nimport { DOMKeyframesResolver } from './DOMKeyframesResolver.mjs';\nimport { isMotionValue } from '../../value/utils/is-motion-value.mjs';\n\nclass DOMVisualElement extends VisualElement {\n    constructor() {\n        super(...arguments);\n        this.KeyframeResolver = DOMKeyframesResolver;\n    }\n    sortInstanceNodePosition(a, b) {\n        /**\n         * compareDocumentPosition returns a bitmask, by using the bitwise &\n         * we're returning true if 2 in that bitmask is set to true. 2 is set\n         * to true if b preceeds a.\n         */\n        return a.compareDocumentPosition(b) & 2 ? 1 : -1;\n    }\n    getBaseTargetFromProps(props, key) {\n        return props.style\n            ? props.style[key]\n            : undefined;\n    }\n    removeValueFromRenderState(key, { vars, style }) {\n        delete vars[key];\n        delete style[key];\n    }\n    handleChildMotionValue() {\n        if (this.childSubscription) {\n            this.childSubscription();\n            delete this.childSubscription;\n        }\n        const { children } = this.props;\n        if (isMotionValue(children)) {\n            this.childSubscription = children.on(\"change\", (latest) => {\n                if (this.current) {\n                    this.current.textContent = `${latest}`;\n                }\n            });\n        }\n    }\n}\n\nexport { DOMVisualElement };\n","import { measureViewportBox } from '../../projection/utils/measure.mjs';\nimport { DOMVisualElement } from '../dom/DOMVisualElement.mjs';\nimport { isCSSVariableName } from '../dom/utils/is-css-variable.mjs';\nimport { getDefaultValueType } from '../dom/value-types/defaults.mjs';\nimport { buildHTMLStyles } from './utils/build-styles.mjs';\nimport { transformProps } from './utils/keys-transform.mjs';\nimport { renderHTML } from './utils/render.mjs';\nimport { scrapeMotionValuesFromProps } from './utils/scrape-motion-values.mjs';\n\nfunction getComputedStyle(element) {\n    return window.getComputedStyle(element);\n}\nclass HTMLVisualElement extends DOMVisualElement {\n    constructor() {\n        super(...arguments);\n        this.type = \"html\";\n        this.renderInstance = renderHTML;\n    }\n    readValueFromInstance(instance, key) {\n        if (transformProps.has(key)) {\n            const defaultType = getDefaultValueType(key);\n            return defaultType ? defaultType.default || 0 : 0;\n        }\n        else {\n            const computedStyle = getComputedStyle(instance);\n            const value = (isCSSVariableName(key)\n                ? computedStyle.getPropertyValue(key)\n                : computedStyle[key]) || 0;\n            return typeof value === \"string\" ? value.trim() : value;\n        }\n    }\n    measureInstanceViewportBox(instance, { transformPagePoint }) {\n        return measureViewportBox(instance, transformPagePoint);\n    }\n    build(renderState, latestValues, props) {\n        buildHTMLStyles(renderState, latestValues, props.transformTemplate);\n    }\n    scrapeMotionValuesFromProps(props, prevProps, visualElement) {\n        return scrapeMotionValuesFromProps(props, prevProps, visualElement);\n    }\n}\n\nexport { HTMLVisualElement, getComputedStyle };\n","import { createBox } from '../../projection/geometry/models.mjs';\nimport { DOMVisualElement } from '../dom/DOMVisualElement.mjs';\nimport { camelToDash } from '../dom/utils/camel-to-dash.mjs';\nimport { getDefaultValueType } from '../dom/value-types/defaults.mjs';\nimport { transformProps } from '../html/utils/keys-transform.mjs';\nimport { buildSVGAttrs } from './utils/build-attrs.mjs';\nimport { camelCaseAttributes } from './utils/camel-case-attrs.mjs';\nimport { isSVGTag } from './utils/is-svg-tag.mjs';\nimport { renderSVG } from './utils/render.mjs';\nimport { scrapeMotionValuesFromProps } from './utils/scrape-motion-values.mjs';\n\nclass SVGVisualElement extends DOMVisualElement {\n    constructor() {\n        super(...arguments);\n        this.type = \"svg\";\n        this.isSVGTag = false;\n        this.measureInstanceViewportBox = createBox;\n    }\n    getBaseTargetFromProps(props, key) {\n        return props[key];\n    }\n    readValueFromInstance(instance, key) {\n        if (transformProps.has(key)) {\n            const defaultType = getDefaultValueType(key);\n            return defaultType ? defaultType.default || 0 : 0;\n        }\n        key = !camelCaseAttributes.has(key) ? camelToDash(key) : key;\n        return instance.getAttribute(key);\n    }\n    scrapeMotionValuesFromProps(props, prevProps, visualElement) {\n        return scrapeMotionValuesFromProps(props, prevProps, visualElement);\n    }\n    build(renderState, latestValues, props) {\n        buildSVGAttrs(renderState, latestValues, this.isSVGTag, props.transformTemplate);\n    }\n    renderInstance(instance, renderState, styleProp, projection) {\n        renderSVG(instance, renderState, styleProp, projection);\n    }\n    mount(instance) {\n        this.isSVGTag = isSVGTag(instance.tagName);\n        super.mount(instance);\n    }\n}\n\nexport { SVGVisualElement };\n","import { Fragment } from 'react';\nimport { HTMLVisualElement } from '../html/HTMLVisualElement.mjs';\nimport { SVGVisualElement } from '../svg/SVGVisualElement.mjs';\nimport { isSVGComponent } from './utils/is-svg-component.mjs';\n\nconst createDomVisualElement = (Component, options) => {\n    return isSVGComponent(Component)\n        ? new SVGVisualElement(options)\n        : new HTMLVisualElement(options, {\n            allowProjection: Component !== Fragment,\n        });\n};\n\nexport { createDomVisualElement };\n","import { animations } from '../../motion/features/animations.mjs';\nimport { gestureAnimations } from '../../motion/features/gestures.mjs';\nimport { createDomVisualElement } from './create-visual-element.mjs';\n\n/**\n * @public\n */\nconst domAnimation = {\n    renderer: createDomVisualElement,\n    ...animations,\n    ...gestureAnimations,\n};\n\nexport { domAnimation };\n","import { number } from '../../../value/types/numbers/index.mjs';\nimport { px } from '../../../value/types/numbers/units.mjs';\nimport { transformPropOrder } from '../../html/utils/keys-transform.mjs';\n\nconst isNumOrPxType = (v) => v === number || v === px;\nconst getPosFromMatrix = (matrix, pos) => parseFloat(matrix.split(\", \")[pos]);\nconst getTranslateFromMatrix = (pos2, pos3) => (_bbox, { transform }) => {\n    if (transform === \"none\" || !transform)\n        return 0;\n    const matrix3d = transform.match(/^matrix3d\\((.+)\\)$/u);\n    if (matrix3d) {\n        return getPosFromMatrix(matrix3d[1], pos3);\n    }\n    else {\n        const matrix = transform.match(/^matrix\\((.+)\\)$/u);\n        if (matrix) {\n            return getPosFromMatrix(matrix[1], pos2);\n        }\n        else {\n            return 0;\n        }\n    }\n};\nconst transformKeys = new Set([\"x\", \"y\", \"z\"]);\nconst nonTranslationalTransformKeys = transformPropOrder.filter((key) => !transformKeys.has(key));\nfunction removeNonTranslationalTransform(visualElement) {\n    const removedTransforms = [];\n    nonTranslationalTransformKeys.forEach((key) => {\n        const value = visualElement.getValue(key);\n        if (value !== undefined) {\n            removedTransforms.push([key, value.get()]);\n            value.set(key.startsWith(\"scale\") ? 1 : 0);\n        }\n    });\n    return removedTransforms;\n}\nconst positionalValues = {\n    // Dimensions\n    width: ({ x }, { paddingLeft = \"0\", paddingRight = \"0\" }) => x.max - x.min - parseFloat(paddingLeft) - parseFloat(paddingRight),\n    height: ({ y }, { paddingTop = \"0\", paddingBottom = \"0\" }) => y.max - y.min - parseFloat(paddingTop) - parseFloat(paddingBottom),\n    top: (_bbox, { top }) => parseFloat(top),\n    left: (_bbox, { left }) => parseFloat(left),\n    bottom: ({ y }, { top }) => parseFloat(top) + (y.max - y.min),\n    right: ({ x }, { left }) => parseFloat(left) + (x.max - x.min),\n    // Transform\n    x: getTranslateFromMatrix(4, 13),\n    y: getTranslateFromMatrix(5, 14),\n};\n// Alias translate longform names\npositionalValues.translateX = positionalValues.x;\npositionalValues.translateY = positionalValues.y;\n\nexport { isNumOrPxType, positionalValues, removeNonTranslationalTransform };\n","import { complex } from '../../../value/types/complex/index.mjs';\nimport { filter } from '../../../value/types/complex/filter.mjs';\nimport { getDefaultValueType } from './defaults.mjs';\n\nfunction getAnimatableNone(key, value) {\n    let defaultValueType = getDefaultValueType(key);\n    if (defaultValueType !== filter)\n        defaultValueType = complex;\n    // If value is not recognised as animatable, ie \"none\", create an animatable version origin based on the target\n    return defaultValueType.getAnimatableNone\n        ? defaultValueType.getAnimatableNone(value)\n        : undefined;\n}\n\nexport { getAnimatableNone };\n","import { color } from '../../../value/types/color/index.mjs';\nimport { filter } from '../../../value/types/complex/filter.mjs';\nimport { numberValueTypes } from './number.mjs';\n\n/**\n * A map of default value types for common values\n */\nconst defaultValueTypes = {\n    ...numberValueTypes,\n    // Color props\n    color,\n    backgroundColor: color,\n    outlineColor: color,\n    fill: color,\n    stroke: color,\n    // Border props\n    borderColor: color,\n    borderTopColor: color,\n    borderRightColor: color,\n    borderBottomColor: color,\n    borderLeftColor: color,\n    filter,\n    WebkitFilter: filter,\n};\n/**\n * Gets the default ValueType for the provided value key\n */\nconst getDefaultValueType = (key) => defaultValueTypes[key];\n\nexport { defaultValueTypes, getDefaultValueType };\n","/**\n * ValueType for \"auto\"\n */\nconst auto = {\n    test: (v) => v === \"auto\",\n    parse: (v) => v,\n};\n\nexport { auto };\n","import { number } from '../../../value/types/numbers/index.mjs';\nimport { px, percent, degrees, vw, vh } from '../../../value/types/numbers/units.mjs';\nimport { testValueType } from './test.mjs';\nimport { auto } from './type-auto.mjs';\n\n/**\n * A list of value types commonly used for dimensions\n */\nconst dimensionValueTypes = [number, px, percent, degrees, vw, vh, auto];\n/**\n * Tests a dimensional value against the list of dimension ValueTypes\n */\nconst findDimensionValueType = (v) => dimensionValueTypes.find(testValueType(v));\n\nexport { dimensionValueTypes, findDimensionValueType };\n","/**\n * Tests a provided value against a ValueType\n */\nconst testValueType = (v) => (type) => type.test(v);\n\nexport { testValueType };\n","import { transformPropOrder } from './keys-transform.mjs';\n\nconst positionalKeys = new Set([\n    \"width\",\n    \"height\",\n    \"top\",\n    \"left\",\n    \"right\",\n    \"bottom\",\n    ...transformPropOrder,\n]);\n\nexport { positionalKeys };\n","import { removeNonTranslationalTransform } from '../dom/utils/unit-conversion.mjs';\nimport { frame } from '../../frameloop/frame.mjs';\n\nconst toResolve = new Set();\nlet isScheduled = false;\nlet anyNeedsMeasurement = false;\nfunction measureAllKeyframes() {\n    if (anyNeedsMeasurement) {\n        const resolversToMeasure = Array.from(toResolve).filter((resolver) => resolver.needsMeasurement);\n        const elementsToMeasure = new Set(resolversToMeasure.map((resolver) => resolver.element));\n        const transformsToRestore = new Map();\n        /**\n         * Write pass\n         * If we're measuring elements we want to remove bounding box-changing transforms.\n         */\n        elementsToMeasure.forEach((element) => {\n            const removedTransforms = removeNonTranslationalTransform(element);\n            if (!removedTransforms.length)\n                return;\n            transformsToRestore.set(element, removedTransforms);\n            element.render();\n        });\n        // Read\n        resolversToMeasure.forEach((resolver) => resolver.measureInitialState());\n        // Write\n        elementsToMeasure.forEach((element) => {\n            element.render();\n            const restore = transformsToRestore.get(element);\n            if (restore) {\n                restore.forEach(([key, value]) => {\n                    var _a;\n                    (_a = element.getValue(key)) === null || _a === void 0 ? void 0 : _a.set(value);\n                });\n            }\n        });\n        // Read\n        resolversToMeasure.forEach((resolver) => resolver.measureEndState());\n        // Write\n        resolversToMeasure.forEach((resolver) => {\n            if (resolver.suspendedScrollY !== undefined) {\n                window.scrollTo(0, resolver.suspendedScrollY);\n            }\n        });\n    }\n    anyNeedsMeasurement = false;\n    isScheduled = false;\n    toResolve.forEach((resolver) => resolver.complete());\n    toResolve.clear();\n}\nfunction readAllKeyframes() {\n    toResolve.forEach((resolver) => {\n        resolver.readKeyframes();\n        if (resolver.needsMeasurement) {\n            anyNeedsMeasurement = true;\n        }\n    });\n}\nfunction flushKeyframeResolvers() {\n    readAllKeyframes();\n    measureAllKeyframes();\n}\nclass KeyframeResolver {\n    constructor(unresolvedKeyframes, onComplete, name, motionValue, element, isAsync = false) {\n        /**\n         * Track whether this resolver has completed. Once complete, it never\n         * needs to attempt keyframe resolution again.\n         */\n        this.isComplete = false;\n        /**\n         * Track whether this resolver is async. If it is, it'll be added to the\n         * resolver queue and flushed in the next frame. Resolvers that aren't going\n         * to trigger read/write thrashing don't need to be async.\n         */\n        this.isAsync = false;\n        /**\n         * Track whether this resolver needs to perform a measurement\n         * to resolve its keyframes.\n         */\n        this.needsMeasurement = false;\n        /**\n         * Track whether this resolver is currently scheduled to resolve\n         * to allow it to be cancelled and resumed externally.\n         */\n        this.isScheduled = false;\n        this.unresolvedKeyframes = [...unresolvedKeyframes];\n        this.onComplete = onComplete;\n        this.name = name;\n        this.motionValue = motionValue;\n        this.element = element;\n        this.isAsync = isAsync;\n    }\n    scheduleResolve() {\n        this.isScheduled = true;\n        if (this.isAsync) {\n            toResolve.add(this);\n            if (!isScheduled) {\n                isScheduled = true;\n                frame.read(readAllKeyframes);\n                frame.resolveKeyframes(measureAllKeyframes);\n            }\n        }\n        else {\n            this.readKeyframes();\n            this.complete();\n        }\n    }\n    readKeyframes() {\n        const { unresolvedKeyframes, name, element, motionValue } = this;\n        /**\n         * If a keyframe is null, we hydrate it either by reading it from\n         * the instance, or propagating from previous keyframes.\n         */\n        for (let i = 0; i < unresolvedKeyframes.length; i++) {\n            if (unresolvedKeyframes[i] === null) {\n                /**\n                 * If the first keyframe is null, we need to find its value by sampling the element\n                 */\n                if (i === 0) {\n                    const currentValue = motionValue === null || motionValue === void 0 ? void 0 : motionValue.get();\n                    const finalKeyframe = unresolvedKeyframes[unresolvedKeyframes.length - 1];\n                    if (currentValue !== undefined) {\n                        unresolvedKeyframes[0] = currentValue;\n                    }\n                    else if (element && name) {\n                        const valueAsRead = element.readValue(name, finalKeyframe);\n                        if (valueAsRead !== undefined && valueAsRead !== null) {\n                            unresolvedKeyframes[0] = valueAsRead;\n                        }\n                    }\n                    if (unresolvedKeyframes[0] === undefined) {\n                        unresolvedKeyframes[0] = finalKeyframe;\n                    }\n                    if (motionValue && currentValue === undefined) {\n                        motionValue.set(unresolvedKeyframes[0]);\n                    }\n                }\n                else {\n                    unresolvedKeyframes[i] = unresolvedKeyframes[i - 1];\n                }\n            }\n        }\n    }\n    setFinalKeyframe() { }\n    measureInitialState() { }\n    renderEndStyles() { }\n    measureEndState() { }\n    complete() {\n        this.isComplete = true;\n        this.onComplete(this.unresolvedKeyframes, this.finalKeyframe);\n        toResolve.delete(this);\n    }\n    cancel() {\n        if (!this.isComplete) {\n            this.isScheduled = false;\n            toResolve.delete(this);\n        }\n    }\n    resume() {\n        if (!this.isComplete)\n            this.scheduleResolve();\n    }\n}\n\nexport { KeyframeResolver, flushKeyframeResolvers };\n","function addUniqueItem(arr, item) {\n    if (arr.indexOf(item) === -1)\n        arr.push(item);\n}\nfunction removeItem(arr, item) {\n    const index = arr.indexOf(item);\n    if (index > -1)\n        arr.splice(index, 1);\n}\n// Adapted from array-move\nfunction moveItem([...arr], fromIndex, toIndex) {\n    const startIndex = fromIndex < 0 ? arr.length + fromIndex : fromIndex;\n    if (startIndex >= 0 && startIndex < arr.length) {\n        const endIndex = toIndex < 0 ? arr.length + toIndex : toIndex;\n        const [item] = arr.splice(fromIndex, 1);\n        arr.splice(endIndex, 0, item);\n    }\n    return arr;\n}\n\nexport { addUniqueItem, moveItem, removeItem };\n","/**\n * Check if value is a numerical string, ie a string that is purely a number eg \"100\" or \"-100.1\"\n */\nconst isNumericalString = (v) => /^-?(?:\\d+(?:\\.\\d+)?|\\.\\d+)$/u.test(v);\n\nexport { isNumericalString };\n","/**\n * Check if the value is a zero value string like \"0px\" or \"0%\"\n */\nconst isZeroValueString = (v) => /^0[^.\\s]+$/u.test(v);\n\nexport { isZeroValueString };\n","/*\n  Value in range from progress\n\n  Given a lower limit and an upper limit, we return the value within\n  that range as expressed by progress (usually a number from 0 to 1)\n\n  So progress = 0.5 would change\n\n  from -------- to\n\n  to\n\n  from ---- to\n\n  E.g. from = 10, to = 20, progress = 0.5 => 15\n\n  @param [number]: Lower limit of range\n  @param [number]: Upper limit of range\n  @param [number]: The progress between lower and upper limits expressed 0-1\n  @return [number]: Value as calculated from progress within range (not limited within range)\n*/\nconst mixNumber = (from, to, progress) => {\n    return from + (to - from) * progress;\n};\n\nexport { mixNumber };\n","/**\n * Pipe\n * Compose other transformers to run linearily\n * pipe(min(20), max(40))\n * @param  {...functions} transformers\n * @return {function}\n */\nconst combineFunctions = (a, b) => (v) => b(a(v));\nconst pipe = (...transformers) => transformers.reduce(combineFunctions);\n\nexport { pipe };\n","import { addUniqueItem, removeItem } from './array.mjs';\n\nclass SubscriptionManager {\n    constructor() {\n        this.subscriptions = [];\n    }\n    add(handler) {\n        addUniqueItem(this.subscriptions, handler);\n        return () => removeItem(this.subscriptions, handler);\n    }\n    notify(a, b, c) {\n        const numSubscriptions = this.subscriptions.length;\n        if (!numSubscriptions)\n            return;\n        if (numSubscriptions === 1) {\n            /**\n             * If there's only a single handler we can just call it without invoking a loop.\n             */\n            this.subscriptions[0](a, b, c);\n        }\n        else {\n            for (let i = 0; i < numSubscriptions; i++) {\n                /**\n                 * Check whether the handler exists before firing as it's possible\n                 * the subscriptions were modified during this loop running.\n                 */\n                const handler = this.subscriptions[i];\n                handler && handler(a, b, c);\n            }\n        }\n    }\n    getSize() {\n        return this.subscriptions.length;\n    }\n    clear() {\n        this.subscriptions.length = 0;\n    }\n}\n\nexport { SubscriptionManager };\n","/*\n  Convert velocity into velocity per second\n\n  @param [number]: Unit per frame\n  @param [number]: Frame duration in ms\n*/\nfunction velocityPerSecond(velocity, frameDuration) {\n    return frameDuration ? velocity * (1000 / frameDuration) : 0;\n}\n\nexport { velocityPerSecond };\n","import { time } from '../frameloop/sync-time.mjs';\nimport { SubscriptionManager } from '../utils/subscription-manager.mjs';\nimport { velocityPerSecond } from '../utils/velocity-per-second.mjs';\nimport { warnOnce } from '../utils/warn-once.mjs';\nimport { frame } from '../frameloop/frame.mjs';\n\n/**\n * Maximum time between the value of two frames, beyond which we\n * assume the velocity has since been 0.\n */\nconst MAX_VELOCITY_DELTA = 30;\nconst isFloat = (value) => {\n    return !isNaN(parseFloat(value));\n};\nconst collectMotionValues = {\n    current: undefined,\n};\n/**\n * `MotionValue` is used to track the state and velocity of motion values.\n *\n * @public\n */\nclass MotionValue {\n    /**\n     * @param init - The initiating value\n     * @param config - Optional configuration options\n     *\n     * -  `transformer`: A function to transform incoming values with.\n     *\n     * @internal\n     */\n    constructor(init, options = {}) {\n        /**\n         * This will be replaced by the build step with the latest version number.\n         * When MotionValues are provided to motion components, warn if versions are mixed.\n         */\n        this.version = \"11.18.2\";\n        /**\n         * Tracks whether this value can output a velocity. Currently this is only true\n         * if the value is numerical, but we might be able to widen the scope here and support\n         * other value types.\n         *\n         * @internal\n         */\n        this.canTrackVelocity = null;\n        /**\n         * An object containing a SubscriptionManager for each active event.\n         */\n        this.events = {};\n        this.updateAndNotify = (v, render = true) => {\n            const currentTime = time.now();\n            /**\n             * If we're updating the value during another frame or eventloop\n             * than the previous frame, then the we set the previous frame value\n             * to current.\n             */\n            if (this.updatedAt !== currentTime) {\n                this.setPrevFrameValue();\n            }\n            this.prev = this.current;\n            this.setCurrent(v);\n            // Update update subscribers\n            if (this.current !== this.prev && this.events.change) {\n                this.events.change.notify(this.current);\n            }\n            // Update render subscribers\n            if (render && this.events.renderRequest) {\n                this.events.renderRequest.notify(this.current);\n            }\n        };\n        this.hasAnimated = false;\n        this.setCurrent(init);\n        this.owner = options.owner;\n    }\n    setCurrent(current) {\n        this.current = current;\n        this.updatedAt = time.now();\n        if (this.canTrackVelocity === null && current !== undefined) {\n            this.canTrackVelocity = isFloat(this.current);\n        }\n    }\n    setPrevFrameValue(prevFrameValue = this.current) {\n        this.prevFrameValue = prevFrameValue;\n        this.prevUpdatedAt = this.updatedAt;\n    }\n    /**\n     * Adds a function that will be notified when the `MotionValue` is updated.\n     *\n     * It returns a function that, when called, will cancel the subscription.\n     *\n     * When calling `onChange` inside a React component, it should be wrapped with the\n     * `useEffect` hook. As it returns an unsubscribe function, this should be returned\n     * from the `useEffect` function to ensure you don't add duplicate subscribers..\n     *\n     * ```jsx\n     * export const MyComponent = () => {\n     *   const x = useMotionValue(0)\n     *   const y = useMotionValue(0)\n     *   const opacity = useMotionValue(1)\n     *\n     *   useEffect(() => {\n     *     function updateOpacity() {\n     *       const maxXY = Math.max(x.get(), y.get())\n     *       const newOpacity = transform(maxXY, [0, 100], [1, 0])\n     *       opacity.set(newOpacity)\n     *     }\n     *\n     *     const unsubscribeX = x.on(\"change\", updateOpacity)\n     *     const unsubscribeY = y.on(\"change\", updateOpacity)\n     *\n     *     return () => {\n     *       unsubscribeX()\n     *       unsubscribeY()\n     *     }\n     *   }, [])\n     *\n     *   return <motion.div style={{ x }} />\n     * }\n     * ```\n     *\n     * @param subscriber - A function that receives the latest value.\n     * @returns A function that, when called, will cancel this subscription.\n     *\n     * @deprecated\n     */\n    onChange(subscription) {\n        if (process.env.NODE_ENV !== \"production\") {\n            warnOnce(false, `value.onChange(callback) is deprecated. Switch to value.on(\"change\", callback).`);\n        }\n        return this.on(\"change\", subscription);\n    }\n    on(eventName, callback) {\n        if (!this.events[eventName]) {\n            this.events[eventName] = new SubscriptionManager();\n        }\n        const unsubscribe = this.events[eventName].add(callback);\n        if (eventName === \"change\") {\n            return () => {\n                unsubscribe();\n                /**\n                 * If we have no more change listeners by the start\n                 * of the next frame, stop active animations.\n                 */\n                frame.read(() => {\n                    if (!this.events.change.getSize()) {\n                        this.stop();\n                    }\n                });\n            };\n        }\n        return unsubscribe;\n    }\n    clearListeners() {\n        for (const eventManagers in this.events) {\n            this.events[eventManagers].clear();\n        }\n    }\n    /**\n     * Attaches a passive effect to the `MotionValue`.\n     *\n     * @internal\n     */\n    attach(passiveEffect, stopPassiveEffect) {\n        this.passiveEffect = passiveEffect;\n        this.stopPassiveEffect = stopPassiveEffect;\n    }\n    /**\n     * Sets the state of the `MotionValue`.\n     *\n     * @remarks\n     *\n     * ```jsx\n     * const x = useMotionValue(0)\n     * x.set(10)\n     * ```\n     *\n     * @param latest - Latest value to set.\n     * @param render - Whether to notify render subscribers. Defaults to `true`\n     *\n     * @public\n     */\n    set(v, render = true) {\n        if (!render || !this.passiveEffect) {\n            this.updateAndNotify(v, render);\n        }\n        else {\n            this.passiveEffect(v, this.updateAndNotify);\n        }\n    }\n    setWithVelocity(prev, current, delta) {\n        this.set(current);\n        this.prev = undefined;\n        this.prevFrameValue = prev;\n        this.prevUpdatedAt = this.updatedAt - delta;\n    }\n    /**\n     * Set the state of the `MotionValue`, stopping any active animations,\n     * effects, and resets velocity to `0`.\n     */\n    jump(v, endAnimation = true) {\n        this.updateAndNotify(v);\n        this.prev = v;\n        this.prevUpdatedAt = this.prevFrameValue = undefined;\n        endAnimation && this.stop();\n        if (this.stopPassiveEffect)\n            this.stopPassiveEffect();\n    }\n    /**\n     * Returns the latest state of `MotionValue`\n     *\n     * @returns - The latest state of `MotionValue`\n     *\n     * @public\n     */\n    get() {\n        if (collectMotionValues.current) {\n            collectMotionValues.current.push(this);\n        }\n        return this.current;\n    }\n    /**\n     * @public\n     */\n    getPrevious() {\n        return this.prev;\n    }\n    /**\n     * Returns the latest velocity of `MotionValue`\n     *\n     * @returns - The latest velocity of `MotionValue`. Returns `0` if the state is non-numerical.\n     *\n     * @public\n     */\n    getVelocity() {\n        const currentTime = time.now();\n        if (!this.canTrackVelocity ||\n            this.prevFrameValue === undefined ||\n            currentTime - this.updatedAt > MAX_VELOCITY_DELTA) {\n            return 0;\n        }\n        const delta = Math.min(this.updatedAt - this.prevUpdatedAt, MAX_VELOCITY_DELTA);\n        // Casts because of parseFloat's poor typing\n        return velocityPerSecond(parseFloat(this.current) -\n            parseFloat(this.prevFrameValue), delta);\n    }\n    /**\n     * Registers a new animation to control this `MotionValue`. Only one\n     * animation can drive a `MotionValue` at one time.\n     *\n     * ```jsx\n     * value.start()\n     * ```\n     *\n     * @param animation - A function that starts the provided animation\n     *\n     * @internal\n     */\n    start(startAnimation) {\n        this.stop();\n        return new Promise((resolve) => {\n            this.hasAnimated = true;\n            this.animation = startAnimation(resolve);\n            if (this.events.animationStart) {\n                this.events.animationStart.notify();\n            }\n        }).then(() => {\n            if (this.events.animationComplete) {\n                this.events.animationComplete.notify();\n            }\n            this.clearAnimation();\n        });\n    }\n    /**\n     * Stop the currently active animation.\n     *\n     * @public\n     */\n    stop() {\n        if (this.animation) {\n            this.animation.stop();\n            if (this.events.animationCancel) {\n                this.events.animationCancel.notify();\n            }\n        }\n        this.clearAnimation();\n    }\n    /**\n     * Returns `true` if this value is currently animating.\n     *\n     * @public\n     */\n    isAnimating() {\n        return !!this.animation;\n    }\n    clearAnimation() {\n        delete this.animation;\n    }\n    /**\n     * Destroy and clean up subscribers to this `MotionValue`.\n     *\n     * The `MotionValue` hooks like `useMotionValue` and `useTransform` automatically\n     * handle the lifecycle of the returned `MotionValue`, so this method is only necessary if you've manually\n     * created a `MotionValue` via the `motionValue` function.\n     *\n     * @public\n     */\n    destroy() {\n        this.clearListeners();\n        this.stop();\n        if (this.stopPassiveEffect) {\n            this.stopPassiveEffect();\n        }\n    }\n}\nfunction motionValue(init, options) {\n    return new MotionValue(init, options);\n}\n\nexport { MotionValue, collectMotionValues, motionValue };\n","import { rgba } from './rgba.mjs';\nimport { isColorString } from './utils.mjs';\n\nfunction parseHex(v) {\n    let r = \"\";\n    let g = \"\";\n    let b = \"\";\n    let a = \"\";\n    // If we have 6 characters, ie #FF0000\n    if (v.length > 5) {\n        r = v.substring(1, 3);\n        g = v.substring(3, 5);\n        b = v.substring(5, 7);\n        a = v.substring(7, 9);\n        // Or we have 3 characters, ie #F00\n    }\n    else {\n        r = v.substring(1, 2);\n        g = v.substring(2, 3);\n        b = v.substring(3, 4);\n        a = v.substring(4, 5);\n        r += r;\n        g += g;\n        b += b;\n        a += a;\n    }\n    return {\n        red: parseInt(r, 16),\n        green: parseInt(g, 16),\n        blue: parseInt(b, 16),\n        alpha: a ? parseInt(a, 16) / 255 : 1,\n    };\n}\nconst hex = {\n    test: /*@__PURE__*/ isColorString(\"#\"),\n    parse: parseHex,\n    transform: rgba.transform,\n};\n\nexport { hex };\n","import { alpha } from '../numbers/index.mjs';\nimport { percent } from '../numbers/units.mjs';\nimport { sanitize } from '../utils/sanitize.mjs';\nimport { isColorString, splitColor } from './utils.mjs';\n\nconst hsla = {\n    test: /*@__PURE__*/ isColorString(\"hsl\", \"hue\"),\n    parse: /*@__PURE__*/ splitColor(\"hue\", \"saturation\", \"lightness\"),\n    transform: ({ hue, saturation, lightness, alpha: alpha$1 = 1 }) => {\n        return (\"hsla(\" +\n            Math.round(hue) +\n            \", \" +\n            percent.transform(sanitize(saturation)) +\n            \", \" +\n            percent.transform(sanitize(lightness)) +\n            \", \" +\n            sanitize(alpha.transform(alpha$1)) +\n            \")\");\n    },\n};\n\nexport { hsla };\n","import { hex } from './hex.mjs';\nimport { hsla } from './hsla.mjs';\nimport { rgba } from './rgba.mjs';\n\nconst color = {\n    test: (v) => rgba.test(v) || hex.test(v) || hsla.test(v),\n    parse: (v) => {\n        if (rgba.test(v)) {\n            return rgba.parse(v);\n        }\n        else if (hsla.test(v)) {\n            return hsla.parse(v);\n        }\n        else {\n            return hex.parse(v);\n        }\n    },\n    transform: (v) => {\n        return typeof v === \"string\"\n            ? v\n            : v.hasOwnProperty(\"red\")\n                ? rgba.transform(v)\n                : hsla.transform(v);\n    },\n};\n\nexport { color };\n","import { clamp } from '../../../utils/clamp.mjs';\nimport { alpha, number } from '../numbers/index.mjs';\nimport { sanitize } from '../utils/sanitize.mjs';\nimport { isColorString, splitColor } from './utils.mjs';\n\nconst clampRgbUnit = (v) => clamp(0, 255, v);\nconst rgbUnit = {\n    ...number,\n    transform: (v) => Math.round(clampRgbUnit(v)),\n};\nconst rgba = {\n    test: /*@__PURE__*/ isColorString(\"rgb\", \"red\"),\n    parse: /*@__PURE__*/ splitColor(\"red\", \"green\", \"blue\"),\n    transform: ({ red, green, blue, alpha: alpha$1 = 1 }) => \"rgba(\" +\n        rgbUnit.transform(red) +\n        \", \" +\n        rgbUnit.transform(green) +\n        \", \" +\n        rgbUnit.transform(blue) +\n        \", \" +\n        sanitize(alpha.transform(alpha$1)) +\n        \")\",\n};\n\nexport { rgbUnit, rgba };\n","function isNullish(v) {\n    return v == null;\n}\n\nexport { isNullish };\n","const singleColorRegex = /^(?:#[\\da-f]{3,8}|(?:rgb|hsl)a?\\((?:-?[\\d.]+%?[,\\s]+){2}-?[\\d.]+%?\\s*(?:[,/]\\s*)?(?:\\b\\d+(?:\\.\\d+)?|\\.\\d+)?%?\\))$/iu;\n\nexport { singleColorRegex };\n","import { floatRegex } from '../utils/float-regex.mjs';\nimport { isNullish } from '../utils/is-nullish.mjs';\nimport { singleColorRegex } from '../utils/single-color-regex.mjs';\n\n/**\n * Returns true if the provided string is a color, ie rgba(0,0,0,0) or #000,\n * but false if a number or multiple colors\n */\nconst isColorString = (type, testProp) => (v) => {\n    return Boolean((typeof v === \"string\" &&\n        singleColorRegex.test(v) &&\n        v.startsWith(type)) ||\n        (testProp &&\n            !isNullish(v) &&\n            Object.prototype.hasOwnProperty.call(v, testProp)));\n};\nconst splitColor = (aName, bName, cName) => (v) => {\n    if (typeof v !== \"string\")\n        return v;\n    const [a, b, c, alpha] = v.match(floatRegex);\n    return {\n        [aName]: parseFloat(a),\n        [bName]: parseFloat(b),\n        [cName]: parseFloat(c),\n        alpha: alpha !== undefined ? parseFloat(alpha) : 1,\n    };\n};\n\nexport { isColorString, splitColor };\n","import { complex } from './index.mjs';\nimport { floatRegex } from '../utils/float-regex.mjs';\n\n/**\n * Properties that should default to 1 or 100%\n */\nconst maxDefaults = new Set([\"brightness\", \"contrast\", \"saturate\", \"opacity\"]);\nfunction applyDefaultFilter(v) {\n    const [name, value] = v.slice(0, -1).split(\"(\");\n    if (name === \"drop-shadow\")\n        return v;\n    const [number] = value.match(floatRegex) || [];\n    if (!number)\n        return v;\n    const unit = value.replace(number, \"\");\n    let defaultValue = maxDefaults.has(name) ? 1 : 0;\n    if (number !== value)\n        defaultValue *= 100;\n    return name + \"(\" + defaultValue + unit + \")\";\n}\nconst functionRegex = /\\b([a-z-]*)\\(.*?\\)/gu;\nconst filter = {\n    ...complex,\n    getAnimatableNone: (v) => {\n        const functions = v.match(functionRegex);\n        return functions ? functions.map(applyDefaultFilter).join(\" \") : v;\n    },\n};\n\nexport { filter };\n","const colorRegex = /(?:#[\\da-f]{3,8}|(?:rgb|hsl)a?\\((?:-?[\\d.]+%?[,\\s]+){2}-?[\\d.]+%?\\s*(?:[,/]\\s*)?(?:\\b\\d+(?:\\.\\d+)?|\\.\\d+)?%?\\))/giu;\n\nexport { colorRegex };\n","import { color } from '../color/index.mjs';\nimport { colorRegex } from '../utils/color-regex.mjs';\nimport { floatRegex } from '../utils/float-regex.mjs';\nimport { sanitize } from '../utils/sanitize.mjs';\n\nfunction test(v) {\n    var _a, _b;\n    return (isNaN(v) &&\n        typeof v === \"string\" &&\n        (((_a = v.match(floatRegex)) === null || _a === void 0 ? void 0 : _a.length) || 0) +\n            (((_b = v.match(colorRegex)) === null || _b === void 0 ? void 0 : _b.length) || 0) >\n            0);\n}\nconst NUMBER_TOKEN = \"number\";\nconst COLOR_TOKEN = \"color\";\nconst VAR_TOKEN = \"var\";\nconst VAR_FUNCTION_TOKEN = \"var(\";\nconst SPLIT_TOKEN = \"${}\";\n// this regex consists of the `singleCssVariableRegex|rgbHSLValueRegex|digitRegex`\nconst complexRegex = /var\\s*\\(\\s*--(?:[\\w-]+\\s*|[\\w-]+\\s*,(?:\\s*[^)(\\s]|\\s*\\((?:[^)(]|\\([^)(]*\\))*\\))+\\s*)\\)|#[\\da-f]{3,8}|(?:rgb|hsl)a?\\((?:-?[\\d.]+%?[,\\s]+){2}-?[\\d.]+%?\\s*(?:[,/]\\s*)?(?:\\b\\d+(?:\\.\\d+)?|\\.\\d+)?%?\\)|-?(?:\\d+(?:\\.\\d+)?|\\.\\d+)/giu;\nfunction analyseComplexValue(value) {\n    const originalValue = value.toString();\n    const values = [];\n    const indexes = {\n        color: [],\n        number: [],\n        var: [],\n    };\n    const types = [];\n    let i = 0;\n    const tokenised = originalValue.replace(complexRegex, (parsedValue) => {\n        if (color.test(parsedValue)) {\n            indexes.color.push(i);\n            types.push(COLOR_TOKEN);\n            values.push(color.parse(parsedValue));\n        }\n        else if (parsedValue.startsWith(VAR_FUNCTION_TOKEN)) {\n            indexes.var.push(i);\n            types.push(VAR_TOKEN);\n            values.push(parsedValue);\n        }\n        else {\n            indexes.number.push(i);\n            types.push(NUMBER_TOKEN);\n            values.push(parseFloat(parsedValue));\n        }\n        ++i;\n        return SPLIT_TOKEN;\n    });\n    const split = tokenised.split(SPLIT_TOKEN);\n    return { values, split, indexes, types };\n}\nfunction parseComplexValue(v) {\n    return analyseComplexValue(v).values;\n}\nfunction createTransformer(source) {\n    const { split, types } = analyseComplexValue(source);\n    const numSections = split.length;\n    return (v) => {\n        let output = \"\";\n        for (let i = 0; i < numSections; i++) {\n            output += split[i];\n            if (v[i] !== undefined) {\n                const type = types[i];\n                if (type === NUMBER_TOKEN) {\n                    output += sanitize(v[i]);\n                }\n                else if (type === COLOR_TOKEN) {\n                    output += color.transform(v[i]);\n                }\n                else {\n                    output += v[i];\n                }\n            }\n        }\n        return output;\n    };\n}\nconst convertNumbersToZero = (v) => typeof v === \"number\" ? 0 : v;\nfunction getAnimatableNone(v) {\n    const parsed = parseComplexValue(v);\n    const transformer = createTransformer(v);\n    return transformer(parsed.map(convertNumbersToZero));\n}\nconst complex = {\n    test,\n    parse: parseComplexValue,\n    createTransformer,\n    getAnimatableNone,\n};\n\nexport { analyseComplexValue, complex };\n","const floatRegex = /-?(?:\\d+(?:\\.\\d+)?|\\.\\d+)/gu;\n\nexport { floatRegex };\n","// If this number is a decimal, make it just five decimal places\n// to avoid exponents\nconst sanitize = (v) => Math.round(v * 100000) / 100000;\n\nexport { sanitize };\n","import { isMotionValue } from '../utils/is-motion-value.mjs';\n\nfunction isWillChangeMotionValue(value) {\n    return Boolean(isMotionValue(value) && value.add);\n}\n\nexport { isWillChangeMotionValue };\n","import { isWillChangeMotionValue } from './is.mjs';\n\nfunction addValueToWillChange(visualElement, key) {\n    const willChange = visualElement.getValue(\"willChange\");\n    /**\n     * It could be that a user has set willChange to a regular MotionValue,\n     * in which case we can't add the value to it.\n     */\n    if (isWillChangeMotionValue(willChange)) {\n        return willChange.add(key);\n    }\n}\n\nexport { addValueToWillChange };\n","import { memo } from 'motion-utils';\n\nconst supportsScrollTimeline = memo(() => window.ScrollTimeline !== undefined);\n\nexport { supportsScrollTimeline };\n","import { supportsScrollTimeline } from '../../utils/supports/scroll-timeline.mjs';\n\nclass BaseGroupPlaybackControls {\n    constructor(animations) {\n        // Bound to accomodate common `return animation.stop` pattern\n        this.stop = () => this.runAll(\"stop\");\n        this.animations = animations.filter(Boolean);\n    }\n    get finished() {\n        // Support for new finished Promise and legacy thennable API\n        return Promise.all(this.animations.map((animation) => \"finished\" in animation ? animation.finished : animation));\n    }\n    /**\n     * TODO: Filter out cancelled or stopped animations before returning\n     */\n    getAll(propName) {\n        return this.animations[0][propName];\n    }\n    setAll(propName, newValue) {\n        for (let i = 0; i < this.animations.length; i++) {\n            this.animations[i][propName] = newValue;\n        }\n    }\n    attachTimeline(timeline, fallback) {\n        const subscriptions = this.animations.map((animation) => {\n            if (supportsScrollTimeline() && animation.attachTimeline) {\n                return animation.attachTimeline(timeline);\n            }\n            else if (typeof fallback === \"function\") {\n                return fallback(animation);\n            }\n        });\n        return () => {\n            subscriptions.forEach((cancel, i) => {\n                cancel && cancel();\n                this.animations[i].stop();\n            });\n        };\n    }\n    get time() {\n        return this.getAll(\"time\");\n    }\n    set time(time) {\n        this.setAll(\"time\", time);\n    }\n    get speed() {\n        return this.getAll(\"speed\");\n    }\n    set speed(speed) {\n        this.setAll(\"speed\", speed);\n    }\n    get startTime() {\n        return this.getAll(\"startTime\");\n    }\n    get duration() {\n        let max = 0;\n        for (let i = 0; i < this.animations.length; i++) {\n            max = Math.max(max, this.animations[i].duration);\n        }\n        return max;\n    }\n    runAll(methodName) {\n        this.animations.forEach((controls) => controls[methodName]());\n    }\n    flatten() {\n        this.runAll(\"flatten\");\n    }\n    play() {\n        this.runAll(\"play\");\n    }\n    pause() {\n        this.runAll(\"pause\");\n    }\n    cancel() {\n        this.runAll(\"cancel\");\n    }\n    complete() {\n        this.runAll(\"complete\");\n    }\n}\n\nexport { BaseGroupPlaybackControls };\n","import { BaseGroupPlaybackControls } from './BaseGroup.mjs';\n\n/**\n * TODO: This is a temporary class to support the legacy\n * thennable API\n */\nclass GroupPlaybackControls extends BaseGroupPlaybackControls {\n    then(onResolve, onReject) {\n        return Promise.all(this.animations).then(onResolve).catch(onReject);\n    }\n}\n\nexport { GroupPlaybackControls };\n","function getValueTransition(transition, key) {\n    return transition\n        ? transition[key] ||\n            transition[\"default\"] ||\n            transition\n        : undefined;\n}\n\nexport { getValueTransition };\n","/**\n * Implement a practical max duration for keyframe generation\n * to prevent infinite loops\n */\nconst maxGeneratorDuration = 20000;\nfunction calcGeneratorDuration(generator) {\n    let duration = 0;\n    const timeStep = 50;\n    let state = generator.next(duration);\n    while (!state.done && duration < maxGeneratorDuration) {\n        duration += timeStep;\n        state = generator.next(duration);\n    }\n    return duration >= maxGeneratorDuration ? Infinity : duration;\n}\n\nexport { calcGeneratorDuration, maxGeneratorDuration };\n","function isGenerator(type) {\n    return typeof type === \"function\";\n}\n\nexport { isGenerator };\n","function attachTimeline(animation, timeline) {\n    animation.timeline = timeline;\n    animation.onfinish = null;\n}\n\nexport { attachTimeline };\n","const isBezierDefinition = (easing) => Array.isArray(easing) && typeof easing[0] === \"number\";\n\nexport { isBezierDefinition };\n","/**\n * Add the ability for test suites to manually set support flags\n * to better test more environments.\n */\nconst supportsFlags = {\n    linearEasing: undefined,\n};\n\nexport { supportsFlags };\n","import { memo } from 'motion-utils';\nimport { supportsFlags } from './flags.mjs';\n\nfunction memoSupports(callback, supportsFlag) {\n    const memoized = memo(callback);\n    return () => { var _a; return (_a = supportsFlags[supportsFlag]) !== null && _a !== void 0 ? _a : memoized(); };\n}\n\nexport { memoSupports };\n","import { memoSupports } from './memo.mjs';\n\nconst supportsLinearEasing = /*@__PURE__*/ memoSupports(() => {\n    try {\n        document\n            .createElement(\"div\")\n            .animate({ opacity: 0 }, { easing: \"linear(0, 1)\" });\n    }\n    catch (e) {\n        return false;\n    }\n    return true;\n}, \"linearEasing\");\n\nexport { supportsLinearEasing };\n","import { progress } from 'motion-utils';\n\nconst generateLinearEasing = (easing, duration, // as milliseconds\nresolution = 10 // as milliseconds\n) => {\n    let points = \"\";\n    const numPoints = Math.max(Math.round(duration / resolution), 2);\n    for (let i = 0; i < numPoints; i++) {\n        points += easing(progress(0, numPoints - 1, i)) + \", \";\n    }\n    return `linear(${points.substring(0, points.length - 2)})`;\n};\n\nexport { generateLinearEasing };\n","import { isBezierDefinition } from '../../../utils/is-bezier-definition.mjs';\nimport { supportsLinearEasing } from '../../../utils/supports/linear-easing.mjs';\nimport { generateLinearEasing } from './linear.mjs';\n\nfunction isWaapiSupportedEasing(easing) {\n    return Boolean((typeof easing === \"function\" && supportsLinearEasing()) ||\n        !easing ||\n        (typeof easing === \"string\" &&\n            (easing in supportedWaapiEasing || supportsLinearEasing())) ||\n        isBezierDefinition(easing) ||\n        (Array.isArray(easing) && easing.every(isWaapiSupportedEasing)));\n}\nconst cubicBezierAsString = ([a, b, c, d]) => `cubic-bezier(${a}, ${b}, ${c}, ${d})`;\nconst supportedWaapiEasing = {\n    linear: \"linear\",\n    ease: \"ease\",\n    easeIn: \"ease-in\",\n    easeOut: \"ease-out\",\n    easeInOut: \"ease-in-out\",\n    circIn: /*@__PURE__*/ cubicBezierAsString([0, 0.65, 0.55, 1]),\n    circOut: /*@__PURE__*/ cubicBezierAsString([0.55, 0, 1, 0.45]),\n    backIn: /*@__PURE__*/ cubicBezierAsString([0.31, 0.01, 0.66, -0.59]),\n    backOut: /*@__PURE__*/ cubicBezierAsString([0.33, 1.53, 0.69, 0.99]),\n};\nfunction mapEasingToNativeEasing(easing, duration) {\n    if (!easing) {\n        return undefined;\n    }\n    else if (typeof easing === \"function\" && supportsLinearEasing()) {\n        return generateLinearEasing(easing, duration);\n    }\n    else if (isBezierDefinition(easing)) {\n        return cubicBezierAsString(easing);\n    }\n    else if (Array.isArray(easing)) {\n        return easing.map((segmentEasing) => mapEasingToNativeEasing(segmentEasing, duration) ||\n            supportedWaapiEasing.easeOut);\n    }\n    else {\n        return supportedWaapiEasing[easing];\n    }\n}\n\nexport { cubicBezierAsString, isWaapiSupportedEasing, mapEasingToNativeEasing, supportedWaapiEasing };\n","const isDragging = {\n    x: false,\n    y: false,\n};\nfunction isDragActive() {\n    return isDragging.x || isDragging.y;\n}\n\nexport { isDragActive, isDragging };\n","function resolveElements(elementOrSelector, scope, selectorCache) {\n    var _a;\n    if (elementOrSelector instanceof Element) {\n        return [elementOrSelector];\n    }\n    else if (typeof elementOrSelector === \"string\") {\n        let root = document;\n        if (scope) {\n            // TODO: Refactor to utils package\n            // invariant(\n            //     Boolean(scope.current),\n            //     \"Scope provided, but no element detected.\"\n            // )\n            root = scope.current;\n        }\n        const elements = (_a = selectorCache === null || selectorCache === void 0 ? void 0 : selectorCache[elementOrSelector]) !== null && _a !== void 0 ? _a : root.querySelectorAll(elementOrSelector);\n        return elements ? Array.from(elements) : [];\n    }\n    return Array.from(elementOrSelector);\n}\n\nexport { resolveElements };\n","import { resolveElements } from '../../utils/resolve-elements.mjs';\n\nfunction setupGesture(elementOrSelector, options) {\n    const elements = resolveElements(elementOrSelector);\n    const gestureAbortController = new AbortController();\n    const eventOptions = {\n        passive: true,\n        ...options,\n        signal: gestureAbortController.signal,\n    };\n    const cancel = () => gestureAbortController.abort();\n    return [elements, eventOptions, cancel];\n}\n\nexport { setupGesture };\n","import { isDragActive } from './drag/state/is-active.mjs';\nimport { setupGesture } from './utils/setup.mjs';\n\n/**\n * Filter out events that are not pointer events, or are triggering\n * while a Motion gesture is active.\n */\nfunction filterEvents(callback) {\n    return (event) => {\n        if (event.pointerType === \"touch\" || isDragActive())\n            return;\n        callback(event);\n    };\n}\n/**\n * Create a hover gesture. hover() is different to .addEventListener(\"pointerenter\")\n * in that it has an easier syntax, filters out polyfilled touch events, interoperates\n * with drag gestures, and automatically removes the \"pointerennd\" event listener when the hover ends.\n *\n * @public\n */\nfunction hover(elementOrSelector, onHoverStart, options = {}) {\n    const [elements, eventOptions, cancel] = setupGesture(elementOrSelector, options);\n    const onPointerEnter = filterEvents((enterEvent) => {\n        const { target } = enterEvent;\n        const onHoverEnd = onHoverStart(enterEvent);\n        if (typeof onHoverEnd !== \"function\" || !target)\n            return;\n        const onPointerLeave = filterEvents((leaveEvent) => {\n            onHoverEnd(leaveEvent);\n            target.removeEventListener(\"pointerleave\", onPointerLeave);\n        });\n        target.addEventListener(\"pointerleave\", onPointerLeave, eventOptions);\n    });\n    elements.forEach((element) => {\n        element.addEventListener(\"pointerenter\", onPointerEnter, eventOptions);\n    });\n    return cancel;\n}\n\nexport { hover };\n","/**\n * Recursively traverse up the tree to check whether the provided child node\n * is the parent or a descendant of it.\n *\n * @param parent - Element to find\n * @param child - Element to test against parent\n */\nconst isNodeOrChild = (parent, child) => {\n    if (!child) {\n        return false;\n    }\n    else if (parent === child) {\n        return true;\n    }\n    else {\n        return isNodeOrChild(parent, child.parentElement);\n    }\n};\n\nexport { isNodeOrChild };\n","const isPrimaryPointer = (event) => {\n    if (event.pointerType === \"mouse\") {\n        return typeof event.button !== \"number\" || event.button <= 0;\n    }\n    else {\n        /**\n         * isPrimary is true for all mice buttons, whereas every touch point\n         * is regarded as its own input. So subsequent concurrent touch points\n         * will be false.\n         *\n         * Specifically match against false here as incomplete versions of\n         * PointerEvents in very old browser might have it set as undefined.\n         */\n        return event.isPrimary !== false;\n    }\n};\n\nexport { isPrimaryPointer };\n","const focusableElements = new Set([\n    \"BUTTON\",\n    \"INPUT\",\n    \"SELECT\",\n    \"TEXTAREA\",\n    \"A\",\n]);\nfunction isElementKeyboardAccessible(element) {\n    return (focusableElements.has(element.tagName) ||\n        element.tabIndex !== -1);\n}\n\nexport { isElementKeyboardAccessible };\n","const isPressing = new WeakSet();\n\nexport { isPressing };\n","import { isPressing } from './state.mjs';\n\n/**\n * Filter out events that are not \"Enter\" keys.\n */\nfunction filterEvents(callback) {\n    return (event) => {\n        if (event.key !== \"Enter\")\n            return;\n        callback(event);\n    };\n}\nfunction firePointerEvent(target, type) {\n    target.dispatchEvent(new PointerEvent(\"pointer\" + type, { isPrimary: true, bubbles: true }));\n}\nconst enableKeyboardPress = (focusEvent, eventOptions) => {\n    const element = focusEvent.currentTarget;\n    if (!element)\n        return;\n    const handleKeydown = filterEvents(() => {\n        if (isPressing.has(element))\n            return;\n        firePointerEvent(element, \"down\");\n        const handleKeyup = filterEvents(() => {\n            firePointerEvent(element, \"up\");\n        });\n        const handleBlur = () => firePointerEvent(element, \"cancel\");\n        element.addEventListener(\"keyup\", handleKeyup, eventOptions);\n        element.addEventListener(\"blur\", handleBlur, eventOptions);\n    });\n    element.addEventListener(\"keydown\", handleKeydown, eventOptions);\n    /**\n     * Add an event listener that fires on blur to remove the keydown events.\n     */\n    element.addEventListener(\"blur\", () => element.removeEventListener(\"keydown\", handleKeydown), eventOptions);\n};\n\nexport { enableKeyboardPress };\n","import { isDragActive } from '../drag/state/is-active.mjs';\nimport { isNodeOrChild } from '../utils/is-node-or-child.mjs';\nimport { isPrimaryPointer } from '../utils/is-primary-pointer.mjs';\nimport { setupGesture } from '../utils/setup.mjs';\nimport { isElementKeyboardAccessible } from './utils/is-keyboard-accessible.mjs';\nimport { enableKeyboardPress } from './utils/keyboard.mjs';\nimport { isPressing } from './utils/state.mjs';\n\n/**\n * Filter out events that are not primary pointer events, or are triggering\n * while a Motion gesture is active.\n */\nfunction isValidPressEvent(event) {\n    return isPrimaryPointer(event) && !isDragActive();\n}\n/**\n * Create a press gesture.\n *\n * Press is different to `\"pointerdown\"`, `\"pointerup\"` in that it\n * automatically filters out secondary pointer events like right\n * click and multitouch.\n *\n * It also adds accessibility support for keyboards, where\n * an element with a press gesture will receive focus and\n *  trigger on Enter `\"keydown\"` and `\"keyup\"` events.\n *\n * This is different to a browser's `\"click\"` event, which does\n * respond to keyboards but only for the `\"click\"` itself, rather\n * than the press start and end/cancel. The element also needs\n * to be focusable for this to work, whereas a press gesture will\n * make an element focusable by default.\n *\n * @public\n */\nfunction press(elementOrSelector, onPressStart, options = {}) {\n    const [elements, eventOptions, cancelEvents] = setupGesture(elementOrSelector, options);\n    const startPress = (startEvent) => {\n        const element = startEvent.currentTarget;\n        if (!isValidPressEvent(startEvent) || isPressing.has(element))\n            return;\n        isPressing.add(element);\n        const onPressEnd = onPressStart(startEvent);\n        const onPointerEnd = (endEvent, success) => {\n            window.removeEventListener(\"pointerup\", onPointerUp);\n            window.removeEventListener(\"pointercancel\", onPointerCancel);\n            if (!isValidPressEvent(endEvent) || !isPressing.has(element)) {\n                return;\n            }\n            isPressing.delete(element);\n            if (typeof onPressEnd === \"function\") {\n                onPressEnd(endEvent, { success });\n            }\n        };\n        const onPointerUp = (upEvent) => {\n            onPointerEnd(upEvent, options.useGlobalTarget ||\n                isNodeOrChild(element, upEvent.target));\n        };\n        const onPointerCancel = (cancelEvent) => {\n            onPointerEnd(cancelEvent, false);\n        };\n        window.addEventListener(\"pointerup\", onPointerUp, eventOptions);\n        window.addEventListener(\"pointercancel\", onPointerCancel, eventOptions);\n    };\n    elements.forEach((element) => {\n        if (!isElementKeyboardAccessible(element) &&\n            element.getAttribute(\"tabindex\") === null) {\n            element.tabIndex = 0;\n        }\n        const target = options.useGlobalTarget ? window : element;\n        target.addEventListener(\"pointerdown\", startPress, eventOptions);\n        element.addEventListener(\"focus\", (event) => enableKeyboardPress(event, eventOptions), eventOptions);\n    });\n    return cancelEvents;\n}\n\nexport { press };\n","import { millisecondsToSeconds, secondsToMilliseconds, noop } from 'motion-utils';\nimport { attachTimeline } from './utils/attach-timeline.mjs';\n\nclass NativeAnimationControls {\n    constructor(animation) {\n        this.animation = animation;\n    }\n    get duration() {\n        var _a, _b, _c;\n        const durationInMs = ((_b = (_a = this.animation) === null || _a === void 0 ? void 0 : _a.effect) === null || _b === void 0 ? void 0 : _b.getComputedTiming().duration) ||\n            ((_c = this.options) === null || _c === void 0 ? void 0 : _c.duration) ||\n            300;\n        return millisecondsToSeconds(Number(durationInMs));\n    }\n    get time() {\n        var _a;\n        if (this.animation) {\n            return millisecondsToSeconds(((_a = this.animation) === null || _a === void 0 ? void 0 : _a.currentTime) || 0);\n        }\n        return 0;\n    }\n    set time(newTime) {\n        if (this.animation) {\n            this.animation.currentTime = secondsToMilliseconds(newTime);\n        }\n    }\n    get speed() {\n        return this.animation ? this.animation.playbackRate : 1;\n    }\n    set speed(newSpeed) {\n        if (this.animation) {\n            this.animation.playbackRate = newSpeed;\n        }\n    }\n    get state() {\n        return this.animation ? this.animation.playState : \"finished\";\n    }\n    get startTime() {\n        return this.animation ? this.animation.startTime : null;\n    }\n    get finished() {\n        return this.animation ? this.animation.finished : Promise.resolve();\n    }\n    play() {\n        this.animation && this.animation.play();\n    }\n    pause() {\n        this.animation && this.animation.pause();\n    }\n    stop() {\n        if (!this.animation ||\n            this.state === \"idle\" ||\n            this.state === \"finished\") {\n            return;\n        }\n        if (this.animation.commitStyles) {\n            this.animation.commitStyles();\n        }\n        this.cancel();\n    }\n    flatten() {\n        var _a;\n        if (!this.animation)\n            return;\n        (_a = this.animation.effect) === null || _a === void 0 ? void 0 : _a.updateTiming({ easing: \"linear\" });\n    }\n    attachTimeline(timeline) {\n        if (this.animation)\n            attachTimeline(this.animation, timeline);\n        return noop;\n    }\n    complete() {\n        this.animation && this.animation.finish();\n    }\n    cancel() {\n        try {\n            this.animation && this.animation.cancel();\n        }\n        catch (e) { }\n    }\n}\n\nexport { NativeAnimationControls };\n","import { millisecondsToSeconds } from 'motion-utils';\nimport { calcGeneratorDuration, maxGeneratorDuration } from './calc-duration.mjs';\n\n/**\n * Create a progress => progress easing function from a generator.\n */\nfunction createGeneratorEasing(options, scale = 100, createGenerator) {\n    const generator = createGenerator({ ...options, keyframes: [0, scale] });\n    const duration = Math.min(calcGeneratorDuration(generator), maxGeneratorDuration);\n    return {\n        type: \"keyframes\",\n        ease: (progress) => {\n            return generator.next(duration * progress).value / scale;\n        },\n        duration: millisecondsToSeconds(duration),\n    };\n}\n\nexport { createGeneratorEasing };\n","import { secondsToMilliseconds } from 'motion-utils';\nimport { supportsLinearEasing } from '../../../utils/supports/linear-easing.mjs';\nimport { createGeneratorEasing } from '../../generators/utils/create-generator-easing.mjs';\nimport { isGenerator } from '../../generators/utils/is-generator.mjs';\nimport { mapEasingToNativeEasing } from './easing.mjs';\n\nconst defaultEasing = \"easeOut\";\nfunction applyGeneratorOptions(options) {\n    var _a;\n    if (isGenerator(options.type)) {\n        const generatorOptions = createGeneratorEasing(options, 100, options.type);\n        options.ease = supportsLinearEasing()\n            ? generatorOptions.ease\n            : defaultEasing;\n        options.duration = secondsToMilliseconds(generatorOptions.duration);\n        options.type = \"keyframes\";\n    }\n    else {\n        options.duration = secondsToMilliseconds((_a = options.duration) !== null && _a !== void 0 ? _a : 0.3);\n        options.ease = options.ease || defaultEasing;\n    }\n}\n// TODO: Reuse for NativeAnimation\nfunction convertMotionOptionsToNative(valueName, keyframes, options) {\n    var _a;\n    const nativeKeyframes = {};\n    const nativeOptions = {\n        fill: \"both\",\n        easing: \"linear\",\n        composite: \"replace\",\n    };\n    nativeOptions.delay = secondsToMilliseconds((_a = options.delay) !== null && _a !== void 0 ? _a : 0);\n    applyGeneratorOptions(options);\n    nativeOptions.duration = options.duration;\n    const { ease, times } = options;\n    if (times)\n        nativeKeyframes.offset = times;\n    nativeKeyframes[valueName] = keyframes;\n    const easing = mapEasingToNativeEasing(ease, options.duration);\n    /**\n     * If this is an easing array, apply to keyframes, not animation as a whole\n     */\n    if (Array.isArray(easing)) {\n        nativeKeyframes.easing = easing;\n    }\n    else {\n        nativeOptions.easing = easing;\n    }\n    return {\n        keyframes: nativeKeyframes,\n        options: nativeOptions,\n    };\n}\n\nexport { applyGeneratorOptions, convertMotionOptionsToNative };\n","import { NativeAnimationControls } from './NativeAnimationControls.mjs';\nimport { convertMotionOptionsToNative } from './utils/convert-options.mjs';\n\nclass PseudoAnimation extends NativeAnimationControls {\n    constructor(target, pseudoElement, valueName, keyframes, options) {\n        const animationOptions = convertMotionOptionsToNative(valueName, keyframes, options);\n        const animation = target.animate(animationOptions.keyframes, {\n            pseudoElement,\n            ...animationOptions.options,\n        });\n        super(animation);\n    }\n}\n\nexport { PseudoAnimation };\n","let pendingRules = {};\nlet style = null;\nconst css = {\n    set: (selector, values) => {\n        pendingRules[selector] = values;\n    },\n    commit: () => {\n        if (!style) {\n            style = document.createElement(\"style\");\n            style.id = \"motion-view\";\n        }\n        let cssText = \"\";\n        for (const selector in pendingRules) {\n            const rule = pendingRules[selector];\n            cssText += `${selector} {\\n`;\n            for (const [property, value] of Object.entries(rule)) {\n                cssText += `  ${property}: ${value};\\n`;\n            }\n            cssText += \"}\\n\";\n        }\n        style.textContent = cssText;\n        document.head.appendChild(style);\n        pendingRules = {};\n    },\n    remove: () => {\n        if (style && style.parentElement) {\n            style.parentElement.removeChild(style);\n        }\n    },\n};\n\nexport { css };\n","import { secondsToMilliseconds } from 'motion-utils';\nimport { BaseGroupPlaybackControls } from '../animation/controls/BaseGroup.mjs';\nimport { getValueTransition } from '../animation/utils/get-value-transition.mjs';\nimport { NativeAnimationControls } from '../animation/waapi/NativeAnimationControls.mjs';\nimport { PseudoAnimation } from '../animation/waapi/PseudoAnimation.mjs';\nimport { applyGeneratorOptions } from '../animation/waapi/utils/convert-options.mjs';\nimport { mapEasingToNativeEasing } from '../animation/waapi/utils/easing.mjs';\nimport { chooseLayerType } from './utils/choose-layer-type.mjs';\nimport { css } from './utils/css.mjs';\nimport { getLayerName } from './utils/get-layer-name.mjs';\nimport { getViewAnimations } from './utils/get-view-animations.mjs';\nimport { hasTarget } from './utils/has-target.mjs';\n\nconst definitionNames = [\"layout\", \"enter\", \"exit\", \"new\", \"old\"];\nfunction startViewAnimation(update, defaultOptions, targets) {\n    if (!document.startViewTransition) {\n        return new Promise(async (resolve) => {\n            await update();\n            resolve(new BaseGroupPlaybackControls([]));\n        });\n    }\n    // TODO: Go over existing targets and ensure they all have ids\n    /**\n     * If we don't have any animations defined for the root target,\n     * remove it from being captured.\n     */\n    if (!hasTarget(\"root\", targets)) {\n        css.set(\":root\", {\n            \"view-transition-name\": \"none\",\n        });\n    }\n    /**\n     * Set the timing curve to linear for all view transition layers.\n     * This gets baked into the keyframes, which can't be changed\n     * without breaking the generated animation.\n     *\n     * This allows us to set easing via updateTiming - which can be changed.\n     */\n    css.set(\"::view-transition-group(*), ::view-transition-old(*), ::view-transition-new(*)\", { \"animation-timing-function\": \"linear !important\" });\n    css.commit(); // Write\n    const transition = document.startViewTransition(async () => {\n        await update();\n        // TODO: Go over new targets and ensure they all have ids\n    });\n    transition.finished.finally(() => {\n        css.remove(); // Write\n    });\n    return new Promise((resolve) => {\n        transition.ready.then(() => {\n            var _a;\n            const generatedViewAnimations = getViewAnimations();\n            const animations = [];\n            /**\n             * Create animations for our definitions\n             */\n            targets.forEach((definition, target) => {\n                // TODO: If target is not \"root\", resolve elements\n                // and iterate over each\n                for (const key of definitionNames) {\n                    if (!definition[key])\n                        continue;\n                    const { keyframes, options } = definition[key];\n                    for (let [valueName, valueKeyframes] of Object.entries(keyframes)) {\n                        if (!valueKeyframes)\n                            continue;\n                        const valueOptions = {\n                            ...getValueTransition(defaultOptions, valueName),\n                            ...getValueTransition(options, valueName),\n                        };\n                        const type = chooseLayerType(key);\n                        /**\n                         * If this is an opacity animation, and keyframes are not an array,\n                         * we need to convert them into an array and set an initial value.\n                         */\n                        if (valueName === \"opacity\" &&\n                            !Array.isArray(valueKeyframes)) {\n                            const initialValue = type === \"new\" ? 0 : 1;\n                            valueKeyframes = [initialValue, valueKeyframes];\n                        }\n                        /**\n                         * Resolve stagger function if provided.\n                         */\n                        if (typeof valueOptions.delay === \"function\") {\n                            valueOptions.delay = valueOptions.delay(0, 1);\n                        }\n                        const animation = new PseudoAnimation(document.documentElement, `::view-transition-${type}(${target})`, valueName, valueKeyframes, valueOptions);\n                        animations.push(animation);\n                    }\n                }\n            });\n            /**\n             * Handle browser generated animations\n             */\n            for (const animation of generatedViewAnimations) {\n                if (animation.playState === \"finished\")\n                    continue;\n                const { effect } = animation;\n                if (!effect || !(effect instanceof KeyframeEffect))\n                    continue;\n                const { pseudoElement } = effect;\n                if (!pseudoElement)\n                    continue;\n                const name = getLayerName(pseudoElement);\n                if (!name)\n                    continue;\n                const targetDefinition = targets.get(name.layer);\n                if (!targetDefinition) {\n                    /**\n                     * If transition name is group then update the timing of the animation\n                     * whereas if it's old or new then we could possibly replace it using\n                     * the above method.\n                     */\n                    const transitionName = name.type === \"group\" ? \"layout\" : \"\";\n                    const animationTransition = {\n                        ...getValueTransition(defaultOptions, transitionName),\n                    };\n                    applyGeneratorOptions(animationTransition);\n                    const easing = mapEasingToNativeEasing(animationTransition.ease, animationTransition.duration);\n                    effect.updateTiming({\n                        delay: secondsToMilliseconds((_a = animationTransition.delay) !== null && _a !== void 0 ? _a : 0),\n                        duration: animationTransition.duration,\n                        easing,\n                    });\n                    animations.push(new NativeAnimationControls(animation));\n                }\n                else if (hasOpacity(targetDefinition, \"enter\") &&\n                    hasOpacity(targetDefinition, \"exit\") &&\n                    effect\n                        .getKeyframes()\n                        .some((keyframe) => keyframe.mixBlendMode)) {\n                    animations.push(new NativeAnimationControls(animation));\n                }\n                else {\n                    animation.cancel();\n                }\n            }\n            resolve(new BaseGroupPlaybackControls(animations));\n        });\n    });\n}\nfunction hasOpacity(target, key) {\n    var _a;\n    return (_a = target === null || target === void 0 ? void 0 : target[key]) === null || _a === void 0 ? void 0 : _a.keyframes.opacity;\n}\n\nexport { startViewAnimation };\n","import { noop } from 'motion-utils';\nimport { startViewAnimation } from './start.mjs';\n\n/**\n * TODO:\n * - Create view transition on next tick\n * - Replace animations with Motion animations\n * - Return GroupAnimation on next tick\n */\nclass ViewTransitionBuilder {\n    constructor(update, options = {}) {\n        this.currentTarget = \"root\";\n        this.targets = new Map();\n        this.notifyReady = noop;\n        this.readyPromise = new Promise((resolve) => {\n            this.notifyReady = resolve;\n        });\n        queueMicrotask(() => {\n            startViewAnimation(update, options, this.targets).then((animation) => this.notifyReady(animation));\n        });\n    }\n    get(selector) {\n        this.currentTarget = selector;\n        return this;\n    }\n    layout(keyframes, options) {\n        this.updateTarget(\"layout\", keyframes, options);\n        return this;\n    }\n    new(keyframes, options) {\n        this.updateTarget(\"new\", keyframes, options);\n        return this;\n    }\n    old(keyframes, options) {\n        this.updateTarget(\"old\", keyframes, options);\n        return this;\n    }\n    enter(keyframes, options) {\n        this.updateTarget(\"enter\", keyframes, options);\n        return this;\n    }\n    exit(keyframes, options) {\n        this.updateTarget(\"exit\", keyframes, options);\n        return this;\n    }\n    crossfade(options) {\n        this.updateTarget(\"enter\", { opacity: 1 }, options);\n        this.updateTarget(\"exit\", { opacity: 0 }, options);\n        return this;\n    }\n    updateTarget(target, keyframes, options = {}) {\n        const { currentTarget, targets } = this;\n        if (!targets.has(currentTarget)) {\n            targets.set(currentTarget, {});\n        }\n        const targetData = targets.get(currentTarget);\n        targetData[target] = { keyframes, options };\n    }\n    then(resolve, reject) {\n        return this.readyPromise.then(resolve, reject);\n    }\n}\nfunction view(update, defaultOptions = {}) {\n    return new ViewTransitionBuilder(update, defaultOptions);\n}\n\nexport { ViewTransitionBuilder, view };\n","import { isDragging } from './is-active.mjs';\n\nfunction setDragLock(axis) {\n    if (axis === \"x\" || axis === \"y\") {\n        if (isDragging[axis]) {\n            return null;\n        }\n        else {\n            isDragging[axis] = true;\n            return () => {\n                isDragging[axis] = false;\n            };\n        }\n    }\n    else {\n        if (isDragging.x || isDragging.y) {\n            return null;\n        }\n        else {\n            isDragging.x = isDragging.y = true;\n            return () => {\n                isDragging.x = isDragging.y = false;\n            };\n        }\n    }\n}\n\nexport { setDragLock };\n","export { GroupPlaybackControls } from './animation/controls/Group.mjs';\nexport { getValueTransition } from './animation/utils/get-value-transition.mjs';\nexport { calcGeneratorDuration, maxGeneratorDuration } from './animation/generators/utils/calc-duration.mjs';\nexport { createGeneratorEasing } from './animation/generators/utils/create-generator-easing.mjs';\nexport { isGenerator } from './animation/generators/utils/is-generator.mjs';\nexport { NativeAnimationControls } from './animation/waapi/NativeAnimationControls.mjs';\nexport { attachTimeline } from './animation/waapi/utils/attach-timeline.mjs';\nexport { cubicBezierAsString, isWaapiSupportedEasing, mapEasingToNativeEasing, supportedWaapiEasing } from './animation/waapi/utils/easing.mjs';\nexport { generateLinearEasing } from './animation/waapi/utils/linear.mjs';\nexport { hover } from './gestures/hover.mjs';\nexport { press } from './gestures/press/index.mjs';\nexport { isBezierDefinition } from './utils/is-bezier-definition.mjs';\nexport { resolveElements } from './utils/resolve-elements.mjs';\nexport { supportsFlags } from './utils/supports/flags.mjs';\nexport { supportsLinearEasing } from './utils/supports/linear-easing.mjs';\nexport { supportsScrollTimeline } from './utils/supports/scroll-timeline.mjs';\nexport { ViewTransitionBuilder, view } from './view/index.mjs';\nexport { isDragActive, isDragging } from './gestures/drag/state/is-active.mjs';\nexport { setDragLock } from './gestures/drag/state/set-active.mjs';\nexport { isNodeOrChild } from './gestures/utils/is-node-or-child.mjs';\nexport { isPrimaryPointer } from './gestures/utils/is-primary-pointer.mjs';\n","import { noop } from './noop.mjs';\n\nlet warning = noop;\nlet invariant = noop;\nif (process.env.NODE_ENV !== \"production\") {\n    warning = (check, message) => {\n        if (!check && typeof console !== \"undefined\") {\n            console.warn(message);\n        }\n    };\n    invariant = (check, message) => {\n        if (!check) {\n            throw new Error(message);\n        }\n    };\n}\n\nexport { invariant, warning };\n","/*#__NO_SIDE_EFFECTS__*/\nfunction memo(callback) {\n    let result;\n    return () => {\n        if (result === undefined)\n            result = callback();\n        return result;\n    };\n}\n\nexport { memo };\n","/*\n  Progress within given range\n\n  Given a lower limit and an upper limit, we return the progress\n  (expressed as a number 0-1) represented by the given value, and\n  limit that progress to within 0-1.\n\n  @param [number]: Lower limit\n  @param [number]: Upper limit\n  @param [number]: Value to find progress within given range\n  @return [number]: Progress of value within range as expressed 0-1\n*/\n/*#__NO_SIDE_EFFECTS__*/\nconst progress = (from, to, value) => {\n    const toFromDifference = to - from;\n    return toFromDifference === 0 ? 1 : (value - from) / toFromDifference;\n};\n\nexport { progress };\n","/**\n * Converts seconds to milliseconds\n *\n * @param seconds - Time in seconds.\n * @return milliseconds - Converted time in milliseconds.\n */\n/*#__NO_SIDE_EFFECTS__*/\nconst secondsToMilliseconds = (seconds) => seconds * 1000;\n/*#__NO_SIDE_EFFECTS__*/\nconst millisecondsToSeconds = (milliseconds) => milliseconds / 1000;\n\nexport { millisecondsToSeconds, secondsToMilliseconds };\n"],"names":["acceleratedValues","Set","instantAnimationState","current","calcBezier","t","a1","a2","cubicBezier","mX1","mY1","mX2","mY2","noop","Z","getTForX","binarySubdivide","x","lowerBound","upperBound","currentX","currentT","i","Math","abs","aX","backOut","backIn","reverse","M","backInOut","mirror","o","anticipate","p","pow","isAnimatable","value","name","Array","isArray","complex","P","test","startsWith","isNotNull","getFinalKeyframe","keyframes","repeat","repeatType","finalKeyframe","resolvedKeyframes","filter","index","length","undefined","BaseAnimation","constructor","autoplay","delay","type","repeatDelay","options","isStopped","hasAttemptedResolve","createdAt","sync_time","X","now","updateFinishedPromise","calcStartTime","resolvedAt","resolved","_resolved","KeyframesResolver","m","onKeyframesResolved","velocity","onComplete","onUpdate","isGenerator","canAnimate","originKeyframe","targetKeyframe","isOriginAnimatable","isTargetAnimatable","errors","K","hasKeyframesChanged","es","xD","resolveFinishedPromise","duration","resolvedAnimation","initPlayback","onPostResolved","then","resolve","reject","currentFinishedPromise","flatten","ease","Promise","hueToRgb","q","mixImmediate","a","b","mixLinearColor","from","to","v","fromExpo","expo","sqrt","colorTypes","hex","$","rgba","hsla","J","getColorType","find","asRGBA","color","Boolean","model","parse","hslaToRgba","hue","saturation","lightness","alpha","red","green","blue","round","mixColor","fromRGBA","toRGBA","blended","number","transform","invisibleValues","mixNumber","getMixer","is_css_variable","mixComplex","mixArray","mixObject","output","numValues","blendValue","map","key","origin","target","template","createTransformer","originStats","V","targetStats","indexes","var","has","values","pipe","z","matchOrder","_a","orderedOrigin","pointers","types","originIndex","originValue","mix","mixer","calcGeneratorVelocity","resolveValue","prevT","max","velocity_per_second","R","springDefaults","stiffness","damping","mass","bounce","visualDuration","restSpeed","granular","default","restDelta","minDuration","maxDuration","minDamping","maxDamping","calcAngularFreq","undampedFreq","dampingRatio","durationKeys","physicsKeys","isSpringType","keys","some","spring","optionsOrVisualDuration","resolveSpring","state","done","isResolvedFromDuration","getSpringOptions","springOptions","root","PI","clamp","u","derived","findSpring","envelope","derivative","time_conversion","w","exponentialDecay","delta","safeMin","exp","e","g","d","approximateRoot","initialGuess","result","isNaN","initialVelocity","initialDelta","undampedAngularFreq","isGranularScale","angularFreq","sin","cos","dampedAngularFreq","freqForT","min","sinh","cosh","generator","calculatedDuration","next","currentVelocity","isBelowVelocityThreshold","isBelowDisplacementThreshold","toString","iI","EO","easing","wk","progress","inertia","power","timeConstant","bounceDamping","bounceStiffness","modifyTarget","timeReachedBoundary","spring$1","isOutOfBounds","nearestBoundary","amplitude","ideal","calcDelta","calcLatest","applyFriction","latest","checkCatchBoundary","hasUpdatedFrame","easeIn","easeOut","easeInOut","isEasingArray","easingLookup","linear","circIn","circ","Z7","circInOut","X7","circOut","Bn","easingDefinitionToFunction","qE","definition","k","x1","y1","x2","y2","keyframeValues","times","easingFunctions","mapTimeToKeyframe","interpolate","input","isClamp","inputLength","isZeroDeltaRange","mixers","createMixers","customMixer","mixerFactory","numMixers","easingFunction","push","interpolator","progressInRange","Y","offset","defaultOffset","arr","fillOffset","remaining","offsetProgress","splice","frameloopDriver","passTimestamp","timestamp","update","start","frameloop_frame","Wi","stop","Pn","frameData","isProcessing","generators","decay","tween","percentToProgress","percent","MainThreadAnimation","holdTime","cancelTime","currentTime","playbackSpeed","pendingPlayState","startTime","resolver","cancel","teardown","onStop","motionValue","element","KeyframeResolver$1","KeyframeResolver","scheduleResolve","Object","assign","keyframes$1","mapPercentToKeyframes","mirroredGenerator","generatorFactory","resolvedDuration","totalDuration","play","pause","tick","sample","speed","timeWithoutDelay","isInDelayPhase","elapsed","frameGenerator","currentIteration","floor","iterationProgress","isAnimationFinished","finish","time","newTime","driver","newSpeed","hasChanged","isScheduled","resume","onPlay","complete","stopDriver","supportsWaapi","memo","hasOwnProperty","call","Element","prototype","unsupportedEasingFunctions","AcceleratedAnimation","DOMKeyframesResolver","s","owner","Vc","hR","pregeneratedAnimation","pregenerateKeyframes","sampleAnimation","pregeneratedKeyframes","animation","startWaapiAnimation","valueName","keyframeOptions","eB","animate","fill","iterations","direction","pendingTimeline","_F","onfinish","set","playbackRate","playState","attachTimeline","timeline","sampleTime","setWithVelocity","supports","HTMLElement","transformTemplate","getProps","accelerated_values","underDampedSpring","criticallyDampedSpring","keyframesTransition","getDefaultTransition","valueKey","keys_transform","G","animateMotionValue","transition","isHandoff","valueTransition","ev","getVelocity","isTransitionDefined","when","_delay","delayChildren","staggerChildren","staggerDirection","shouldSkip","GlobalConfig","c","skipAnimations","get","sP","getOptimisedAppearId","visualElement","props","_data_id_mjs__WEBPACK_IMPORTED_MODULE_0__","acos","_modifiers_reverse_mjs__WEBPACK_IMPORTED_MODULE_0__","_modifiers_mirror_mjs__WEBPACK_IMPORTED_MODULE_1__","mirrorEasing","reverseEasing","addDomEvent","eventName","handler","passive","addEventListener","removeEventListener","extractEventInfo","event","point","pageX","y","pageY","addPointerInfo","motion_dom__WEBPACK_IMPORTED_MODULE_0__","DJ","clearTime","_frame_mjs__WEBPACK_IMPORTED_MODULE_0__","_utils_GlobalConfig_mjs__WEBPACK_IMPORTED_MODULE_1__","useManualTiming","performance","queueMicrotask","Feature","node","isMounted","convertBoundingBoxToBox","top","left","right","bottom","convertBoxToBoundingBox","transformBoxPoints","transformPoint","topLeft","bottomRight","scalePoint","scale","originPoint","applyPointDelta","translate","boxScale","applyAxisDelta","axis","applyBoxDelta","box","applyTreeDeltas","treeScale","treePath","isSharedTransition","treeLength","projectionDelta","style","display","layoutScroll","scroll","transformBox","_utils_has_transform_mjs__WEBPACK_IMPORTED_MODULE_0__","ud","latestValues","translateAxis","distance","transformAxis","axisTranslate","axisScale","axisOrigin","_utils_mix_number_mjs__WEBPACK_IMPORTED_MODULE_1__","scaleX","originX","scaleY","originY","createAxisDelta","createDelta","createAxis","createBox","isIdentityScale","hasScale","hasTransform","has2DTranslate","rotate","rotateX","rotateY","skewX","skewY","is2DTranslate","measureViewportBox","instance","_geometry_conversion_mjs__WEBPACK_IMPORTED_MODULE_0__","i8","d7","getBoundingClientRect","measurePageBox","rootProjectionNode","transformPagePoint","viewportBox","_geometry_delta_apply_mjs__WEBPACK_IMPORTED_MODULE_1__","am","invalidTemplates","splitCSSVariableRegex","unresolvedKeyframes","readKeyframes","keyframe","trim","getVariableValue","depth","token","fallback","parseCSSVariable","match","exec","token1","token2","window","getComputedStyle","getPropertyValue","trimmed","is_numerical_string","parseFloat","resolveNoneKeyframes","keys_position","originType","dimensions","C","targetType","unit_conversion","mP","needsMeasurement","noneKeyframeIndexes","is_zero_value_string","W","makeNoneKeyframesAnimatable","animatableTemplate","noneIndex","animatable_none","T","measureInitialState","suspendedScrollY","pageYOffset","measuredOrigin","lw","measureKeyframe","getValue","jump","measureEndState","finalKeyframeIndex","removedTransforms","forEach","unsetTransformName","unsetTransformValue","shallowCompare","prev","prevLength","resolveVariant","custom","resolve_variants","animateTarget","targetAndTransition","transitionOverride","transitionEnd","animations","animationTypeState","animationState","getState","valueTarget","shouldBlockAnimation","protectedKeys","needsAnimating","shouldBlock","MotionHandoffAnimation","appearId","get_appear_id","add_will_change","motion_value","shouldReduceMotion","all","setTarget","resolve_value","hasValue","addValue","es_value","BX","animateVariant","variant","presenceContext","getAnimation","getChildAnimations","variantChildren","size","forwardDelay","animateChildren","maxStaggerDuration","generateStaggerDuration","sort","sortByTreeOrder","child","notify","first","last","sortNodePosition","numVariantProps","variant_props","reversePriorityOrder","numAnimationTypes","createTypeState","isActive","prevResolvedValues","createState","whileInView","whileHover","whileTap","whileDrag","whileFocus","exit","AnimationFeature","L","createAnimationState","animateVisualElement","resolvedDefinition","isInitialRender","buildResolvedTypeValues","acc","animateChanges","changedActiveType","context","getVariantContext","isControllingVariants","parent","initial","prop","is_variant_label","removedKeys","encounteredKeys","removedVariantIndex","Infinity","typeState","propIsVariant","activeDelta","isInherited","manuallyAnimateOnMount","prevProp","is_animation_controls","H","variantDidChange","shouldAnimateType","handledRemovedValues","definitionList","resolvedValues","reduce","allKeys","markToAnimate","delete","liveStyle","is_keyframes_target","add","blockInitialAnimation","fallbackAnimation","fallbackTarget","getBaseTarget","shouldAnimate","setActive","setAnimateFunction","makeAnimator","reset","updateAnimationControlsSubscription","unmountControls","subscribe","mount","prevAnimate","prevProps","unmount","id","ExitAnimationFeature","arguments","isPresent","onExitComplete","prevIsPresent","prevPresenceContext","exitAnimation","register","handleHoverEvent","lifecycle","callback","postRender","event_info","Q","HoverGesture","Mr","startEvent","endEvent","FocusGesture","onFocus","isFocusVisible","matches","onBlur","add_dom_event","E","handlePressEvent","PressGesture","OD","success","useGlobalTarget","globalTapTarget","observerCallbacks","WeakMap","observers","fireObserverCallback","entry","fireAllObserverCallbacks","entries","thresholdNames","InViewFeature","hasEnteredView","isInView","startObserver","viewport","margin","rootMargin","amount","once","threshold","observeIntersection","rootInteresectionObserver","initIntersectionObserver","lookupRoot","document","rootObservers","JSON","stringify","IntersectionObserver","observe","unobserve","isIntersecting","onViewportEnter","onViewportLeave","hasViewportOptionChanged","prevViewport","prefersReducedMotion","hasReducedMotionListener","valueTypes","findValueType","l","visualElementStore","propEventHandlers","VisualElement","scrapeMotionValuesFromProps","_props","_prevProps","_visualElement","reducedMotionConfig","visualState","children","isVariantNode","Map","features","valueSubscriptions","prevMotionValues","events","propEventSubscriptions","notifyUpdate","render","triggerBuild","renderInstance","renderState","projection","renderScheduledAt","scheduleRender","baseTarget","initialValues","is_controlling_variants","willChange","initialMotionValues","is_motion_value","removeFromVariantTree","addVariantChild","bindToMotionValue","initPrefersReducedMotion","is_browser","j","matchMedia","motionMediaQuery","setReducedMotionPreferences","addListener","remove","clear","feature","removeSyncCheck","valueIsTransform","removeOnChange","on","latestValue","preRender","isTransformDirty","removeOnRenderRequest","MotionCheckAppearSync","other","sortInstanceNodePosition","updateFeatures","definitions","featureDefinitions","featureDefinition","isEnabled","FeatureConstructor","build","measureInstanceViewportBox","models","dO","getStaticValue","setStaticValue","listener","updateMotionValuesFromProps","nextValue","prevValue","existingValue","hasAnimated","removeValue","handleChildMotionValue","getVariant","variants","getTransformPagePoint","getClosestVariantNode","closestVariantNode","unsubscribe","removeValueFromRenderState","defaultValue","readValue","getBaseTargetFromProps","readValueFromInstance","setBaseTarget","valueFromInitial","subscription_manager","args","DOMVisualElement","compareDocumentPosition","vars","childSubscription","textContent","HTMLVisualElement","N","defaultType","defaults","A","computedStyle","f","measure","build_styles","r","scrape_motion_values","U","SVGVisualElement","isSVGTag","camel_to_dash","D","getAttribute","utils_scrape_motion_values","build_attrs","styleProp","utils_render","is_svg_tag","tagName","domAnimation","renderer","Component","is_svg_component","allowProjection","react","Fragment","inView","tap","focus","hover","isNumOrPxType","_value_types_numbers_index_mjs__WEBPACK_IMPORTED_MODULE_0__","Rx","_value_types_numbers_units_mjs__WEBPACK_IMPORTED_MODULE_1__","px","getPosFromMatrix","matrix","pos","split","getTranslateFromMatrix","pos2","pos3","_bbox","matrix3d","transformKeys","nonTranslationalTransformKeys","_html_utils_keys_transform_mjs__WEBPACK_IMPORTED_MODULE_2__","_","removeNonTranslationalTransform","positionalValues","width","paddingLeft","paddingRight","height","paddingTop","paddingBottom","translateX","translateY","getAnimatableNone","defaultValueType","_defaults_mjs__WEBPACK_IMPORTED_MODULE_0__","_value_types_complex_filter_mjs__WEBPACK_IMPORTED_MODULE_1__","h","_value_types_complex_index_mjs__WEBPACK_IMPORTED_MODULE_2__","defaultValueTypes","_number_mjs__WEBPACK_IMPORTED_MODULE_0__","_value_types_color_index_mjs__WEBPACK_IMPORTED_MODULE_1__","backgroundColor","outlineColor","stroke","borderColor","borderTopColor","borderRightColor","borderBottomColor","borderLeftColor","_value_types_complex_filter_mjs__WEBPACK_IMPORTED_MODULE_2__","WebkitFilter","getDefaultValueType","dimensionValueTypes","numbers","units","aQ","RW","vw","vh","findDimensionValueType","testValueType","positionalKeys","_keys_transform_mjs__WEBPACK_IMPORTED_MODULE_0__","toResolve","anyNeedsMeasurement","measureAllKeyframes","resolversToMeasure","elementsToMeasure","transformsToRestore","_dom_utils_unit_conversion_mjs__WEBPACK_IMPORTED_MODULE_0__","Ei","restore","scrollTo","readAllKeyframes","flushKeyframeResolvers","isAsync","isComplete","_frameloop_frame_mjs__WEBPACK_IMPORTED_MODULE_1__","read","resolveKeyframes","currentValue","valueAsRead","setFinalKeyframe","renderEndStyles","addUniqueItem","item","indexOf","removeItem","isNumericalString","isZeroValueString","combineFunctions","transformers","SubscriptionManager","subscriptions","_array_mjs__WEBPACK_IMPORTED_MODULE_0__","y4","cl","numSubscriptions","getSize","velocityPerSecond","frameDuration","isFloat","collectMotionValues","MotionValue","init","version","canTrackVelocity","updateAndNotify","_frameloop_sync_time_mjs__WEBPACK_IMPORTED_MODULE_0__","updatedAt","setPrevFrameValue","setCurrent","change","renderRequest","prevFrameValue","prevUpdatedAt","onChange","subscription","_utils_subscription_manager_mjs__WEBPACK_IMPORTED_MODULE_1__","_frameloop_frame_mjs__WEBPACK_IMPORTED_MODULE_2__","clearListeners","eventManagers","attach","passiveEffect","stopPassiveEffect","endAnimation","getPrevious","_utils_velocity_per_second_mjs__WEBPACK_IMPORTED_MODULE_3__","startAnimation","animationStart","animationComplete","clearAnimation","animationCancel","isAnimating","destroy","_utils_mjs__WEBPACK_IMPORTED_MODULE_0__","substring","parseInt","_rgba_mjs__WEBPACK_IMPORTED_MODULE_1__","alpha$1","_numbers_units_mjs__WEBPACK_IMPORTED_MODULE_1__","_utils_sanitize_mjs__WEBPACK_IMPORTED_MODULE_2__","_numbers_index_mjs__WEBPACK_IMPORTED_MODULE_3__","Fq","_rgba_mjs__WEBPACK_IMPORTED_MODULE_0__","_hex_mjs__WEBPACK_IMPORTED_MODULE_1__","_hsla_mjs__WEBPACK_IMPORTED_MODULE_2__","clampRgbUnit","_utils_clamp_mjs__WEBPACK_IMPORTED_MODULE_0__","rgbUnit","_numbers_index_mjs__WEBPACK_IMPORTED_MODULE_1__","_utils_mjs__WEBPACK_IMPORTED_MODULE_2__","_utils_sanitize_mjs__WEBPACK_IMPORTED_MODULE_3__","singleColorRegex","isColorString","testProp","splitColor","aName","bName","cName","float_regex","maxDefaults","applyDefaultFilter","slice","_utils_float_regex_mjs__WEBPACK_IMPORTED_MODULE_0__","unit","replace","functionRegex","_index_mjs__WEBPACK_IMPORTED_MODULE_1__","functions","join","colorRegex","NUMBER_TOKEN","COLOR_TOKEN","complexRegex","analyseComplexValue","originalValue","tokenised","parsedValue","parseComplexValue","source","numSections","sanitize","convertNumbersToZero","_b","parsed","transformer","floatRegex","addValueToWillChange","easing_mapEasingToNativeEasing","supportsLinearEasing","generateLinearEasing","isBezierDefinition","cubicBezierAsString","segmentEasing","supportedWaapiEasing","supportsScrollTimeline","ScrollTimeline","BaseGroup_BaseGroupPlaybackControls","runAll","finished","getAll","propName","setAll","newValue","methodName","controls","GroupPlaybackControls","onResolve","onReject","catch","get_value_transition_getValueTransition","maxGeneratorDuration","calcGeneratorDuration","supportsFlags","linearEasing","memoSupports","supportsFlag","memoized","createElement","opacity","resolution","points","numPoints","isWaapiSupportedEasing","every","isDragging","setupGesture","elementOrSelector","elements","resolveElements","scope","selectorCache","querySelectorAll","gestureAbortController","AbortController","signal","abort","filterEvents","pointerType","onHoverStart","eventOptions","onPointerEnter","enterEvent","onHoverEnd","onPointerLeave","leaveEvent","isNodeOrChild","parentElement","isPrimaryPointer","button","isPrimary","focusableElements","isPressing","WeakSet","keyboard_filterEvents","firePointerEvent","dispatchEvent","PointerEvent","bubbles","enableKeyboardPress","focusEvent","currentTarget","handleKeydown","handleKeyup","isValidPressEvent","press","onPressStart","cancelEvents","startPress","onPressEnd","onPointerEnd","onPointerUp","onPointerCancel","upEvent","cancelEvent","tabIndex","setDragLock","warning","_noop_mjs__WEBPACK_IMPORTED_MODULE_0__","invariant","toFromDifference","secondsToMilliseconds","seconds","millisecondsToSeconds","milliseconds"],"sourceRoot":""}