{"version":3,"file":"static/chunks/cebd11e7-ac46f9e80810ed46.js","mappings":"uGA+5CAA,EA47GAC,EADAA,aAx1JAC,OAAAC,cAAA,CAAAC,EAAA,aAA6C,CAAEC,MAAA,KAE/C,IAAAC,EAAYC,EAAQ,OACpBC,EAAYD,EAAQ,MACpBE,EAAgBF,EAAQ,OACxBG,EAAsBH,EAAQ,OAC9BI,EAAgBJ,EAAQ,OACxBK,EAAWL,EAAQ,OACnBM,EAAUN,EAAQ,MAElB,SAAAO,EAAAC,CAAA,EAAqC,OAAAA,GAAA,iBAAAA,GAAA,YAAAA,EAAAA,EAAA,CAA4D,QAAAA,CAAA,EAoBjG,IAAAC,EAAAC,SAlBAF,CAAA,EACA,GAAAA,GAAAA,EAAAG,UAAA,QAAAH,EACA,IAAAI,EAAAjB,OAAAkB,MAAA,OAaA,OAZAL,GACAb,OAAAmB,IAAA,CAAAN,GAAAO,OAAA,UAAAC,CAAA,EACA,GAAAA,YAAAA,EAAA,CACA,IAAAC,EAAAtB,OAAAuB,wBAAA,CAAAV,EAAAQ,GACArB,OAAAC,cAAA,CAAAgB,EAAAI,EAAAC,EAAAE,GAAA,CAAAF,EAAA,CACAG,WAAA,GACAD,IAAA,WAAuC,OAAAX,CAAA,CAAAQ,EAAA,CACvC,EACA,CACA,GAEAJ,EAAA,QAAAJ,EACAb,OAAA0B,MAAA,CAAAT,EACA,EAEAX,GACAqB,EAAAf,EAAAN,GACAsB,EAAAhB,EAAAF,GAMAmB,GAAA,KAAwB,IAAPC,GAA2BA,EAAOD,GAAA,CADnD,cAKAE,EAAA,SAAAC,CAAA,EAA8C,OAC9CC,UAAA,SAAAC,CAAA,EAAkC,OAAAF,EAAAG,IAAA,UAAAC,CAAA,EAAwC,QAAAF,CAAA,CAAAE,EAAA,EAAuB,CACjG,CAAC,EACDC,EAAA,CACAC,cAAAP,EAAA,8BACAQ,UAAAR,EAAA,CACA,UACA,OACA,WACA,aACA,WACA,aACA,YACA,cACA,EACAS,KAAAT,EAAA,UACAU,KAAAV,EAAA,yBACAW,MAAAX,EAAA,gBACAY,MAAAZ,EAAA,4CACAa,IAAAb,EAAA,iDACAc,IAAAd,EAAA,CACA,QACA,aACA,oBACA,WACA,EACAe,OAAAf,EAAA,CACA,cACA,kBACA,kBACA,CACA,EACA,SAAAgB,EAAAC,CAAA,EACA,QAAAC,KAAAD,EACA,OAAAA,CAAA,CAAAC,EAAA,GAEAA,8BAAAA,EACAZ,EAAAa,yBAAA,CAAAF,CAAA,CAAAC,EAAA,CAGAZ,CAAA,CAAAY,EAAA,CAAAE,SAAA,CAAAH,CAAA,CAAAC,EAAA,CAGA,CAEA,IAAAG,EAAA9C,EAAA+C,aAAA,EAAwCC,OAAA,KAExCC,EAAAvD,OAAAmB,IAAA,CAAAkB,GACAmB,EAAAD,EAAAE,MAAA,CAkCAC,EAAApD,EAAA+C,aAAA,EACAM,mBAAA,SAAAC,CAAA,EAAuC,OAAAA,CAAA,EACvCC,SAAA,GACAC,cAAA,OACA,GAEAC,EAAAzD,EAAA+C,aAAA,KACA,SAAAW,IACA,OAAA1D,EAAA2D,UAAA,CAAAF,GAAAG,aAAA,CAMA,IAAAC,EAAA7D,EAAA+C,aAAA,OAEAe,EAAA,oBAAAC,SAEAC,EAAAF,EAAA9D,EAAAiE,eAAA,CAAAjE,EAAAkE,SAAA,CAGAC,EAAA,CAA6BC,QAAA,MAC7BC,EAAA,GA2CA,SAAAC,IASA,OALA,GAAAC,WA5CA,GADAF,EAAA,GACAP,GAEA,GAAAU,OAAAC,UAAA,EACA,IAAAC,EAAAF,OAAAC,UAAA,6BACAE,EAAA,WACA,OAAAR,EAAAC,OAAA,CAAAM,EAAAE,OAAA,EAEAF,EAAAG,WAAA,CAAAF,GACAA,GACA,MAEAR,EAAAC,OAAA,IAEA,IAgCAU,EAAAC,MAAA,CAAA/E,EAAAgF,QAAA,CAAAb,EAAAC,OAAA,QAMA,SAAAa,IACA,IAAAC,EAAAZ,IACAd,EAAAxD,EAAA2D,UAAA,CAAAP,GAAAI,aAAA,OACA,UAAAA,IAGA,WAAAA,GAIA0B,EAEA,CAmCA,SAAAC,EAAAC,CAAA,EACA,uBAAAA,GACA1F,OAAA2F,SAAA,CAAAC,cAAA,CAAAC,IAAA,CAAAH,EAAA,UACA,CAmCA,SAAAI,EAAAC,CAAA,EACA,OAAAC,MAAAC,OAAA,CAAAF,EACA,CAIA,SAAAG,EAAAH,CAAA,EACA,uBAAAA,GAAAD,EAAAC,EACA,CAiBA,SAAAI,EAAAjE,CAAA,CAAAkE,CAAA,CAAAC,CAAA,CAAAC,CAAA,CAAAC,CAAA,EACA,IAAAnB,EAwBA,OAvBA,SAAAkB,GAAoCA,CAAAA,EAAA,IACpC,SAAAC,GAAsCA,CAAAA,EAAA,IAItC,mBAAAH,GACAA,CAAAA,EAAAA,EAAAC,MAAAA,EAAAA,EAAAnE,EAAAmE,MAAA,CAAAC,EAAAC,EAAA,EAMA,iBAAAH,GACAA,CAAAA,EAAA,OAAAhB,CAAAA,EAAAlD,EAAAsE,QAAA,GAAApB,KAAA,IAAAA,EAAA,OAAAA,CAAA,CAAAgB,EAAA,EAOA,mBAAAA,GACAA,CAAAA,EAAAA,EAAAC,MAAAA,EAAAA,EAAAnE,EAAAmE,MAAA,CAAAC,EAAAC,EAAA,EAEAH,CACA,CACA,SAAAK,EAAAvC,CAAA,CAAAkC,CAAA,CAAAC,CAAA,EACA,IAxCA3B,EAQAgC,EAgCAxE,EAAAgC,EAAAyC,QAAA,GACA,OAAAR,EAAAjE,EAAAkE,EAAAC,MAAAA,EAAAA,EAAAnE,EAAAmE,MAAA,EAzCA3B,EAAA,GACAR,EAAA0C,YAAA,UAAAzG,CAAA,CAAA8C,CAAA,EAAuD,OAAAyB,CAAA,CAAAzB,EAAA,CAAA9C,EAAAqB,GAAA,KACvDkD,IAMAgC,EAAA,GACAxC,EAAA0C,YAAA,UAAAzG,CAAA,CAAA8C,CAAA,EAAuD,OAAAyD,CAAA,CAAAzD,EAAA,CAAA9C,EAAA0G,WAAA,KACvDH,GAgCA,CACA,SAAAI,EAAA5E,CAAA,EACA,IAAAkD,EACA,gCAAAA,CAAAA,EAAAlD,EAAA6E,OAAA,GAAA3B,KAAA,IAAAA,EAAA,OAAAA,EAAA4B,KAAA,GACAd,EAAAhE,EAAA+E,OAAA,GACAf,EAAAhE,EAAA6E,OAAA,GACAb,EAAAhE,EAAAgF,UAAA,GACAhB,EAAAhE,EAAAiF,SAAA,GACAjB,EAAAhE,EAAAkF,QAAA,GACAlB,EAAAhE,EAAAmF,UAAA,GACAnB,EAAAhE,EAAAM,IAAA,CACA,CACA,SAAA8E,EAAApF,CAAA,EACA,MAAAqF,CAAAA,CAAAT,CAAAA,EAAA5E,IAAAA,EAAAsE,QAAA,CACA,CAmBA,SAAAgB,EAAAC,CAAA,EACA,OAAAzB,MAAAC,OAAA,CAAAwB,GAAAA,EAAAC,IAAA,MAAAD,CACA,CASA,SAAAE,EAAAC,CAAA,EACA,IAAAlC,EAAApF,EAAAuH,MAAA,OAIA,OAHA,OAAAnC,EAAAhB,OAAA,EACAgB,CAAAA,EAAAhB,OAAA,CAAAkD,GAAA,EAEAlC,EAAAhB,OAAA,CAQA,IAAAoD,EAAA,CAKAC,uBAAA,GAKAC,eAAA,EACA,EAEAC,EAAA,EASAC,EAAA5H,EAAA+C,aAAA,KAKA8E,EAAA7H,EAAA+C,aAAA,KA+BA+E,EAAA,SAAAC,CAAA,EAEA,SAAAD,IACA,OAAAC,OAAAA,GAAAA,EAAAC,KAAA,MAAAC,YAAA,KAkBA,OApBAnI,EAAAoI,SAAA,CAAAJ,EAAAC,GAOAD,EAAAzC,SAAA,CAAA8C,uBAAA,YAEA,OADA,KAAAC,WAAA,GACA,IACA,EACAN,EAAAzC,SAAA,CAAAgD,kBAAA,cACAP,EAAAzC,SAAA,CAAA+C,WAAA,YACA,IAAAtD,EAAA,KAAAlD,KAAA,CAAAgC,EAAAkB,EAAAlB,aAAA,CAAAhC,EAAAkD,EAAAlD,KAAA,CACAgC,GACAA,EAAA0E,QAAA,CAAA1G,EACA,EACAkG,EAAAzC,SAAA,CAAAkD,MAAA,YACA,YAAA3G,KAAA,CAAA4G,QAAA,EAEAV,CACA,EAACzG,EAAA,QAAAwB,SAAA,EAWD,SAAA4F,EAAA3D,CAAA,EACA,IAAA4D,EAAA5D,EAAA4D,iBAAA,CAAAC,EAAA7D,EAAA6D,mBAAA,CAAA/F,EAAAkC,EAAAlC,yBAAA,CAAAgG,EAAA9D,EAAA8D,SAAA,CAAAC,EAAA/D,EAAA+D,cAAA,CAAAhG,EAAAiC,EAAAjC,SAAA,QACA6F,GAAAjG,EAAAiG,GAqDA1I,EAAA8I,UAAA,CApDA,SAAAlH,CAAA,CAAAmH,CAAA,EACA,IAlEAjE,EAAAlB,EAAAoF,EACAC,EACAC,EAAAC,EAAAhH,EAAAiH,EAAAC,EACAC,EAqHAL,EACAC,EACAK,EAlLAzE,EAAA6B,EAAAF,EA5JA7E,EAAA+G,EACAa,EACAC,EACAC,GACAC,GACAC,GAgBAhG,GAqBAA,GA4OAsF,IAuDAA,EAAApE,EAAAoE,QAAA,CAEAK,CADAA,EAAA,OAAAN,CAAAA,EAAAjJ,EAAA2D,UAAA,CAAAiE,EAAA,GAAAqB,KAAA,IAAAA,EAAA,OAAAA,EAAAY,EAAA,GACAX,KAAAY,IAAAZ,EACAK,EAAA,IAAAL,EACAA,GA1DAtH,EAAA9B,EAAAiK,QAAA,CAAAjK,EAAAiK,QAAA,IAAgDnI,GAAA,CAAYsH,SAAAA,EAAA,GAO5D,IAAAc,GAAAhK,EAAA2D,UAAA,CAAAP,GACAV,GAAA,KACAuH,IApIAtD,EAAA7B,CAAAA,EAAAoF,SAdAtI,CAAA,CAAAqI,CAAA,EACA,GAAAzD,EAAA5E,GAAA,CACA,IAAA+E,EAAA/E,EAAA+E,OAAA,CAAAF,EAAA7E,EAAA6E,OAAA,CACA,OACAE,QAAAA,CAAA,IAAAA,GAAAf,EAAAe,GACAA,EACAmD,KAAAA,EACArD,QAAAb,EAAAa,GAAAA,EAAAqD,KAAAA,CACA,CACA,CACA,MAAAlI,CAAA,IAAAA,EAAAuI,OAAA,CAAAF,EAAA,EACA,EAuIArI,EApIA5B,EAAA2D,UAAA,CAAAF,KAAAkD,OAAA,CAAAF,EAAA3B,EAAA2B,OAAA,CACAzG,EAAAoK,OAAA,YAAuC,OAAUzD,QAAAA,EAAAF,QAAAA,CAAA,CAAoC,EAAI,CAAAS,EAAAP,GAAAO,EAAAT,GAAA,GA+IzF4D,GAAAL,GAAAzG,QAAA,CAAAuG,KAAAA,EAtGAzC,EAAA,WACA,GAAAG,EAAAE,cAAA,CACA,OAAAC,GAEA,GAsGA2C,GAAAzB,EAAAjH,EAAAoI,GAAAzG,QAAA,EAqBA,MApBA,CAAAyG,GAAAzG,QAAA,EAAAO,IAOAmG,GAAArG,aAAA,EAxTAhC,EAwTA9B,EAAAiK,QAAA,CAAAjK,EAAAiK,QAAA,IAA6GC,IAAApI,GAxT7G+G,EAwT6GA,EAvT7Ga,EAAAxJ,EAAA2D,UAAA,CAAAb,GACA2G,EAAA/F,IACAgG,GAAA1J,EAAA2D,UAAA,CAAAE,GACA8F,GAAA1E,IACA2E,GAAA5J,EAAAuH,MAAA,CAAAuC,KAAAA,GAIAnB,GACAA,CAAAA,EAAAa,EAAAe,QAAA,EACA,CAAAX,GAAAxF,OAAA,EAAAuE,GACAiB,CAAAA,GAAAxF,OAAA,CAAAuE,EA4SA9F,EA5SA,CACAyH,YA2SAA,GA1SAb,OAAAA,EACA7H,MAAAA,EACA4I,WAAAd,MAAAA,GAAA,OAAAA,GAAAG,EAAA,CACAY,sBAAA,CAAAf,MAAAA,GAAA,OAAAA,GAAA/C,OAAA,OACAgD,mBAAAA,EACA,EAAS,EAET/F,GAAAgG,GAAAxF,OAAA,CACAJ,EAAA,WACAJ,MAAAA,IAAAA,GAAA8G,UAAA,EACA,GACA1K,EAAAkE,SAAA,YACA,IAAAY,CACA,QAAAA,CAAAA,EAAAlB,MAAAA,GAAA,OAAAA,GAAA+G,cAAA,GAAA7F,KAAA,IAAAA,GAAAA,EAAA8F,cAAA,EACA,GACA5G,EAAA,WAA4C,kBAAqB,OAAAJ,MAAAA,GAAA,OAAAA,GAAAiH,aAAA,KAAwG,IACzKjH,IAsLAkB,EAqGAlD,EArGAgC,EAqGAqG,GAAArG,aAAA,CArGAoF,EAqGApG,GACAb,EAAAa,yBAAA,CApGAsG,EAAApE,EAAAoE,QAAA,CAAAC,EAAArE,EAAAqE,MAAA,CAAAhH,EAAA2C,EAAA3C,IAAA,CAAAiH,EAAAtE,EAAAsE,eAAA,CAAAC,EAAAvE,EAAAuE,YAAA,CACAC,EAAAtJ,EAAA2D,UAAA,CAAAkE,GACA,CAAAmB,GACA,CAAApF,GACAA,CAAAA,MAAAA,EAAA,OAAAA,EAAAkH,UAAA,IAGAlH,EAAAkH,UAAA,KAAA9B,EA4FAqB,GA5FAzG,EAAAmH,eAAA,UAAA9B,CAAAA,EAAArF,EAAA6F,MAAA,GAAAR,KAAA,IAAAA,EAAA,OAAAA,EAAA6B,UAAA,EACAlH,EAAAkH,UAAA,CAAAE,UAAA,EACA9B,SAAAA,EACAC,OAAAA,EACA8B,oBAAAhE,CAAAA,CAAA9E,GAAAiH,GAAAjE,EAAAiE,GACAxF,cAAAA,EACAsH,eAAA,WAAsC,OAAAtH,EAAAsH,cAAA,IAQtCC,cAAA,iBAAAhC,EAAAA,EAAA,OACAG,uBAAAA,EACAD,aAAAA,CACA,IAiFA3G,GAAA0I,SAvbAxJ,CAAA,CAAAgC,CAAA,CAAA8E,CAAA,EACA,IAAAhG,EAAA,GACA8G,EAAAxJ,EAAA2D,UAAA,CAAAb,GACA,IAAAc,EACA,WAKA,gBAAArC,GAAAmH,GAAAc,EAAAxG,MAAA,EACA/C,EAAAoL,SAAA,wJAEA,QAAAC,EAAA,EAAoBA,EAAApI,EAAiBoI,IAAA,CACrC,IAAAC,EAAAtI,CAAA,CAAAqI,EAAA,CACAxG,EAAA/C,CAAA,CAAAwJ,EAAA,CAAA5J,EAAAmD,EAAAnD,SAAA,CAAAkB,EAAAiC,EAAAjC,SAAA,CAMAlB,EAAAC,IAAAiB,GACAH,EAAA8I,IAAA,CAAAhL,EAAAiL,aAAA,CAAA5I,EAAA/C,EAAAiK,QAAA,EAAqFpH,IAAA4I,CAAA,EAAa3J,EAAA,CAAWgC,cAAAA,CAAA,IAE7G,CACA,OAAAlB,CACA,EA8ZAd,EAAAqI,GAAArG,aAAA,CAAA8E,IAMAlI,EAAAiL,aAAA,CAAA3D,EAAA,CAAuElE,cAAAqG,GAAArG,aAAA,CAAAhC,MAAA9B,EAAAiK,QAAA,CAAAjK,EAAAiK,QAAA,IAA6EC,IAAApI,EAAA,EACpJc,GACAlC,EAAAiL,aAAA,CAAAhI,EAAAiI,QAAA,EAAqE7L,MAAAoK,EAAA,EAAgBrB,EAAA/F,EAAAjB,EAAAyI,IA7RrFzG,GA6RqFqG,GAAArG,aAAA,CA5RrF5D,EAAA2L,WAAA,UAAAC,CAAA,EACA,IAAA9G,CACA8G,CAAAA,GAAA,QAAA9G,CAAAA,EAAAwF,GAAAuB,KAAA,GAAA/G,KAAA,IAAAA,GAAAA,EAAAS,IAAA,CA0RqF+E,GA1RrFsB,EAAA,EACAhI,IACAgI,CAAAA,EACAhI,GAAAiI,KAAA,CAAAD,GACAhI,GAAAkI,OAAA,IAsRqF/C,IAnRrF,mBAmRqFA,EAlRrFA,EAAA6C,GAEAzG,EAgRqF4D,IA/QrFA,CAAAA,EAAA3E,OAAA,CAAAwH,CAAA,EAGA,EAMA,CAAAhI,GAAA,GAsQqF0G,GAAAN,GAAAzG,QAAA,CAAA0G,GAAArG,aAAA,GACrF,EAEA,CAwBA,SAAAmI,EAAAC,CAAA,EACA,SAAAjG,EAAAlD,CAAA,CAAAoJ,CAAA,EAEA,OADA,SAAAA,GAAsDA,CAAAA,EAAA,IACtDxD,EAAAuD,EAAAnJ,EAAAoJ,GACA,CACA,uBAAAC,MACA,OAAAnG,EAMA,IAAAoG,EAAA,IAAAC,IACA,WAAAF,MAAAnG,EAAA,CAMA7E,IAAA,SAAAmL,CAAA,CAAA1J,CAAA,EAOA,OAHAwJ,EAAAG,GAAA,CAAA3J,IACAwJ,EAAAI,GAAA,CAAA5J,EAAAoD,EAAApD,IAEAwJ,EAAAjL,GAAA,CAAAyB,EACA,CACA,EACA,CAMA,IAAA6J,EAAA,CACA,UACA,SACA,OACA,OACA,UACA,IACA,QACA,OACA,SACA,SACA,OACA,WACA,OACA,UACA,UACA,WACA,OACA,OACA,MACA,SACA,SACA,OACA,QACA,MACA,OACA,CAEA,SAAAC,EAAA5J,CAAA,EACA,GAKA,iBAAAA,GAIAA,EAAA6J,QAAA,YAGA,GAIAF,EAAAG,OAAA,CAAA9J,GAAA,IAIA,QAAA+J,IAAA,CAAA/J,GACA,SAEA,QACA,CAEA,IAAAgK,EAAA,GACA,SAAAC,GAAAC,CAAA,EACArN,OAAAsN,MAAA,CAAAH,EAAAE,EACA,CAMA,IAAAE,GAAA,iBASAC,GAAA,qCASA,SAAAC,GAAAC,CAAA,CAAAC,CAAA,EACA,OAAAH,GAAAP,OAAA,CAAAS,GAAAF,GAAAP,OAAA,CAAAU,EACA,CAVAC,CALA,qCAKAxM,OAAA,UAAAyM,CAAA,EACA,OAAAN,GAAAnM,OAAA,UAAA0M,CAAA,EACA,OAAAN,GAAA1B,IAAA,CAAA+B,EAAAC,EACA,EACA,GAUA,IAAAC,GAAA,IAAAC,IAAAR,IACA,SAAAS,GAAAhL,CAAA,EACA,OAAA8K,GAAAnB,GAAA,CAAA3J,EACA,CAIA,IAAAiL,GAAA,IAAAF,IAAA,iCAKA,SAAAG,GAAAlL,CAAA,CAAAmC,CAAA,EACA,IAAAqE,EAAArE,EAAAqE,MAAA,CAAAD,EAAApE,EAAAoE,QAAA,CACA,OAAAyE,GAAAhL,IALAiL,GAAAtB,GAAA,CAMA3J,IACA,CAAAwG,GAAAD,KAAAY,IAAAZ,CAAA,GACA,GAAA2D,CAAA,CAAAlK,EAAA,EAAAA,YAAAA,CAAA,CACA,CAEA,IAAAmL,GAAA,SAAAjO,CAAA,EACA,MAAAoH,CAAAA,CAAApH,CAAAA,OAAAA,GAAA,iBAAAA,GAAAA,EAAA0G,WAAA,CACA,EAEAwH,GAAA,CACAC,EAAA,aACAC,EAAA,aACAC,EAAA,aACAC,qBAAA,aACA,EAqDA,SAAAC,GAAAzL,CAAA,EACA,OAAAA,EAAA0L,UAAA,MACA,CAWA,IAAAC,GAAAxO,EAAAiK,QAAA,CAAAjK,EAAAiK,QAAA,IAA0C7J,EAAAqO,MAAA,GAA6BC,UAAAC,KAAAC,KAAA,GAEvEC,GAAA,CAEAC,YAAA1O,EAAA2O,EAAA,CACAC,eAAA5O,EAAA2O,EAAA,CACAE,iBAAA7O,EAAA2O,EAAA,CACAG,kBAAA9O,EAAA2O,EAAA,CACAI,gBAAA/O,EAAA2O,EAAA,CACAK,aAAAhP,EAAA2O,EAAA,CACAM,OAAAjP,EAAA2O,EAAA,CACAO,oBAAAlP,EAAA2O,EAAA,CACAQ,qBAAAnP,EAAA2O,EAAA,CACAS,wBAAApP,EAAA2O,EAAA,CACAU,uBAAArP,EAAA2O,EAAA,CAEAW,MAAAtP,EAAA2O,EAAA,CACAY,SAAAvP,EAAA2O,EAAA,CACAa,OAAAxP,EAAA2O,EAAA,CACAc,UAAAzP,EAAA2O,EAAA,CACAe,KAAA1P,EAAA2O,EAAA,CACAgB,IAAA3P,EAAA2O,EAAA,CACAiB,MAAA5P,EAAA2O,EAAA,CACAkB,OAAA7P,EAAA2O,EAAA,CACAmB,KAAA9P,EAAA2O,EAAA,CAEAoB,QAAA/P,EAAA2O,EAAA,CACAqB,WAAAhQ,EAAA2O,EAAA,CACAsB,aAAAjQ,EAAA2O,EAAA,CACAuB,cAAAlQ,EAAA2O,EAAA,CACAwB,YAAAnQ,EAAA2O,EAAA,CACAyB,OAAApQ,EAAA2O,EAAA,CACA0B,UAAArQ,EAAA2O,EAAA,CACA2B,YAAAtQ,EAAA2O,EAAA,CACA4B,aAAAvQ,EAAA2O,EAAA,CACA6B,WAAAxQ,EAAA2O,EAAA,CAEA8B,OAAAzQ,EAAA0Q,OAAA,CACAC,QAAA3Q,EAAA0Q,OAAA,CACAE,QAAA5Q,EAAA0Q,OAAA,CACAG,QAAA7Q,EAAA0Q,OAAA,CACAI,MAAA9Q,EAAA8Q,KAAA,CACAC,OAAA/Q,EAAA8Q,KAAA,CACAE,OAAAhR,EAAA8Q,KAAA,CACAG,OAAAjR,EAAA8Q,KAAA,CACAI,KAAAlR,EAAA0Q,OAAA,CACAS,MAAAnR,EAAA0Q,OAAA,CACAU,MAAApR,EAAA0Q,OAAA,CACAW,SAAArR,EAAA2O,EAAA,CACA2C,WAAAtR,EAAA2O,EAAA,CACA4C,WAAAvR,EAAA2O,EAAA,CACA6C,WAAAxR,EAAA2O,EAAA,CACAb,EAAA9N,EAAA2O,EAAA,CACAZ,EAAA/N,EAAA2O,EAAA,CACAX,EAAAhO,EAAA2O,EAAA,CACA8C,YAAAzR,EAAA2O,EAAA,CACAV,qBAAAjO,EAAA2O,EAAA,CACA+C,QAAA1R,EAAA2R,KAAA,CACAC,QAAA5R,EAAA6R,kBAAA,CACAC,QAAA9R,EAAA6R,kBAAA,CACAE,QAAA/R,EAAA2O,EAAA,CAEAqD,OAAA5D,GAEA6D,YAAAjS,EAAA2R,KAAA,CACAO,cAAAlS,EAAA2R,KAAA,CACAQ,WAAA/D,EACA,EAEA,SAAAgE,GAAAC,CAAA,CAAAC,CAAA,CAAAC,CAAA,CAAAC,CAAA,EAEA,IA3FAzJ,EAAA0J,EAAAC,EA0FA9N,EACA+N,EAAAN,EAAAM,KAAA,CAAAC,EAAAP,EAAAO,IAAA,CAAAtE,EAAA+D,EAAA/D,SAAA,CAAAuE,EAAAR,EAAAQ,aAAA,CAAAC,EAAAT,EAAAS,eAAA,CAIAD,EAAA5P,MAAA,GAEA,IAAA8P,EAAA,GACAC,EAAA,GAEAC,EAAA,GAOA,QAAAxQ,KAAA6P,EAAA,CACA,IAAA3S,EAAA2S,CAAA,CAAA7P,EAAA,CAIA,GAAAyL,GAAAzL,GAAA,CACAmQ,CAAA,CAAAnQ,EAAA,CAAA9C,EACA,QACA,CAEA,IAAAuT,EAAAzE,EAAA,CAAAhM,EAAA,CACA0Q,EAvGAC,GAAA,iBAuGAzT,EAtGAyT,EAAA9E,SAAA,CAsGA3O,GAAAA,EACA,GAAA8N,GAAAhL,GAAA,CAMA,GAJAsQ,EAAA,GACAzE,CAAA,CAAA7L,EAAA,CAAA0Q,EACAN,EAAAvH,IAAA,CAAA7I,GAEA,CAAAwQ,EACA,SAEAtT,IAAA,QAAAiF,CAAAA,EAAAsO,EAAAG,OAAA,GAAAzO,KAAA,IAAAA,EAAAA,EAAA,IACAqO,CAAAA,EAAA,GACA,MApMAvF,GAAAtB,GAAA,CAqMA3J,IACAqQ,CAAA,CAAArQ,EAAA,CAAA0Q,EAEAH,EAAA,IAGAL,CAAA,CAAAlQ,EAAA,CAAA0Q,CAEA,CACAJ,EACAJ,EAAArE,SAAA,CAAAgF,SApLA1O,CAAA,CAAAmE,CAAA,CAAAwK,CAAA,CAAAf,CAAA,EACA,IAAAlE,EAAA1J,EAAA0J,SAAA,CAAAuE,EAAAjO,EAAAiO,aAAA,CACAJ,EAAA1J,EAAAyK,0BAAA,CAAAd,EAAA3J,EAAA0K,kBAAA,CAEAC,EAAA,GAEAb,EAAAc,IAAA,CAAA1G,IAMA,QAHA2G,EAAA,GAEAC,EAAAhB,EAAA5P,MAAA,CACAmI,EAAA,EAAoBA,EAAAyI,EAAsBzI,IAAA,CAC1C,IAAA3I,EAAAoQ,CAAA,CAAAzH,EAAA,CACAsI,GAAA,GAAAI,MAAA,CAAAjG,EAAA,CAAApL,EAAA,EAAAA,EAAA,KAAAqR,MAAA,CAAAxF,CAAA,CAAA7L,EAAA,OACA,MAAAA,GACAmR,CAAAA,EAAA,GACA,CAeA,MAdA,CAAAA,GAhBAnB,CAAAA,KAAA,IAAAA,GAAAA,CAAA,EAiBAiB,GAAA,gBAGAA,EAAAA,EAAAK,IAAA,GAIAvB,EACAkB,EAAAlB,EAAAlE,EAAAiF,EAAA,GAAAG,GAzBAhB,CAAAA,KAAA,IAAAA,GAAAA,CAAA,GA2BAa,GACAG,CAAAA,EAAA,QAEAA,CACA,EAmJArB,EAAAE,EAAAU,EAAAT,GAEAA,EACAG,EAAArE,SAAA,CAAAkE,EAAA,GAA8C,IAE9C,CAAAF,EAAAhE,SAAA,EAAAqE,EAAArE,SAAA,EACAqE,CAAAA,EAAArE,SAAA,SAEA0E,GACAL,CAAAA,EAAAG,eAAA,EAtJA/J,EAAAnE,EAAAgN,OAAA,CAAAa,EAAA7N,EAAAkN,OAAA,CAAAY,EAAA9N,EAAAmN,OAAA,CACA,GAAA+B,MAAA,CADA/K,KAAA,IAAAA,EAAA,MAAAA,EACA,KAAA+K,MAAA,CADArB,KAAA,IAAAA,EAAA,MAAAA,EACA,KAAAqB,MAAA,CADApB,KAAA,IAAAA,EAAA,EAAAA,GAsJA,CAEA,CAEA,IAAAsB,GAAA,WAA0C,OAC1CrB,MAAA,GACArE,UAAA,GACAuE,cAAA,GACAC,gBAAA,GACAF,KAAA,EACA,CAAC,EAED,SAAAqB,GAAAC,CAAA,CAAAC,CAAA,CAAAzS,CAAA,EACA,QAAAe,KAAA0R,EACAvG,GAAAuG,CAAA,CAAA1R,EAAA,GAAAkL,GAAAlL,EAAAf,IACAwS,CAAAA,CAAA,CAAAzR,EAAA,CAAA0R,CAAA,CAAA1R,EAAA,CAGA,CAmDA,IAAA2R,GAAA,IAAA5G,IAAA,CACA,UACA,UACA,OACA,QACA,WACA,aACA,oBACA,kBACA,SACA,UACA,SACA,WACA,mBACA,yBACA,4BACA,kBACA,wBACA,mBACA,sBACA,WACA,cACA,SACA,YACA,2BACA,kBACA,sBACA,OACA,eACA,eACA,kBACA,oBACA,mBACA,SACA,SACA,cACA,eACA,kBACA,iBACA,YACA,QACA,aACA,WACA,oBACA,QACA,aACA,cACA,eACA,aACA,aACA,WACA,aACA,cACA,kBACA,kBACA,WACA,eACA,EASA,SAAA6G,GAAA5R,CAAA,EACA,OAAA2R,GAAAhI,GAAA,CAAA3J,EACA,CAEA,IAAA6R,GAAA,SAAA7R,CAAA,EAAqC,OAAA4R,GAAA5R,EAAA,EACrC,SAAA8R,GAAAC,CAAA,EACAA,GAGAF,CAAAA,GAAA,SAAA7R,CAAA,EACA,OAAAA,EAAA0L,UAAA,QAAAkG,GAAA5R,GAAA+R,EAAA/R,EACA,EACA,CAcA,IAMA8R,GAA4B1U,EAAA,OAAA4U,CAAA,CAC5B,CACA,MAAA7P,EAAA,CAEA,CACA,SAAA8P,GAAAhT,CAAA,CAAAiT,CAAA,CAAAC,CAAA,EACA,IAAAC,EAAA,GACA,QAAApS,KAAAf,EACA4S,CAAAA,GAAA7R,IACAmS,CAAA,IAAAA,GAAAP,GAAA5R,IACA,CAAAkS,GAAA,CAAAN,GAAA5R,IAEAf,EAAA,WAAAe,EAAA0L,UAAA,aACA0G,CAAAA,CAAA,CAAApS,EAAA,CAAAf,CAAA,CAAAe,EAAA,EAGA,OAAAoS,CACA,CAEA,SAAAC,GAAAC,CAAA,CAAAC,CAAA,CAAAtF,CAAA,EACA,uBAAAqF,EACAA,EACA/U,EAAA2O,EAAA,CAAAL,SAAA,CAAA0G,EAAAtF,EAAAqF,EACA,CAWA,IAAAE,GAAA,CACAD,OAAA,oBACAE,MAAA,kBACA,EACAC,GAAA,CACAH,OAAA,mBACAE,MAAA,iBACA,EA4BA,SAAAE,GAAA/C,CAAA,CAAAzN,CAAA,CAAA2N,CAAA,CAAAC,CAAA,EACA,IAzCA6C,EACAC,EAmBAC,EAAAP,EAAAQ,EAQA7U,EAIA8U,EACAC,EAQAC,EAAA/Q,EAAA+Q,KAAA,CAAAC,EAAAhR,EAAAgR,KAAA,CAAAhE,EAAAhN,EAAAgN,OAAA,CAAAE,EAAAlN,EAAAkN,OAAA,CAAA2D,EAAA7Q,EAAA6Q,UAAA,CAAA1M,EAAAnE,EAAA8Q,WAAA,CAAAjD,EAAA7N,EAAAiR,UAAA,CAGAzD,GAAAC,EADAzS,EAAAkW,MAAA,CAAAlR,EAAA,+EACA2N,EAAAC,GACAH,EAAA0D,KAAA,CAAA1D,EAAAM,KAAA,CACAN,EAAAM,KAAA,IACA,IAAAoD,EAAA1D,EAAA0D,KAAA,CAAApD,EAAAN,EAAAM,KAAA,CAAAqD,EAAA3D,EAAA2D,UAAA,CAKAD,EAAAzH,SAAA,GACA0H,GACArD,CAAAA,EAAArE,SAAA,CAAAyH,EAAAzH,SAAA,EACA,OAAAyH,EAAAzH,SAAA,EAGA0H,GACApE,CAAAA,KAAAhI,IAAAgI,GAAAE,KAAAlI,IAAAkI,GAAAa,EAAArE,SAAA,GACAqE,CAAAA,EAAAG,eAAA,EA5DAuC,EAAAP,GA4DAlD,KAAAhI,IAAAgI,EAAAA,EAAA,GA5DAoE,EAAAlI,CAAA,CAAAkI,EAAA1G,KAAA,EACAgG,EAAAR,GA2DAhD,KAAAlI,IAAAkI,EAAAA,EAAA,GA3DAkE,EAAAjI,CAAA,CAAAiI,EAAAxG,MAAA,EACA,GAAAsE,MAAA,CAAAuB,EAAA,KAAAvB,MAAA,CAAAwB,GA0DA,EAGA1L,KAAAA,IAAA+L,GACAI,CAAAA,EAAAjI,CAAA,CAAA6H,CAAA,EACA/L,KAAAA,IAAAgM,GACAG,CAAAA,EAAAhI,CAAA,CAAA6H,CAAA,EAEAhM,KAAAA,IAAA6L,IAhDAD,EAiDA,GAhDA,UADAD,EAqBAxM,KAAA,IAAAA,EAAA,EAAAA,IApB8BwM,CAAAA,EAAA,GAC9B,UAFAP,EAqBAvC,KAAA,IAAAA,EAAA,EAAAA,IAnB6BuC,CAAAA,EAAA,GAC7B,SAAAQ,GAAkCA,CAAAA,EAAA,IAElCO,EAAAN,UAAA,GAKAM,CAAA,CAAApV,CAFAA,EAAA6U,EAAAP,GAAAE,IAEAH,MAAA,EAAAhV,EAAA2O,EAAA,CAAAL,SAAA,EAAA0G,GAEAS,EAAAzV,EAAA2O,EAAA,CAAAL,SAAA,CAqCAmH,GApCAC,EAAA1V,EAAA2O,EAAA,CAAAL,SAAA,CAAAiH,GACAQ,CAAA,CAAApV,EAAAuU,KAAA,KAAApB,MAAA,CAAA2B,EAAA,KAAA3B,MAAA,CAAA4B,GAqCA,CAEA,IAAAO,GAAA,WAAyC,OAAArW,EAAAiK,QAAA,CAAAjK,EAAAiK,QAAA,IAAwCmK,MAAA,CAA8B+B,MAAA,IAAW,EAkC1HG,GAAA,kBAKAC,GAAA,SAAAC,CAAA,EACA,OAAAA,EAAAC,OAAA,CAAAH,GALA,SAKAI,WAAA,EACA,EAEA,SAAAC,GAAAC,CAAA,CAAA5R,CAAA,CAAA6R,CAAA,CAAA7L,CAAA,EACA,IAAA+H,EAAA/N,EAAA+N,KAAA,CAAAC,EAAAhO,EAAAgO,IAAA,CAGA,QAAAnQ,KAFAjD,OAAAsN,MAAA,CAAA0J,EAAA7D,KAAA,CAAAA,EAAA/H,GAAAA,EAAA8L,mBAAA,CAAAD,IAEA7D,EACA4D,EAAA7D,KAAA,CAAAgE,WAAA,CAAAlU,EAAAmQ,CAAA,CAAAnQ,EAAA,CAEA,CAKA,IAAAmU,GAAA,IAAApJ,IAAA,CACA,gBACA,kBACA,eACA,mBACA,aACA,WACA,oBACA,eACA,cACA,aACA,UACA,UACA,eACA,mBACA,mBACA,eACA,cACA,UACA,oBACA,aACA,EAEA,SAAAqJ,GAAAL,CAAA,CAAAM,CAAA,CAAAC,CAAA,CAAAnM,CAAA,EAEA,QAAAnI,KADA8T,GAAAC,EAAAM,EAAAlN,KAAAA,EAAAgB,GACAkM,EAAAf,KAAA,CACAS,EAAAQ,YAAA,IAAA5K,GAAA,CAAA3J,GAAAA,EAAA0T,GAAA1T,GAAAqU,EAAAf,KAAA,CAAAtT,EAAA,CAEA,CAEA,SAAAwU,GAAAvV,CAAA,EACA,IAAAiR,EAAAjR,EAAAiR,KAAA,CACAuE,EAAA,GACA,QAAAzU,KAAAkQ,EACA/E,CAAAA,GAAA+E,CAAA,CAAAlQ,EAAA,GAAAkL,GAAAlL,EAAAf,EAAA,GACAwV,CAAAA,CAAA,CAAAzU,EAAA,CAAAkQ,CAAA,CAAAlQ,EAAA,EAGA,OAAAyU,CACA,CAEA,SAAAC,GAAAzV,CAAA,EACA,IAAAwV,EAAAD,GAAAvV,GACA,QAAAe,KAAAf,EACAkM,GAAAlM,CAAA,CAAAe,EAAA,GAEAyU,CAAAA,CAAA,CADAzU,MAAAA,GAAAA,MAAAA,EAAA,OAAAA,EAAA2U,WAAA,GAAA3U,EACA,CAAAf,CAAA,CAAAe,EAAA,EAGA,OAAAyU,CACA,CAEA,SAAAG,GAAA9R,CAAA,EACA,uBAAAA,GAAA,mBAAAA,EAAAiB,KAAA,CAGA,IAAA8Q,GAAA,SAAA/R,CAAA,EACA,OAAAC,MAAAC,OAAA,CAAAF,EACA,EAKAgS,GAAA,SAAAhS,CAAA,EAEA,OAAA+R,GAAA/R,GAAAA,CAAA,CAAAA,EAAAtC,MAAA,OAAAsC,CACA,EAOA,SAAAiS,GAAA7X,CAAA,EACA,IAAA8X,EAAA7J,GAAAjO,GAAAA,EAAAqB,GAAA,GAAArB,EACA,OAAA+X,GAdA,iBAcAD,GAdAlS,EAAAoS,GAAA,EAAApS,EAAAqS,OAAA,CAeAH,EAAAG,OAAA,GACAH,CACA,CAEA,SAAAI,GAAAjT,CAAA,CAAAlD,CAAA,CAAAqI,CAAA,CAAAP,CAAA,EACA,IAAA2N,EAAAvS,EAAAuS,2BAAA,CAAAW,EAAAlT,EAAAkT,iBAAA,CAAAC,EAAAnT,EAAAmT,OAAA,CACA1F,EAAA,CACAC,aAAA0F,SAmBAtW,CAAA,CAAAqI,CAAA,CAAAP,CAAA,CAAAyO,CAAA,EACA,IAAAC,EAAA,GACA3N,EAAA,CAAAf,MAAAA,EAAA,OAAAA,EAAA/C,OAAA,OACA0R,EAAAF,EAAAvW,GACA,QAAAe,KAAA0V,EACAD,CAAA,CAAAzV,EAAA,CAAA+U,GAAAW,CAAA,CAAA1V,EAAA,EAEA,IAAAgE,EAAA/E,EAAA+E,OAAA,CAAAF,EAAA7E,EAAA6E,OAAA,CACA6R,EAAA9R,EAAA5E,GACA2W,EAAAvR,EAAApF,GACAqI,GACAsO,GACA,CAAAD,GACA1W,CAAA,IAAAA,EAAAuI,OAAA,GACAxD,MAAAA,GAAAA,CAAAA,EAAAsD,EAAAtD,OAAA,EACAF,MAAAA,GAAAA,CAAAA,EAAAwD,EAAAxD,OAAA,GAEA,IAAA+R,EAAA/N,GAAA9D,CAAA,IAAAA,EACA8R,EAAAD,EAAA/R,EAAAE,EA8BA,OA7BA8R,GACA,kBAAAA,GACA,CAAAlB,GAAAkB,IAEAC,CADAhT,MAAAC,OAAA,CAAA8S,GAAAA,EAAA,CAAAA,EAAA,EACA3X,OAAA,UAAAgF,CAAA,EACA,IAAA6S,EAAA9S,EAAAjE,EAAAkE,GACA,GAAA6S,GAEA,IAAAC,EAAAD,EAAAC,aAAA,CAAwDD,EAAAE,UAAA,CAAqB,IAAAzE,EAAAtU,EAAAkW,MAAA,CAAA2C,EAAA,gCAC7E,QAAAhW,KAAAyR,EAAA,CACA,IAAA0E,EAAA1E,CAAA,CAAAzR,EAAA,CACA,GAAA+C,MAAAC,OAAA,CAAAmT,GAAA,CAKA,IAAAC,EAAAP,EACAM,EAAA3V,MAAA,GACA,EACA2V,EAAAA,CAAA,CAAAC,EAAA,CAEA,OAAAD,GACAV,CAAAA,CAAA,CAAAzV,EAAA,CAAAmW,CAAA,CAEA,CACA,QAAAnW,KAAAiW,EACAR,CAAA,CAAAzV,EAAA,CAAAiW,CAAA,CAAAjW,EAAA,CACA,GAEAyV,CACA,EApEAxW,EAAAqI,EAAAP,EAAA2N,GACAL,YAAAgB,GACA,EAIA,OAHAC,GACA1F,CAAAA,EAAA1G,KAAA,UAAAD,CAAA,EAA4C,OAAAqM,EAAArW,EAAAgK,EAAA2G,EAAA,GAE5CA,CACA,CACA,IAAAyG,GAAA,SAAAhP,CAAA,EACA,gBAAApI,CAAA,CAAA2B,CAAA,EACA,IAAA0G,EAAAjK,EAAA2D,UAAA,CAAAF,GACAiG,EAAA1J,EAAA2D,UAAA,CAAAE,GACA,OAAAN,EACAwU,GAAA/N,EAAApI,EAAAqI,EAAAP,GACArC,EAAA,WACA,OAAA0Q,GAAA/N,EAAApI,EAAAqI,EAAAP,EACA,EACA,CACA,EAoDAuP,GAAA,CACApQ,eAAAmQ,GAAA,CACA3B,4BAAAA,GACAW,kBAAA7B,GACA8B,QAAA,SAAArW,CAAA,CAAAgK,CAAA,CAAA9G,CAAA,EACA,IAAAkS,EAAAlS,EAAAkS,WAAA,CAAAxE,EAAA1N,EAAA0N,YAAA,CACA,IACAwE,EAAAd,UAAA,CACA,mBAAAtK,EAAAsN,OAAA,CAEAtN,EAAAsN,OAAA,GACAtN,EAAAuN,qBAAA,EACA,CACA,MAAA5Y,EAAA,CAEAyW,EAAAd,UAAA,EACAlI,EAAA,EACAC,EAAA,EACAuB,MAAA,EACAE,OAAA,CACA,CACA,CACA4F,GAAA0B,EAAAxE,EAAA,CAAuDkB,2BAAA,IAAmC9R,EAAA8Q,iBAAA,EAC1FqE,GAAAnL,EAAAoL,EACA,CACA,EACA,EAEAoC,GAAA,CACAvQ,eAAAmQ,GAAA,CACA3B,4BAAAF,GACAa,kBAAA9D,EACA,EACA,EAEA,SAAAmF,GAAAxW,CAAA,CAAAiC,CAAA,CAAA4D,CAAA,CAAAC,CAAA,CAAA/F,CAAA,EACA,IApOAkS,EAoOA7L,EAAAnE,EAAAgQ,kBAAA,CACAwE,EAAA7M,EAAA5J,GACAoW,GACAG,GACA,OAAAtZ,EAAAiK,QAAA,CAAAjK,EAAAiK,QAAA,IAA2CuP,GAAA,CAAiB5Q,kBAAAA,EAAAE,SAAA,EAvO5D,UADAkM,EAoOA7L,KAAA,IAAAA,GAAAA,IAnOyC6L,CAAAA,EAAA,IACzC,SAAAjS,CAAA,CAAAjB,CAAA,CAAAyI,CAAA,CAAAjF,CAAA,CAAAN,CAAA,CAAAvB,CAAA,EACA,IAAAiP,EAAA1N,EAAA0N,YAAA,CAIA+G,EAAAC,CAHA/M,EAAA5J,GAlBA,SAAAjB,CAAA,CAAA0I,CAAA,EACA,IAAAiP,EAAAvZ,EAAAoK,OAAA,YACA,IAAAmI,EAAA4D,KAEA,OADAb,GAAA/C,EAAAjI,EAAA,CAA4CoJ,2BAAA,IAAmC9R,EAAA8Q,iBAAA,EAC/E5S,EAAAiK,QAAA,CAAAjK,EAAAiK,QAAA,IAA+CwI,EAAA0D,KAAA,GAAkBpD,MAAA/S,EAAAiK,QAAA,IAAwBwI,EAAAM,KAAA,GACzF,EAAK,CAAAvI,EAAA,EACL,GAAA1I,EAAAiR,KAAA,EACA,IAAA4G,EAAA,GACAtF,GAAAsF,EAAA7X,EAAAiR,KAAA,CAAAjR,GACA2X,EAAA1G,KAAA,CAAA/S,EAAAiK,QAAA,CAAAjK,EAAAiK,QAAA,IAA4D0P,GAAAF,EAAA1G,KAAA,CAC5D,CACA,OAAA0G,CACA,EAlPA,SAAA3X,CAAA,CAAA0I,CAAA,CAAA/G,CAAA,EAEA,IAbAsP,EAVAH,EAuBAgH,EAAA,GACA7G,GAVAsB,GAJAtB,EAAA,GADAjR,EAAAiR,KAAA,KAeAjR,GATAlC,OAAAsN,MAAA,CAAA6F,GAfAH,EAAA5N,EAAA4N,iBAAA,CACA1S,EAAAoK,OAAA,YACA,IAAAmI,EAAA2B,KACA5B,GAAAC,EAqBAjI,EArBA,CAA8CoJ,2BAAA,CAqB9CnQ,CArB8C,EAAuCmP,GACrF,IAAAI,EAAAP,EAAAO,IAAA,CAAAD,EAAAN,EAAAM,KAAA,CACA,OAAA/S,EAAAiK,QAAA,CAAAjK,EAAAiK,QAAA,IAA+C+I,GAAAD,EAC/C,EAAK,CAkBLvI,EAlBK,IAUL1I,EAAA+X,eAAA,EACA9G,CAAAA,EAAAjR,EAAA+X,eAAA,CAAA9G,EAAA,EAEAA,GAqBA,OAfAjR,EAAAO,IAAA,EAAAP,CAAA,IAAAA,EAAAgY,YAAA,GAEAF,EAAAG,SAAA,IAEAhH,EAAAiH,UAAA,CACAjH,EAAAkH,gBAAA,CACAlH,EAAAmH,kBAAA,CACA,OAEAnH,EAAAoH,WAAA,CACArY,CAAA,IAAAA,EAAAO,IAAA,CACA,OACA,OAAA6R,MAAA,CAAApS,MAAAA,EAAAO,IAAA,WAEAuX,EAAA7G,KAAA,CAAAA,EACA6G,CACA,CAsOA,EACA9X,EAAA4Q,EAAAjP,GACAwR,EAAAH,GAAAhT,EAAA,iBAAAiB,EAAAiS,GACAoF,EAAApa,EAAAiK,QAAA,CAAAjK,EAAAiK,QAAA,CAAAjK,EAAAiK,QAAA,IAA0EgL,GAAAwE,GAAA,CAAkCnU,IAAAA,CAAA,GAI5G,OAHAiF,GACA6P,CAAAA,CAAA,uBAAA7P,CAAA,EAEArK,EAAAyL,aAAA,CAAA5I,EAAAqX,EACA,GA0N4DvR,oBAAAA,EAAA/F,0BAAAA,EAAAC,UAAAA,CAAA,EAC5D,CAaA,SAAAsX,GAAA/F,CAAA,CAAAgG,CAAA,CAAAC,CAAA,CAAA5H,CAAA,EAGA,OAFA,SAAAA,GAA8BA,CAAAA,EAAA,CAAY6H,QAAA,KAC1ClG,EAAAmG,gBAAA,CAAAH,EAAAC,EAAA5H,GACA,WAAyB,OAAA2B,EAAAoG,mBAAA,CAAAJ,EAAAC,EAAA,CACzB,CAsBA,SAAAI,GAAArV,CAAA,CAAAgV,CAAA,CAAAC,CAAA,CAAA5H,CAAA,EACAzS,EAAAkE,SAAA,YACA,IAAAwS,EAAAtR,EAAAhB,OAAA,CACA,GAAAiW,GAAA3D,EACA,OAAAyD,GAAAzD,EAAA0D,EAAAC,EAAA5H,EAEA,EAAK,CAAArN,EAAAgV,EAAAC,EAAA5H,EAAA,CACL,CAsBA,SAAAiI,GAAAC,CAAA,QAEA,oBAAAC,cAAAD,aAAAC,aACA,YAAAD,EAAAE,WAAA,EAEAF,aAAAG,UACA,CAxEAlb,EAAAJ,aAAqB,QAErBA,CADAA,EAQCI,EAAAJ,aAAA,EAA4BI,CAAAA,EAAAJ,aAAqB,MAPlD,kBACAA,EAAA,mBACAA,EAAA,eACAA,EAAA,iBACAA,EAAA,mBACAA,EAAA,qBACAA,EAAA,YAoFA,IAAAub,GAAA,CAAyBC,MAAA,EAAAC,MAAA,GAiBzB,SAAAC,GAAAP,CAAA,CAAAQ,CAAA,MAhBAA,EAGAC,EAMAD,EASA,OADA,SAAAA,GAAgCA,CAAAA,EAAA,QAChC,CACAC,MAAAC,EAtCAC,OAAA,EAoBA,UADAH,EAoBAA,IAnBgCA,CAAAA,EAAA,QAGhC,CACAnN,EAAAoN,CAFAA,EAAAG,EADAD,OAAA,KAAA/a,EAAAib,cAAA,KACAT,GAEA,CAAAI,EAAA,KACAlN,EAAAmN,CAAA,CAAAD,EAAA,QAIA,UADAA,EAYAA,IAXgCA,CAAAA,EAAA,QAChC,CACAnN,EAAAoN,CAAA,CAAAD,EAAA,KACAlN,EAAAmN,CAAA,CAAAD,EAAA,MASA,CACA,CACA,IAAAM,GAAA,SAAApB,CAAA,CAAAqB,CAAA,EACA,SAAAA,GAAiDA,CAAAA,EAAA,IACjD,IAAAC,EAAA,SAAAhB,CAAA,EACA,OAAAN,EAAAM,EAAAO,GAAAP,GACA,EACA,OAAAe,EAvCA,SAAAf,CAAA,EACA,IAAAD,EAAAC,aAAAG,WACA,EAAAJ,GACAA,GAAAC,IAAAA,EAAAiB,MAAA,GAEAC,EAAAlB,EAEA,EAkCAgB,CACA,EAaAG,GAAA,CACAC,YAAA,YACAC,YAAA,YACAC,UAAA,UACAC,cAAA,cACAC,YAAA,YACAC,WAAA,WACAC,aAAA,aACAC,aAAA,YACA,EACAC,GAAA,CACAR,YAAA,aACAC,YAAA,YACAC,UAAA,WACAC,cAAA,aACA,EACA,SAAAM,GAAA1a,CAAA,EACA,GA1BAgC,GAAAU,OAAAA,OAAAiY,aAAA,OA6BA,GA1BA3Y,GAAAU,OAAAA,OAAAkY,YAAA,CA2BA,OAAAH,EAAA,CAAAza,EAAA,MAEA,GA1BAgC,GAAAU,OAAAA,OAAAmY,WAAA,CA2BA,OAAAb,EAAA,CAAAha,EAAA,CAEA,OAAAA,CACA,CACA,SAAA8a,GAAAxI,CAAA,CAAAgG,CAAA,CAAAC,CAAA,CAAA5H,CAAA,EACA,OAAA0H,GAAA/F,EAAAoI,GAAApC,GAAAqB,GAAApB,EAAAD,gBAAAA,GAAA3H,EACA,CACA,SAAAoK,GAAAzX,CAAA,CAAAgV,CAAA,CAAAC,CAAA,CAAA5H,CAAA,EACA,OAAAgI,GAAArV,EAAAoX,GAAApC,GAAAC,GAAAoB,GAAApB,EAAAD,gBAAAA,GAAA3H,EACA,CAEA,SAAAqK,GAAAhb,CAAA,EACA,IAAAib,EAAA,KACA,yBAIA,OAAAA,IACAA,EAAAjb,EAJA,WACAib,EAAA,IACA,EAMA,CACA,CACA,IAAAC,GAAAF,GAAA,kBACAG,GAAAH,GAAA,gBACA,SAAAI,GAAA/a,CAAA,EACA,IAAA4a,EAAA,GACA,GAAA5a,MAAAA,EACA4a,EAAAE,UAEA,GAAA9a,MAAAA,EACA4a,EAAAC,SAEA,CACA,IAAAG,EAAAH,KACAI,EAAAH,IACAE,CAAAA,GAAAC,EACAL,EAAA,WACAI,IACAC,GACA,GAIAD,GACAA,IACAC,GACAA,IAEA,CACA,OAAAL,CACA,CACA,SAAAM,KAGA,IAAAC,EAAAJ,GAAA,UACA,CAAAI,IAEAA,IACA,GACA,CAEA,SAAAC,GAAA3Z,CAAA,CAAA4Z,CAAA,CAAAC,CAAA,EACA,gBAAA9C,CAAA,CAAA+C,CAAA,EACA,IAAA5Y,CACA,EAAA4V,GAAAC,IAAA0C,OAKA,OAAAvY,CAAAA,EAAAlB,EAAA+G,cAAA,GAAA7F,KAAA,IAAAA,GAAAA,EAAA6Y,SAAA,CAAA/d,EAAAJ,aAAA,CAAAoe,KAAA,CAAAJ,GACAC,MAAAA,GAAAA,EAAA9C,EAAA+C,GACA,CACA,CAkBA,IAAAG,GAAA,SAAApU,CAAA,CAAAqU,CAAA,QACA,EAAAA,IAGArU,IAAAqU,GAIAD,GAAApU,EAAAqU,EAAAC,aAAA,EAEA,EAEA,SAAAC,GAAAP,CAAA,EACA,OAAAzd,EAAAkE,SAAA,YAAyC,kBAAqB,OAAAuZ,GAAA,GAAuB,GACrF,CA8DA,IAAAQ,GAAA,IAAAvQ,IACA,SAAAwQ,GAAAC,CAAA,CAAAC,CAAA,CAAA1H,CAAA,EACAyH,GAAAF,GAAA3R,GAAA,CAAA8R,KAEAC,QAAAC,IAAA,CAAAF,GACA1H,GACA2H,QAAAC,IAAA,CAAA5H,GACAuH,GAAAM,GAAA,CAAAH,GACA,CAOA,IAAAI,GAAA,IAAAC,QAMAC,GAAA,IAAAD,QACAE,GAAA,SAAAC,CAAA,EACA,IAAA9Z,CACA,QAAAA,CAAAA,EAAA0Z,GAAAtd,GAAA,CAAA0d,EAAAxK,MAAA,IAAAtP,KAAA,IAAAA,GAAAA,EAAA8Z,EACA,EACAC,GAAA,SAAAC,CAAA,EACAA,EAAAhe,OAAA,CAAA6d,GACA,EA6CAI,GAAA,CACAld,KAAA,EACAmd,IAAA,CACA,EA2EAC,GAAA,SAAAC,CAAA,EAAgD,gBAAAtd,CAAA,EAEhD,OADAsd,EAAAtd,GACA,IACA,GAEAud,GAAA,CACA3c,OAAAyc,GAlGA,SAAAna,CAAA,EACA,IAAAlB,EAAAkB,EAAAlB,aAAA,CAAAwb,EAAAta,EAAAsa,WAAA,CAAAC,EAAAva,EAAAua,eAAA,CAAAC,EAAAxa,EAAAwa,eAAA,CAAArW,EAAAnE,EAAAya,QAAA,CAAAA,EAAAtW,KAAA,IAAAA,EAAA,GAAoMA,EACpMsJ,EAAAvS,EAAAuH,MAAA,EACAiY,eAAA,GACAC,SAAA,EACA,GACAC,EAAAzY,CAAAA,CAAAmY,CAAAA,GAAAC,GAAAC,CAAA,CACAC,CAAAA,EAAAI,IAAA,EAAApN,EAAAnO,OAAA,CAAAob,cAAA,EACAE,CAAAA,EAAA,IAIAE,CAHA,oBAAAC,qBAyDA,SAAAH,CAAA,CAAAnN,CAAA,CAAA3O,CAAA,CAAAkB,CAAA,EACA,IAAAmE,EAAAnE,EAAAgb,QAAA,CAAAA,EAAA7W,KAAA,IAAAA,GAAAA,EACAjJ,EAAAkE,SAAA,YACAwb,GAAAI,IAEA,eAAAve,GACA2c,GAAA,uGAUA6B,sBAAA,WAEAxN,EAAAiN,cAAA,IACA,IAFA1a,EAEAua,EAAAzb,EAAAyC,QAAA,GAAAgZ,eAAA,OACAA,GAAAA,EAAA,MACA,OAAAva,CAAAA,EAAAlB,EAAA+G,cAAA,GAAA7F,KAAA,IAAAA,GAAAA,EAAA6Y,SAAA,CAAA/d,EAAAJ,aAAA,CAAAwgB,MAAA,IACA,GACA,EAAK,CAAAN,EAAA,CACL,EAxEA,SAAAA,CAAA,CAAAnN,CAAA,CAAA3O,CAAA,CAAAkB,CAAA,EACA,IAAAmb,EAAAnb,EAAAmb,IAAA,CAAAC,EAAApb,EAAAwL,MAAA,CAAArH,EAAAnE,EAAAqb,MAAA,CAAAA,EAAAlX,KAAA,IAAAA,EAAA,OAAAA,EAAA0W,EAAA7a,EAAA6a,IAAA,CACA3f,EAAAkE,SAAA,YACA,GAAAwb,GAEA,IAjCAhJ,EAnBAuJ,EAAAxN,EACA2N,EAOAC,EACA1d,EAWA2d,EAgCA7N,EAAA,CACAwN,KAAAA,MAAAA,EAAA,OAAAA,EAAA7b,OAAA,CACA8b,WAAAA,EACAK,UAAA,iBAAAJ,EAAAA,EAAApB,EAAA,CAAAoB,EAAA,EAgCA,OApEAzJ,EAoEA9S,EAAA4c,WAAA,GAvFAP,EAAAnb,EAAAmb,IAAA,CAAAxN,EAAA3S,EAAAkW,MAAA,CAuFAvD,EAvFA,UACA2N,EAAAH,GAAAlc,SAIA2a,GAAApS,GAAA,CAAA8T,IACA1B,GAAAnS,GAAA,CAAA6T,EAAA,IAQAC,CANAA,EAAA3B,GAAAxd,GAAA,CAAAkf,GAMA,CALAzd,EAAA8d,KAAAC,SAAA,CAAAjO,GAKA,EACA4N,CAAAA,CAAA,CAAA1d,EAAA,KAAAkd,qBAAAhB,GAAA/e,EAAAiK,QAAA,EAAiGkW,KAAAA,CAAA,EAAYxN,GAAA,EAK7G6N,EAHAD,CAAA,CAAA1d,EAAA,CAIA6b,GAAAjS,GAAA,CAAAmK,EAoCA,SAAAkI,CAAA,EAEA,IADA9Z,EACA6b,EAAA/B,EAAA+B,cAAA,CAIA,GAAApO,EAAAkN,QAAA,GAAAkB,GAOA,GALApO,EAAAkN,QAAA,CAAAkB,EAKAhB,GAAA,CAAAgB,GAAApO,EAAAiN,cAAA,CACA,OAEAmB,GACApO,CAAAA,EAAAiN,cAAA,KAEA,OAAA1a,CAAAA,EAAAlB,EAAA+G,cAAA,GAAA7F,KAAA,IAAAA,GAAAA,EAAA6Y,SAAA,CAAA/d,EAAAJ,aAAA,CAAAwgB,MAAA,CAAAW,GAKA,IAAA/e,EAAAgC,EAAAyC,QAAA,GACAoX,EAAAkD,EACA/e,EAAAyd,eAAA,CACAzd,EAAA0d,eAAA,OACA7B,GAAAA,EAAAmB,GACA,GAhEA0B,EAAAM,OAAA,CAAAlK,GACA,WACA8H,GAAAqC,MAAA,CAAAnK,GACA4J,EAAAQ,SAAA,CAAApK,EACA,EA8DA,EAAK,CAAAgJ,EAAAO,EAAAC,EAAAC,EAAA,CACL,CAjDA,EACAT,EAAAnN,EAAAnO,OAAA,CAAAR,EAAA2b,EACA,GAsFAjd,IAAA2c,GAtNA,SAAAna,CAAA,EACA,IAAAic,EAAAjc,EAAAic,KAAA,CAAAC,EAAAlc,EAAAkc,UAAA,CAAAC,EAAAnc,EAAAmc,WAAA,CAAAna,EAAAhC,EAAAgC,QAAA,CAAAlD,EAAAkB,EAAAlB,aAAA,CACAsd,EAAAH,GAAAC,GAAAC,GAAAna,EACAqa,EAAAnhB,EAAAuH,MAAA,KACA6Z,EAAAphB,EAAAuH,MAAA,OAIA8Z,EAAA,CACA/G,QAAA,CAAA0G,CAAAA,GAAAD,GAAAE,GAAAK,CAAA,CACA,EACA,SAAAC,IACA,IAAAzc,CACA,QAAAA,CAAAA,EAAAsc,EAAAhd,OAAA,GAAAU,KAAA,IAAAA,GAAAA,EAAAS,IAAA,CAAA6b,GACAA,EAAAhd,OAAA,KACA,CACA,SAAAod,IACA,IAAA1c,EAIA,OAHAyc,IACAJ,EAAA/c,OAAA,IACA,OAAAU,CAAAA,EAAAlB,EAAA+G,cAAA,GAAA7F,KAAA,IAAAA,GAAAA,EAAA6Y,SAAA,CAAA/d,EAAAJ,aAAA,CAAAiiB,GAAA,KACA,CAAApE,IACA,CACA,SAAAqE,EAAA/G,CAAA,CAAA+C,CAAA,EACA8D,KAMA,IAAA5d,EAAA4c,WAAA,GAAA7F,EAAAvG,MAAA,EAEA2M,MAAAA,GAAAA,EAAApG,EAAA+C,GADAuD,MAAAA,GAAAA,EAAAtG,EAAA+C,EACA,CACA,CACA,SAAAiE,EAAAhH,CAAA,CAAA+C,CAAA,EACA8D,KAEAP,CAAAA,MAAAA,GAAAA,EAAAtG,EAAA+C,EAAA,CACA,CACA,SAAA4D,EAAA3G,CAAA,CAAA+C,CAAA,EACA,IAAA5Y,EACAyc,IACAJ,EAAA/c,OAAA,GAEA+c,EAAA/c,OAAA,IACAgd,EAAAhd,OAAA,CAAAjE,EAAAyhB,IAAA,CAAAhF,GAAApY,OAAA,YAAAkd,EAAAL,GAAAzE,GAAApY,OAAA,gBAAAmd,EAAAN,IAIA,OAAAvc,CAAAA,EAAAlB,EAAA+G,cAAA,GAAA7F,KAAA,IAAAA,GAAAA,EAAA6Y,SAAA,CAAA/d,EAAAJ,aAAA,CAAAiiB,GAAA,KACAT,MAAAA,GAAAA,EAAArG,EAAA+C,GACA,CACAb,GAAAjZ,EAAA,cAAAsd,EAAAI,EAAAxX,KAAAA,EAAAuX,GACArD,GAAAuD,EACA,GAiKAnf,MAAA6c,GArbA,SAAAna,CAAA,EACA,IAAAiC,EAAAjC,EAAAiC,UAAA,CAAAnD,EAAAkB,EAAAlB,aAAA,CASA6W,GAAA7W,EAAA,QAAAmD,EARA,WACA,IAAAjC,CACA,QAAAA,CAAAA,EAAAlB,EAAA+G,cAAA,GAAA7F,KAAA,IAAAA,GAAAA,EAAA6Y,SAAA,CAAA/d,EAAAJ,aAAA,CAAAqiB,KAAA,IACA,EAKA/X,KAAAA,GACA2Q,GAAA7W,EAAA,OAAAmD,EALA,WACA,IAAAjC,CACA,QAAAA,CAAAA,EAAAlB,EAAA+G,cAAA,GAAA7F,KAAA,IAAAA,GAAAA,EAAA6Y,SAAA,CAAA/d,EAAAJ,aAAA,CAAAqiB,KAAA,IACA,EAEA/X,KAAAA,EACA,GA0aAzH,MAAA4c,GA7PA,SAAAna,CAAA,EACA,IAAAgd,EAAAhd,EAAAgd,YAAA,CAAAC,EAAAjd,EAAAid,UAAA,CAAAnb,EAAA9B,EAAA8B,UAAA,CAAAhD,EAAAkB,EAAAlB,aAAA,CACAiZ,GAAAjZ,EAAA,eAAAke,GAAAlb,EACA2W,GAAA3Z,EAAA,GAAAke,GACAhY,KAAAA,EAAA,CAAuBwQ,QAAA,CAAAwH,CAAA,GACvBjF,GAAAjZ,EAAA,eAAAme,GAAAnb,EACA2W,GAAA3Z,EAAA,GAAAme,GACAjY,KAAAA,EAAA,CAAuBwQ,QAAA,CAAAyH,CAAA,EACvB,EAsPA,EAEAC,GAAA,EACAC,GAAA,WAAgC,OAAAD,IAAA,EAChCE,GAAA,WAA0B,OAAA7a,EAAA4a,GAAA,EAiC1B,SAAAE,KACA,IAAAlY,EAAAjK,EAAA2D,UAAA,CAAAE,GACA,GAAAoG,OAAAA,EACA,gBACA,IAAAmY,EAAAnY,EAAAmY,SAAA,CAAAC,EAAApY,EAAAoY,cAAA,CAAAC,EAAArY,EAAAqY,QAAA,CAIAzY,EAAAqY,YACAliB,EAAAkE,SAAA,YAAkC,OAAAoe,EAAAzY,EAAA,EAAsB,IAExD,CAAAuY,GAAAC,EAAA,IADA,WAAqC,OAAAA,MAAAA,EAAA,OAAAA,EAAAxY,EAAA,EACrC,MA6BA,SAAA0Y,GAAAC,CAAA,CAAAC,CAAA,EACA,IAAA/c,MAAAC,OAAA,CAAA8c,GACA,SACA,IAAAC,EAAAD,EAAAtf,MAAA,CACA,GAAAuf,IAAAF,EAAArf,MAAA,CACA,SACA,QAAAmI,EAAA,EAAoBA,EAAAoX,EAAgBpX,IACpC,GAAAmX,CAAA,CAAAnX,EAAA,GAAAkX,CAAA,CAAAlX,EAAA,CACA,SAEA,QACA,CAQA,IAAAqX,GAAA,SAAAC,CAAA,EAAiD,OAAAA,IAAAA,CAAA,EAEjDC,GAAA,CACAC,OAAA3iB,EAAA2iB,MAAA,CACAC,OAAA5iB,EAAA4iB,MAAA,CACAC,UAAA7iB,EAAA6iB,SAAA,CACAC,QAAA9iB,EAAA8iB,OAAA,CACAC,OAAA/iB,EAAA+iB,MAAA,CACAC,UAAAhjB,EAAAgjB,SAAA,CACAC,QAAAjjB,EAAAijB,OAAA,CACAC,OAAAljB,EAAAkjB,MAAA,CACAC,UAAAnjB,EAAAmjB,SAAA,CACAC,QAAApjB,EAAAojB,OAAA,CACAC,WAAArjB,EAAAqjB,UAAA,CACAC,SAAAtjB,EAAAsjB,QAAA,CACAC,YAAAvjB,EAAAujB,WAAA,CACAC,UAAAxjB,EAAAwjB,SAAA,EAEAC,GAAA,SAAA9d,CAAA,EACA,GAAAJ,MAAAC,OAAA,CAAAG,GAAA,CAEA7F,EAAAoL,SAAA,CAAAvF,IAAAA,EAAA3C,MAAA,4DACA,IAAA2B,EAAAhF,EAAAiF,MAAA,CAAAe,EAAA,GAAA+d,EAAA/e,CAAA,IAAAgf,EAAAhf,CAAA,IAAAif,EAAAjf,CAAA,IAAAkf,EAAAlf,CAAA,IACA,OAAA3E,EAAA8jB,WAAA,CAAAJ,EAAAC,EAAAC,EAAAC,EACA,OACA,iBAAAle,GAEA7F,EAAAoL,SAAA,CAAAwX,KAAA/Y,IAAA+Y,EAAA,CAAA/c,EAAA,yBAAAkO,MAAA,CAAAlO,EAAA,MACA+c,EAAA,CAAA/c,EAAA,EAEAA,CACA,EAcAoe,GAAA,SAAAvhB,CAAA,CAAA9C,CAAA,QAEA,WAAA8C,MAKA,iBAAA9C,GAAA6F,MAAAC,OAAA,CAAA9F,IAEA,iBAAAA,GACAK,EAAAikB,OAAA,CAAAvX,IAAA,CAAA/M,IACA,CAAAA,EAAAwO,UAAA,SAKA,EAEA+V,GAAA,WAAsC,OACtC9Q,KAAA,SACA+Q,UAAA,IACAC,QAAA,GACAC,UAAA,EACA,CAAC,EACDC,GAAA,SAAAC,CAAA,EAA6C,OAC7CnR,KAAA,SACA+Q,UAAA,IACAC,QAAAG,IAAAA,EAAA,EAAAhW,KAAAiW,IAAA,SACAH,UAAA,EACA,CAAC,EACDI,GAAA,WAAgC,OAChCrR,KAAA,YACAsR,KAAA,SACAC,SAAA,EACA,CAAC,EACDC,GAAA,SAAA1M,CAAA,EAAoC,OACpC9E,KAAA,YACAuR,SAAA,GACAzM,OAAAA,CACA,CAAC,EACD2M,GAAA,CACA/W,EAAAoW,GACAnW,EAAAmW,GACAlW,EAAAkW,GACAzT,OAAAyT,GACAvT,QAAAuT,GACAtT,QAAAsT,GACArT,QAAAqT,GACAnT,OAAAuT,GACAtT,OAAAsT,GACAxT,MAAAwT,GACA5S,QAAA+S,GACAK,gBAAAL,GACAM,MAAAN,GACApR,QAAAiR,EACA,EACAU,GAAA,SAAAC,CAAA,CAAAV,CAAA,EACA,IAAAW,EAQA,OANAA,EADA5N,GAAAiN,GACAK,GAIAC,EAAA,CAAAI,EAAA,EAAAJ,GAAAxR,OAAA,CAEAzT,EAAAiK,QAAA,EAA4B0a,GAAAA,CAAA,EAAQW,EAAAX,GACpC,EAKAY,GAAAvlB,EAAAiK,QAAA,CAAAjK,EAAAiK,QAAA,IAAwD4E,IAAA,CAExDsW,MAAA/kB,EAAA+kB,KAAA,CAAAD,gBAAA9kB,EAAA+kB,KAAA,CAAAK,aAAAplB,EAAA+kB,KAAA,CAAAM,KAAArlB,EAAA+kB,KAAA,CAAAO,OAAAtlB,EAAA+kB,KAAA,CAEAQ,YAAAvlB,EAAA+kB,KAAA,CAAAS,eAAAxlB,EAAA+kB,KAAA,CAAAU,iBAAAzlB,EAAA+kB,KAAA,CAAAW,kBAAA1lB,EAAA+kB,KAAA,CAAAY,gBAAA3lB,EAAA+kB,KAAA,CAAAa,OAAA5lB,EAAA4lB,MAAA,CAAAC,aAAA7lB,EAAA4lB,MAAA,GAIAE,GAAA,SAAArjB,CAAA,EAA2C,OAAA0iB,EAAA,CAAA1iB,EAAA,EAE3C,SAAAsjB,GAAAtjB,CAAA,CAAA9C,CAAA,EAEA,IADAiF,EACAohB,EAAAF,GAAArjB,GAIA,OAHAujB,IAAAhmB,EAAA4lB,MAAA,EACAI,CAAAA,EAAAhmB,EAAAikB,OAAA,EAEA,OAAArf,CAAAA,EAAAohB,EAAAD,iBAAA,GAAAnhB,KAAA,IAAAA,EAAA,OAAAA,EAAAS,IAAA,CAAA2gB,EAAArmB,EACA,CAEA,IAAAsmB,GAAA,CACA/hB,QAAA,EACA,EAWAgiB,GAAA,GAiJA,SAAAC,GAAAxmB,CAAA,EACA,OAAAA,IAAAA,GACA,iBAAAA,GACAymB,IAAAA,WAAAzmB,IACAA,KAAAA,EAAA8M,OAAA,KACA,CACA,SAAA4Z,GAAAC,CAAA,EACA,uBAAAA,EACA,EACAP,GAAA,GAAAO,EACA,CACA,SAAAC,GAAA5N,CAAA,CAAAlW,CAAA,EACA,OAAAkW,CAAA,CAAAlW,EAAA,EAAAkW,EAAA,SAAAA,CACA,CAKA,SAAA6N,GAAA/jB,CAAA,CAAA9C,CAAA,CAAAuU,CAAA,CAAAyE,CAAA,EAKA,OAJA,SAAAA,GAAiCA,CAAAA,EAAA,IACjCsN,GAAA/hB,OAAA,EACAyU,CAAAA,EAAA,CAAuBvF,KAAA,KAEvBzT,EAAA6G,KAAA,UAAAigB,CAAA,EAGA,IAjHA9N,EACA/T,EAAAmE,EA4BAmL,EACAtP,EACA8hB,EACA3R,EACA4R,EAgBAC,EA8DAC,EACAC,EACA/kB,GApFAmS,EAoFAA,EAjFAa,EAAA,OAAAnQ,CAAAA,EAAA8hB,CADAA,EAAAH,GAkFA5N,EAAAlW,IAjFAskB,IAAA,GAAAniB,KAAA,IAAAA,EAAAA,EAAAjF,EAAAqB,GAAA,GACA2lB,EAAA3C,GAgFAvhB,EAhFAyR,GACAa,SAAAA,GAAA4R,GAAA,iBAAAzS,EAKAa,EAAAgR,GA0EAtjB,EA1EAyR,GAEAiS,GAAApR,IAAA,iBAAAb,EACAa,EAAAsR,GAAAnS,GAEA,CAAA1O,MAAAC,OAAA,CAAAyO,IACAiS,GAAAjS,IACA,iBAAAa,GACAb,CAAAA,EAAAmS,GAAAtR,EAAA,EAEA6R,EAAA5C,GAgEAvhB,EAhEAsS,GACAhV,EAAAinB,OAAA,CAAAJ,IAAAD,EAAA,6BAAA7S,MAAA,CA+DArR,EA/DA,WAAAqR,MAAA,CAAAiB,EAAA,UAAAjB,MAAA,CAAAI,EAAA,OAAAJ,MAAA,CAAAiB,EAAA,+DAAAjB,MAAA,CAAAiB,EAAA,8BAAAjB,MAAA,CAAAI,EAAA,+BA+BA,GACAyS,GACAD,CAAA,IAAAA,EAAAtT,IAAA,CAhCA,WACA,IAxCAuF,EAAApG,EAAA9P,EACAmC,EA3EAA,EAQAA,EACA8f,EAAAuC,EAAAC,EAAAC,EAAAC,EAAAzO,EACApG,EAwGAA,EAAA,CACAwU,KAAAhS,EACAwP,GAAArQ,EACAhO,SAAAvG,EAAA0G,WAAA,GACAogB,WAyDAA,EAxDAY,SAAA,SAAA9hB,CAAA,EAAqC,OAAA5F,EAAA0M,GAAA,CAAA9G,EAAA,CACrC,EACA,MAAAmhB,YAAAA,EAAAtT,IAAA,EACAsT,UAAAA,EAAAtT,IAAA,CACAnT,EAAAqnB,OAAA,CAAA1nB,EAAAiK,QAAA,CAAAjK,EAAAiK,QAAA,IAAgE0I,GAAAmU,IAChEzmB,EAAAsG,OAAA,CAAA3G,EAAAiK,QAAA,CAAAjK,EAAAiK,QAAA,KAlDA8O,EAkDgE+N,EAlDhEnU,EAkDgEA,EAlDhE9P,EAqGAA,EAnGA+C,MAAAC,OAAA,CAAA8M,EAAAgS,EAAA,GACA,QAAA3f,CAAAA,EAAA+T,EAAAgM,QAAA,GAAA/f,KAAA,IAAAA,GAAA+T,CAAAA,EAAAgM,QAAA,MATAnf,MAAAC,OAAA,CAAA8M,EAAAgS,EAAA,GAAAhS,OAAAA,EAAAgS,EAAA,MACAhS,EAAAgS,EAAA,CAAA3kB,EAAA2nB,aAAA,IAAA3nB,EAAAiF,MAAA,CAAA0N,EAAAgS,EAAA,MACAhS,EAAAgS,EAAA,IAAAhS,EAAAwU,IAAA,EArEAniB,CADAA,EAmFA+T,GAlFA6O,IAAA,CAAa5iB,EAAA6iB,KAAA,CAAU7iB,EAAA8iB,aAAA,CAAkB9iB,EAAA+iB,eAAA,CAAoB/iB,EAAAgjB,gBAAA,CAAqBhjB,EAAAijB,MAAA,CAAWjjB,EAAAkjB,UAAA,CAAeljB,EAAAmjB,WAAA,CAAgBnjB,EAAAmiB,IAAA,CAC5HvnB,OAAAmB,IAAA,CADqIf,EAAAkW,MAAA,CAAAlR,EAAA,mHACrI3B,MAAA,EAkFA0V,CAAAA,EAAA/Y,EAAAiK,QAAA,CAAAjK,EAAAiK,QAAA,IAAqD8O,GAAAqM,GAAAviB,EAAA8P,EAAAgS,EAAA,IAErD3kB,EAAAiK,QAAA,CAAAjK,EAAAiK,QAAA,IAA2C0I,IA7E3CmS,EAAA9f,CADAA,EA8E2C+T,GA7E3C+L,IAAA,CAAAuC,EAAAriB,EAAAqiB,KAAA,CAAAC,EAAAtiB,EAAAsiB,IAAA,CAAAC,EAAAviB,EAAAuiB,IAAA,CAAAC,EAAAxiB,EAAAwiB,IAAA,CAAAzO,EAAA/Y,EAAAkW,MAAA,CAAAlR,EAAA,uCACA2N,EAAA3S,EAAAiK,QAAA,IAAmC8O,GACnCsO,GACA1U,CAAAA,EAAA,OAAA0U,CAAA,EAIAtO,EAAAgM,QAAA,EACApS,CAAAA,EAAA,SAAAkQ,GAAA9J,EAAAgM,QAAA,GACAhM,EAAAoP,WAAA,EACAxV,CAAAA,EAAAwV,WAAA,CAAAtF,GAAA9J,EAAAoP,WAAA,GAIArD,GACAnS,CAAAA,EAAA,KAAAyV,MAvIAviB,OAAA,CAuIAif,IAvIA,iBAAAA,CAAA,IAwIAA,EAAAuD,GAAA,CAAAvE,IACAA,GAAAgB,EAAA,EAKA,UAAA/L,EAAAvF,IAAA,EACAb,CAAAA,EAAAa,IAAA,cAIA8T,CAAAA,GAAAE,GAAAD,CAAA,IACApnB,EAAAinB,OAAA,EAAAd,GAAA,mGACAA,GAAA,GACAgB,EACA3U,EAAAuV,UAAA,WAEAV,EACA7U,EAAAuV,UAAA,QAEAX,GACA5U,CAAAA,EAAAuV,UAAA,WAEAvV,EAAAsV,MAAA,CAAAT,GAAAF,GAAAC,GAAAxO,EAAAkP,MAAA,EAOA,WAAAlP,EAAAvF,IAAA,EACAb,CAAAA,EAAAa,IAAA,cACAb,MAmEgE,CAAkE8U,SAAA,SAAA9hB,CAAA,EAClI,IAAAX,EACA2N,EAAA8U,QAAA,CAAA9hB,GACA,OAAAX,CAAAA,EAAA8hB,EAAAW,QAAA,GAAAziB,KAAA,IAAAA,GAAAA,EAAAS,IAAA,CAAAqhB,EAAAnhB,EACA,EAAiBkhB,WAAA,WACjB,IAAA7hB,EACA2N,EAAAkU,UAAA,GACA,OAAA7hB,CAAAA,EAAA8hB,EAAAD,UAAA,GAAA7hB,KAAA,IAAAA,GAAAA,EAAAS,IAAA,CAAAqhB,EACA,IACA,EACA,WAEA,IADA9hB,EAAAmE,EACAmf,EAAA3Q,GAAArD,GAKA,OAJAvU,EAAA0M,GAAA,CAAA6b,GACAzB,IACA,OAAA7hB,CAAAA,EAAA8hB,MAAAA,EAAA,OAAAA,EAAAW,QAAA,GAAAziB,KAAA,IAAAA,GAAAA,EAAAS,IAAA,CAAAqhB,EAAAwB,GACA,OAAAnf,CAAAA,EAAA2d,MAAAA,EAAA,OAAAA,EAAAD,UAAA,GAAA1d,KAAA,IAAAA,GAAAA,EAAA1D,IAAA,CAAAqhB,GACA,CAAiByB,KAAA,aACjB,GAkCAV,EA/GA,OAAA1e,CAAAA,EAAA,OAAAnE,CAAAA,EAAA8hB,CADAH,GAFA5N,EAkHAA,EAAAlW,IAhHA,IACAglB,KAAA,GAAA7iB,KAAA,IAAAA,EAAAA,EAAA+T,EAAA8O,KAAA,GAAA1e,KAAA,IAAAA,EAAAA,EAAA,EAgHAvC,EAAA,WAAkC,OAAAsgB,EAAA/kB,GAAA,EAOlC,OANA0lB,EACAZ,EAAAviB,OAAA8jB,UAAA,CAAA5hB,EAAAic,GAAAgF,IAGAjhB,IAEA,WACA6hB,aAAAxB,GACAC,MAAAA,GAAAA,EAAAqB,IAAA,EACA,CACA,EACA,CAYA,SAAAG,GAAAC,CAAA,CAAAC,CAAA,EACAD,KAAAA,EAAA9b,OAAA,CAAA+b,IAAAD,EAAAjd,IAAA,CAAAkd,EACA,CACA,SAAAC,GAAAF,CAAA,CAAAC,CAAA,EACA,IAAA3P,EAAA0P,EAAA9b,OAAA,CAAA+b,EACA3P,CAAAA,EAAA,IAAA0P,EAAAG,MAAA,CAAA7P,EAAA,EACA,CAaA,IAAA8P,GAAA,WACA,SAAAA,IACA,KAAAC,aAAA,IAkCA,OAhCAD,EAAAxjB,SAAA,CAAAkZ,GAAA,UAAAlE,CAAA,EACA,IAAA0O,EAAA,KAEA,OADAP,GAAA,KAAAM,aAAA,CAAAzO,GACA,WAA6B,OAAAsO,GAAAI,EAAAD,aAAA,CAAAzO,EAAA,CAC7B,EACAwO,EAAAxjB,SAAA,CAAA2jB,MAAA,UAAA5b,CAAA,CAAAC,CAAA,CAAA4b,CAAA,EACA,IAAAC,EAAA,KAAAJ,aAAA,CAAA3lB,MAAA,CACA,GAAA+lB,GAEA,GAAAA,IAAAA,EAIA,KAAAJ,aAAA,IAAA1b,EAAAC,EAAA4b,QAGA,QAAA3d,EAAA,EAA4BA,EAAA4d,EAAsB5d,IAAA,CAKlD,IAAA+O,EAAA,KAAAyO,aAAA,CAAAxd,EAAA,CACA+O,GAAAA,EAAAjN,EAAAC,EAAA4b,EACA,EAEA,EACAJ,EAAAxjB,SAAA,CAAA8jB,OAAA,YACA,YAAAL,aAAA,CAAA3lB,MAAA,EAEA0lB,EAAAxjB,SAAA,CAAA+jB,KAAA,YACA,KAAAN,aAAA,CAAA3lB,MAAA,EACA,EACA0lB,CACA,IAUAQ,GAAA,WASA,SAAAA,EAAA/hB,CAAA,EACA,IAAAyhB,EAAA,KAKA,KAAAO,OAAA,SAMA,KAAAC,SAAA,GAMA,KAAAC,WAAA,GAMA,KAAAC,iBAAA,KAAAZ,GAMA,KAAAa,yBAAA,KAAAb,GAMA,KAAAc,iBAAA,KAAAd,GAQA,KAAAe,gBAAA,IACA,KAAAC,eAAA,UAAApkB,CAAA,CAAA8C,CAAA,EACA,SAAAA,GAAqCA,CAAAA,EAAA,IACrCwgB,EAAAtG,IAAA,CAAAsG,EAAA3kB,OAAA,CACA2kB,EAAA3kB,OAAA,CAAAqB,EAEA,IAAAX,EAAA1E,EAAA0pB,YAAA,GAAAC,EAAAjlB,EAAAilB,KAAA,CAAAC,EAAAllB,EAAAklB,SAAA,CACAjB,EAAAS,WAAA,GAAAQ,IACAjB,EAAAQ,SAAA,CAAAQ,EACAhB,EAAAS,WAAA,CAAAQ,EACA1oB,EAAA,QAAA2oB,UAAA,CAAAlB,EAAAmB,qBAAA,GAGAnB,EAAAtG,IAAA,GAAAsG,EAAA3kB,OAAA,EACA2kB,EAAAU,iBAAA,CAAAT,MAAA,CAAAD,EAAA3kB,OAAA,EAGA2kB,EAAAW,yBAAA,CAAAP,OAAA,IACAJ,EAAAW,yBAAA,CAAAV,MAAA,CAAAD,EAAAxiB,WAAA,IAGAgC,GACAwgB,EAAAY,iBAAA,CAAAX,MAAA,CAAAD,EAAA3kB,OAAA,CAEA,EASA,KAAA8lB,qBAAA,YAAmD,OAAA5oB,EAAA,QAAA2oB,UAAA,CAAAlB,EAAAoB,aAAA,GAUnD,KAAAA,aAAA,UAAArlB,CAAA,EACAA,EAAAklB,SAAA,GACAjB,EAAAS,WAAA,GACAT,EAAAtG,IAAA,CAAAsG,EAAA3kB,OAAA,CACA2kB,EAAAW,yBAAA,CAAAV,MAAA,CAAAD,EAAAxiB,WAAA,IAEA,EACA,KAAA6jB,WAAA,IACA,KAAA3H,IAAA,MAAAre,OAAA,CAAAkD,EACA,KAAAsiB,gBAAA,CAhHA,CAAAS,MAAA/D,WAgHA,KAAAliB,OAAA,EACA,CA0LA,OAzIAilB,EAAAhkB,SAAA,CAAAilB,QAAA,UAAAC,CAAA,EACA,YAAAd,iBAAA,CAAAlL,GAAA,CAAAgM,EACA,EACAlB,EAAAhkB,SAAA,CAAAmlB,cAAA,YACA,KAAAf,iBAAA,CAAAL,KAAA,EACA,EASAC,EAAAhkB,SAAA,CAAAolB,eAAA,UAAAF,CAAA,EAGA,OADAA,EAAA,KAAArpB,GAAA,IACA,KAAAyoB,iBAAA,CAAApL,GAAA,CAAAgM,EACA,EAMAlB,EAAAhkB,SAAA,CAAAqlB,MAAA,UAAAC,CAAA,EACA,KAAAA,aAAA,CAAAA,CACA,EAgBAtB,EAAAhkB,SAAA,CAAAkH,GAAA,UAAA9G,CAAA,CAAA8C,CAAA,EACA,SAAAA,GAAiCA,CAAAA,EAAA,IACjC,QAAAoiB,aAAA,CAIA,KAAAA,aAAA,CAAAllB,EAAA,KAAAokB,eAAA,EAHA,KAAAA,eAAA,CAAApkB,EAAA8C,EAKA,EAQA8gB,EAAAhkB,SAAA,CAAAnE,GAAA,YACA,YAAAkD,OAAA,EAKAilB,EAAAhkB,SAAA,CAAAulB,WAAA,YACA,YAAAnI,IAAA,EASA4G,EAAAhkB,SAAA,CAAAkB,WAAA,YAEA,YAAAqjB,gBAAA,CAEAzpB,EAAA0qB,iBAAA,CAAAvE,WAAA,KAAAliB,OAAA,EACAkiB,WAAA,KAAA7D,IAAA,OAAA8G,SAAA,EACA,CACA,EAaAF,EAAAhkB,SAAA,CAAAqB,KAAA,UAAAzE,CAAA,EACA,IAAA8mB,EAAA,KAEA,OADA,KAAAV,IAAA,GACA,IAAAyC,QAAA,SAAAC,CAAA,EACAhC,EAAAqB,WAAA,IACArB,EAAAiC,aAAA,CAAA/oB,EAAA8oB,EACA,GAASE,IAAA,YAAqB,OAAAlC,EAAAmC,cAAA,IAC9B,EAMA7B,EAAAhkB,SAAA,CAAAgjB,IAAA,YACA,KAAA2C,aAAA,EACA,KAAAA,aAAA,GACA,KAAAE,cAAA,EACA,EAMA7B,EAAAhkB,SAAA,CAAA8lB,WAAA,YACA,aAAAH,aAAA,EAEA3B,EAAAhkB,SAAA,CAAA6lB,cAAA,YACA,KAAAF,aAAA,KACA,EAUA3B,EAAAhkB,SAAA,CAAA+lB,OAAA,YACA,KAAA3B,iBAAA,CAAAL,KAAA,GACA,KAAAO,iBAAA,CAAAP,KAAA,GACA,KAAAf,IAAA,EACA,EACAgB,CACA,IACA,SAAAgC,GAAA/jB,CAAA,EACA,WAAA+hB,GAAA/hB,EACA,CAKA,IAAAgkB,GAAA,SAAA7lB,CAAA,EAAmC,gBAAA6N,CAAA,EAAyB,OAAAA,EAAA1G,IAAA,CAAAnH,EAAA,GAa5D8lB,GAAA,CAAArrB,EAAAqO,MAAA,CAAArO,EAAA2O,EAAA,CAAA3O,EAAAsrB,OAAA,CAAAtrB,EAAA0Q,OAAA,CAAA1Q,EAAAurB,EAAA,CAAAvrB,EAAAwrB,EAAA,CARA,CACA9e,KAAA,SAAAnH,CAAA,EAAyB,MAAAA,SAAAA,CAAA,EACzBkmB,MAAA,SAAAlmB,CAAA,EAA0B,OAAAA,CAAA,CAC1B,EAKA,CAIAmmB,GAAA,SAAAnmB,CAAA,EACA,OAAA8lB,GAAAM,IAAA,CAAAP,GAAA7lB,GACA,EAKAqmB,GAAAhsB,EAAA2nB,aAAA,CAAA3nB,EAAA2nB,aAAA,IAAA3nB,EAAAiF,MAAA,CAAAwmB,IAAA,KAAArrB,EAAA+kB,KAAA,CAAA/kB,EAAAikB,OAAA,MAkBA,SAAA4H,GAAAnoB,CAAA,CAAAkC,CAAA,EACA,IAAA6S,EAAAxS,EAAAvC,EAAAkC,GACAhB,EAAA6T,EAAA/U,EAAAooB,oBAAA,CAAArT,EAAA,OAAgF1P,EAAAnE,EAAA8T,aAAA,CAAkE9T,EAAA+T,UAAA,CAAe,IAAAzE,EAAAtU,EAAAkW,MAAA,CAAAlR,EAAA,gCAEjK,QAAAnC,KADAyR,EAAAtU,EAAAiK,QAAA,CAAAjK,EAAAiK,QAAA,IAA6CqK,GADmCnL,KAAA,IAAAA,EAAA,GAA4DA,GAE5I,CACA,IAAApJ,EAAA4X,GAAArD,CAAA,CAAAzR,EAAA,EAZAiB,EAAAqoB,QAAA,CAaAtpB,GAZAiB,EAAAsoB,QAAA,CAYAvpB,GAZA4J,GAAA,CAYA1M,GATA+D,EAAAuoB,QAAA,CASAxpB,EATA0oB,GASAxrB,GACA,CACA,CACA,SAAAusB,GAAAxoB,CAAA,CAAAyoB,CAAA,EAEAC,EADA7E,aAAA,IAAA3nB,EAAAiF,MAAA,CAAAsnB,GAAA,IAAAE,OAAA,GACAzrB,OAAA,UAAA6B,CAAA,EAEA,IADAmC,EACA0nB,EAAA5oB,EAAA6oB,UAAA,CAAA9pB,EACA6pB,CAAAA,GAAAT,GAAAnoB,EAAA4oB,GACA,OAAA1nB,CAAAA,EAAAlB,EAAA8oB,eAAA,GAAA5nB,KAAA,IAAAA,GAAAA,EAAAhE,OAAA,UAAAgd,CAAA,EACAsO,GAAAtO,EAAAuO,EACA,EACA,EACA,CAYA,SAAAM,GAAA/oB,CAAA,CAAAwQ,CAAA,CAAAa,CAAA,EAGA,IAFAnQ,EAAAmE,EAAA0J,EAEAia,EAAAltB,OAAAmB,IAAA,CAAAuT,GAAA0R,MAAA,UAAAnjB,CAAA,EAAmE,OAAAiB,EAAAqoB,QAAA,CAAAtpB,EAAA,GACnEkqB,EAAAD,EAAAzpB,MAAA,CACA,GAAA0pB,EAEA,QAAAvhB,EAAA,EAAoBA,EAAAuhB,EAAkBvhB,IAAA,CACtC,IAvcA7F,EAKAA,EA6YAA,EAqDA9C,EAAAiqB,CAAA,CAAAthB,EAAA,CACAwhB,EAAA1Y,CAAA,CAAAzR,EAAA,CACA9C,EAAA,KAKA6F,MAAAC,OAAA,CAAAmnB,IACAjtB,CAAAA,EAAAitB,CAAA,KAOA,OAAAjtB,GACAA,CAAAA,EAAA,OAAAoJ,CAAAA,EAAA,OAAAnE,CAAAA,EAAAmQ,CAAA,CAAAtS,EAAA,GAAAmC,KAAA,IAAAA,EAAAA,EAAAlB,EAAAmpB,SAAA,CAAApqB,EAAA,GAAAsG,KAAA,IAAAA,EAAAA,EAAAmL,CAAA,CAAAzR,EAAA,QAMA9C,IAEA,iBAAAA,GACAmtB,CAAAA,EAAAntB,EAheuC,iBAAA+M,IAAA,CAAAnH,KAKvCA,EA2dA5F,EA3duC,aAAA+M,IAAA,CAAAnH,GA2dvC,EAEA5F,EAAAymB,WAAAzmB,IAhFA4F,EAkFA5F,EAAA,CAlFmCisB,GAAAD,IAAA,CAAAP,GAAA7lB,KAkFnCvF,EAAAikB,OAAA,CAAAvX,IAAA,CAAAkgB,IACAjtB,CAAAA,EAAAomB,GAAAtjB,EAAAmqB,EAAA,GAEAlpB,EAAAuoB,QAAA,CAAAxpB,EAAA0oB,GAAAxrB,IACA,OAAA8S,CAAAA,EAAA,EAAAhQ,EAAA,GAAAgQ,KAAA,IAAAA,GAAAC,CAAAA,CAAA,CAAAjQ,EAAA,CAAA9C,CAAA,EACA+D,EAAAqpB,aAAA,CAAAtqB,EAAA9C,GACA,CACA,CAOA,SAAAqtB,GAAA9Y,CAAA,CAAAyE,CAAA,CAAAjV,CAAA,EAEA,IADAkB,EAAAmE,EACAgM,EAAA,GACA,QAAAtS,KAAAyR,EACAa,CAAA,CAAAtS,EAAA,CACA,OAAAmC,CAAAA,EAAAqoB,SAXAxqB,CAAA,CAAAkW,CAAA,EACA,GAAAA,EAGA,MAAA+N,CADA/N,CAAA,CAAAlW,EAAA,EAAAkW,EAAA,SAAAA,CAAA,EACAoO,IAAA,EAOAtkB,EAAAkW,EAAA,GAAA/T,KAAA,IAAAA,EAAAA,EAAA,OAAAmE,CAAAA,EAAArF,EAAAsoB,QAAA,CAAAvpB,EAAA,GAAAsG,KAAA,IAAAA,EAAA,OAAAA,EAAA/H,GAAA,GAEA,OAAA+T,CACA,CAEA,SAAAmY,GAAAxpB,CAAA,CAAAkC,CAAA,CAAA2M,CAAA,EAIA,GAHA,SAAAA,GAA8BA,CAAAA,EAAA,IAC9B7O,EAAAypB,oBAAA,CAAAvnB,GAEAJ,MAAAC,OAAA,CAAAG,GAAA,CACA,IAFA7D,EAKAA,EAAA6oB,QAAA9L,GAAA,CAHAlZ,EAAAqiB,GAAA,UAAAqE,CAAA,EACA,OAAAc,GAAA1pB,EAAA4oB,EAAA/Z,EACA,GAEA,MACA,oBAAA3M,EACA7D,EAAAqrB,GAAA1pB,EAAAkC,EAAA2M,OAEA,CACA,IAAA8a,EAAA,mBAAAznB,EACAK,EAAAvC,EAAAkC,EAAA2M,EAAA1M,MAAA,EACAD,EACA7D,EAAAurB,GAAA5pB,EAAA2pB,EAAA9a,EACA,CACA,OAAAxQ,EAAAgpB,IAAA,YACA,OAAArnB,EAAA6pB,uBAAA,CAAA3nB,EACA,EACA,CACA,SAAAwnB,GAAA1pB,CAAA,CAAA4oB,CAAA,CAAA/Z,CAAA,EAEA,SAAAA,GAA8BA,CAAAA,EAAA,IAC9B,IAFA3N,EAEA6T,EAAAxS,EAAAvC,EAAA4oB,EAAA/Z,EAAA1M,MAAA,EACAkD,EAAA,CAAA0P,GAAA,IAA4BE,UAAA,CAAAA,EAAA5P,KAAA,IAAAA,EAAArF,EAAAshB,oBAAA,OAAsFjc,CAClHwJ,CAAAA,EAAAib,kBAAA,EACA7U,CAAAA,EAAApG,EAAAib,kBAAA,EAMA,IAAAC,EAAAhV,EACA,WAAwB,OAAA6U,GAAA5pB,EAAA+U,EAAAlG,EAAA,EACxB,WAAwB,OAAAqY,QAAAC,OAAA,IAKxB6C,EAAA,QAAA9oB,CAAAA,EAAAlB,EAAA8oB,eAAA,GAAA5nB,KAAA,IAAAA,EAAA,OAAAA,EAAA8K,IAAA,EACA,SAAAie,CAAA,EACA,SAAAA,GAA2CA,CAAAA,EAAA,GAC3C,IAqDAjG,EAAAC,EAAAC,EAAArV,EAIAqb,EACAC,EACAC,EA3DAlpB,EAAA+T,EAAA+O,aAAA,CACA,OAoDAA,EApDAA,CADA9iB,KAAA,IAAAA,EAAA,EAAAA,CAAA,EACA+oB,EAoDAhG,EArDAhP,EAAAgP,eAAA,CAqDAC,EArDAjP,EAAAiP,gBAAA,CAqDArV,EApDAA,EAqDA,SAAAmV,GAAoCA,CAAAA,EAAA,GACpC,SAAAC,GAAsCA,CAAAA,EAAA,GACtC,SAAAC,GAAuCA,CAAAA,EAAA,GACvCgG,EAAA,GACAC,EAAA,CAAAnqB,EAAA8oB,eAAA,CAAA9c,IAAA,IAAAiY,EACAmG,EAAAlG,IAAAA,EACA,SAAAxc,CAAA,EAEA,OADA,SAAAA,GAAgCA,CAAAA,EAAA,GAChCA,EAAAuc,CACA,EACA,SAAAvc,CAAA,EAEA,OADA,SAAAA,GAAgCA,CAAAA,EAAA,GAChCyiB,EAAAziB,EAAAuc,CACA,EACAniB,MAAAuhB,IAAA,CAAArjB,EAAA8oB,eAAA,EACA7Y,IAAA,CAAAoa,IACAntB,OAAA,UAAAgd,CAAA,CAAAxS,CAAA,EACAwiB,EAAAtiB,IAAA,CAAA8hB,GAAAxP,EAtEA0O,EAsEA1sB,EAAAiK,QAAA,CAAAjK,EAAAiK,QAAA,IAAuF0I,GAAA,CAAckV,MAAAC,EAAAoG,EAAA1iB,EAAA,IAAmD2f,IAAA,YAAsB,OAAAnN,EAAA2P,uBAAA,CAtE9KjB,EAsE8K,GAC9K,GACA1B,QAAA9L,GAAA,CAAA8O,EAvEA,EACA,WAAwB,OAAAhD,QAAAC,OAAA,IAKxBrD,EAAA7O,EAAA6O,IAAA,CACA,IAAAA,EAOA,OAAAoD,QAAA9L,GAAA,EAAA2O,IAAAC,EAAAnb,EAAAkV,KAAA,IANA,IAAAhV,EAAA7S,EAAAiF,MAAA,CAAA2iB,mBAAAA,EACA,CAAAiG,EAAAC,EAAA,CACA,CAAAA,EAAAD,EAAA,IAAAO,EAAAvb,CAAA,IAAAwb,EAAAxb,CAAA,IACA,OAAAub,IAAAjD,IAAA,CAAAkD,EAKA,CAIA,SAAAX,GAAA5pB,CAAA,CAAAkC,CAAA,CAAAhB,CAAA,EAEA,IADAmE,EACA0J,EAAA7N,KAAA,IAAAA,EAAA,GAAgCA,EAAA8N,EAAAD,EAAAgV,KAAA,CAAAA,EAAA/U,KAAA,IAAAA,EAAA,EAAAA,EAAA8a,EAAA/a,EAAA+a,kBAAA,CAAApa,EAAAX,EAAAW,IAAA,CAChC8a,EAAAxqB,EAAAooB,oBAAA,CAAAlmB,GAAAuoB,EAAAD,EAAAvV,UAAA,CAAAA,EAAAwV,KAAA,IAAAA,EAAAzqB,EAAAshB,oBAAA,GAAAmJ,EAAAzV,EAAAwV,EAAAxV,aAAA,CAAAxE,EAAAtU,EAAAkW,MAAA,CAAAoY,EAAA,gCACAV,GACA7U,CAAAA,EAAA6U,CAAA,EACA,IAAAI,EAAA,GACAQ,EAAAhb,GAAA,QAAArK,CAAAA,EAAArF,EAAA+G,cAAA,GAAA1B,KAAA,IAAAA,EAAA,OAAAA,EAAAslB,QAAA,GAAAjb,EAAA,EACA,QAAA3Q,KAAAyR,EAAA,CACA,IAAAvU,EAAA+D,EAAAsoB,QAAA,CAAAvpB,GACAmW,EAAA1E,CAAA,CAAAzR,EAAA,CACA,MAAA9C,GACAiZ,KAAAhP,IAAAgP,GACAwV,GACAE,SAmDA1pB,CAAA,CAAAnC,CAAA,EACA,IAAA8rB,EAAA3pB,EAAA2pB,aAAA,CAAAC,EAAA5pB,EAAA4pB,cAAA,CACAC,EAAAF,EAAAnpB,cAAA,CAAA3C,IAAA+rB,CAAA,IAAAA,CAAA,CAAA/rB,EAAA,CAEA,OADA+rB,CAAA,CAAA/rB,EAAA,IACAgsB,CACA,EAxDAL,EAAA3rB,EAAA,GAGA,IAAAikB,EAAA9mB,EAAAiK,QAAA,EAA+C4d,MAAAA,CAAA,EAAc9O,EAI7DjV,CAAAA,EAAA+F,kBAAA,EAAAgE,GAAAhL,IACAikB,CAAAA,EAAA9mB,EAAAiK,QAAA,CAAAjK,EAAAiK,QAAA,IAA8D6c,GAAA,CAAsBtT,KAAA,GAAAqU,MAAA,GAAuB,EAE3G,IAAA1lB,EAAAykB,GAAA/jB,EAAA9C,EAAAiZ,EAAA8N,GACAkH,EAAAtiB,IAAA,CAAAvJ,GACA,CACA,OAAA6oB,QAAA9L,GAAA,CAAA8O,GAAA7C,IAAA,YACArS,GAAAmT,GAAAnoB,EAAAgV,EACA,EACA,CA0BA,SAAAqV,GAAA7gB,CAAA,CAAAC,CAAA,EACA,OAAAD,EAAAwhB,gBAAA,CAAAvhB,EACA,CAcA,IAAAwhB,GAAA,CACAjvB,EAAAJ,aAAA,CAAAsvB,OAAA,CACAlvB,EAAAJ,aAAA,CAAAwgB,MAAA,CACApgB,EAAAJ,aAAA,CAAAqiB,KAAA,CACAjiB,EAAAJ,aAAA,CAAAoe,KAAA,CACAhe,EAAAJ,aAAA,CAAAiiB,GAAA,CACA7hB,EAAAJ,aAAA,CAAAuvB,IAAA,CACAnvB,EAAAJ,aAAA,CAAAwvB,IAAA,CACA,CACAC,GAAAnvB,EAAA2nB,aAAA,IAAA3nB,EAAAiF,MAAA,CAAA8pB,IAAA,IAAAtC,OAAA,GACA2C,GAAAL,GAAA1rB,MAAA,CA6SA,SAAAgsB,GAAA3R,CAAA,EAEA,OADA,SAAAA,GAA+BA,CAAAA,EAAA,IAC/B,CACAA,SAAAA,EACAiR,cAAA,GACAC,eAAA,GACAU,mBAAA,EACA,CACA,CAcA,IAAAtB,GAAA,CACA7rB,UAAAgd,GAAA,SAAAna,CAAA,EACA,IAAAlB,EAAAkB,EAAAlB,aAAA,CAAA6C,EAAA3B,EAAA2B,OAAA,CAMA7C,EAAA+G,cAAA,EAAA/G,CAAAA,EAAA+G,cAAA,CAAA0kB,SAlUAzrB,CAAA,EACA,IA6SAkB,EA7SA2B,EARA,SAAAqnB,CAAA,EACA,OAAAhD,QAAA9L,GAAA,CAAA8O,EAAA3F,GAAA,UAAArjB,CAAA,EAEA,OAAAsoB,GAKAxpB,EANAkB,EAAA7C,SAAA,CAAA6C,EAAA2N,OAAA,CAEA,GACA,EAIAF,GA8SAzN,CADAA,EAAA,GACA,CAAAlF,EAAAJ,aAAA,CAAAsvB,OAAA,EAAAK,GAAA,IACArqB,CAAA,CAAAlF,EAAAJ,aAAA,CAAAwgB,MAAA,EAAAmP,KACArqB,CAAA,CAAAlF,EAAAJ,aAAA,CAAAoe,KAAA,EAAAuR,KACArqB,CAAA,CAAAlF,EAAAJ,aAAA,CAAAiiB,GAAA,EAAA0N,KACArqB,CAAA,CAAAlF,EAAAJ,aAAA,CAAAuvB,IAAA,EAAAI,KACArqB,CAAA,CAAAlF,EAAAJ,aAAA,CAAAqiB,KAAA,EAAAsN,KACArqB,CAAA,CAAAlF,EAAAJ,aAAA,CAAAwvB,IAAA,EAAAG,KACArqB,GApTAwqB,EAAA,GACAC,EAAA,GAKAC,EAAA,SAAAC,CAAA,CAAA3pB,CAAA,EACA,IAAA6S,EAAAxS,EAAAvC,EAAAkC,GACA,GAAA6S,EAAA,CACAA,EAAAE,UAAA,CAAiC,IAAAD,EAAAD,EAAAC,aAAA,CAAAxE,EAAAtU,EAAAkW,MAAA,CAAA2C,EAAA,gCACjC8W,EAAA3vB,EAAAiK,QAAA,CAAAjK,EAAAiK,QAAA,CAAAjK,EAAAiK,QAAA,IAAiE0lB,GAAArb,GAAAwE,EACjE,CACA,OAAA6W,CACA,EAqBA,SAAA7kB,EAAA6H,CAAA,CAAAid,CAAA,EAiMA,QAhMA5qB,EACAlD,EAAAgC,EAAAyC,QAAA,GACA4D,EAAArG,EAAA+rB,iBAAA,SAKA7B,EAAA,GAKA8B,EAAA,IAAAliB,IAMAmiB,EAAA,GAKAC,EAAAC,IAyKAzkB,EAAA,EAAwBA,EAAA4jB,GAAuB5jB,KAC/C0kB,SAzKA1kB,CAAA,EACA,IA4NAmX,EA5NAnP,EAAA2b,EAAA,CAAA3jB,EAAA,CACA2kB,EAAA1d,CAAA,CAAAe,EAAA,CACAnM,EAAA,OAAArC,CAAAA,EAAAlD,CAAA,CAAA0R,EAAA,GAAAxO,KAAA,IAAAA,EAAAA,EAAAmF,CAAA,CAAAqJ,EAAA,CACA4c,EAAAtqB,EAAAuB,GAKAgpB,EAAA7c,IAAAoc,EAAAO,EAAAzS,QAAA,KACA,MAAA2S,GACAL,CAAAA,EAAAxkB,CAAAA,EAOA,IAAA8kB,EAAAjpB,IAAA8C,CAAA,CAAAqJ,EAAA,EAAAnM,IAAAvF,CAAA,CAAA0R,EAAA,EAAA4c,EAeA,GAXAE,GACAb,GACA3rB,EAAAysB,sBAAA,EACAD,CAAAA,EAAA,IAMAH,EAAAxB,aAAA,CAAA3uB,EAAAiK,QAAA,IAAuD8lB,GAIvD,GAAAI,EAAAzS,QAAA,EAAA2S,OAAAA,GAEA,CAAAhpB,GAAA,CAAA8oB,EAAAK,QAAA,EAEA/Y,GAAApQ,EAAA,GACA,kBAAAA,GAQA,IAAAopB,GA6KA9N,EA7KAwN,EAAAK,QAAA,CA8KA,iBA9KAnpB,EA+KAqb,IAAAC,IAEAjd,EAjLA2B,IAkLA,CAAAob,GAlLApb,EAkLAsb,IAjLA+N,EAAAD,GAEAjd,IAAAoc,GACAO,EAAAzS,QAAA,EACA,CAAA4S,GACAF,GAEA5kB,EAAAwkB,GAAAI,EAKAO,EAAA/qB,MAAAC,OAAA,CAAAwB,GAAAA,EAAA,CAAAA,EAAA,CAKAupB,EAAAD,EAAAE,MAAA,CAAAnB,EAAA,GACA,MAAAW,GACAO,CAAAA,EAAA,IAUA,IAAAznB,EAAAgnB,EAAAb,kBAAA,CAAAA,EAAAnmB,KAAA,IAAAA,EAAA,GAA2FA,EAC3F2nB,EAAA9wB,EAAAiK,QAAA,CAAAjK,EAAAiK,QAAA,IAA0DqlB,GAAAsB,GAC1DG,EAAA,SAAAluB,CAAA,EACA6tB,EAAA,GACAZ,EAAA/O,MAAA,CAAAle,GACAstB,EAAAvB,cAAA,CAAA/rB,EAAA,GACA,EACA,QAAAA,KAAAiuB,EAAA,CACA,IAAApO,EAAAkO,CAAA,CAAA/tB,EAAA,CACA8f,EAAA2M,CAAA,CAAAzsB,EAAA,CAEAktB,EAAAvqB,cAAA,CAAA3C,KAKA6f,IAAAC,EAKAjL,GAAAgL,IAAAhL,GAAAiL,GACA,CAAAF,GAAAC,EAAAC,IAAA8N,EACAM,EAAAluB,GAOAstB,EAAAxB,aAAA,CAAA9rB,EAAA,IAGA6f,KAAA1Y,IAAA0Y,EAEAqO,EAAAluB,GAIAitB,EAAArR,GAAA,CAAA5b,GAGA6f,KAAA1Y,IAAA0Y,GAAAoN,EAAAtjB,GAAA,CAAA3J,GAKAkuB,EAAAluB,GAOAstB,EAAAxB,aAAA,CAAA9rB,EAAA,IAEA,CAKAstB,EAAAK,QAAA,CAAAnpB,EACA8oB,EAAAb,kBAAA,CAAAsB,EAIAT,EAAAzS,QAAA,EACAqS,CAAAA,EAAA/vB,EAAAiK,QAAA,CAAAjK,EAAAiK,QAAA,IAAkE8lB,GAAAa,EAAA,EAElEnB,GAAA3rB,EAAA6G,qBAAA,EACA+lB,CAAAA,EAAA,IAOAA,GAAA,CAAAJ,GACAtC,EAAAtiB,IAAA,CAAAxD,KAAA,CAAA8lB,EAAAhuB,EAAA2nB,aAAA,IAAA3nB,EAAAiF,MAAA,CAAA0rB,EAAAtI,GAAA,UAAAlmB,CAAA,EAAiI,OACjIA,UAAAA,EACAwQ,QAAA3S,EAAAiK,QAAA,EAA8CuJ,KAAAA,CAAA,EAAYb,EAC1D,CAAiB,IAAI,KAErB,EAQAnH,GAQA,GANAgkB,EAAAxvB,EAAAiK,QAAA,IAA2C8lB,GAM3CD,EAAAhgB,IAAA,EACA,IAAAkhB,EAAA,GACAlB,EAAA9uB,OAAA,UAAA6B,CAAA,EACA,IAAAouB,EAAAntB,EAAAotB,aAAA,CAAAruB,EACAmH,MAAAA,IAAAinB,GACAD,CAAAA,CAAA,CAAAnuB,EAAA,CAAAouB,CAAA,CAEA,GACAjD,EAAAtiB,IAAA,EAA8BvJ,UAAA6uB,CAAA,EAC9B,CACA,IAAAG,EAAAhqB,CAAAA,CAAA6mB,EAAA3qB,MAAA,CAOA,OANAosB,GACA3tB,CAAA,IAAAA,EAAA+E,OAAA,EACA,CAAA/C,EAAAysB,sBAAA,EACAY,CAAAA,EAAA,IAEA1B,EAAA,GACA0B,EAAAxqB,EAAAqnB,GAAAhD,QAAAC,OAAA,EACA,CAkBA,OACAmG,WAnQA,SAAAvuB,CAAA,EACA,OAAA2sB,KAAAxlB,IAAAwlB,CAAA,CAAA3sB,EAAA,EAmQAiI,eAAAA,EACA+S,UAjBA,SAAArK,CAAA,CAAAkK,CAAA,CAAA/K,CAAA,EAGA,GAAAF,CAAA,CAAAe,EAAA,CAAAkK,QAAA,GAAAA,EACA,OAAAsN,QAAAC,OAAA,EAEA,QAAAjmB,CAAAA,EAAAlB,EAAA8oB,eAAA,GAAA5nB,KAAA,IAAAA,GAAAA,EAAAhE,OAAA,UAAAgd,CAAA,EAAgH,IAAAhZ,EAAQ,cAAAA,CAAAA,EAAAgZ,EAAAnT,cAAA,GAAA7F,KAAA,IAAAA,EAAA,OAAAA,EAAA6Y,SAAA,CAAArK,EAAAkK,EAAA,GACxHjL,CAAA,CAAAe,EAAA,CAAAkK,QAAA,CAAAA,EACA,IAPA1Y,EAOAgpB,EAAAljB,EAAA6H,EAAAa,GACA,QAAA3Q,KAAA4P,EACAA,CAAA,CAAA5P,EAAA,CAAA8rB,aAAA,IAEA,OAAAX,CACA,EAKAqD,mBA/PA,SAAAC,CAAA,EACA3qB,EAAA2qB,EAAAxtB,EACA,EA8PA2qB,SAAA,WAAgC,OAAAhc,CAAA,CAChC,CACA,EAwCA3O,EAAA,EAIA2T,GAAA9Q,IACAzG,EAAAkE,SAAA,YAA0C,OAAAuC,EAAA4qB,SAAA,CAAAztB,EAAA,EAA0C,CAAA6C,EAAA,CAEpF,GACAvE,KAAA+c,GAAA,SAAArd,CAAA,EACA,IAAAmE,EAAAnE,EAAAmE,MAAA,CAAAnC,EAAAhC,EAAAgC,aAAA,CACAkB,EAAAhF,EAAAiF,MAAA,CAAAod,KAAA,GAAAC,EAAAtd,CAAA,IAAAwsB,EAAAxsB,CAAA,IACA4E,EAAA1J,EAAA2D,UAAA,CAAAE,GACA7D,EAAAkE,SAAA,YAEAN,EAAAwe,SAAA,CAAAA,EACA,IAFAtd,EAAAmE,EAEAhH,EAAA,OAAA6C,CAAAA,EAAAlB,EAAA+G,cAAA,GAAA7F,KAAA,IAAAA,EAAA,OAAAA,EAAA6Y,SAAA,CAAA/d,EAAAJ,aAAA,CAAAwvB,IAAA,EAAA5M,EAAA,CAA4Jrc,OAAA,OAAAkD,CAAAA,EAAAS,MAAAA,EAAA,OAAAA,EAAA3D,MAAA,GAAAkD,KAAA,IAAAA,EAAAA,EAAAlD,CAAA,EAC5J,CAAAqc,GAAAngB,MAAAA,GAAAA,EAAAgpB,IAAA,CAAAqG,EACA,EAAS,CAAAlP,EAAA,CACT,EACA,EAKAmP,GAAA,WACA,SAAAA,EAAA5W,CAAA,CAAA6W,CAAA,CAAA1sB,CAAA,EACA,IAAAikB,EAAA,KACoC1lB,EAAA4F,CAApCnE,KAAA,IAAAA,EAAA,GAAoCA,CAAA,EAAAzB,kBAAA,CA2DpC,GAvDA,KAAAouB,UAAA,MAIA,KAAAC,aAAA,MAIA,KAAAC,iBAAA,MAIA,KAAAH,QAAA,IACA,KAAAI,WAAA,YACA,GAAA7I,EAAA2I,aAAA,EAAA3I,EAAA4I,iBAAA,EAEA,IAAAjU,EAAAmU,GAAA9I,EAAA4I,iBAAA,CAAA5I,EAAA+I,OAAA,EACAC,EAAAhJ,OAAAA,EAAA0I,UAAA,CAIAO,EAAA7xB,EAAAoR,QAAA,CAAAmM,EAAAxI,MAAA,EAA4ElH,EAAA,EAAAC,EAAA,KAAY,EACxF,MAAA+jB,GAEA,IAAA5W,EAAAsC,EAAAtC,KAAA,CACA4O,EAAA5pB,EAAA0pB,YAAA,GAAAE,SAAA,CACAjB,EAAA+I,OAAA,CAAAtmB,IAAA,CAAA1L,EAAAiK,QAAA,CAAAjK,EAAAiK,QAAA,IAA+DqR,GAAA,CAAY4O,UAAAA,CAAA,IAC3E,IAAAllB,EAAAikB,EAAAyI,QAAA,CAAAS,EAAAntB,EAAAmtB,OAAA,CAAAC,EAAAptB,EAAAotB,MAAA,CACAH,IACAE,GAAAA,EAAAlJ,EAAA2I,aAAA,CAAAhU,GACAqL,EAAA0I,UAAA,CAAA1I,EAAA2I,aAAA,EAEAQ,GAAAA,EAAAnJ,EAAA2I,aAAA,CAAAhU,IACA,EACA,KAAAyU,iBAAA,UAAAxX,CAAA,CAAA+C,CAAA,EAIA,GAHAqL,EAAA2I,aAAA,CAAA/W,EACAoO,EAAA4I,iBAAA,CAAAS,GAAA1U,EAAAqL,EAAA1lB,kBAAA,EAEAqX,GAAAC,IAAAA,IAAAA,EAAA0X,OAAA,EACAtJ,EAAAuJ,eAAA,CAAA3X,EAAA+C,GACA,MACA,CAEApc,EAAA,QAAAixB,MAAA,CAAAxJ,EAAA6I,WAAA,IACA,EACA,KAAAU,eAAA,UAAA3X,CAAA,CAAA+C,CAAA,EACAqL,EAAAyJ,GAAA,GACA,IAAA1tB,EAAAikB,EAAAyI,QAAA,CAAAiB,EAAA3tB,EAAA2tB,KAAA,CAAAC,EAAA5tB,EAAA4tB,YAAA,CACAC,EAAAd,GAAAO,GAAA1U,EAAAqL,EAAA1lB,kBAAA,EAAA0lB,EAAA+I,OAAA,CACA/I,CAAAA,EAAA0I,UAAA,EAAAgB,GACAA,EAAA9X,EAAAgY,GAEAD,GAAAA,EAAA/X,EAAAgY,EACA,EAEAtX,CAr4DAV,EAAAW,OAAA,GAq4DAX,CAAAA,EAAAW,OAAA,CAAAnY,MAAA,KAEA,KAAAquB,QAAA,CAAAA,EACA,KAAAnuB,kBAAA,CAAAA,EAEA,IAAAuvB,EAAAR,GADAlX,GAAAP,GACA,KAAAtX,kBAAA,EACA+X,EAAAwX,EAAAxX,KAAA,CACA4O,EAAA5pB,EAAA0pB,YAAA,GAAAE,SAAA,CACA,KAAA8H,OAAA,EAAAhyB,EAAAiK,QAAA,CAAAjK,EAAAiK,QAAA,IAAwDqR,GAAA,CAAY4O,UAAAA,CAAA,GAAsB,CAC1F,IAAA6I,EAAArB,EAAAqB,cAAA,CACAA,GACAA,EAAAlY,EAAAkX,GAAAe,EAAA,KAAAd,OAAA,GACA,KAAAgB,eAAA,CAAA3yB,EAAAyhB,IAAA,CAAAhF,GAAApY,OAAA,mBAAA2tB,iBAAA,EAAAvV,GAAApY,OAAA,iBAAA8tB,eAAA,EAAA1V,GAAApY,OAAA,qBAAA8tB,eAAA,GACA,CAQA,OAPAf,EAAAlsB,SAAA,CAAA0tB,cAAA,UAAAvB,CAAA,EACA,KAAAA,QAAA,CAAAA,CACA,EACAD,EAAAlsB,SAAA,CAAAmtB,GAAA,YACA,KAAAM,eAAA,OAAAA,eAAA,GACA1yB,EAAA4yB,UAAA,CAAAT,MAAA,MAAAX,WAAA,CACA,EACAL,CACA,IACA,SAAAa,GAAA1U,CAAA,CAAAra,CAAA,EACA,OAAAA,EAAA,CAAkC+X,MAAA/X,EAAAqa,EAAAtC,KAAA,GAAwCsC,CAC1E,CACA,SAAAuV,GAAA7lB,CAAA,CAAAC,CAAA,EACA,OAAaW,EAAAZ,EAAAY,CAAA,CAAAX,EAAAW,CAAA,CAAAC,EAAAb,EAAAa,CAAA,CAAAZ,EAAAY,CAAA,CACb,CACA,SAAA4jB,GAAA/sB,CAAA,CAAAgtB,CAAA,EACA,IAAA1W,EAAAtW,EAAAsW,KAAA,CACA,OACAA,MAAAA,EACA2O,MAAAkJ,GAAA7X,EAAA8X,GAAApB,IACA5c,OAAA+d,GAAA7X,EAKA0W,CAAA,KAJA1rB,SAAAG,SASAurB,CAAA,CAAAvI,CAAA,EACA,GAAAuI,EAAA3uB,MAAA,GACA,OAAiB6K,EAAA,EAAAC,EAAA,GAKjB,IAHA,IAAA3C,EAAAwmB,EAAA3uB,MAAA,GACAgwB,EAAA,KACAC,EAAAF,GAAApB,GAGA,GAFA,IACAqB,EAAArB,CAAA,CAAAxmB,EAAA,EACA8nB,CAAAA,EAAApJ,SAAA,CAAAmJ,EAAAnJ,SAAA,CACArH,GAnBA,GAmBA,IAGArX,IAEA,IAAA6nB,EACA,OAAiBnlB,EAAA,EAAAC,EAAA,GAEjB,IAAAolB,EAAA,CAAAD,EAAApJ,SAAA,CAAAmJ,EAAAnJ,SAAA,MACA,GAAAqJ,IAAAA,EACA,OAAiBrlB,EAAA,EAAAC,EAAA,GAEjB,IAAAhI,EAAA,CACA+H,EAAA,CAAAolB,EAAAplB,CAAA,CAAAmlB,EAAAnlB,CAAA,EAAAqlB,EACAplB,EAAA,CAAAmlB,EAAAnlB,CAAA,CAAAklB,EAAAllB,CAAA,EAAAolB,CACA,EAOA,OANAptB,EAAA+H,CAAA,GAAA+hB,KACA9pB,CAAAA,EAAA+H,CAAA,IAEA/H,EAAAgI,CAAA,GAAA8hB,KACA9pB,CAAAA,EAAAgI,CAAA,IAEAhI,CACA,EA1CA6rB,EAAA,EACA,CACA,CAIA,SAAAoB,GAAApB,CAAA,EACA,OAAAA,CAAA,CAAAA,EAAA3uB,MAAA,IAqCA,SAAAmwB,GAAAC,CAAA,EACA,OAAAA,EAAAC,GAAA,CAAAD,EAAAE,GAAA,CAEA,SAAAC,GAAA7zB,CAAA,CAAAuU,CAAA,CAAAuf,CAAA,EAGA,OAFA,SAAAvf,GAA6BA,CAAAA,EAAA,GAC7B,SAAAuf,GAAkCA,CAAAA,EAAA,KAClCxzB,EAAAoR,QAAA,CAAA1R,EAAAuU,GAAAuf,CACA,CACA,SAAAC,GAAA7J,CAAA,CAAA1V,CAAA,CAAAD,CAAA,CAAAa,CAAA,EACA,SAAAA,GAA6BA,CAAAA,EAAA,IAC7B8U,EAAA9U,MAAA,CAAAA,EACA8U,EAAA8J,WAAA,CAAA1zB,EAAA0X,GAAA,CAAAxD,EAAAof,GAAA,CAAApf,EAAAmf,GAAA,CAAAzJ,EAAA9U,MAAA,EACA8U,EAAA/Y,KAAA,CAAAsiB,GAAAlf,GAAAkf,GAAAjf,GACAqf,CAAAA,GAAA3J,EAAA/Y,KAAA,UAAAqZ,MAAAN,EAAA/Y,KAAA,IACA+Y,CAAAA,EAAA/Y,KAAA,IACA+Y,EAAA+J,SAAA,CACA3zB,EAAA0X,GAAA,CAAAzD,EAAAqf,GAAA,CAAArf,EAAAof,GAAA,CAAAzJ,EAAA9U,MAAA,EAAA8U,EAAA8J,WAAA,CACAH,CAAAA,GAAA3J,EAAA+J,SAAA,GAAAzJ,MAAAN,EAAA+J,SAAA,IACA/J,CAAAA,EAAA+J,SAAA,GACA,CACA,SAAAC,GAAAhK,CAAA,CAAA1V,CAAA,CAAAD,CAAA,CAAAa,CAAA,EACA2e,GAAA7J,EAAA/b,CAAA,CAAAqG,EAAArG,CAAA,CAAAoG,EAAApG,CAAA,CAAAiH,MAAAA,EAAA,OAAAA,EAAAnD,OAAA,EACA8hB,GAAA7J,EAAA9b,CAAA,CAAAoG,EAAApG,CAAA,CAAAmG,EAAAnG,CAAA,CAAAgH,MAAAA,EAAA,OAAAA,EAAAjD,OAAA,CACA,CACA,SAAAgiB,GAAA5f,CAAA,CAAA6f,CAAA,CAAAxqB,CAAA,EACA2K,EAAAqf,GAAA,CAAAhqB,EAAAgqB,GAAA,CAAAQ,EAAAR,GAAA,CACArf,EAAAof,GAAA,CAAApf,EAAAqf,GAAA,CAAAH,GAAAW,EACA,CAKA,SAAAC,GAAA9f,CAAA,CAAAjL,CAAA,CAAAM,CAAA,EACA2K,EAAAqf,GAAA,CAAAtqB,EAAAsqB,GAAA,CAAAhqB,EAAAgqB,GAAA,CACArf,EAAAof,GAAA,CAAApf,EAAAqf,GAAA,CAAAH,GAAAnqB,EACA,CACA,SAAAgrB,GAAA/f,CAAA,CAAAjL,CAAA,CAAAM,CAAA,EACAyqB,GAAA9f,EAAApG,CAAA,CAAA7E,EAAA6E,CAAA,CAAAvE,EAAAuE,CAAA,EACAkmB,GAAA9f,EAAAnG,CAAA,CAAA9E,EAAA8E,CAAA,CAAAxE,EAAAwE,CAAA,CACA,CAwBA,SAAAmmB,GAAAb,CAAA,CAAAE,CAAA,CAAAD,CAAA,EACA,OACAC,IAAAA,KAAA3pB,IAAA2pB,EAAAF,EAAAE,GAAA,CAAAA,EAAA3pB,KAAAA,EACA0pB,IAAAA,KAAA1pB,IAAA0pB,EACAD,EAAAC,GAAA,CAAAA,EAAAD,CAAAA,EAAAC,GAAA,CAAAD,EAAAE,GAAA,EACA3pB,KAAAA,CACA,CACA,CAeA,SAAAuqB,GAAAC,CAAA,CAAAC,CAAA,EAEA,IADAzvB,EACA2uB,EAAAc,EAAAd,GAAA,CAAAa,EAAAb,GAAA,CACAD,EAAAe,EAAAf,GAAA,CAAAc,EAAAd,GAAA,CAOA,OAJAe,EAAAf,GAAA,CAAAe,EAAAd,GAAA,CACAa,EAAAd,GAAA,CAAAc,EAAAb,GAAA,EACA3uB,CAAAA,EAAAA,CAAAA,EAAAhF,EAAAiF,MAAA,EAAAyuB,EAAAC,EAAA,QAAAD,EAAA1uB,CAAA,KAEA,CAAa2uB,IAAAA,EAAAD,IAAAA,CAAA,CACb,CAwDA,SAAAgB,GAAAC,CAAA,CAAAC,CAAA,CAAAC,CAAA,EACA,OACAlB,IAAAmB,GAAAH,EAAAC,GACAlB,IAAAoB,GAAAH,EAAAE,EACA,CACA,CACA,SAAAC,GAAAH,CAAA,CAAAI,CAAA,EACA,IAAA/vB,EACA,uBAAA2vB,EACAA,EACA,OAAA3vB,CAAAA,EAAA2vB,CAAA,CAAAI,EAAA,GAAA/vB,KAAA,IAAAA,EAAAA,EAAA,CACA,CAEA,IAAAgwB,GAAA,WAAoC,OACpChB,UAAA,EACA9iB,MAAA,EACAiE,OAAA,EACA4e,YAAA,CACA,CAAC,EACDkB,GAAA,WAAgC,OAChC/mB,EAAA8mB,KACA7mB,EAAA6mB,IACA,CAAC,EACDE,GAAA,WAA+B,OAAUvB,IAAA,EAAAD,IAAA,EAAgB,EACzDyB,GAAA,WAA8B,OAC9BjnB,EAAAgnB,KACA/mB,EAAA+mB,IACA,CAAC,EAED,SAAAE,GAAAzX,CAAA,EACA,OAAAA,EAAA,KAAAA,EAAA,MAQA,SAAA0X,GAAArwB,CAAA,EACA,IAAA+K,EAAA/K,EAAA+K,GAAA,CACA,OACA7B,EAAA,CAAaylB,IAFb3uB,EAAAkL,IAAA,CAEawjB,IAFb1uB,EAAAgL,KAAA,EAGA7B,EAAA,CAAawlB,IAAA5jB,EAAA2jB,IAHb1uB,EAAAiL,MAAA,CAIA,CACA,CAuBA,SAAAqlB,GAAApkB,CAAA,EACA,OAAAA,KAAAlH,IAAAkH,GAAAA,IAAAA,CACA,CACA,SAAAqkB,GAAAvwB,CAAA,EACA,IAAAkM,EAAAlM,EAAAkM,KAAA,CAAAC,EAAAnM,EAAAmM,MAAA,CAAAC,EAAApM,EAAAoM,MAAA,CACA,OAAAkkB,GAAApkB,IACA,CAAAokB,GAAAnkB,IACA,CAAAmkB,GAAAlkB,EACA,CACA,SAAA+B,GAAAmF,CAAA,MASAvY,EAAAA,EARA,OAAAw1B,GAAAjd,IASAvY,CADAA,EAPAuY,EAAApK,CAAA,GAQAnO,OAAAA,GAAAA,CADAA,EANAuY,EAAAnK,CAAA,GAOApO,OAAAA,GANAuY,EAAAlK,CAAA,EACAkK,EAAAzH,MAAA,EACAyH,EAAAvH,OAAA,EACAuH,EAAAtH,OAAA,CAiBA,SAAAwkB,GAAAla,CAAA,CAAA0Y,CAAA,CAAA9iB,CAAA,CAAA6iB,CAAA,CAAA0B,CAAA,EAIA,OAHAzrB,KAAAA,IAAAyrB,GACAna,CAAAA,EAPAyY,EADA7iB,EADAoK,CAAAA,EASAyY,CATA,CASA,EAEAA,EAVA7iB,EADAoK,CAAAA,EAWAyY,CAXA,EAWAC,CACA,CAIA,SAAA0B,GAAAjC,CAAA,CAAAO,CAAA,CAAA9iB,CAAA,CAAA6iB,CAAA,CAAA0B,CAAA,EACA,SAAAzB,GAAgCA,CAAAA,EAAA,GAChC,SAAA9iB,GAA4BA,CAAAA,EAAA,GAC5BuiB,EAAAE,GAAA,CAAA6B,GAAA/B,EAAAE,GAAA,CAAAK,EAAA9iB,EAAA6iB,EAAA0B,GACAhC,EAAAC,GAAA,CAAA8B,GAAA/B,EAAAC,GAAA,CAAAM,EAAA9iB,EAAA6iB,EAAA0B,EACA,CAIA,SAAAE,GAAAC,CAAA,CAAA5wB,CAAA,EACA,IAAAkJ,EAAAlJ,EAAAkJ,CAAA,CAAAC,EAAAnJ,EAAAmJ,CAAA,CACAunB,GAAAE,EAAA1nB,CAAA,CAAAA,EAAA8lB,SAAA,CAAA9lB,EAAAgD,KAAA,CAAAhD,EAAA6lB,WAAA,EACA2B,GAAAE,EAAAznB,CAAA,CAAAA,EAAA6lB,SAAA,CAAA7lB,EAAA+C,KAAA,CAAA/C,EAAA4lB,WAAA,CACA,CAwCA,SAAA8B,GAAApC,CAAA,CAAAhiB,CAAA,EACAgiB,EAAAE,GAAA,CAAAF,EAAAE,GAAA,CAAAliB,EACAgiB,EAAAC,GAAA,CAAAD,EAAAC,GAAA,CAAAjiB,CACA,CAMA,SAAAqkB,GAAArC,CAAA,CAAAsC,CAAA,CAAA/wB,CAAA,EACA,IAAAmE,EAAAnJ,EAAAiF,MAAA,CAAAD,EAAA,GAAAnC,EAAAsG,CAAA,IAAA6sB,EAAA7sB,CAAA,IAAA8sB,EAAA9sB,CAAA,IACA+sB,EAAAH,KAAA/rB,IAAA+rB,CAAA,CAAAE,EAAA,CAAAF,CAAA,CAAAE,EAAA,IACAlC,EAAA1zB,EAAA0X,GAAA,CAAA0b,EAAAE,GAAA,CAAAF,EAAAC,GAAA,CAAAwC,GAEAR,GAAAjC,EAAAsC,CAAA,CAAAlzB,EAAA,CAAAkzB,CAAA,CAAAC,EAAA,CAAAjC,EAAAgC,EAAA7kB,KAAA,CACA,CAIA,IAAAilB,GAAA,yBACAC,GAAA,yBAIA,SAAAC,GAAAT,CAAA,CAAAlnB,CAAA,EACAonB,GAAAF,EAAA1nB,CAAA,CAAAQ,EAAAynB,IACAL,GAAAF,EAAAznB,CAAA,CAAAO,EAAA0nB,GACA,CAEA,SAAAE,GAAAxqB,CAAA,CAAAwmB,CAAA,EACA,OAAA+C,GAAAkB,SA1IAjb,CAAA,CAAAgX,CAAA,EACA,IAAAA,EACA,OAAAhX,EACA,IAAAkb,EAAAlE,EAAA,CAAmCpkB,EAAAoN,EAAApL,IAAA,CAAA/B,EAAAmN,EAAAvL,GAAA,GACnC0mB,EAAAnE,EAAA,CAAuCpkB,EAAAoN,EAAAtL,KAAA,CAAA7B,EAAAmN,EAAArL,MAAA,GACvC,OACAF,IAAAymB,EAAAroB,CAAA,CACA+B,KAAAsmB,EAAAtoB,CAAA,CACA+B,OAAAwmB,EAAAtoB,CAAA,CACA6B,MAAAymB,EAAAvoB,CAAA,CAEA,EA+HApC,EAAAuN,qBAAA,GAAAiZ,GACA,CAWA,IAAAoE,GAAA,IAAA/X,QAKAgY,GAAA,WACA,SAAAA,EAAA7yB,CAAA,EAIA,KAAA8yB,cAAA,MACA,KAAAC,UAAA,IACA,KAAAC,gBAAA,MACA,KAAA/C,WAAA,EAA6B7lB,EAAA,EAAAC,EAAA,GAI7B,KAAA4oB,WAAA,IACA,KAAAC,qBAAA,IAIA,KAAAC,OAAA,CAAA9B,KACA,KAAArxB,aAAA,CAAAA,CACA,CAyXA,OAxXA6yB,EAAApxB,SAAA,CAAAqB,KAAA,UAAAswB,CAAA,CAAAlyB,CAAA,EACA,IAAAikB,EAAA,KACoCpW,EAAA1J,CAApCnE,KAAA,IAAAA,EAAA,GAAoCA,CAAA,EAAAmyB,YAAA,CAAAA,EAAAtkB,KAAA,IAAAA,GAAAA,CAIpC,WAAA/O,aAAA,CAAAwe,SAAA,EAsFA,MAAA8U,UAAA,KAAA3F,GAAAyF,EAAA,CACAnE,eArFA,SAAAlY,CAAA,EAGAoO,EAAAiC,aAAA,GACAiM,GACAlO,EAAAkO,YAAA,CAAA/b,GAAAP,EAAA,QAAAS,KAAA,CAEA,EA+EA6W,QA9EA,SAAAtX,CAAA,CAAA+C,CAAA,EAGA,IAFA5Y,EAEAmE,EAAA8f,EAAA1iB,QAAA,GAAAlE,EAAA8G,EAAA9G,IAAA,CAAAg1B,EAAAluB,EAAAkuB,eAAA,CAAAC,EAAAnuB,EAAAmuB,WAAA,CACAj1B,CAAAA,CAAAA,GAAAg1B,IACApO,EAAA2N,cAAA,EACA3N,EAAA2N,cAAA,GACA3N,EAAA2N,cAAA,CAAAxZ,GAAA/a,GAEA4mB,EAAA2N,cAAA,CALA,IAQA3N,EAAA4N,UAAA,IACA5N,EAAA6N,gBAAA,MACA7N,EAAAsO,kBAAA,GACAtO,EAAAnlB,aAAA,CAAAkH,UAAA,GACAie,EAAAnlB,aAAA,CAAAkH,UAAA,CAAAwsB,kBAAA,IACAvO,EAAAnlB,aAAA,CAAAkH,UAAA,CAAAsJ,MAAA,CAAAtK,KAAAA,GAKAorB,GAAA,SAAA3B,CAAA,EAEA,IADAzuB,EAAAmE,EACA7E,EAAA2kB,EAAAwO,kBAAA,CAAAhE,GAAAryB,GAAA,MAIA,GAAAhB,EAAAsrB,OAAA,CAAA5e,IAAA,CAAAxI,GAAA,CACA,IAAAozB,EAAA,OAAAvuB,CAAAA,EAAA,OAAAnE,CAAAA,EAAAikB,EAAAnlB,aAAA,CAAAkH,UAAA,GAAAhG,KAAA,IAAAA,EAAA,OAAAA,EAAAqE,MAAA,GAAAF,KAAA,IAAAA,EAAA,OAAAA,EAAAwuB,MAAA,CAAAlE,EAAA,CACA,GAAAiE,EAAA,CACA,IAAAE,EAAApE,GAAAkE,GACApzB,EAAAszB,WAAAtzB,GAAA,IAAAszB,CACA,CACA,CACA3O,EAAA8K,WAAA,CAAAN,EAAA,CAAAnvB,CACA,GAEAgzB,MAAAA,GAAAA,EAAAzc,EAAA+C,GACA,OAAA5Y,CAAAA,EAAAikB,EAAAnlB,aAAA,CAAA+G,cAAA,GAAA7F,KAAA,IAAAA,GAAAA,EAAA6Y,SAAA,CAAA/d,EAAAJ,aAAA,CAAAuvB,IAAA,KACA,EAuCAmD,OAtCA,SAAAvX,CAAA,CAAA+C,CAAA,EAEA,IAAA5Y,EAAAikB,EAAA1iB,QAAA,GAAA8wB,EAAAryB,EAAAqyB,eAAA,CAAAQ,EAAA7yB,EAAA6yB,iBAAA,CAAAC,EAAA9yB,EAAA8yB,eAAA,CAAAC,EAAA/yB,EAAA+yB,MAAA,CAEA,MAAA9O,EAAA2N,cAAA,EAEA,IAsUAoB,EAEAC,EAxUA7iB,EAAAwI,EAAAxI,MAAA,CAEA,GAAAyiB,GAAA5O,OAAAA,EAAA6N,gBAAA,EACA7N,EAAA6N,gBAAA,EAoUA,SAAAkB,GAAoCA,CAAAA,EAAA,IACpCC,EAAA,KACAtpB,KAAAupB,GAAA,CAAA9iB,EAAAjH,CAAA,EAAA6pB,EACAC,EAAA,IAEAtpB,KAAAupB,GAAA,CAAA9iB,EAAAlH,CAAA,EAAA8pB,GACAC,CAAAA,EAAA,KAEAA,GA1UA,OAAAhP,EAAA6N,gBAAA,EACAgB,CAAAA,MAAAA,GAAAA,EAAA7O,EAAA6N,gBAAA,GAEA,MACA,CAEA7N,EAAAkP,UAAA,KAAAva,EAAAtC,KAAA,CAAAlG,GACA6T,EAAAkP,UAAA,KAAAva,EAAAtC,KAAA,CAAAlG,GAOA6T,EAAAnlB,aAAA,CAAA8G,UAAA,GAKAmtB,MAAAA,GAAAA,EAAAld,EAAA+C,GACA,EAQAgV,aAPA,SAAA/X,CAAA,CAAA+C,CAAA,EACA,OAAAqL,EAAAV,IAAA,CAAA1N,EAAA+C,EACA,CAMA,EAAS,CAAIra,mBAAA,KAAAO,aAAA,CAAAs0B,qBAAA,IAAgE,CAC7E,EACAzB,EAAApxB,SAAA,CAAAgjB,IAAA,UAAA1N,CAAA,CAAA+C,CAAA,EACA,IAAAiZ,EAAA,KAAAA,UAAA,CAEA,GADA,KAAAwB,MAAA,GACAxB,GAEA,IAAAvwB,EAAAsX,EAAAtX,QAAA,CACA,KAAAsgB,cAAA,CAAAtgB,GACA,IAAAgyB,EAAA,KAAA/xB,QAAA,GAAA+xB,SAAA,OACAA,GAAAA,EAAAzd,EAAA+C,GACA,EACA+Y,EAAApxB,SAAA,CAAA8yB,MAAA,YAQA,IAPArzB,EAAAmE,CACA,MAAA0tB,UAAA,IACA,KAAA/yB,aAAA,CAAAkH,UAAA,EACA,MAAAlH,aAAA,CAAAkH,UAAA,CAAAwsB,kBAAA,KAEA,OAAAxyB,CAAAA,EAAA,KAAAoyB,UAAA,GAAApyB,KAAA,IAAAA,GAAAA,EAAA0tB,GAAA,GACA,KAAA0E,UAAA,CAAAptB,KAAAA,EAEA,CADA,KAAAzD,QAAA,GAAA8wB,eAAA,EACA,KAAAT,cAAA,GACA,KAAAA,cAAA,GACA,KAAAA,cAAA,OAEA,OAAAztB,CAAAA,EAAA,KAAArF,aAAA,CAAA+G,cAAA,GAAA1B,KAAA,IAAAA,GAAAA,EAAA0U,SAAA,CAAA/d,EAAAJ,aAAA,CAAAuvB,IAAA,IACA,EACA0H,EAAApxB,SAAA,CAAA4yB,UAAA,UAAA1E,CAAA,CAAA8E,CAAA,CAAAnjB,CAAA,EACA,IAAA/S,EAAA,KAAAkE,QAAA,GAAAlE,IAAA,CAEA,MAAAm2B,GAAA/E,EAAApxB,EAAA,KAAAy0B,gBAAA,GAEA,IAhdAxb,EAAAtW,EAAAiyB,EACAtD,EAAAD,EA+cA+E,EAAA,KAAAhB,kBAAA,CAAAhE,GACA/Q,EAAA,KAAAqR,WAAA,CAAAN,EAAA,CAAAre,CAAA,CAAAqe,EAAA,CAEA,KAAAsD,WAAA,OAAAA,WAAA,CAAAtD,EAAA,GAndAnY,EAodAoH,EApdA1d,EAodA,KAAA+xB,WAAA,CAAAtD,EAAA,CApdAwD,EAodA,KAAAA,OAAA,CAAAxD,EAAA,CAndAE,EAAA3uB,EAAA2uB,GAAA,CAAAD,EAAA1uB,EAAA0uB,GAAA,CACAC,KAAA3pB,IAAA2pB,GAAArY,EAAAqY,EAEArY,EAAA2b,EAAA52B,EAAA0X,GAAA,CAAA4b,EAAArY,EAAA2b,EAAAtD,GAAA,EAAAhlB,KAAA+kB,GAAA,CAAApY,EAAAqY,GAEA3pB,KAAAA,IAAA0pB,GAAApY,EAAAoY,GAEApY,CAAAA,EAAA2b,EAAA52B,EAAA0X,GAAA,CAAA2b,EAAApY,EAAA2b,EAAAvD,GAAA,EAAA/kB,KAAAglB,GAAA,CAAArY,EAAAoY,EAAA,EA4cAhR,EA1cApH,GA4cAmd,EAAAhsB,GAAA,CAAAiW,GACA,EACAiU,EAAApxB,SAAA,CAAAgyB,kBAAA,YACA,IA5bAmB,EACA3oB,EAAAG,EAAAD,EAAAD,EA+DA2kB,EA4XA1L,EAAA,KACAjkB,EAAA,KAAAuB,QAAA,GAAA+C,EAAAtE,EAAAsE,eAAA,CAAAqrB,EAAA3vB,EAAA2vB,WAAA,CACAtrB,EAAA,MAAAvF,aAAA,CAAAkH,UAAA,MAAyD3B,MAAA,CACzDsvB,EAAA,KAAA5B,WAAA,CACAztB,GAAAjE,EAAAiE,GACA,KAAAytB,WAAA,EACA,MAAAA,WAAA,MAAA6B,qBAAA,IAIAtvB,GAAAD,EACA,KAAA0tB,WAAA,EAvcA2B,EAucArvB,EAAAsuB,MAAA,CAtcA5nB,EAAA/K,EAAA+K,GAAA,CAAAG,EAAAlL,EAAAkL,IAAA,CAAAD,EAAAjL,EAAAiL,MAAA,CAAAD,EAAAhL,EAAAgL,KAAA,CACA,CACA9B,EAAAomB,GAAAoE,EAAAxqB,CAAA,CAAAgC,EAAAF,GACA7B,EAAAmmB,GAAAoE,EAAAvqB,CAAA,CAAA4B,EAAAE,EACA,GAqcA,KAAA8mB,WAAA,IAGA,KAAAE,OAAA,EA5YA,UADAtC,EA6YAA,IA5YkCA,CAAAA,EALlC,GAKkC,EAClCA,CAAA,IAAAA,EACAA,EAAA,EAEA,KAAAA,GACAA,CAAAA,EAVA,GAUA,EAEA,CACAzmB,EAAAwmB,GAAAC,EAAA,gBACAxmB,EAAAumB,GAAAC,EAAA,eACA,GAuYAgE,IAAA,KAAA5B,WAAA,EACA1tB,GACA,KAAA0tB,WAAA,EACA,MAAAC,qBAAA,EACA5B,GAAA,SAAA3B,CAAA,EACA,GAAAxK,EAAAwO,kBAAA,CAAAhE,GAAA,KAraApqB,EAAA0tB,EACA8B,CAqaA5P,CAAAA,EAAA8N,WAAA,CAAAtD,EAAA,EAtaApqB,EAsaAA,EAAAsuB,MAAA,CAAAlE,EAAA,CAtaAsD,EAsaA9N,EAAA8N,WAAA,CAAAtD,EAAA,CAraAoF,EAAA,GACA7uB,KAAAA,IAAA+sB,EAAApD,GAAA,EACAkF,CAAAA,EAAAlF,GAAA,CAAAoD,EAAApD,GAAA,CAAAtqB,EAAAsqB,GAAA,EAEA3pB,KAAAA,IAAA+sB,EAAArD,GAAA,EACAmF,CAAAA,EAAAnF,GAAA,CAAAqD,EAAArD,GAAA,CAAArqB,EAAAsqB,GAAA,EAEAkF,EA+ZA,CACA,EAEA,EACAlC,EAAApxB,SAAA,CAAAqzB,qBAAA,YACA,IAAA5zB,EAAA,KAAAuB,QAAA,GAAAwwB,EAAA/xB,EAAAsE,eAAA,CAAAwvB,EAAA9zB,EAAA8zB,wBAAA,CACA,IAAA/B,GAAA,CAAA1xB,EAAA0xB,GACA,SACA,IAAAgC,EAAAhC,EAAAzyB,OAAA,CACAnE,EAAAoL,SAAA,CAAAwtB,OAAAA,EAAA,0GACA,IAAA/tB,EAAA,KAAAlH,aAAA,CAAAkH,UAAA,CAEA,IAAAA,GAAA,CAAAA,EAAA3B,MAAA,CACA,SACA,IAAA2vB,GAxNAC,EAwNAjuB,EAAAmV,IAAA,CAvNA+Y,EAAA5C,GAuNAyC,EAAA,KAAAj1B,aAAA,CAAAs0B,qBAAA,KAtNAe,EAAAF,EAAAE,MAAA,IAEAtD,GAAAqD,EAAAhrB,CAAA,CAAAirB,EAAAjrB,CAAA,EACA2nB,GAAAqD,EAAA/qB,CAAA,CAAAgrB,EAAAhrB,CAAA,GAEA+qB,GAkNAE,EA9cA,CACAlrB,EAAAqmB,GAAAmE,CAFAA,EA+cA1tB,EAAA3B,MAAA,CAAAsuB,MAAA,EA7cAzpB,CAAA,CAAA8qB,EAAA9qB,CAAA,EACAC,EAAAomB,GAAAmE,EAAAvqB,CAAA,CAAA6qB,EAAA7qB,CAAA,CACA,EAgdA,GAAA2qB,EAAA,CACA,IA/NAG,EACAC,EACAC,EAxPAT,EAiGA1zB,EACAkJ,EAAAC,EAmXAkrB,EAAAP,GAnXA5qB,EAAAlJ,CADAA,EAoXAo0B,GAnXAlrB,CAAA,CACA,CAAa6B,IAAA5B,CADbA,EAAAnJ,EAAAmJ,CAAA,EACawlB,GAAA,CAAA3jB,MAAA9B,EAAAwlB,GAAA,CAAAzjB,OAAA9B,EAAAulB,GAAA,CAAAxjB,KAAAhC,EAAAylB,GAAA,GAmXb,MAAAqD,qBAAA,GAAAqC,EACAA,GACAD,CAAAA,EAAA/D,GAAAgE,EAAA,CAEA,CACA,OAAAD,CACA,EACAzC,EAAApxB,SAAA,CAAAqhB,cAAA,UAAAtgB,CAAA,EACA,IAAA2iB,EAAA,KACAjkB,EAAA,KAAAuB,QAAA,GAAAlE,EAAA2C,EAAA3C,IAAA,CAAAi3B,EAAAt0B,EAAAs0B,YAAA,CAAA3E,EAAA3vB,EAAA2vB,WAAA,CAAA4E,EAAAv0B,EAAAu0B,cAAA,CAAAC,EAAAx0B,EAAAw0B,gBAAA,CAAAC,EAAAz0B,EAAAy0B,mBAAA,CACA1C,EAAA,KAAAA,WAAA,KAwBA,OAAA/L,QAAA9L,GAAA,CAvBAkW,GAAA,SAAA3B,CAAA,EAEA,GAAA+E,GAAA/E,EAAApxB,EAAA4mB,EAAA6N,gBAAA,GAGA,IAJA9xB,EAIA+T,EAAA,OAAA/T,CAAAA,EAAA+xB,MAAAA,EAAA,OAAAA,CAAA,CAAAtD,EAAA,GAAAzuB,KAAA,IAAAA,EAAAA,EAAA,GACAw0B,GACAzgB,CAAAA,EAAA,CAA+B4a,IAAA,EAAAD,IAAA,IAS/B,IAAAhM,EAAA1nB,EAAAiK,QAAA,CAAAjK,EAAAiK,QAAA,EAA0DuJ,KAAA,UAAAlN,SAAAgzB,EAAAhzB,CAAA,CAAAmtB,EAAA,GAAAiG,gBAF1D/E,EAAA,QAE0DgF,cAD1DhF,EAAA,OAC0DiF,aAAA,IAAAC,UAAA,EAAApV,UAAA,IAA8K8U,GAAAxgB,GAIxO,OAAAkQ,EAAA6Q,uBAAA,CAAArG,EAAA/L,GACA,IAEAyD,IAAA,CAAAsO,EACA,EACA9C,EAAApxB,SAAA,CAAAu0B,uBAAA,UAAArG,CAAA,CAAA1a,CAAA,EACA,IAAA0f,EAAA,KAAAhB,kBAAA,CAAAhE,GACA,OAAA7M,GAAA6M,EAAAgF,EAAA,EAAA1f,EACA,EACA4d,EAAApxB,SAAA,CAAA2lB,aAAA,YACA,IAAAjC,EAAA,KACAmM,GAAA,SAAA3B,CAAA,EAAmC,OAAAxK,EAAAwO,kBAAA,CAAAhE,GAAAlL,IAAA,IACnC,EAOAoO,EAAApxB,SAAA,CAAAkyB,kBAAA,UAAAhE,CAAA,EAEA,IADAzuB,EAAAmE,EACA4wB,EAAA,QAAAtG,EAAAjc,WAAA,GAEA,OAAAwiB,IADA,CAAAl2B,aAAA,CAAAyC,QAAA,GAAAwzB,EAAA,EAGA,KAAAj2B,aAAA,CAAAsoB,QAAA,CAAAqH,EAAA,OAAAtqB,CAAAA,EAAA,OAAAnE,CAAAA,EAAA,KAAAlB,aAAA,CAAAyC,QAAA,GAAAM,OAAA,GAAA7B,KAAA,IAAAA,EAAA,OAAAA,CAAA,CAAAyuB,EAAA,GAAAtqB,KAAA,IAAAA,EAAAA,EAAA,EACA,EACAwtB,EAAApxB,SAAA,CAAA4xB,YAAA,UAAA7b,CAAA,EACA,IAAA2N,EAAA,KACAmM,GAAA,SAAA3B,CAAA,EAGA,GAAA+E,GAAA/E,EAFAxK,EAAA1iB,QAAA,GAAAlE,IAAA,CAEA4mB,EAAA6N,gBAAA,GAEA,IAAA9rB,EAAAie,EAAAnlB,aAAA,CAAAkH,UAAA,CACAytB,EAAAxP,EAAAwO,kBAAA,CAAAhE,GACA,GAAAzoB,GAAAA,EAAA3B,MAAA,EACA,IAAArE,EAAAgG,EAAA3B,MAAA,CAAAsuB,MAAA,CAAAlE,EAAA,CAAAE,EAAA3uB,EAAA2uB,GAAA,CAAAD,EAAA1uB,EAAA0uB,GAAA,CACA+E,EAAAhsB,GAAA,CAAA6O,CAAA,CAAAmY,EAAA,CAAApzB,EAAA0X,GAAA,CAAA4b,EAAAD,EAAA,IACA,EACA,EACA,EAMAiD,EAAApxB,SAAA,CAAA00B,8BAAA,YACA,IACAj1B,EADAikB,EAAA,KAEA9f,EAAA,KAAA5C,QAAA,GAAAlE,EAAA8G,EAAA9G,IAAA,CAAAiH,EAAAH,EAAAG,eAAA,CACA0B,EAAA,KAAAlH,aAAA,CAAAkH,UAAA,CACA,KAAA1B,IAAA0B,GAAA,KAAA+rB,WAAA,EAMA,KAAA7L,aAAA,GAKA,IAAAgP,EAAA,CAA4BhsB,EAAA,EAAAC,EAAA,GAC5BinB,GAAA,SAAA3B,CAAA,EACA,IAAAgF,EAAAxP,EAAAwO,kBAAA,CAAAhE,GACA,GAAAgF,EAAA,CACA,IA9iBAlkB,EAAAD,EACAa,EACAglB,EACAC,EA2iBAC,EAAA5B,EAAAr3B,GAAA,EACA84B,CAAAA,CAAA,CAAAzG,EAAA,EA/iBAlf,EA+iBA,CAAiDof,IAAA0G,EAAA3G,IAAA2G,CAAA,EA/iBjD/lB,EA+iB2E2U,EAAA8N,WAAA,CAAAtD,EAAA,CA9iB3Ete,EAAA,GACAglB,EAAA3G,GAAAjf,GAEA6lB,CADAA,EAAA5G,GAAAlf,IACA6lB,EACAhlB,EAAA9U,EAAAi6B,QAAA,CAAAhmB,EAAAqf,GAAA,CAAArf,EAAAof,GAAA,CAAAyG,EAAA5lB,EAAAof,GAAA,EAEAwG,EAAAC,GACAjlB,CAAAA,EAAA9U,EAAAi6B,QAAA,CAAA/lB,EAAAof,GAAA,CAAApf,EAAAmf,GAAA,CAAA0G,EAAA9lB,EAAAqf,GAAA,GAEAtzB,EAAAk6B,KAAA,KAAAplB,GAsiBA,CACA,GAIA,IAAAvC,EAAA,KAAA9O,aAAA,CAAAyC,QAAA,GAAAqM,iBAAA,CACA,KAAA9O,aAAA,CAAA4c,WAAA,GAAA3N,KAAA,CAAArE,SAAA,CAAAkE,EACAA,EAAA,GAAkC,IAClC,OACA,OAAA5N,CAAAA,EAAAgG,EAAAmV,IAAA,GAAAnb,KAAA,IAAAA,GAAAA,EAAAw1B,YAAA,GACAxvB,EAAAyvB,YAAA,GACA,KAAAlD,kBAAA,GAKAnC,GAAA,SAAA3B,CAAA,EACA,GAAA+E,GAAA/E,EAAApxB,EAAA,OAKA,IAAAo2B,EAAAxP,EAAAwO,kBAAA,CAAAhE,GACAzuB,EAAAikB,EAAA8N,WAAA,CAAAtD,EAAA,CAAAE,EAAA3uB,EAAA2uB,GAAA,CAAAD,EAAA1uB,EAAA0uB,GAAA,CACA+E,EAAAhsB,GAAA,CAAApM,EAAA0X,GAAA,CAAA4b,EAAAD,EAAAwG,CAAA,CAAAzG,EAAA,GACA,GACA,EACAkD,EAAApxB,SAAA,CAAAm1B,YAAA,YACA,IACA11B,EADAikB,EAAA,KAEAyN,GAAAjqB,GAAA,MAAA3I,aAAA,OAKA,IAAA62B,EAAA7d,GAJA,KAAAhZ,aAAA,CAAA4c,WAAA,GAIA,uBAAA7F,CAAA,EACA,IAAA7V,EAAAikB,EAAA1iB,QAAA,GAAAlE,EAAA2C,EAAA3C,IAAA,CAAA8G,EAAAnE,EAAA8U,YAAA,CACAzX,GADA8G,CAAAA,KAAA,IAAAA,GAAAA,CAAA,GACA8f,EAAAriB,KAAA,CAAAiU,EACA,GACA+f,EAAA,WAEAv1B,EADA4jB,EAAA1iB,QAAA,GAAA+C,eAAA,GAEA2f,CAAAA,EAAA8N,WAAA,CAAA9N,EAAA2P,qBAAA,GAEA,EACA5tB,EAAA,KAAAlH,aAAA,CAAAkH,UAAA,CACA6vB,EAAA7vB,EAAAyP,gBAAA,WAAAmgB,GACA5vB,GAAA,CAAAA,EAAA3B,MAAA,GACA,OAAArE,CAAAA,EAAAgG,EAAAmV,IAAA,GAAAnb,KAAA,IAAAA,GAAAA,EAAAw1B,YAAA,GACAxvB,EAAAyvB,YAAA,IAEAG,IAKA,IAAAE,EAAAzgB,GAAA3V,OAAA,oBACA,OAAAukB,EAAAgR,8BAAA,EACA,GAkBA,OAbAjvB,EAAAyP,gBAAA,sBAAAzV,CAAA,EACA,IAAAilB,EAAAjlB,EAAAilB,KAAA,CAAA8Q,EAAA/1B,EAAA+1B,gBAAA,CACA9R,EAAA4N,UAAA,EAAAkE,IACA3F,GAAA,SAAA3B,CAAA,EACA,IAAAlI,EAAAtC,EAAAwO,kBAAA,CAAAhE,GACAlI,IAEAtC,EAAA8K,WAAA,CAAAN,EAAA,EAAAxJ,CAAA,CAAAwJ,EAAA,CAAAO,SAAA,CACAzI,EAAA9e,GAAA,CAAA8e,EAAAnqB,GAAA,GAAA6oB,CAAA,CAAAwJ,EAAA,CAAAO,SAAA,EACA,GACA/K,EAAAnlB,aAAA,CAAA8G,UAAA,GAEA,GACA,WACAkwB,IACAH,IACAE,GACA,CACA,EACAlE,EAAApxB,SAAA,CAAAgB,QAAA,YACA,IAAAzE,EAAA,KAAAgC,aAAA,CAAAyC,QAAA,GACAvB,EAAAlD,EAAAO,IAAA,CAAA8G,EAAArH,EAAA+1B,iBAAA,CAAAhlB,EAAA/Q,EAAAu1B,eAAA,CAAAvkB,EAAAhR,EAAAwH,eAAA,CAAAglB,EAAAxsB,EAAA6yB,WAAA,CAAApG,EAAAzsB,EAAAw3B,YAAA,CACA,OAAAt5B,EAAAiK,QAAA,CAAAjK,EAAAiK,QAAA,IAA+CnI,GAAA,CAAYO,KAD3D2C,KAAA,IAAAA,GAAAA,EAC2D6yB,kBAD3D1uB,KAAA,IAAAA,GAAAA,EAC2DkuB,gBAD3DxkB,KAAA,IAAAA,GAAAA,EAC2DvJ,gBAD3DwJ,KAAA,IAAAA,GAAAA,EAC2D6hB,YAD3DrG,KAAA,IAAAA,EA3mBA,IA2mBAA,EAC2DgL,aAD3D/K,KAAA,IAAAA,GAAAA,CAC2D,EAC3D,EACAoI,CACA,IACA,SAAA6B,GAAAP,CAAA,CAAA51B,CAAA,CAAAy0B,CAAA,EACA,OAAAz0B,CAAA,IAAAA,GAAAA,IAAA41B,CAAA,GACAnB,CAAAA,OAAAA,GAAAA,IAAAmB,CAAA,CACA,CA2EA,IAAA51B,GAAA,CACAI,IAAA0c,GA7BA,SAAAna,CAAA,EACA,IAAAg2B,EAAAh2B,EAAAg2B,KAAA,CAAAC,EAAAj2B,EAAAi2B,UAAA,CAAAC,EAAAl2B,EAAAk2B,QAAA,CAAAC,EAAAn2B,EAAAm2B,iBAAA,CAAAr3B,EAAAkB,EAAAlB,aAAA,CAEAszB,EAAAl3B,EAAAuH,MAAA,OACAlE,EAAArD,EAAA2D,UAAA,CAAAP,GAAAC,kBAAA,CACAmuB,EAAA,CACAqB,eAAAoI,EACAhJ,QAAA8I,EACA7I,OAAA4I,EACArI,MAAA,SAAA9X,CAAA,CAAA+C,CAAA,EACAwZ,EAAA9yB,OAAA,MACA42B,GAAAA,EAAArgB,EAAA+C,EACA,CACA,EACA1d,EAAAkE,SAAA,YACA,OAAAgzB,EAAA9yB,OAAA,EACA8yB,EAAA9yB,OAAA,CAAA2uB,cAAA,CAAAvB,EAEA,GAMA3U,GAAAjZ,EAAA,cAAAs3B,CAtBAJ,GAAAC,GAAAC,GAAAC,CAAA,GAiBA,SAAAtgB,CAAA,EACAuc,EAAA9yB,OAAA,KAAAmtB,GAAA5W,EAAA6W,EAAA,CACAnuB,mBAAAA,CACA,EACA,GAEA2a,GAAA,WAAmC,OAAAkZ,EAAA9yB,OAAA,EAAA8yB,EAAA9yB,OAAA,CAAAouB,GAAA,IACnC,GAIArwB,KAAA8c,GApDA,SAAArd,CAAA,EACA,IAAAu5B,EAAAv5B,EAAAw5B,YAAA,CAAAx3B,EAAAhC,EAAAgC,aAAA,CACAw3B,EAAA/zB,EAAA,WAAiD,WAAAovB,GAAA7yB,EAAA,GAGjD5D,EAAAkE,SAAA,YAAkC,OAAAi3B,GAAAA,EAAA9J,SAAA,CAAA+J,EAAA,EAAwE,CAAAA,EAAAD,EAAA,EAE1Gn7B,EAAAkE,SAAA,YAAkC,OAAAk3B,EAAAZ,YAAA,IAAqC,CAAAY,EAAA,CACvE,EA6CA,EAEAC,GAAA,CACA,gBACA,sBACA,eACA,oBACA,SACA,SACA,oBACA,0BACA,iBACA,uBACA,gBACA,UACA,CAmFAz3B,GAAA,SAAAkB,CAAA,EACA,IAAAmE,EAAAnE,EAAAw2B,QAAA,CAAAA,EAAAryB,KAAA,IAAAA,EAAA,GAAAA,EAAAsyB,EAAAz2B,EAAAy2B,KAAA,CAAAvK,EAAAlsB,EAAAksB,aAAA,CAAAhF,EAAAlnB,EAAAknB,oBAAA,CAAAoK,EAAAtxB,EAAAsxB,kBAAA,CAAAoF,EAAA12B,EAAAyD,MAAA,CAAAkzB,EAAA32B,EAAA22B,qBAAA,CAAAC,EAAA52B,EAAA42B,0BAAA,CAAA9M,EAAA9pB,EAAA8pB,gBAAA,CAAAvX,EAAAvS,EAAAuS,2BAAA,CACA,gBAAAvS,CAAA,CAAA2N,CAAA,EACA,IApFAkpB,EACAC,EACAC,EA4FAjwB,EAiCAkwB,EA3CAryB,EAAA3E,EAAA2E,MAAA,CAAA7H,EAAAkD,EAAAlD,KAAA,CAAA4I,EAAA1F,EAAA0F,UAAA,CAAAC,EAAA3F,EAAA2F,qBAAA,CAAAH,EAAAxF,EAAAwF,WAAA,CAAAX,EAAA7E,EAAA6E,kBAAA,MACA,IAAA8I,GAAkCA,CAAAA,EAAA,IAClC,IAAAspB,EAAA,GACAvpB,EAAAlI,EAAAkI,YAAA,CAAAwE,EAAA1M,EAAA0M,WAAA,CAYA6kB,GAnGAF,EAAAN,GAAAlT,GAAA,YAA2C,WAAAU,EAAA,GAC3C+S,EAAA,GACAC,EAAA,CACAG,kBAAA,WAAyC,OAAAL,EAAA76B,OAAA,UAAAm7B,CAAA,EAA6C,OAAAA,EAAA7S,KAAA,IAAyB,EAC/G8S,oBAAA,SAAAt6B,CAAA,EACAy5B,GAAAv6B,OAAA,UAAAgB,CAAA,EAEA,IADAgD,EACAq3B,EAAA,KAAAr6B,EACAs6B,EAAAx6B,CAAA,CAAAu6B,EAAA,QAEAr3B,CAAAA,EAAA82B,CAAA,CAAA95B,EAAA,GAAAgD,KAAA,IAAAA,GAAAA,EAAAS,IAAA,CAAAq2B,GAEAQ,GACAR,CAAAA,CAAA,CAAA95B,EAAA,CAAA+5B,CAAA,CAAAM,EAAA,CAAAC,EAAA,CAEA,EACA,CACA,EACAT,EAAA76B,OAAA,UAAAm7B,CAAA,CAAA3wB,CAAA,EACAuwB,CAAA,MAAAR,EAAA,CAAA/vB,EAAA,WAAA+O,CAAA,EAA2D,OAAA4hB,EAAA1d,GAAA,CAAAlE,EAAA,EAC3DwhB,CAAA,UAAAR,EAAA,CAAA/vB,EAAA,aAEA,QADA+wB,EAAA,GACAC,EAAA,EAA6BA,EAAAr0B,UAAA9E,MAAA,CAAuBm5B,IACpDD,CAAA,CAAAC,EAAA,CAAAr0B,SAAA,CAAAq0B,EAAA,CAEA,OAAAL,EAAAjT,MAAA,CAAAhhB,KAAA,CAAAi0B,EAAAn8B,EAAA2nB,aAAA,IAAA3nB,EAAAiF,MAAA,CAAAs3B,GAAA,IACA,CACA,GACAR,GA6EAzjB,EAAA,IAAAhM,IAKAmwB,EAAA,IAAAnwB,IAMAowB,EAAA,GAKAC,EAAA38B,EAAAiK,QAAA,IAA0CyI,GAW1C,SAAAjK,IACAqD,GAAAmwB,IAEAW,IACAlB,EAAA5vB,EAAAoL,EAAApV,EAAAiR,KAAA,CAAA6D,EAAA5L,UAAA,EACA,CACA,SAAA4xB,IACAnB,EAAA7kB,EAAAM,EAAAxE,EAAAC,EAAA7Q,EACA,CACA,SAAA2wB,IACAsJ,EAAAc,YAAA,CAAAnqB,EACA,CAIA,SAAAoqB,EAAAj6B,CAAA,CAAA9C,CAAA,EACA,IAAAg9B,EAAAh9B,EAAAyqB,QAAA,UAAAwS,CAAA,EACAtqB,CAAA,CAAA7P,EAAA,CAAAm6B,EACAl7B,EAAA2lB,QAAA,EAAAjmB,EAAA,QAAAixB,MAAA,CAAAA,EAAA,MACA,GACAwK,EAAAl9B,EAAA4qB,eAAA,CAAA/T,EAAAxL,cAAA,EACAqxB,EAAAhwB,GAAA,CAAA5J,EAAA,WACAk6B,IACAE,GACA,EACA,CAWA,IAAAC,EAAA3lB,EAAAzV,GACA,QAAAe,KAAAq6B,EAAA,CACA,IAAAn9B,EAAAm9B,CAAA,CAAAr6B,EAAA,MACAmH,IAAA0I,CAAA,CAAA7P,EAAA,EAAAmL,GAAAjO,IACAA,EAAA0M,GAAA,CAAAiG,CAAA,CAAA7P,EAAA,IAEA,CAIA,IAAA2V,EAAA9R,EAAA5E,GACA2W,EAAAvR,EAAApF,GACA8U,EAAA5W,EAAAiK,QAAA,CAAAjK,EAAAiK,QAAA,EAAsDuxB,SAAAA,EAKtDl3B,QAAA,KAIA64B,MAAAxzB,EAAAA,EAAAwzB,KAAA,KAAAxzB,OAAAA,EAAAjB,SAAA,IAAAkF,IAIAlD,WAAAA,EAAAb,mBAAAA,EAMA+iB,gBAAAnU,EAAA,IAAA7K,IAAA5D,KAAAA,EAOAozB,UAAApzB,KAAAA,EASAumB,uBAAAppB,CAAAA,CAAAwC,CAAAA,MAAAA,EAAA,OAAAA,EAAAsyB,SAAA,IAKAtxB,sBAAAA,EAMAsxB,UAAA,WAAqC,MAAA90B,CAAAA,CAAA2E,CAAA,EAA2BC,MAAA,SAAAsxB,CAAA,EAChEpB,EAAA,GACAnwB,EAAA8K,EAAAtS,OAAA,CAAA+4B,EACAzmB,EAAA5L,UAAA,EACA4L,EAAA5L,UAAA,CAAAe,KAAA,CAAAsxB,GAEA5kB,GAAA9O,GAAA,CAAA6O,GACAwjB,CAAAA,EAAAryB,MAAAA,EAAA,OAAAA,EAAA2zB,eAAA,CAAA1mB,EAAA,EAEA0B,EAAAtX,OAAA,UAAAjB,CAAA,CAAA8C,CAAA,EAAuD,OAAAi6B,EAAAj6B,EAAA9C,EAAA,GACvD4J,MAAAA,GAAAA,EAAAjB,QAAA,CAAA+V,GAAA,CAAA7H,GACAA,EAAApO,QAAA,CAAA1G,EACA,EAIAkK,QAAA,WACA,IAAAhH,CACA,QAAAA,CAAAA,EAAA4R,EAAA5L,UAAA,GAAAhG,KAAA,IAAAA,GAAAA,EAAAgH,OAAA,GACA1L,EAAA4yB,UAAA,CAAAT,MAAA,CAAAA,GACAnyB,EAAA4yB,UAAA,CAAAzqB,MAAA,CAAAA,GACAg0B,EAAAz7B,OAAA,UAAAu8B,CAAA,EAA+D,OAAAA,GAAA,GAC/DvB,MAAAA,GAAAA,IACAryB,MAAAA,GAAAA,EAAAjB,QAAA,CAAAqY,MAAA,CAAAnK,GACAmlB,EAAAG,iBAAA,GACApwB,EAAA9B,KAAAA,EACAiyB,EAAA,EACA,EAIAqB,gBAAA,SAAAtf,CAAA,EAEA,IADAhZ,EACAw4B,EAAA5mB,EAAA6mB,qBAAA,GACA,GAAAD,EAEA,OADA,OAAAx4B,CAAAA,EAAAw4B,EAAA5Q,eAAA,GAAA5nB,KAAA,IAAAA,GAAAA,EAAAyZ,GAAA,CAAAT,GACA,WACA,OAAAwf,EAAA5Q,eAAA,CAAA7L,MAAA,CAAA/C,EACA,CAEA,EAAa8Q,iBAAA,SAAA4O,CAAA,SAIb,GAAAlC,IAAAkC,EAAAlC,QAAA,CAEA1M,EAAAlY,EAAA8J,WAAA,GAAAgd,EAAAhd,WAAA,IADA,CAEA,EAKA+c,sBAAA,WACA,OAAAhlB,EAAA7B,EAAAjN,MAAAA,EAAA,OAAAA,EAAA8zB,qBAAA,EACA,EAIAE,YAAA,WAAuC,OAAA77B,EAAAsH,QAAA,EAIvCsX,YAAA,WAAuC,OAAA5U,CAAA,EAIvC8xB,eAAA,SAAA/6B,CAAA,EAA6C,OAAA6P,CAAA,CAAA7P,EAAA,EAA2Bg7B,eAAA,SAAAh7B,CAAA,CAAA9C,CAAA,EAA0C,OAAA2S,CAAA,CAAA7P,EAAA,CAAA9C,CAAA,EAMlHkL,gBAAA,WAA2C,OAAAyH,CAAA,EAK3CorB,cAAA,SAAAC,CAAA,EACAnnB,EAAAwmB,SAAA,GAAAW,IAEAnnB,EAAAwmB,SAAA,CAAAW,EACAnnB,EAAAxL,cAAA,GACA,EAQA8gB,qBAAA,SAAA5X,CAAA,CAAA0pB,CAAA,EAEA,OADA,SAAAA,GAA4CA,CAAAA,EAAA,IAC5C9R,EAAAtV,EAAAtC,EAAAxS,EAAAk8B,EACA,EAMA1H,mBAAA,WACA,OAAAA,EAAAxqB,EAAAhK,EACA,EAKAuqB,SAAA,SAAAxpB,CAAA,CAAA9C,CAAA,EAEA6W,EAAAuV,QAAA,CAAAtpB,IACA+T,EAAAqnB,WAAA,CAAAp7B,GACAyV,EAAA7L,GAAA,CAAA5J,EAAA9C,GACA2S,CAAA,CAAA7P,EAAA,CAAA9C,EAAAqB,GAAA,GACA07B,EAAAj6B,EAAA9C,EACA,EAIAk+B,YAAA,SAAAp7B,CAAA,EACA,IAAAmC,EACAsT,EAAAyI,MAAA,CAAAle,GACA,OAAAmC,CAAAA,EAAAy3B,EAAAr7B,GAAA,CAAAyB,EAAA,GAAAmC,KAAA,IAAAA,GAAAA,IACAy3B,EAAA1b,MAAA,CAAAle,GACA,OAAA6P,CAAA,CAAA7P,EAAA,CACA+4B,EAAA/4B,EAAAqU,EACA,EAIAiV,SAAA,SAAAtpB,CAAA,EAAuC,OAAAyV,EAAA9L,GAAA,CAAA3J,EAAA,EAKvCupB,SAAA,SAAAvpB,CAAA,CAAAq7B,CAAA,EACA,IAAAn+B,EAAAuY,EAAAlX,GAAA,CAAAyB,GAKA,OAJAmH,KAAAA,IAAAjK,GAAAm+B,KAAAl0B,IAAAk0B,IACAn+B,EAAAwrB,GAAA2S,GACAtnB,EAAAyV,QAAA,CAAAxpB,EAAA9C,IAEAA,CACA,EAIAyG,aAAA,SAAAmX,CAAA,EAAgD,OAAArF,EAAAtX,OAAA,CAAA2c,EAAA,EAMhDsP,UAAA,SAAApqB,CAAA,EACA,IAAAmC,EACA,cAAAA,CAAAA,EAAA0N,CAAA,CAAA7P,EAAA,GAAAmC,KAAA,IAAAA,EAAAA,EAAA22B,EAAA7vB,EAAAjJ,EAAA8P,EACA,EAKAwa,cAAA,SAAAtqB,CAAA,CAAA9C,CAAA,EACA48B,CAAA,CAAA95B,EAAA,CAAA9C,CACA,EAKAmxB,cAAA,SAAAruB,CAAA,EACA,GAAAquB,EAAA,CACA,IAAA5c,EAAA4c,EAAApvB,EAAAe,GACA,GAAAyR,KAAAtK,IAAAsK,GAAA,CAAAtG,GAAAsG,GACA,OAAAA,CACA,CACA,OAAAqoB,CAAA,CAAA95B,EAAA,CACA,EAAek5B,GAAA,CAIfN,MAAA,WAEA,OADAmB,IACA1lB,CACA,EAIA9L,eAAA,WACA5J,EAAA,QAAAiH,MAAA,CAAAA,EAAA,MACA,EAOAmC,WAAAnC,EAKAD,SAAA,SAAA21B,CAAA,EACAA,CAAAA,EAAAvrB,iBAAA,EAAA9Q,EAAA8Q,iBAAA,GACAgE,EAAAxL,cAAA,GAEAtJ,EAAAq8B,EACApC,EAAAK,mBAAA,CAAA+B,GACAzB,EAAA0B,SA9YAxnB,CAAA,CAAA8L,CAAA,CAAAC,CAAA,EACA,IAAA3d,EACA,QAAAnC,KAAA6f,EAAA,CACA,IAAA2b,EAAA3b,CAAA,CAAA7f,EAAA,CACAy7B,EAAA3b,CAAA,CAAA9f,EAAA,CACA,GAAAmL,GAAAqwB,GAKAznB,EAAAyV,QAAA,CAAAxpB,EAAAw7B,QASA,GAAArwB,GAAAswB,GAKA1nB,EAAAyV,QAAA,CAAAxpB,EAAA0oB,GAAA8S,SAEA,GAAAC,IAAAD,GAMA,GAAAznB,EAAAuV,QAAA,CAAAtpB,GAAA,CACA,IAAA07B,EAAA3nB,EAAAwV,QAAA,CAAAvpB,EAEA,CAAA07B,EAAAjU,WAAA,EAAAiU,EAAA9xB,GAAA,CAAA4xB,EACA,MAEAznB,EAAAyV,QAAA,CAAAxpB,EAAA0oB,GAAA,OAAAvmB,CAAAA,EAAA4R,EAAAgnB,cAAA,CAAA/6B,EAAA,GAAAmC,KAAA,IAAAA,EAAAA,EAAAq5B,IAGA,CAEA,QAAAx7B,KAAA8f,EACA3Y,KAAAA,IAAA0Y,CAAA,CAAA7f,EAAA,EACA+T,EAAAqnB,WAAA,CAAAp7B,GAEA,OAAA6f,CACA,EA8VA9L,EAAAW,EAAAzV,GAAA46B,EACA,EAAan2B,SAAA,WAA0B,OAAAzE,CAAA,EAKvC6qB,WAAA,SAAA3qB,CAAA,EAA0C,IAAAgD,EAAQ,cAAAA,CAAAA,EAAAlD,EAAAsE,QAAA,GAAApB,KAAA,IAAAA,EAAA,OAAAA,CAAA,CAAAhD,EAAA,EAIlDojB,qBAAA,WAAgD,OAAAtjB,EAAAiX,UAAA,EAA0Bqf,sBAAA,WAC1E,OAAAt2B,EAAAyB,kBAAA,EAKAssB,kBAAA,SAAA2O,CAAA,EAEA,GADA,SAAAA,GAAgDA,CAAAA,EAAA,IAChDA,EACA,OAAA70B,MAAAA,EAAA,OAAAA,EAAAkmB,iBAAA,GACA,IAAArX,EAAA,CACA,IAAAimB,EAAA,CAAA90B,MAAAA,EAAA,OAAAA,EAAAkmB,iBAAA,QAIA,OAHA7lB,KAAAA,IAAAlI,EAAA+E,OAAA,EACA43B,CAAAA,EAAA53B,OAAA,CAAA/E,EAAA+E,OAAA,EAEA43B,CACA,CAEA,QADAt0B,EAAA,GACAqB,EAAA,EAAgCA,EAAAkzB,GAAqBlzB,IAAA,CACrD,IAAAC,EAAAkzB,EAAA,CAAAnzB,EAAA,CACAnE,EAAAvF,CAAA,CAAA2J,EAAA,CACA3F,CAAAA,EAAAuB,IAAAA,CAAA,IAAAA,CAAA,GACA8C,CAAAA,CAAA,CAAAsB,EAAA,CAAApE,CAAA,CAEA,CACA,OAAA8C,CACA,IACA,OAAAyM,CACA,CACA,EACA+nB,GAAA3+B,EAAA2nB,aAAA,aAAA3nB,EAAAiF,MAAA,CAAA8pB,IAAA,IACA2P,GAAAC,GAAAt7B,MAAA,CAEA,SAAAu7B,GAAA7+B,CAAA,EACA,uBAAAA,GAAAA,EAAAwO,UAAA,UACA,CAUA,IAAAswB,GAAA,uDASA,SAAAC,GAAAx6B,CAAA,CAAAsS,CAAA,CAAAumB,CAAA,EACA,SAAAA,GAA4BA,CAAAA,EAAA,GAC5Bh9B,EAAAoL,SAAA,CAAA4xB,GAHA,EAGA,yDAAAjpB,MAAA,CAAA5P,EAAA,yDACA,IAAAU,EAAAhF,EAAAiF,MAAA,CAAA85B,SAXAz6B,CAAA,EACA,IAAA06B,EAAAH,GAAAI,IAAA,CAAA36B,GACA,IAAA06B,EACA,UACA,IAAAh6B,EAAAhF,EAAAiF,MAAA,CAAA+5B,EAAA,GACA,OADAh6B,CAAA,IAAAA,CAAA,IACA,EAMAV,GAAA,GAAA46B,EAAAl6B,CAAA,IAAAgb,EAAAhb,CAAA,IAEA,GAAAk6B,GAGA,IAAArmB,EAAAnU,OAAAy6B,gBAAA,CAAAvoB,GAAAwoB,gBAAA,CAAAF,UACA,EACArmB,EAAA1E,IAAA,GAEAyqB,GAAA5e,GAEA8e,GAAA9e,EAAApJ,EAAAumB,EAAA,GAGAnd,EAEA,CA8CA,IAAAqf,GAAA,IAAAzxB,IAAA,CACA,QACA,SACA,MACA,OACA,QACA,SACA,IACA,IACA,EACA0xB,GAAA,SAAAz8B,CAAA,EAAuC,OAAAw8B,GAAA7yB,GAAA,CAAA3J,EAAA,EAIvC08B,GAAA,SAAAx/B,CAAA,CAAA4kB,CAAA,EAGA5kB,EAAA0M,GAAA,CAAAkY,EAAA,IACA5kB,EAAA0M,GAAA,CAAAkY,EACA,EACA6a,GAAA,SAAA75B,CAAA,EACA,OAAAA,IAAAvF,EAAAqO,MAAA,EAAA9I,IAAAvF,EAAA2O,EAAA,CAIApP,EADAA,EAOCA,GAAAA,CAAAA,EAAA,KAND,cACAA,EAAA,gBACAA,EAAA,YACAA,EAAA,cACAA,EAAA,UACAA,EAAA,gBAEA,IAAA8/B,GAAA,SAAAC,CAAA,CAAAC,CAAA,EACA,OAAAnZ,WAAAkZ,EAAAE,KAAA,OAAAD,EAAA,CACA,EACAE,GAAA,SAAAC,CAAA,CAAAC,CAAA,EACA,gBAAAC,CAAA,CAAAh7B,CAAA,EACA,IAAA0J,EAAA1J,EAAA0J,SAAA,CACA,GAAAA,SAAAA,GAAA,CAAAA,EACA,SACA,IAAAuxB,EAAAvxB,EAAAswB,KAAA,uBACA,GAAAiB,EACA,OAAAR,GAAAQ,CAAA,IAAAF,GAGA,IAAAL,EAAAhxB,EAAAswB,KAAA,4BACA,EACAS,GAAAC,CAAA,IAAAI,GAGA,CAGA,CACA,EACA7sB,GAAA,IAAArF,IAAA,eACAsyB,GAAA9yB,GAAA4Y,MAAA,UAAAnjB,CAAA,EAA2E,OAAAoQ,GAAAzG,GAAA,CAAA3J,EAAA,GAe3Es9B,GAAA,CAEAzwB,MAAA,SAAA1K,CAAA,CAAAmE,CAAA,EACA,IAAA+E,EAAAlJ,EAAAkJ,CAAA,CACA2E,EAAA1J,EAAAoH,WAAA,CAAAuC,EAAA3J,EAAAkH,YAAA,CACA,OAAAnC,EAAAwlB,GAAA,CAAAxlB,EAAAylB,GAAA,CAAAnN,WADA3T,KAAA,IAAAA,EAAA,IAAAA,GACA2T,WADA1T,KAAA,IAAAA,EAAA,IAAAA,EAEA,EACAlD,OAAA,SAAA5K,CAAA,CAAAmE,CAAA,EACA,IAAAgF,EAAAnJ,EAAAmJ,CAAA,CACA0E,EAAA1J,EAAAiH,UAAA,CAAA0C,EAAA3J,EAAAmH,aAAA,CACA,OAAAnC,EAAAulB,GAAA,CAAAvlB,EAAAwlB,GAAA,CAAAnN,WADA3T,KAAA,IAAAA,EAAA,IAAAA,GACA2T,WADA1T,KAAA,IAAAA,EAAA,IAAAA,EAEA,EACA/C,IAAA,SAAAiwB,CAAA,CAAAh7B,CAAA,EAEA,OAAAwhB,WADAxhB,EAAA+K,GAAA,CAEA,EACAG,KAAA,SAAA8vB,CAAA,CAAAh7B,CAAA,EAEA,OAAAwhB,WADAxhB,EAAAkL,IAAA,CAEA,EACAD,OAAA,SAAAjL,CAAA,CAAAmE,CAAA,EACA,IAAAgF,EAAAnJ,EAAAmJ,CAAA,CAEA,OAAAqY,WADArd,EAAA4G,GAAA,EACA5B,CAAAA,EAAAulB,GAAA,CAAAvlB,EAAAwlB,GAAA,CACA,EACA3jB,MAAA,SAAAhL,CAAA,CAAAmE,CAAA,EACA,IAAA+E,EAAAlJ,EAAAkJ,CAAA,CAEA,OAAAsY,WADArd,EAAA+G,IAAA,EACAhC,CAAAA,EAAAwlB,GAAA,CAAAxlB,EAAAylB,GAAA,CACA,EAEAzlB,EAAA2xB,GAAA,MACA1xB,EAAA0xB,GAAA,KACA,EACAO,GAAA,SAAA9rB,CAAA,CAAAxQ,CAAA,CAAAu8B,CAAA,EACA,IAAAC,EAAAx8B,EAAAwyB,kBAAA,GACA1f,EAAA9S,EAAA4c,WAAA,GACA6f,EAAApB,iBAAAvoB,GACA4pB,EAAAD,EAAAC,OAAA,CACArrB,EAAA,EAGA,UAAAqrB,GACA18B,EAAA+5B,cAAA,WAAAvpB,EAAAksB,OAAA,WAKAH,EAAAr/B,OAAA,UAAA6B,CAAA,EACAsS,CAAA,CAAAtS,EAAA,CAAAs9B,EAAA,CAAAt9B,EAAA,CAAAy9B,EAAAC,EACA,GAEAz8B,EAAA8G,UAAA,GACA,IAAA61B,EAAA38B,EAAAwyB,kBAAA,GAQA,OAPA+J,EAAAr/B,OAAA,UAAA6B,CAAA,EAIA08B,GADAz7B,EAAAsoB,QAAA,CAAAvpB,GACAsS,CAAA,CAAAtS,EAAA,EACAyR,CAAA,CAAAzR,EAAA,CAAAs9B,EAAA,CAAAt9B,EAAA,CAAA49B,EAAAF,EACA,GACAjsB,CACA,EACAosB,GAAA,SAAA58B,CAAA,CAAAwQ,CAAA,CAAAa,CAAA,CAAA2D,CAAA,EACA,SAAA3D,GAA6BA,CAAAA,EAAA,IAC7B,SAAA2D,GAAoCA,CAAAA,EAAA,IACpCxE,EAAAtU,EAAAiK,QAAA,IAA8BqK,GAC9BwE,EAAA9Y,EAAAiK,QAAA,IAAqC6O,GACrC,IAAA6nB,EAAA/gC,OAAAmB,IAAA,CAAAuT,GAAA0R,MAAA,CAAAsZ,IAGAsB,EAAA,GACAC,EAAA,GACAC,EAAA,GA4EA,GA3EAH,EAAA3/B,OAAA,UAAA6B,CAAA,EACA,IAMAk+B,EANAhhC,EAAA+D,EAAAsoB,QAAA,CAAAvpB,GACA,GAAAiB,EAAAqoB,QAAA,CAAAtpB,IAEA,IAAAskB,EAAAhS,CAAA,CAAAtS,EAAA,CACAm+B,EAAAlV,GAAA3E,GACAxC,EAAArQ,CAAA,CAAAzR,EAAA,CAMA,GAAA6U,GAAAiN,GAAA,CACA,IAAAsc,EAAAtc,EAAAthB,MAAA,CACA69B,EAAAvc,OAAAA,CAAA,QAEAqc,EAAAlV,GADA3E,EAAAxC,CAAA,CAAAuc,EAAA,EAEA,QAAA11B,EAAA01B,EAAoC11B,EAAAy1B,EAAkBz1B,IACtDu1B,EAMA5gC,EAAAoL,SAAA,CAAAugB,GAAAnH,CAAA,CAAAnZ,EAAA,IAAAu1B,EAAA,2CALAA,EAAAjV,GAAAnH,CAAA,CAAAnZ,EAAA,EACArL,EAAAoL,SAAA,CAAAw1B,IAAAC,GACAxB,GAAAwB,IAAAxB,GAAAuB,GAAA,gEAMA,MAEAA,EAAAjV,GAAAnH,GAEA,GAAAqc,IAAAD,GAGA,GAAAvB,GAAAwB,IAAAxB,GAAAuB,GAAA,CACA,IA1HAI,EA0HA78B,EAAAvE,EAAAqB,GAAA,EACA,kBAAAkD,GACAvE,EAAA0M,GAAA,CAAA+Z,WAAAliB,IAEA,iBAAAqgB,EACArQ,CAAA,CAAAzR,EAAA,CAAA2jB,WAAA7B,GAEA/e,MAAAC,OAAA,CAAA8e,IAAAoc,IAAA3gC,EAAA2O,EAAA,EACAuF,CAAAA,CAAA,CAAAzR,EAAA,CAAA8hB,EAAA0D,GAAA,CAAA7B,WAAA,CAEA,KACA,CAAAwa,MAAAA,EAAA,OAAAA,EAAAtyB,SAAA,GACAqyB,CAAAA,MAAAA,EAAA,OAAAA,EAAAryB,SAAA,GACAyY,CAAAA,IAAAA,GAAAxC,IAAAA,CAAA,EAGAwC,IAAAA,EACApnB,EAAA0M,GAAA,CAAAs0B,EAAAryB,SAAA,CAAAyY,IAGA7S,CAAA,CAAAzR,EAAA,CAAAm+B,EAAAtyB,SAAA,CAAAiW,IAMAkc,IApJAM,EAAA,GACAjB,GAAAl/B,OAAA,UAAA6B,CAAA,EACA,IAAA9C,EAAA+D,EAAAsoB,QAAA,CAAAvpB,EACAmH,MAAAA,IAAAjK,IACAohC,EAAAz1B,IAAA,EAAA7I,EAAA9C,EAAAqB,GAAA,KACArB,EAAA0M,GAAA,CAAA5J,EAAA0L,UAAA,eAEA,GAEA4yB,EAAA99B,MAAA,EACAS,EAAA8G,UAAA,GA2IAg2B,EA1IAO,EA4IAN,EAAA,IAEAC,EAAAp1B,IAAA,CAAA7I,GACAiW,CAAA,CAAAjW,EAAA,CACAiW,KAAA9O,IAAA8O,CAAA,CAAAjW,EAAA,CACAiW,CAAA,CAAAjW,EAAA,CACAyR,CAAA,CAAAzR,EAAA,CACA08B,GAAAx/B,EAAA4kB,KAGA,IACAmc,EAAAz9B,MAAA,CAoBA,OAAiBiR,OAAAA,EAAAwE,cAAAA,CAAA,EAnBjB,IAAAsoB,EAAAN,EAAAj0B,OAAA,cACAnI,OAAA28B,WAAA,CACA,KACAC,EAAAlB,GAAA9rB,EAAAxQ,EAAAg9B,GAaA,OAXAF,EAAAv9B,MAAA,EACAu9B,EAAA5/B,OAAA,UAAAgE,CAAA,EACA,IAAAmE,EAAAnJ,EAAAiF,MAAA,CAAAD,EAAA,GAAAnC,EAAAsG,CAAA,IAAApJ,EAAAoJ,CAAA,IACArF,EAAAsoB,QAAA,CAAAvpB,GAAA4J,GAAA,CAAA1M,EACA,GAGA+D,EAAA8G,UAAA,GAEA,OAAAw2B,GACA18B,OAAA68B,QAAA,EAA8BxxB,IAAAqxB,CAAA,GAC9B,CAAiB9sB,OAAAgtB,EAAAxoB,cAAAA,CAAA,CAKjB,EAkBA0oB,GAAA,SAAA19B,CAAA,CAAAwQ,CAAA,CAAAa,CAAA,CAAA2D,CAAA,EACA,IAXAxE,EAAAwE,EAWAD,EAAA4oB,SA7SA39B,CAAA,CAAAkB,CAAA,CAAA8T,CAAA,EAEA,IADA3P,EACAmL,EAAAtU,EAAAkW,MAAA,CAAAlR,EAAA,IACA4R,EAAA9S,EAAA4c,WAAA,GACA,IAAA9J,CAAAA,aAAA8qB,OAAA,EACA,OAAiBptB,OAAAA,EAAAwE,cAAAA,CAAA,EAiBjB,QAAAjW,KAdAiW,GACAA,CAAAA,EAAA9Y,EAAAiK,QAAA,IAAyC6O,EAAA,EAGzChV,EAAA0C,YAAA,UAAAzG,CAAA,EACA,IAAAuE,EAAAvE,EAAAqB,GAAA,GACA,GAAAw9B,GAAAt6B,IAEA,IAAAuU,EAAAimB,GAAAx6B,EAAAsS,GACAiC,GACA9Y,EAAA0M,GAAA,CAAAoM,GACA,GAGAvE,EAAA,CACA,IAAAhQ,EAAAgQ,CAAA,CAAAzR,EAAA,CACA,GAAA+7B,GAAAt6B,IAEA,IAAAuU,EAAAimB,GAAAx6B,EAAAsS,GACAiC,IAGAvE,CAAA,CAAAzR,EAAA,CAAAgW,EAIAC,GACA,QAAA3P,CAAAA,EAAA2P,CAAA,CAAAjW,EAAA,GAAAsG,KAAA,IAAAA,GAAA2P,CAAAA,CAAA,CAAAjW,EAAA,CAAAyB,CAAA,IACA,CACA,OAAagQ,OAAAA,EAAAwE,cAAAA,CAAA,CACb,EAuQAhV,EAAAwQ,EAAAwE,GAGA,OAdAxE,EAYAA,EAAAuE,EAAAvE,MAAA,CAZAwE,EAaAA,EAAAD,EAAAC,aAAA,CAZA6oB,OA/OA5gC,IAAA,CA+OAuT,GA/OAvS,IAAA,CAAAu9B,IAgPAoB,GAYA58B,EAZAwQ,EAYAa,EAZA2D,GACA,CAAYxE,OAAAA,EAAAwE,cAAAA,CAAA,CAYZ,EAKA8oB,GAAA,CACApG,SAAA,MACAG,sBAAA,SAAAkG,CAAA,CAAAh/B,CAAA,EACA,GAAAgL,GAAAhL,GAAA,CACA,IAAAi/B,EAAA5b,GAAArjB,GACA,OAAAi/B,GAAAA,EAAAruB,OAAA,GACA,CAEA,IAAAsuB,EAVAr9B,OAAAy6B,gBAAA,CAUA0C,GACA,OAAAvzB,GAAAzL,GACAk/B,EAAA3C,gBAAA,CAAAv8B,GACAk/B,CAAA,CAAAl/B,EAAA,IAEA,EACAisB,iBAAA,SAAAxhB,CAAA,CAAAC,CAAA,EAMA,OAAAD,EAAAA,EAAA00B,uBAAA,CAAAz0B,GAAA,IACA,EACA2jB,cAAA,SAAApvB,CAAA,CAAAe,CAAA,EACA,IAAAmC,EACA,cAAAA,CAAAA,EAAAlD,EAAAiR,KAAA,GAAA/N,KAAA,IAAAA,EAAA,OAAAA,CAAA,CAAAnC,EAAA,EAEAyzB,mBAAA,SAAA1f,CAAA,CAAA5R,CAAA,EAEA,OAAAsxB,GAAA1f,EADA5R,EAAAzB,kBAAA,CAEA,EAQA0+B,eAAA,SAAArrB,CAAA,CAAAirB,CAAA,CAAA//B,CAAA,EACA,IAAA8Q,EAAA9Q,EAAA8Q,iBAAA,CACAivB,EAAA9uB,KAAA,CAAArE,SAAA,CAAAkE,EACAA,EAAA,GAAkC,IAClC,OAEAgE,EAAAxL,cAAA,EACA,EACA82B,iBAAA,SAAAp2B,CAAA,CAAAq2B,CAAA,EACAr2B,EAAAiH,KAAA,CAAArE,SAAA,CAAAyzB,EAAApvB,KAAA,CAAArE,SAAA,EAEAktB,2BAAA,SAAA/4B,CAAA,CAAAmC,CAAA,EACA,IAAAgO,EAAAhO,EAAAgO,IAAA,CAAAD,EAAA/N,EAAA+N,KAAA,QACAC,CAAA,CAAAnQ,EAAA,CACA,OAAAkQ,CAAA,CAAAlQ,EAAA,EAMAqpB,qBAAA,SAAAtV,CAAA,CAAA5R,CAAA,CAAAmE,CAAA,CAAA8yB,CAAA,EACA,IAAApiB,EAAA1Q,EAAA0Q,eAAA,MACA,IAAAoiB,GAAoCA,CAAAA,EAAA,IACpC,IAAAljB,EAAA/T,EAAA+T,UAAA,CAAAD,EAAA9T,EAAA8T,aAAA,CAAAxE,EAAAtU,EAAAkW,MAAA,CAAAlR,EAAA,gCACAmQ,EAAAiY,GAAA9Y,EAAAyE,GAAA,GAAuDnC,GAYvD,GARAiD,IACAf,GACAA,CAAAA,EAAAe,EAAAf,EAAA,EACAxE,GACAA,CAAAA,EAAAuF,EAAAvF,EAAA,EACAa,GACAA,CAAAA,EAAA0E,EAAA1E,EAAA,GAEA8mB,EAAA,CACApP,GAAAjW,EAAAtC,EAAAa,GACA,IAAAitB,EAAAZ,GAAA5qB,EAAAtC,EAAAa,EAAA2D,GACAA,EAAAspB,EAAAtpB,aAAA,CACAxE,EAAA8tB,EAAA9tB,MAAA,CAEA,OAAAtU,EAAAiK,QAAA,EAAgC8O,WAAAA,EAAAD,cAAAA,CAAA,EAAsDxE,EACtF,EACAiD,4BAAAF,GACAokB,MAAA,SAAA7kB,CAAA,CAAAM,CAAA,CAAAxE,CAAA,CAAAC,CAAA,CAAA7Q,CAAA,EACAkI,KAAAA,IAAA4M,EAAAwmB,SAAA,EACAlmB,CAAAA,EAAAnE,KAAA,CAAAgrB,UAAA,CAAAnnB,EAAAwmB,SAAA,CACA,UACA,UAEA5qB,GAAA0E,EAAAxE,EAAAC,EAAA7Q,EAAA8Q,iBAAA,CACA,EACAnK,OAAAkO,EACA,EACA0rB,GAAAv+B,GAAA89B,IAEAU,GAAAx+B,GAAA9D,EAAAiK,QAAA,CAAAjK,EAAAiK,QAAA,IAAqE23B,IAAA,CAAiB1Q,cAAA,SAAApvB,CAAA,CAAAe,CAAA,EACtF,OAAAf,CAAA,CAAAe,EAAA,EACK84B,sBAAA,SAAAkG,CAAA,CAAAh/B,CAAA,EACL,IAAAmC,SACA,GAAAnC,GACA,QAAAmC,CAAAA,EAAAkhB,GAAArjB,EAAA,GAAAmC,KAAA,IAAAA,EAAA,OAAAA,EAAAyO,OAAA,MAEA5Q,EAAA,GAAA2J,GAAA,CAAA3J,GAAAA,EAAA0T,GAAA1T,GACAg/B,EAAAU,YAAA,CAAA1/B,GACA,EAAK0U,4BAAAA,GAAAkkB,MAAA,SAAA+G,CAAA,CAAAtrB,CAAA,CAAAxE,CAAA,CAAAC,CAAA,CAAA7Q,CAAA,EACL0T,GAAA0B,EAAAxE,EAAAC,EAAA7Q,EAAA8Q,iBAAA,CACA,EAAKnK,OAAAwO,EAAA,IAELwrB,GAAA,SAAA1/B,CAAA,CAAA4P,CAAA,EACA,OAAAhG,EAAA5J,GACAu/B,GAAA3vB,EAAA,CAAsCiB,2BAAA,KACtCyuB,GAAA1vB,EAAA,CAAuCiB,2BAAA,IACvC,EAEA,SAAA8uB,GAAAC,CAAA,CAAAlP,CAAA,SACA,EAAAC,GAAA,GAAAD,EAAAE,GAAA,CACA,EACA,EAAAF,CAAAA,EAAAC,GAAA,CAAAD,EAAAE,GAAA,KACA,CAQA,IAAAiP,GAAA,CACAC,QAAA,SAAAxI,CAAA,CAAAyI,CAAA,EACA,IAAAA,EAAAxuB,MAAA,CACA,OAAA+lB,EAKA,oBAAAA,EAAA,CACA,IAAAj6B,EAAA2O,EAAA,CAAAjC,IAAA,CAAAutB,GAIA,OAAAA,EAHAA,EAAA7T,WAAA6T,EAKA,CAKA,IAAAnsB,EAAAw0B,GAAArI,EAAAyI,EAAAxuB,MAAA,CAAApG,CAAA,EACAC,EAAAu0B,GAAArI,EAAAyI,EAAAxuB,MAAA,CAAAnG,CAAA,EACA,SAAA+F,MAAA,CAAAhG,EAAA,MAAAgG,MAAA,CAAA/F,EAAA,IACA,CACA,EAEA40B,GAAA,QAqDAC,GAAA,SAAA/6B,CAAA,EAEA,SAAA+6B,IACA,OAAA/6B,OAAAA,GAAAA,EAAAC,KAAA,MAAAC,YAAA,KA+FA,OAjGAnI,EAAAoI,SAAA,CAAA46B,EAAA/6B,GASA+6B,EAAAz9B,SAAA,CAAA09B,iBAAA,YACA,IAAAha,EAAA,KACAjkB,EAAA,KAAAlD,KAAA,CAAAgC,EAAAkB,EAAAlB,aAAA,CAAAo/B,EAAAl+B,EAAAk+B,WAAA,CAAAC,EAAAn+B,EAAAm+B,iBAAA,CAAA/5B,EAAApE,EAAAoE,QAAA,CACA4B,EAAAlH,EAAAkH,UAAA,CACAgC,GAAAo2B,IACAp4B,IACAk4B,CAAAA,MAAAA,EAAA,OAAAA,EAAAG,KAAA,GACAH,EAAAG,KAAA,CAAA5kB,GAAA,CAAAzT,GACAm4B,CAAAA,MAAAA,EAAA,OAAAA,EAAA3gB,QAAA,GAAApZ,GACA+5B,EAAA3gB,QAAA,CAAAxX,GAEAA,EAAAmV,IAAA,CAAAmjB,SAAA,GACAt4B,EAAAyP,gBAAA,gCACAwO,EAAAuI,YAAA,EACA,GACAxmB,EAAAE,UAAA,CAAAlL,EAAAiK,QAAA,CAAAjK,EAAAiK,QAAA,IAAkEe,EAAA2H,OAAA,GAAyB4P,eAAA,WAA8B,OAAA0G,EAAAuI,YAAA,QAEzH9pB,EAAAE,cAAA,GACA,EACAo7B,EAAAz9B,SAAA,CAAA8C,uBAAA,UAAAk7B,CAAA,EACA,IAAAta,EAAA,KACAjkB,EAAA,KAAAlD,KAAA,CAAA0hC,EAAAx+B,EAAAw+B,gBAAA,CAAA1/B,EAAAkB,EAAAlB,aAAA,CAAAzB,EAAA2C,EAAA3C,IAAA,CAAAigB,EAAAtd,EAAAsd,SAAA,CACAtX,EAAAlH,EAAAkH,UAAA,QACAA,IASAA,EAAAsX,SAAA,CAAAA,EACAjgB,GACAkhC,EAAAC,gBAAA,GAAAA,GACAA,KAAAx5B,IAAAw5B,EACAx4B,EAAAy4B,UAAA,GAGA,KAAAjS,YAAA,GAEA+R,EAAAjhB,SAAA,GAAAA,IACAA,EACAtX,EAAA04B,OAAA,GAEA14B,EAAA24B,QAAA,IAMAniC,EAAA,QAAA2oB,UAAA,YACA,IAAAnlB,EACA,QAAAA,CAAAA,EAAAgG,EAAA44B,QAAA,KAAA5+B,KAAA,IAAAA,EAAA,OAAAA,EAAA6+B,OAAA,CAAAxgC,MAAA,GACA4lB,EAAAuI,YAAA,EAEA,KAhCA,IAoCA,EACAwR,EAAAz9B,SAAA,CAAAgD,kBAAA,YACA,IAAAyC,EAAA,KAAAlJ,KAAA,CAAAgC,aAAA,CAAAkH,UAAA,CACAA,IACAA,EAAAmV,IAAA,CAAAmjB,SAAA,GACA,CAAAt4B,EAAA84B,gBAAA,EAAA94B,EAAA+4B,MAAA,IACA,KAAAvS,YAAA,GAGA,EACAwR,EAAAz9B,SAAA,CAAAy+B,oBAAA,YACA,IAAAh/B,EAAA,KAAAlD,KAAA,CAAAgC,EAAAkB,EAAAlB,aAAA,CAAAo/B,EAAAl+B,EAAAk+B,WAAA,CAAAe,EAAAj/B,EAAAm+B,iBAAA,CACAn4B,EAAAlH,EAAAkH,UAAA,CACAA,IACAA,EAAAk5B,yBAAA,GACAhB,CAAAA,MAAAA,EAAA,OAAAA,EAAAG,KAAA,GACAH,EAAAG,KAAA,CAAA9F,MAAA,CAAAvyB,GACAi5B,CAAAA,MAAAA,EAAA,OAAAA,EAAAE,UAAA,GACAF,EAAAE,UAAA,CAAAn5B,GAEA,EACAg4B,EAAAz9B,SAAA,CAAAisB,YAAA,YACA,IAAAA,EAAA,KAAA1vB,KAAA,CAAA0vB,YAAA,OACAA,GAAAA,GACA,EACAwR,EAAAz9B,SAAA,CAAAkD,MAAA,YACA,WACA,EACAu6B,CACA,EAACzhC,EAAA,QAAAwB,SAAA,EAMDqgC,GAAA,CACAh0B,aAAApP,EAAAiK,QAAA,CAAAjK,EAAAiK,QAAA,IAAkD24B,IAAA,CAA0BwB,QAAA,CAC5E,sBACA,uBACA,yBACA,0BACA,GACA90B,oBAAAszB,GACArzB,qBAAAqzB,GACAnzB,uBAAAmzB,GACApzB,wBAAAozB,GACAyB,UAxKA,CACAxB,QAAA,SAAAxI,CAAA,CAAAr1B,CAAA,EACA,IAAAs/B,EAAAt/B,EAAAs/B,SAAA,CAAAC,EAAAv/B,EAAAu/B,eAAA,CACAC,EAAAnK,EAIAoK,EAAApK,EAAAztB,QAAA,SACA83B,EAAA,GACAD,GACApK,CAAAA,EAAAA,EAAA5jB,OAAA,CAAAooB,GAAA,SAAAG,CAAA,EAEA,OADA0F,EAAAh5B,IAAA,CAAAszB,GACA+D,EACA,EAAa,EAEb,IAAA4B,EAAAvkC,EAAAikB,OAAA,CAAAwH,KAAA,CAAAwO,GAEA,GAAAsK,EAAAthC,MAAA,GACA,OAAAmhC,EACA,IAAAI,EAAAxkC,EAAAikB,OAAA,CAAAwgB,iBAAA,CAAAxK,GACAjlB,EAAA,iBAAAuvB,CAAA,QAEAG,EAAAP,EAAAr2B,CAAA,CAAAgD,KAAA,CAAAozB,EAAAp2B,CAAA,CACA62B,EAAAR,EAAAp2B,CAAA,CAAA+C,KAAA,CAAAozB,EAAAn2B,CAAA,CACAw2B,CAAA,GAAAvvB,EAAA,EAAA0vB,EACAH,CAAA,GAAAvvB,EAAA,EAAA2vB,EAOA,IAAAC,EAAA3kC,EAAA0X,GAAA,CAAA+sB,EAAAC,EAAA,GAEA,kBAAAJ,CAAA,GAAAvvB,EAAA,EACAuvB,CAAAA,CAAA,GAAAvvB,EAAA,EAAA4vB,CAAA,EAEA,iBAAAL,CAAA,GAAAvvB,EAAA,EACAuvB,CAAAA,CAAA,GAAAvvB,EAAA,EAAA4vB,CAAA,EACA,IAAAC,EAAAL,EAAAD,GACA,GAAAF,EAAA,CACA,IAAAS,EAAA,EACAD,EAAAA,EAAAxuB,OAAA,CAAAssB,GAAA,WACA,IAAAoC,EAAAT,CAAA,CAAAQ,EAAA,CAEA,OADAA,IACAC,CACA,EACA,CACA,OAAAF,CACA,CACA,CAuHA,EAEAG,GAAA,CACAljC,cApBA,SAAAJ,CAAA,EACA,IAAAkD,EAAAhF,EAAAiF,MAAA,CAAAod,KAAA,GAAAC,EAAAtd,CAAA,IAAAwsB,EAAAxsB,CAAA,IACAk+B,EAAAhjC,EAAA2D,UAAA,CAAAiE,GACA,OAAAvG,EAAA,QAAAoK,aAAA,CAAAq3B,GAAAhjC,EAAAiK,QAAA,IAA+FnI,EAAA,CAAWohC,YAAAA,EAAAC,kBAAAjjC,EAAA2D,UAAA,CAAAkE,GAAAua,UAAAA,EAAAkP,aAAAA,CAAA,GAC1G,CAiBA,EA6BA,SAAA7qB,GAAAwgB,CAAA,CAAAxC,CAAA,CAAA5L,CAAA,EACA,SAAAA,GAAiCA,CAAAA,EAAA,IACjC,IAAAhZ,EAAAiO,GAAAmZ,GAAAA,EAAAoE,GAAApE,GAEA,OADAP,GAAA,GAAA7mB,EAAA4kB,EAAA5L,GACA,CACAwP,KAAA,WAA4B,OAAAxoB,EAAAwoB,IAAA,IAC5B8C,YAAA,WAAmC,OAAAtrB,EAAAsrB,WAAA,GACnC,CACA,CAEA,IAAAga,GAAA,kDACAC,GAAAD,GAAAhiC,MAAA,CACAkiC,GAAA,SAAAxlC,CAAA,EACA,uBAAAA,EAAAymB,WAAAzmB,GAAAA,CACA,EACAylC,GAAA,SAAAzlC,CAAA,EACA,uBAAAA,GAAAK,EAAA2O,EAAA,CAAAjC,IAAA,CAAA/M,EACA,EA4CA,SAAA0lC,GAAAntB,CAAA,CAAAotB,CAAA,EACA,IAAA1gC,EACA,cAAAA,CAAAA,EAAAsT,CAAA,CAAAotB,EAAA,GAAA1gC,KAAA,IAAAA,EAAAA,EAAAsT,EAAAlJ,YAAA,CAyBA,IAAAu2B,GAAAC,GAAA,KAAAvlC,EAAAijB,OAAA,EACAuiB,GAAAD,GAAA,OAAAvlC,EAAA2iB,MAAA,EACA,SAAA4iB,GAAAjS,CAAA,CAAAD,CAAA,CAAAoS,CAAA,EACA,gBAAAtiC,CAAA,SAEA,EAAAmwB,EACA,EACAnwB,EAAAkwB,EACA,EACAoS,EAAAzlC,EAAAi6B,QAAA,CAAA3G,EAAAD,EAAAlwB,GACA,CACA,CAOA,SAAAuiC,GAAAtS,CAAA,CAAAuS,CAAA,EACAvS,EAAAE,GAAA,CAAAqS,EAAArS,GAAA,CACAF,EAAAC,GAAA,CAAAsS,EAAAtS,GAAA,CAOA,SAAAuS,GAAArQ,CAAA,CAAAsQ,CAAA,EACAH,GAAAnQ,EAAA1nB,CAAA,CAAAg4B,EAAAh4B,CAAA,EACA63B,GAAAnQ,EAAAznB,CAAA,CAAA+3B,EAAA/3B,CAAA,CACA,CAKA,SAAAg4B,GAAA7qB,CAAA,CAAA0Y,CAAA,CAAA9iB,CAAA,CAAA6iB,CAAA,CAAA0B,CAAA,EAMA,OALAna,GAAA0Y,EACA1Y,EA73DAyY,EADA7iB,EA83DAA,EA/3DAoK,CAAAA,EA+3DAyY,CA/3DA,EAg4DA/pB,KAAAA,IAAAyrB,GACAna,CAAAA,EA/3DAyY,EADA7iB,EAg4DAukB,EAj4DAna,CAAAA,EAi4DAyY,CAj4DA,CAi4DA,EAEAzY,CACA,CA2BA,SAAA8qB,GAAA3S,CAAA,CAAAsC,CAAA,CAAA/wB,CAAA,CAAAmQ,CAAA,CAAAkxB,CAAA,EACA,IAAAl9B,EAAAnJ,EAAAiF,MAAA,CAAAD,EAAA,GAAAnC,EAAAsG,CAAA,IAAA6sB,EAAA7sB,CAAA,IAAA8sB,EAAA9sB,CAAA,KACAm9B,SAzBA7S,CAAA,CAAAO,CAAA,CAAA9iB,CAAA,CAAAiE,CAAA,CAAAsgB,CAAA,CAAAuQ,CAAA,CAAAK,CAAA,EAWA,GAVA,SAAArS,GAAgCA,CAAAA,EAAA,GAChC,SAAA9iB,GAA4BA,CAAAA,EAAA,GAC5B,SAAAiE,GAA6BA,CAAAA,EAAA,IAC7B,SAAA6wB,GAAiCA,CAAAA,EAAAvS,CAAA,EACjC,SAAA4S,GAAiCA,CAAAA,EAAA5S,CAAA,EACjCrzB,EAAAsrB,OAAA,CAAA5e,IAAA,CAAAknB,KACAA,EAAAxN,WAAAwN,GAEAA,EAAAuS,EADAxuB,GAAA,CAAAsuB,EAAA1S,GAAA,CAAA0S,EAAA3S,GAAA,CAAAM,EAAA,KACAqS,EAAA1S,GAAA,EAEA,iBAAAK,GAEA,IAAAD,EAAA1zB,EAAA0X,GAAA,CAAAiuB,EAAArS,GAAA,CAAAqS,EAAAtS,GAAA,CAAAve,GACAse,IAAAuS,GACAjS,CAAAA,GAAAC,CAAA,EACAP,EAAAE,GAAA,CAAAwS,GAAA1S,EAAAE,GAAA,CAAAK,EAAA9iB,EAAA6iB,EAAA0B,GACAhC,EAAAC,GAAA,CAAAyS,GAAA1S,EAAAC,GAAA,CAAAM,EAAA9iB,EAAA6iB,EAAA0B,GACA,EAOAhC,EAAAsC,CAAA,CAAAlzB,EAAA,CAAAkzB,CAAA,CAAAC,EAAA,CAAAD,CAAA,CAAAE,EAAA,CAAAF,EAAA7kB,KAAA,CAAAiE,EAAAkxB,EACA,CAIA,IAAAG,GAAA,yBACAC,GAAA,yBAKA,SAAAC,GAAA9Q,CAAA,CAAAG,CAAA,CAAAmQ,CAAA,CAAAS,CAAA,EACAP,GAAAxQ,EAAA1nB,CAAA,CAAA6nB,EAAAyQ,GAAAN,MAAAA,EAAA,OAAAA,EAAAh4B,CAAA,CAAAy4B,MAAAA,EAAA,OAAAA,EAAAz4B,CAAA,EACAk4B,GAAAxQ,EAAAznB,CAAA,CAAA4nB,EAAA0Q,GAAAP,MAAAA,EAAA,OAAAA,EAAA/3B,CAAA,CAAAw4B,MAAAA,EAAA,OAAAA,EAAAx4B,CAAA,CACA,CAEA,SAAAy4B,GAAA3c,CAAA,EACA,OAAAA,IAAAA,EAAA+J,SAAA,EAAA/J,IAAAA,EAAA/Y,KAAA,CAEA,SAAA21B,GAAA5c,CAAA,EACA,OAAA2c,GAAA3c,EAAA/b,CAAA,GAAA04B,GAAA3c,EAAA9b,CAAA,CACA,CACA,SAAA24B,GAAAx5B,CAAA,CAAAC,CAAA,EACA,OAAAD,EAAAY,CAAA,CAAAylB,GAAA,GAAApmB,EAAAW,CAAA,CAAAylB,GAAA,EACArmB,EAAAY,CAAA,CAAAwlB,GAAA,GAAAnmB,EAAAW,CAAA,CAAAwlB,GAAA,EACApmB,EAAAa,CAAA,CAAAwlB,GAAA,GAAApmB,EAAAY,CAAA,CAAAwlB,GAAA,EACArmB,EAAAa,CAAA,CAAAulB,GAAA,GAAAnmB,EAAAY,CAAA,CAAAulB,GAAA,CAGA,IAAAqT,GAAA,WACA,SAAAA,IACA,KAAAlD,OAAA,IAwGA,OAtGAkD,EAAAxhC,SAAA,CAAAkZ,GAAA,UAAAqkB,CAAA,EACApa,GAAA,KAAAmb,OAAA,CAAAf,GACAA,EAAA13B,cAAA,EACA,EACA27B,EAAAxhC,SAAA,CAAAg4B,MAAA,UAAAuF,CAAA,EAKA,GAJAja,GAAA,KAAAgb,OAAA,CAAAf,GACAA,IAAA,KAAAkE,QAAA,EACA,MAAAA,QAAA,CAAAh9B,KAAAA,CAAA,EAEA84B,IAAA,KAAAmE,IAAA,EACA,IAAAD,EAAA,KAAAnD,OAAA,MAAAA,OAAA,CAAAxgC,MAAA,IACA2jC,GACA,KAAAtD,OAAA,CAAAsD,EAEA,CACA,EACAD,EAAAxhC,SAAA,CAAAo+B,QAAA,UAAAb,CAAA,EACA,IAMAkE,EANAE,EAAA,KAAArD,OAAA,CAAAsD,SAAA,UAAAC,CAAA,EAAqE,OAAAtE,IAAAsE,CAAA,GACrE,GAAAF,IAAAA,EACA,SAKA,QAAA17B,EAAA07B,EAAkC17B,GAAA,EAAQA,IAAA,CAC1C,IAAA47B,EAAA,KAAAvD,OAAA,CAAAr4B,EAAA,CACA,GAAA47B,CAAA,IAAAA,EAAA9kB,SAAA,EACA0kB,EAAAI,EACA,KACA,CACA,OACA,EAAAJ,IACA,KAAAtD,OAAA,CAAAsD,GACA,GAKA,EACAD,EAAAxhC,SAAA,CAAAm+B,OAAA,UAAAZ,CAAA,CAAAuE,CAAA,EAEA,IADAriC,EACAgiC,EAAA,KAAAC,IAAA,CACAnE,IAAAkE,IAEA,KAAAA,QAAA,CAAAA,EACA,KAAAC,IAAA,CAAAnE,EACAA,EAAAwE,IAAA,GACAN,IACAA,EAAAl7B,QAAA,EAAAk7B,EAAA57B,cAAA,GACA03B,EAAA13B,cAAA,GACA03B,EAAAyE,UAAA,CAAAP,EACAK,GACAvE,CAAAA,EAAAyE,UAAA,CAAAC,eAAA,KAEAR,EAAAS,QAAA,GACA3E,EAAA2E,QAAA,CAAAT,EAAAS,QAAA,CACA3E,EAAA2E,QAAA,CAAA/0B,YAAA,CACAs0B,EAAAU,eAAA,EAAAV,EAAAt0B,YAAA,CACAowB,EAAA2E,QAAA,CAAAE,QAAA,KAEA,QAAA3iC,CAAAA,EAAA89B,EAAA3iB,IAAA,GAAAnb,KAAA,IAAAA,EAAA,OAAAA,EAAA4iC,UAAA,GACA9E,CAAAA,EAAA+E,aAAA,KAGA,KADA/E,EAAAnwB,OAAA,CAAAm1B,SAAA,EAEAd,EAAAe,IAAA,IAeA,EACAhB,EAAAxhC,SAAA,CAAAyiC,qBAAA,YACA,KAAAnE,OAAA,CAAA7iC,OAAA,UAAA8hC,CAAA,EACA,IAAA99B,EAAAmE,EAAA0J,EAAAC,EAAAwb,CACA,QAAAnlB,CAAAA,EAAA,CAAAnE,EAAA89B,EAAAnwB,OAAA,EAAA4P,cAAA,GAAApZ,KAAA,IAAAA,GAAAA,EAAA1D,IAAA,CAAAT,GACA,OAAAspB,CAAAA,EAAA,OAAAzb,CAAAA,EAAAiwB,EAAAmF,YAAA,GAAAp1B,KAAA,IAAAA,EAAA,QAAAC,EAAAD,EAAAF,OAAA,EAAA4P,cAAA,GAAA+L,KAAA,IAAAA,GAAAA,EAAA7oB,IAAA,CAAAqN,EACA,EACA,EACAi0B,EAAAxhC,SAAA,CAAA6F,cAAA,YACA,KAAAy4B,OAAA,CAAA7iC,OAAA,UAAA8hC,CAAA,EACAA,EAAAh3B,QAAA,EAAAg3B,EAAA13B,cAAA,IACA,EACA,EAKA27B,EAAAxhC,SAAA,CAAA2iC,kBAAA,YACA,KAAAjB,IAAA,OAAAA,IAAA,CAAAQ,QAAA,EACA,MAAAR,IAAA,CAAAQ,QAAA,CAAAz9B,KAAAA,CAAA,CAEA,EACA+8B,CACA,IAGA,SAAAoB,GAAAle,CAAA,CAAAqa,CAAA,CAAA8D,CAAA,EAOA,IAAAC,EAAApe,EAAA/b,CAAA,CAAA8lB,SAAA,CAAAsQ,EAAAp2B,CAAA,CACAo6B,EAAAre,EAAA9b,CAAA,CAAA6lB,SAAA,CAAAsQ,EAAAn2B,CAAA,CACAO,EAAA,eAAAwF,MAAA,CAAAm0B,EAAA,QAAAn0B,MAAA,CAAAo0B,EAAA,WAMA,GADA55B,GAAA,SAAAwF,MAAA,GAAAowB,EAAAp2B,CAAA,OAAAgG,MAAA,GAAAowB,EAAAn2B,CAAA,OACAi6B,EAAA,CACA,IAAAv3B,EAAAu3B,EAAAv3B,MAAA,CAAAE,EAAAq3B,EAAAr3B,OAAA,CAAAC,EAAAo3B,EAAAp3B,OAAA,CACAH,GACAnC,CAAAA,GAAA,UAAAwF,MAAA,CAAArD,EAAA,UACAE,GACArC,CAAAA,GAAA,WAAAwF,MAAA,CAAAnD,EAAA,UACAC,GACAtC,CAAAA,GAAA,WAAAwF,MAAA,CAAAlD,EAAA,SACA,CAKA,IAAAu3B,EAAAte,EAAA/b,CAAA,CAAAgD,KAAA,CAAAozB,EAAAp2B,CAAA,CACAs6B,EAAAve,EAAA9b,CAAA,CAAA+C,KAAA,CAAAozB,EAAAn2B,CAAA,CAEA,MAAAO,qDADAA,CAAAA,GAAA,SAAAwF,MAAA,CAAAq0B,EAAA,MAAAr0B,MAAA,CAAAs0B,EAAA,MACA,OAAA95B,CACA,CAEA,IAAA+5B,GAAA,SAAAn7B,CAAA,CAAAC,CAAA,EACA,OAAAD,EAAA6vB,KAAA,CAAA5vB,EAAA4vB,KAAA,EAGAuL,GAAA,WACA,SAAAA,IACA,KAAAhgC,QAAA,IACA,KAAAigC,OAAA,GACA,CAcA,OAbAD,EAAAnjC,SAAA,CAAAkZ,GAAA,UAAAT,CAAA,EACA0K,GAAA,KAAAhgB,QAAA,CAAAsV,GACA,KAAA2qB,OAAA,GACA,EACAD,EAAAnjC,SAAA,CAAAg4B,MAAA,UAAAvf,CAAA,EACA6K,GAAA,KAAAngB,QAAA,CAAAsV,GACA,KAAA2qB,OAAA,GACA,EACAD,EAAAnjC,SAAA,CAAAvE,OAAA,UAAA2c,CAAA,EACA,KAAAgrB,OAAA,OAAAjgC,QAAA,CAAAqL,IAAA,CAAA00B,IACA,KAAAE,OAAA,IACA,KAAAjgC,QAAA,CAAA1H,OAAA,CAAA2c,EACA,EACA+qB,CACA,IAOA,SAAAE,GAAA5jC,CAAA,EACA,IAAA6jC,EAAA7jC,EAAA6jC,oBAAA,CAAAC,EAAA9jC,EAAA8jC,aAAA,CAAAC,EAAA/jC,EAAA+jC,aAAA,CAAAC,EAAAhkC,EAAAgkC,iBAAA,CAAA/G,EAAAj9B,EAAAi9B,cAAA,CACA,kBACA,SAAAgH,EAAAl/B,CAAA,CAAA2I,CAAA,CAAA/I,CAAA,EACA,IAAAsf,EAAA,UACA,IAAAvW,GAA2CA,CAAAA,EAAA,IAC3C,SAAA/I,GAAqCA,CAAAA,EAAAm/B,MAAAA,EAAA,OAAAA,GAAA,EAOrC,KAAApgC,QAAA,KAAAkF,IAKA,KAAA+E,OAAA,IAMA,KAAAu2B,eAAA,IACA,KAAA1R,kBAAA,IAOA,KAAAqQ,aAAA,IAIA,KAAAsB,qBAAA,IACA,KAAAC,qBAAA,IAKA,KAAAxB,UAAA,IAIA,KAAAyB,KAAA,IAKA,KAAAC,UAAA,IAIA,KAAAC,oBAAA,IASA,KAAAjF,SAAA,EAA+Bp2B,EAAA,EAAAC,EAAA,GAI/B,KAAAq7B,aAAA,KAAAl9B,IAEA,KAAAm9B,cAAA,KAAAn9B,IACA,KAAAo9B,iBAAA,YACAzgB,EAAA2e,UAAA,GACA3e,EAAA2e,UAAA,IACA3e,EAAA0gB,iBAAA,GAEA,EACA,KAAAC,gBAAA,YACA3gB,EAAA4gB,KAAA,CAAA7oC,OAAA,CAAA8oC,IACA7gB,EAAA4gB,KAAA,CAAA7oC,OAAA,CAAA+oC,GACA,EACA,KAAAC,YAAA,IACA,KAAA5M,SAAA,IACA,KAAA6M,iBAAA,GAKA,KAAAC,WAAA,KAAA59B,IACA,KAAAvC,EAAA,CAAAA,EACA,KAAA2I,YAAA,CAAAA,EACA,KAAAyN,IAAA,CAAAxW,EAAAA,EAAAwW,IAAA,EAAAxW,EAAA,KACA,KAAAwgC,IAAA,CAAAxgC,EAAA3J,EAAA2nB,aAAA,CAAA3nB,EAAA2nB,aAAA,IAAA3nB,EAAAiF,MAAA,CAAA0E,EAAAwgC,IAAA,OAAAxgC,EAAA,QACA,KAAAA,MAAA,CAAAA,EACA,KAAAwzB,KAAA,CAAAxzB,EAAAA,EAAAwzB,KAAA,KACApzB,GAAA,KAAAoW,IAAA,CAAAiqB,qBAAA,CAAArgC,EAAA,MACA,QAAAyB,EAAA,EAA4BA,EAAA,KAAA2+B,IAAA,CAAA9mC,MAAA,CAAsBmI,IAClD,KAAA2+B,IAAA,CAAA3+B,EAAA,CAAA+9B,oBAAA,GAEA,MAAAppB,IAAA,SACA,MAAA0pB,KAAA,KAAAnB,EAAA,CACA,CAq5BA,OAp5BAO,EAAA1jC,SAAA,CAAAkV,gBAAA,UAAAzY,CAAA,CAAAuY,CAAA,EAIA,OAHA,KAAAivB,aAAA,CAAAh9B,GAAA,CAAAxK,IACA,KAAAwnC,aAAA,CAAA/8B,GAAA,CAAAzK,EAAA,IAAA+mB,IAEA,KAAAygB,aAAA,CAAApoC,GAAA,CAAAY,GAAAyc,GAAA,CAAAlE,EACA,EACA0uB,EAAA1jC,SAAA,CAAA8kC,eAAA,UAAAroC,CAAA,EAEA,QADAu6B,EAAA,GACAC,EAAA,EAA6BA,EAAAr0B,UAAA9E,MAAA,CAAuBm5B,IACpDD,CAAA,CAAAC,EAAA,GAAAr0B,SAAA,CAAAq0B,EAAA,CAFA,IAIA8N,EAAA,KAAAd,aAAA,CAAApoC,GAAA,CAAAY,EACAsoC,OAAAA,GAAAA,EAAAphB,MAAA,CAAAhhB,KAAA,CAAAoiC,EAAAtqC,EAAA2nB,aAAA,IAAA3nB,EAAAiF,MAAA,CAAAs3B,GAAA,IACA,EACA0M,EAAA1jC,SAAA,CAAAglC,YAAA,UAAAvoC,CAAA,EACA,YAAAwnC,aAAA,CAAAh9B,GAAA,CAAAxK,EACA,EACAinC,EAAA1jC,SAAA,CAAA6kC,qBAAA,UAAArgC,CAAA,CAAA+4B,CAAA,EACA,KAAA2G,cAAA,CAAAh9B,GAAA,CAAA1C,EAAA+4B,EACA,EAIAmG,EAAA1jC,SAAA,CAAAwG,KAAA,UAAAD,CAAA,CAAA+7B,CAAA,EACA,IAAA5e,EAAA,KAGA,GADA,SAAA4e,GAA4CA,CAAAA,EAAA,KAC5C,KAAA/7B,QAAA,EAEA,KAAAu9B,KAAA,CACAv9B,aAAA0+B,YAAA1+B,QAAAA,EAAA2+B,OAAA,CACA,KAAA3+B,QAAA,CAAAA,EACA,IAAA3C,EAAA,KAAAwJ,OAAA,CAAAvJ,EAAAD,EAAAC,QAAA,CAAAC,EAAAF,EAAAE,MAAA,CAAAvF,EAAAqF,EAAArF,aAAA,CAUA,GATAA,GAAA,CAAAA,EAAA4c,WAAA,IACA5c,EAAAiI,KAAA,CAAAD,GAEA,KAAAqU,IAAA,CAAA0pB,KAAA,CAAAprB,GAAA,OACA,OAAAzZ,CAAAA,EAAA,KAAA2E,MAAA,GAAA3E,KAAA,IAAAA,GAAAA,EAAA0D,QAAA,CAAA+V,GAAA,OACA,KAAA1U,EAAA,OAAAoW,IAAA,CAAAspB,cAAA,CAAA1oB,MAAA,MAAAhX,EAAA,EACA89B,GAAAx+B,CAAAA,GAAAD,CAAA,GACA,MAAAy+B,aAAA,KAEAgB,EAAA,CAEA,IAnBA7jC,EAkBA0lC,EACAC,EAAA,WACA,OAAA1hB,EAAA9I,IAAA,CAAAipB,qBAAA,GACA,EACAP,EAAA/8B,EAAA,WACAmd,EAAA9I,IAAA,CAAAipB,qBAAA,IACA3gB,aAAAiiB,GACAA,EAAAhmC,OAAA8jB,UAAA,CAAAmiB,EAAA,KACAjjC,EAAAC,sBAAA,GACAD,EAAAC,sBAAA,IACAshB,EAAA4gB,KAAA,CAAA7oC,OAAA,CAAA4pC,IAEA,EACA,CACAxhC,GACA,KAAA+W,IAAA,CAAA0qB,kBAAA,CAAAzhC,EAAA,MAGA,UAAAuJ,OAAA,CAAAhM,OAAA,EACA7C,GACAsF,CAAAA,GAAAC,CAAA,GACA,KAAAoR,gBAAA,sBAAAzV,CAAA,EAEA,IADAmE,EAAA0J,EAAAC,EAAAwb,EAAAC,EACAtE,EAAAjlB,EAAAilB,KAAA,CAAA8Q,EAAA/1B,EAAA+1B,gBAAA,CAAA+P,EAAA9lC,EAAA8lC,wBAAA,CAAAC,EAAA/lC,EAAAqE,MAAA,CACA,GAAA4f,EAAA+hB,sBAAA,IACA/hB,EAAA3U,MAAA,CAAAtK,KAAAA,EACAif,EAAAgiB,cAAA,CAAAjhC,KAAAA,EACA,MACA,CAEA,IAAAkhC,EAAA,OAAAr4B,CAAAA,EAAA,OAAA1J,CAAAA,EAAA8f,EAAAtW,OAAA,CAAAoG,UAAA,GAAA5P,KAAA,IAAAA,EAAAA,EAAArF,EAAAshB,oBAAA,KAAAvS,KAAA,IAAAA,EAAAA,EAAAs4B,GACAC,EAAAtnC,EAAAyC,QAAA,GAAA8kC,EAAAD,EAAAC,sBAAA,CAAAC,EAAAF,EAAAE,yBAAA,CAKAC,EAAA,CAAAtiB,EAAAuiB,YAAA,EACA,CAAA1E,GAAA7d,EAAAuiB,YAAA,CAAAT,IACAD,EAMAW,EAAA,CAAA1Q,GAAA+P,EACA,WAAAh4B,CAAAA,EAAAmW,EAAAse,UAAA,GAAAz0B,KAAA,IAAAA,EAAA,OAAAA,EAAAhH,QAAA,GACA2/B,GACA1Q,GACAwQ,CAAAA,GAAA,CAAAtiB,EAAA6a,gBAAA,GACA7a,EAAAse,UAAA,GACAte,EAAAgf,YAAA,CAAAhf,EAAAse,UAAA,CACAte,EAAAgf,YAAA,CAAAA,YAAA,CAAAj+B,KAAAA,GAEAif,EAAAyiB,kBAAA,CAAAzhB,EAAAwhB,GACA,IAAAE,EAAA3rC,EAAAiK,QAAA,CAAAjK,EAAAiK,QAAA,IAA+E0c,GAAAukB,EAAA,YAAqDU,OAAAP,EAAAxkB,WAAAykB,CAAA,EACpIxnC,CAAAA,EAAA+F,kBAAA,GACA8hC,EAAA9jB,KAAA,GACA8jB,EAAAn4B,IAAA,KAEAyV,EAAArC,cAAA,CAAA+kB,EACA,MAOA5Q,GACA9R,IAAAA,EAAAghB,iBAAA,EACAhhB,EAAA2hB,eAAA,GAEA3hB,EAAA8a,MAAA,YAAAxV,CAAAA,EAAA,CAAAD,EAAArF,EAAAtW,OAAA,EAAA4P,cAAA,GAAAgM,KAAA,IAAAA,GAAAA,EAAA9oB,IAAA,CAAA6oB,EAAA,CAEArF,CAAAA,EAAAuiB,YAAA,CAAAT,CACA,GAEA,EACA9B,EAAA1jC,SAAA,CAAAyG,OAAA,YACA,IAAAhH,EAAAmE,CACA,MAAAwJ,OAAA,CAAAvJ,QAAA,OAAAq6B,UAAA,GACA,KAAAtjB,IAAA,CAAA0pB,KAAA,CAAAtM,MAAA,OACA,OAAAv4B,CAAAA,EAAA,KAAA4+B,QAAA,KAAA5+B,KAAA,IAAAA,GAAAA,EAAAu4B,MAAA,OACA,OAAAp0B,CAAAA,EAAA,KAAAQ,MAAA,GAAAR,KAAA,IAAAA,GAAAA,EAAAT,QAAA,CAAAqY,MAAA,OACA,KAAAjV,QAAA,CAAA9B,KAAAA,EACA1J,EAAA4yB,UAAA,CAAA2Y,SAAA,MAAAjC,gBAAA,CACA,EAEAX,EAAA1jC,SAAA,CAAAumC,WAAA,YACA,KAAA3C,qBAAA,GACA,EACAF,EAAA1jC,SAAA,CAAAwmC,aAAA,YACA,KAAA5C,qBAAA,GACA,EACAF,EAAA1jC,SAAA,CAAAymC,eAAA,YACA,YAAA7C,qBAAA,OAAAC,qBAAA,EAEAH,EAAA1jC,SAAA,CAAAylC,sBAAA,YACA,IAAAhmC,EACA,YAAAwyB,kBAAA,EACA,QAAAxyB,CAAAA,EAAA,KAAA2E,MAAA,GAAA3E,KAAA,IAAAA,EAAA,OAAAA,EAAAgmC,sBAAA,KACA,EACA,EAEA/B,EAAA1jC,SAAA,CAAA0mC,WAAA,YACA,IAAAjnC,EACA,KAAAgnC,eAAA,KAEA,KAAApE,UAAA,IACA,OAAA5iC,CAAAA,EAAA,KAAA6kC,KAAA,GAAA7kC,KAAA,IAAAA,GAAAA,EAAAhE,OAAA,CAAAkrC,IACA,EACAjD,EAAA1jC,SAAA,CAAAk+B,UAAA,UAAA0I,CAAA,EAGA,GADA,SAAAA,GAAoDA,CAAAA,EAAA,IACpD,KAAAhsB,IAAA,CAAA6rB,eAAA,IACA,OAAA7iC,CAAAA,EAAA,CAAAnE,EAAA,KAAA2N,OAAA,EAAA4P,cAAA,GAAApZ,KAAA,IAAAA,GAAAA,EAAA1D,IAAA,CAAAT,GACA,MACA,CAEA,GADA,KAAAmb,IAAA,CAAAynB,UAAA,OAAAznB,IAAA,CAAA8rB,WAAA,IACA,KAAApE,aAAA,EAEA,KAAAA,aAAA,IACA,QAVA7iC,EAAAmE,EAAA0J,EAUArH,EAAA,EAA4BA,EAAA,KAAA2+B,IAAA,CAAA9mC,MAAA,CAAsBmI,IAAA,CAClD,IAAAs3B,EAAA,KAAAqH,IAAA,CAAA3+B,EAAA,CACAs3B,EAAAyG,oBAAA,IAKAzG,EAAAtI,YAAA,EACA,CACA,IAAA1nB,EAAA,KAAAH,OAAA,CAAAvJ,EAAA0J,EAAA1J,QAAA,CAAAC,EAAAyJ,EAAAzJ,MAAA,CACA,GAAAD,KAAAY,IAAAZ,GAAAC,GAEA,IAAAuJ,EAAA,OAAAC,CAAAA,EAAA,KAAAF,OAAA,CAAA7O,aAAA,GAAA+O,KAAA,IAAAA,EAAA,OAAAA,EAAAtM,QAAA,GAAAqM,iBAAA,CACA,KAAAw5B,0BAAA,CAAAx5B,MAAAA,EAAA,OAAAA,EAAA,KAAAF,YAAA,KACA,KAAA25B,cAAA,GACAF,GAAA,KAAA9B,eAAA,gBACA,EAEApB,EAAA1jC,SAAA,CAAA+9B,SAAA,YAKA,GAJA,KAAA0I,eAAA,GAIA,CACA,KAAAD,aAAA,GACA,KAAApC,iBAAA,GACA,KAAAE,KAAA,CAAA7oC,OAAA,CAAAsrC,IACA,MACA,CACA,KAAA1E,UAAA,GAEA,KAAAA,UAAA,IAOA,KAAA6B,cAAA,CAAA35B,IAAA,GACA,KAAA25B,cAAA,CAAAzoC,OAAA,CAAAurC,IACA,KAAA9C,cAAA,CAAAngB,KAAA,IAKA,KAAAugB,KAAA,CAAA7oC,OAAA,CAAAwrC,IAKA,KAAA3C,KAAA,CAAA7oC,OAAA,CAAAy5B,IAKA,KAAAoP,KAAA,CAAA7oC,OAAA,CAAAyrC,IACA,KAAA9C,iBAAA,GAEArpC,EAAAosC,SAAA,CAAAja,MAAA,GACAnyB,EAAAosC,SAAA,CAAAb,SAAA,GACAvrC,EAAAosC,SAAA,CAAAjkC,MAAA,GACA,EACAwgC,EAAA1jC,SAAA,CAAAokC,iBAAA,YACA,KAAAE,KAAA,CAAA7oC,OAAA,CAAA2rC,IACA,KAAAzC,WAAA,CAAAlpC,OAAA,CAAA4rC,GACA,EACA3D,EAAA1jC,SAAA,CAAAsnC,wBAAA,YACArrC,EAAA,QAAAqqC,SAAA,MAAAjC,gBAAA,OACA,EACAX,EAAA1jC,SAAA,CAAA2+B,yBAAA,YACA,IAAAjb,EAAA,KAMAznB,EAAA,QAAA2oB,UAAA,YACAlB,EAAA4e,aAAA,CACA5e,EAAA9I,IAAA,CAAAmjB,SAAA,GAGAra,EAAA9I,IAAA,CAAAupB,iBAAA,EAEA,EACA,EAIAT,EAAA1jC,SAAA,CAAA8mC,cAAA,YACA,SAAA5E,QAAA,OAAA37B,QAAA,EAEA,IAAAghC,EAAA,KAAAC,OAAA,GACA1jC,EAAA,KAAA2jC,eAAA,MAAAC,mBAAA,CAAAH,IACAI,GAAA7jC,GACA,KAAAo+B,QAAA,EACAqF,SAAAA,EACAzjC,OAAAA,EACAqJ,aAAA,EACA,EACA,EACAu2B,EAAA1jC,SAAA,CAAAk1B,YAAA,YAEA,QAAA3uB,QAAA,GAGA,KAAA0uB,YAAA,GACA,KAAA7nB,OAAA,CAAAxH,mBAAA,OAAA44B,MAAA,IACA,KAAA8D,aAAA,GAUA,QAAAN,UAAA,QAAAA,UAAA,CAAAz7B,QAAA,CACA,QAjBA9G,EAiBAwG,EAAA,EAAgCA,EAAA,KAAA2+B,IAAA,CAAA9mC,MAAA,CAAsBmI,IAEtDs3B,IADA,CAAAqH,IAAA,CAAA3+B,EAAA,CACAgvB,YAAA,GAGA,IAAAsS,EAAA,KAAAC,OAAA,GACAG,GAAAJ,GACA,IAAAK,EAAA,KAAA9jC,MAAA,CACA,KAAAA,MAAA,EACAyjC,SAAAA,EACAnV,OAAA,KAAAsV,mBAAA,CAAAH,EACA,EACA,KAAAM,eAAA,CAAAjY,KACA,KAAA0S,aAAA,IACA,KAAAtD,eAAA,CAAAv6B,KAAAA,EACA,KAAAqgC,eAAA,gBAAAhhC,MAAA,CAAAsuB,MAAA,EACA,OAAA3yB,CAAAA,EAAA,KAAA2N,OAAA,CAAA7O,aAAA,GAAAkB,KAAA,IAAAA,GAAAA,EAAAqoC,mBAAA,MAAAhkC,MAAA,CAAAsuB,MAAA,CAAAwV,MAAAA,EAAA,OAAAA,EAAAxV,MAAA,EACA,EACAsR,EAAA1jC,SAAA,CAAAi1B,YAAA,YACA,KAAA7nB,OAAA,CAAApJ,YAAA,OAAAuC,QAAA,GACA,KAAAwhC,YAAA,CAAAtE,EAAA,KAAAl9B,QAAA,EACA,KAAAqtB,MAAA,CAAA4P,EAAA,KAAAj9B,QAAA,EAEA,EACAm9B,EAAA1jC,SAAA,CAAA08B,cAAA,YAEA,GAAAA,GAEA,IAHAj9B,EAGAuoC,EAAA,KAAA1F,aAAA,OAAA0B,oBAAA,CACAiE,EAAA,KAAAjJ,eAAA,GAAAsC,GAAA,KAAAtC,eAAA,EACA3xB,EAAA,OAAA5N,CAAAA,EAAA,KAAA2N,OAAA,CAAA7O,aAAA,GAAAkB,KAAA,IAAAA,EAAA,OAAAA,EAAAuB,QAAA,GAAAqM,iBAAA,CACA66B,EAAA76B,MAAAA,EAAA,OAAAA,EAAA,KAAAF,YAAA,KACAg7B,EAAAD,IAAA,KAAArB,0BAAA,CACAmB,GACAC,CAAAA,GACAr6B,GAAA,KAAAT,YAAA,GACAg7B,CAAA,IACAzL,EAAA,KAAAn2B,QAAA,CAAA2hC,GACA,KAAAlE,oBAAA,IACA,KAAAn+B,cAAA,IAEA,EACA69B,EAAA1jC,SAAA,CAAAwnC,OAAA,YACA,IAAAjpC,EAAA,KAAA6O,OAAA,CAAA7O,aAAA,CACA,IAAAA,EACA,OAAAqxB,KACA,IAAAS,EAAA9xB,EAAAwyB,kBAAA,GAEA6C,EAAA,KAAAhZ,IAAA,CAAAgZ,MAAA,CAKA,OAJAA,IACAtD,GAAAD,EAAA1nB,CAAA,CAAAirB,EAAAjrB,CAAA,EACA2nB,GAAAD,EAAAznB,CAAA,CAAAgrB,EAAAhrB,CAAA,GAEAynB,CACA,EACAqT,EAAA1jC,SAAA,CAAA0nC,mBAAA,UAAArX,CAAA,EACA,IAAA+X,EAAAxY,KACA8Q,GAAA0H,EAAA/X,GAKA,QAAApqB,EAAA,EAA4BA,EAAA,KAAA2+B,IAAA,CAAA9mC,MAAA,CAAsBmI,IAAA,CAClD,IAAAs3B,EAAA,KAAAqH,IAAA,CAAA3+B,EAAA,CACAoiC,EAAA9K,EAAA3J,MAAA,CAAAxmB,EAAAmwB,EAAAnwB,OAAA,CAAA26B,EAAAxK,EAAAwK,YAAA,CACA,GAAAxK,IAAA,KAAA3iB,IAAA,EAAAytB,GAAAj7B,EAAApJ,YAAA,EAKA,GAAA+jC,EAAA,CACArH,GAAA0H,EAAA/X,GACA,IAAAiY,EAAA,KAAA1tB,IAAA,CAAAgZ,MAAA,CAKA0U,IACAhY,GAAA8X,EAAAz/B,CAAA,EAAA2/B,EAAA3/B,CAAA,EACA2nB,GAAA8X,EAAAx/B,CAAA,EAAA0/B,EAAA1/B,CAAA,EAEA,CACA0nB,GAAA8X,EAAAz/B,CAAA,CAAA0/B,EAAA1/B,CAAA,EACA2nB,GAAA8X,EAAAx/B,CAAA,CAAAy/B,EAAAz/B,CAAA,CACA,CACA,CACA,OAAAw/B,CACA,EACA1E,EAAA1jC,SAAA,CAAAuoC,cAAA,UAAAlY,CAAA,CAAAmY,CAAA,EACA,SAAAA,GAA4CA,CAAAA,EAAA,IAC5C,IAAAC,EAAA7Y,KACA8Q,GAAA+H,EAAApY,GACA,QAAApqB,EAAA,EAA4BA,EAAA,KAAA2+B,IAAA,CAAA9mC,MAAA,CAAsBmI,IAAA,CAClD,IAAAs3B,EAAA,KAAAqH,IAAA,CAAA3+B,EAAA,EACAuiC,GACAjL,EAAAnwB,OAAA,CAAApJ,YAAA,EACAu5B,EAAA3J,MAAA,EACA2J,IAAAA,EAAA3iB,IAAA,EACAkW,GAAA2X,EAAA,CACA9/B,EAAA,CAAA40B,EAAA3J,MAAA,CAAAjrB,CAAA,CACAC,EAAA,CAAA20B,EAAA3J,MAAA,CAAAhrB,CAAA,GAGAgF,GAAA2vB,EAAApwB,YAAA,GAEA2jB,GAAA2X,EAAAlL,EAAApwB,YAAA,CACA,CAIA,OAHAS,GAAA,KAAAT,YAAA,GACA2jB,GAAA2X,EAAA,KAAAt7B,YAAA,EAEAs7B,CACA,EACA/E,EAAA1jC,SAAA,CAAAynC,eAAA,UAAApX,CAAA,EAEA,IADA5wB,EACAipC,EAAA9Y,KACA8Q,GAAAgI,EAAArY,GACA,QAAApqB,EAAA,EAA4BA,EAAA,KAAA2+B,IAAA,CAAA9mC,MAAA,CAAsBmI,IAAA,CAClD,IAAAs3B,EAAA,KAAAqH,IAAA,CAAA3+B,EAAA,CACA,GAAAs3B,EAAAh3B,QAAA,EAEAqH,GAAA2vB,EAAApwB,YAAA,GAEA6iB,GAAAuN,EAAApwB,YAAA,GAAAowB,EAAAuJ,cAAA,GACA,IAAA1F,EAAAxR,KAEA8Q,GAAAU,EADA7D,EAAAiK,OAAA,IAEArG,GAAAuH,EAAAnL,EAAApwB,YAAA,QAAA1N,CAAAA,EAAA89B,EAAA2E,QAAA,GAAAziC,KAAA,IAAAA,EAAA,OAAAA,EAAAqE,MAAA,CAAAs9B,GACA,CAIA,OAHAxzB,GAAA,KAAAT,YAAA,GACAg0B,GAAAuH,EAAA,KAAAv7B,YAAA,EAEAu7B,CACA,EAIAhF,EAAA1jC,SAAA,CAAA2oC,cAAA,UAAAjkB,CAAA,EACA,KAAAkkB,WAAA,CAAAlkB,EACA,KAAA9J,IAAA,CAAA0sB,wBAAA,EACA,EACA5D,EAAA1jC,SAAA,CAAA2F,UAAA,UAAAyH,CAAA,EACA,IAAA3N,CACA,MAAA2N,OAAA,CAAA3S,EAAAiK,QAAA,CAAAjK,EAAAiK,QAAA,CAAAjK,EAAAiK,QAAA,IAA0E,KAAA0I,OAAA,EAAAA,GAAA,CAA6Bm1B,UAAA,OAAA9iC,CAAAA,EAAA2N,EAAAm1B,SAAA,GAAA9iC,KAAA,IAAAA,GAAAA,CAAA,EACvG,EACAikC,EAAA1jC,SAAA,CAAA+mC,iBAAA,YACA,KAAAnT,MAAA,CAAAnvB,KAAAA,EACA,KAAAX,MAAA,CAAAW,KAAAA,EACA,KAAAy9B,QAAA,CAAAz9B,KAAAA,EACA,KAAAoiC,0BAAA,CAAApiC,KAAAA,EACA,KAAAmkC,WAAA,CAAAnkC,KAAAA,EACA,KAAAsK,MAAA,CAAAtK,KAAAA,EACA,KAAA69B,aAAA,GACA,EAIAoB,EAAA1jC,SAAA,CAAAukC,kBAAA,YAEA,IAn2FAx1B,EAAA6f,EAAAxqB,EAk2FA3E,EACAmE,EAAA,KAAAwJ,OAAA,CAAAtJ,EAAAF,EAAAE,MAAA,CAAAD,EAAAD,EAAAC,QAAA,CAIA,KAAAC,MAAA,EAAAA,CAAAA,GAAAD,CAAA,IAQA,MAAA+kC,WAAA,QAAAlD,cAAA,GAEA,KAAAmD,cAAA,MAAAC,0BAAA,GACA,KAAAD,cAAA,OAAAA,cAAA,CAAA/kC,MAAA,GACA,KAAA4hC,cAAA,CAAA9V,KACA,KAAAmZ,oBAAA,CAAAnZ,KACAd,GAAA,KAAAia,oBAAA,MAAAjlC,MAAA,CAAAsuB,MAAA,MAAAyW,cAAA,CAAA/kC,MAAA,CAAAsuB,MAAA,EACAsO,GAAA,KAAAgF,cAAA,MAAAqD,oBAAA,IAOA,MAAArD,cAAA,OAAAkD,WAAA,KAKA,KAAA75B,MAAA,GACA,KAAAA,MAAA,CAAA6gB,KACA,KAAAoZ,oBAAA,CAAApZ,MAKA,KAAA8V,cAAA,EACA,KAAAqD,oBAAA,EACA,QAAAtpC,CAAAA,EAAA,KAAAopC,cAAA,GAAAppC,KAAA,IAAAA,EAAA,OAAAA,EAAAsP,MAAA,IA34FAA,EA44FA,KAAAA,MAAA,CA54FA6f,EA44FA,KAAA8W,cAAA,CA54FAthC,EA44FA,KAAAykC,cAAA,CAAA95B,MAAA,CA34FA4f,GAAA5f,EAAApG,CAAA,CAAAimB,EAAAjmB,CAAA,CAAAvE,EAAAuE,CAAA,EACAgmB,GAAA5f,EAAAnG,CAAA,CAAAgmB,EAAAhmB,CAAA,CAAAxE,EAAAwE,CAAA,GA+4FA,KAAAggC,WAAA,EACA,KAAAlG,YAAA,CAEA,KAAA3zB,MAAA,MAAAw5B,cAAA,MAAAzkC,MAAA,CAAAsuB,MAAA,EAGAsO,GAAA,KAAA3xB,MAAA,MAAAjL,MAAA,CAAAsuB,MAAA,EAEAhC,GAAA,KAAArhB,MAAA,MAAA65B,WAAA,GAMAlI,GAAA,KAAA3xB,MAAA,MAAAjL,MAAA,CAAAsuB,MAAA,EAKA,KAAA6W,8BAAA,GACA,KAAAA,8BAAA,IACA,KAAAJ,cAAA,MAAAC,0BAAA,GACA,KAAAD,cAAA,EACAjnC,CAAAA,CAAA,KAAAinC,cAAA,CAAAnG,YAAA,EACA9gC,CAAAA,CAAA,KAAA8gC,YAAA,EACA,MAAAmG,cAAA,CAAAz7B,OAAA,CAAApJ,YAAA,EACA,KAAA6kC,cAAA,CAAA95B,MAAA,GACA,KAAA22B,cAAA,CAAA9V,KACA,KAAAmZ,oBAAA,CAAAnZ,KACAd,GAAA,KAAAia,oBAAA,MAAAh6B,MAAA,MAAA85B,cAAA,CAAA95B,MAAA,EACA2xB,GAAA,KAAAgF,cAAA,MAAAqD,oBAAA,KAGA,EACArF,EAAA1jC,SAAA,CAAA8oC,0BAAA,YACA,WAAA1kC,MAAA,EAAAwJ,GAAA,KAAAxJ,MAAA,CAAA+I,YAAA,SAEA,MAAA/I,MAAA,CAAAshC,cAAA,OAAAthC,MAAA,CAAAwkC,WAAA,GACA,KAAAxkC,MAAA,CAAAN,MAAA,CACA,KAAAM,MAAA,CAGA,KAAAA,MAAA,CAAA0kC,0BAAA,EAEA,EACApF,EAAA1jC,SAAA,CAAAwkC,cAAA,YAEA,IADA/kC,EACAmE,EAAA,KAAAwJ,OAAA,CAAAtJ,EAAAF,EAAAE,MAAA,CAAAD,EAAAD,EAAAC,QAAA,CAWA,GANA,KAAA8/B,eAAA,CAAA/hC,CAAAA,CAAA,SAAAnC,CAAAA,EAAA,KAAA2E,MAAA,GAAA3E,KAAA,IAAAA,EAAA,OAAAA,EAAAkkC,eAAA,GACA,KAAApF,gBAAA,EACA,KAAA2K,gBAAA,EACA,KAAAvF,eAAA,EACA,MAAAiF,WAAA,MAAAlD,cAAA,CAAAjhC,KAAAA,CAAA,EAEA,KAAAX,MAAA,EAAAA,CAAAA,GAAAD,CAAA,GAEA,IAAA69B,EAAA,KAAAyH,OAAA,GAKAzI,GAAA,KAAAmH,eAAA,MAAA/jC,MAAA,CAAAsuB,MAAA,EAKAgX,SA1tFA/Y,CAAA,CAAA0O,CAAA,CAAAsK,CAAA,CAAAC,CAAA,EAEA,SAAAA,GAAyCA,CAAAA,EAAA,IACzC,IAFA7pC,EAAAmE,EAOA25B,EACA7Y,EANA6kB,EAAAF,EAAAvrC,MAAA,CACA,GAAAyrC,GAGAxK,EAAAp2B,CAAA,CAAAo2B,EAAAn2B,CAAA,GAGA,QAAA3C,EAAA,EAAoBA,EAAAsjC,EAAgBtjC,IAEpCye,EAAA6Y,CADAA,EAAA8L,CAAA,CAAApjC,EAAA,EACA+4B,eAAA,CACA,QAAAp7B,CAAAA,EAAA,OAAAnE,CAAAA,EAAA89B,EAAAh3B,QAAA,GAAA9G,KAAA,IAAAA,EAAA,OAAAA,EAAA+N,KAAA,GAAA5J,KAAA,IAAAA,EAAA,OAAAA,EAAAq3B,OAAA,iBAEAqO,GACA/L,EAAAnwB,OAAA,CAAApJ,YAAA,EACAu5B,EAAA3J,MAAA,EACA2J,IAAAA,EAAA3iB,IAAA,EACAkW,GAAAT,EAAA,CAAgC1nB,EAAA,CAAA40B,EAAA3J,MAAA,CAAAjrB,CAAA,CAAAC,EAAA,CAAA20B,EAAA3J,MAAA,CAAAhrB,CAAA,GAEhC8b,IAEAqa,EAAAp2B,CAAA,EAAA+b,EAAA/b,CAAA,CAAAgD,KAAA,CACAozB,EAAAn2B,CAAA,EAAA8b,EAAA9b,CAAA,CAAA+C,KAAA,CAEAykB,GAAAC,EAAA3L,IAEA4kB,GAAA17B,GAAA2vB,EAAApwB,YAAA,GACA2jB,GAAAT,EAAAkN,EAAApwB,YAAA,GAGA,EA0rFA,KAAA06B,eAAA,MAAA9I,SAAA,MAAA6F,IAAA,CAAAhjC,CAAAA,CAAA,KAAA8gC,YAAA,SAAAhB,GACA,IAAA3yB,EAAA2yB,EAAA3yB,MAAA,CACA,GAAAA,GAEA,KAAAiwB,eAAA,GACA,KAAAA,eAAA,CAAAtP,KACA,KAAA8Z,4BAAA,CAAA9Z,MAEA,IAAA+Z,EAAA,KAAA1K,SAAA,CAAAp2B,CAAA,CACA+gC,EAAA,KAAA3K,SAAA,CAAAn2B,CAAA,CACA+gC,EAAA,KAAAC,mBAAA,CAUAlb,GAAA,KAAAsQ,eAAA,MAAA6I,eAAA,CAAA94B,EAAA,KAAA5B,YAAA,EACA,KAAAy8B,mBAAA,CAAAhH,GAAA,KAAA5D,eAAA,MAAAD,SAAA,EACA,MAAA6K,mBAAA,GAAAD,GACA,KAAA5K,SAAA,CAAAp2B,CAAA,GAAA8gC,GACA,KAAA1K,SAAA,CAAAn2B,CAAA,GAAA8gC,CAAA,IACA,KAAAjF,YAAA,IACA,KAAA5+B,cAAA,GACA,KAAAi/B,eAAA,oBAAA/1B,KAEA,EACA20B,EAAA1jC,SAAA,CAAAwiC,IAAA,YACA,KAAA3K,SAAA,GAEA,EACA6L,EAAA1jC,SAAA,CAAA+hC,IAAA,YACA,KAAAlK,SAAA,GAEA,EACA6L,EAAA1jC,SAAA,CAAA6F,cAAA,UAAAgkC,CAAA,EACA,IAAApqC,EAAAmE,EAAA0J,CACA,UAAAu8B,GAAwCA,CAAAA,EAAA,IACxC,OAAAjmC,CAAAA,EAAA,CAAAnE,EAAA,KAAA2N,OAAA,EAAAvH,cAAA,GAAAjC,KAAA,IAAAA,GAAAA,EAAA1D,IAAA,CAAAT,GACAoqC,GAAA,QAAAv8B,CAAAA,EAAA,KAAA+wB,QAAA,KAAA/wB,KAAA,IAAAA,GAAAA,EAAAzH,cAAA,IACA,KAAA68B,YAAA,QAAAA,YAAA,CAAAn8B,QAAA,EACA,MAAAm8B,YAAA,CAAAj+B,KAAAA,CAAA,CAEA,EACAi/B,EAAA1jC,SAAA,CAAAmmC,kBAAA,UAAAzhB,CAAA,CAAAwhB,CAAA,EACA,IACAzmC,EADAikB,EAAA,UAEA,IAAAwiB,GAA2DA,CAAAA,EAAA,IAC3D,IAAAhE,EAAA,KAAAA,QAAA,CACA4H,EAAA,CAAA5H,MAAAA,EAAA,OAAAA,EAAA/0B,YAAA,MACA48B,EAAAtvC,EAAAiK,QAAA,IAA+C,KAAAyI,YAAA,EAC/Cy7B,EAAAlZ,IACA,MAAAgW,cAAA,MAAAqD,oBAAA,CAAAtkC,KAAAA,EACA,KAAAwkC,8BAAA,EAAA/C,EACA,IAAA8D,EAAApa,KACAqa,EAAA/H,MAAAA,EAAA,OAAAA,EAAAE,QAAA,CACA8H,EAAA,YAAAzqC,CAAAA,EAAA,KAAA4+B,QAAA,KAAA5+B,KAAA,IAAAA,EAAA,OAAAA,EAAA6+B,OAAA,CAAAxgC,MAAA,MACAqsC,EAAAvoC,CAAAA,CAAAqoC,CAAAA,GACA,CAAAC,GACA,UAAA98B,OAAA,CAAAm1B,SAAA,EACA,MAAAqC,IAAA,CAAApoC,IAAA,CAAA4tC,GAAA,CACA,MAAA1F,iBAAA,GACA,KAAA2F,cAAA,UAAAvV,CAAA,EAEA,IAgaA4K,EAAA9d,EAjaAniB,EACAs1B,EAAAD,EAAA,IACAwV,GAAA1B,EAAAjgC,CAAA,CAAA+b,EAAA/b,CAAA,CAAAosB,GACAuV,GAAA1B,EAAAhgC,CAAA,CAAA8b,EAAA9b,CAAA,CAAAmsB,GACArR,EAAAilB,cAAA,CAAAC,GACAllB,EAAAgiB,cAAA,EACAhiB,EAAAqlB,oBAAA,EACArlB,EAAA5f,MAAA,EACA,QAAArE,CAAAA,EAAAikB,EAAAmlB,cAAA,GAAAppC,KAAA,IAAAA,EAAA,OAAAA,EAAAqE,MAAA,IACAgrB,GAAAkb,EAAAtmB,EAAA5f,MAAA,CAAAsuB,MAAA,CAAA1O,EAAAmlB,cAAA,CAAA/kC,MAAA,CAAAsuB,MAAA,EAwZAsN,EAvZAhc,EAAAgiB,cAAA,CAuZA9jB,EAvZA8B,EAAAqlB,oBAAA,CAwZAwB,GAAA7K,EAAA/2B,CAAA,CAAAiZ,EAAAjZ,CAAA,CAAAyW,EAAAzW,CAAA,CAxZAosB,GAyZAwV,GAAA7K,EAAA92B,CAAA,CAAAgZ,EAAAhZ,CAAA,CAAAwW,EAAAxW,CAAA,CAzZAmsB,IAEAkV,IACAvmB,EAAAye,eAAA,CAAA4H,EACAS,SA1jCAz7B,CAAA,CAAA07B,CAAA,CAAA/I,CAAA,CAAA3M,CAAA,CAAAoV,CAAA,CAAAD,CAAA,EACA,IAAAzqC,EAAAmE,EAAA0J,EAAAC,EACA48B,GACAp7B,EAAAxC,OAAA,CAAAzR,EAAA0X,GAAA,GAGA,OAAA/S,CAAAA,EAAAiiC,EAAAn1B,OAAA,GAAA9M,KAAA,IAAAA,EAAAA,EAAA,EAAA2gC,GAAArL,IACAhmB,EAAA27B,WAAA,CAAA5vC,EAAA0X,GAAA,QAAA5O,CAAAA,EAAA6mC,EAAAl+B,OAAA,GAAA3I,KAAA,IAAAA,EAAAA,EAAA,IAAA08B,GAAAvL,KAEAmV,GACAn7B,CAAAA,EAAAxC,OAAA,CAAAzR,EAAA0X,GAAA,QAAAlF,CAAAA,EAAAm9B,EAAAl+B,OAAA,GAAAe,KAAA,IAAAA,EAAAA,EAAA,SAAAC,CAAAA,EAAAm0B,EAAAn1B,OAAA,GAAAgB,KAAA,IAAAA,EAAAA,EAAA,EAAAwnB,EAAA,EAKA,QAAA9uB,EAAA,EAAoBA,EAAA85B,GAAgB95B,IAAA,CACpC,IAAA0kC,EAAA,SAAAh8B,MAAA,CAAAmxB,EAAA,CAAA75B,EAAA,WACA2kC,EAAA1K,GAAAuK,EAAAE,GACAE,EAAA3K,GAAAwB,EAAAiJ,GACAC,CAAAA,KAAAnmC,IAAAmmC,GAAAC,KAAApmC,IAAAomC,CAAA,IAEAD,GAAAA,CAAAA,EAAA,GACAC,GAAAA,CAAAA,EAAA,GACAD,IAAAA,GACAC,IAAAA,GACA5K,GAAA2K,KAAA3K,GAAA4K,IAEA97B,CAAA,CAAA47B,EAAA,CAAAvhC,KAAA+kB,GAAA,CAAArzB,EAAA0X,GAAA,CAAAwtB,GAAA4K,GAAA5K,GAAA6K,GAAA9V,GAAA,GACAl6B,CAAAA,EAAAsrB,OAAA,CAAA5e,IAAA,CAAAsjC,IAAAhwC,EAAAsrB,OAAA,CAAA5e,IAAA,CAAAqjC,EAAA,GACA77B,CAAAA,CAAA,CAAA47B,EAAA,QAIA57B,CAAA,CAAA47B,EAAA,CAAAE,EAEA,CAIAJ,CAAAA,EAAAn/B,MAAA,EAAAo2B,EAAAp2B,MAAA,GACAyD,CAAAA,EAAAzD,MAAA,CAAAxQ,EAAA0X,GAAA,CAAAi4B,EAAAn/B,MAAA,IAAAo2B,EAAAp2B,MAAA,IAAAypB,EAAA,CAEA,EAghCAgV,EAAAD,EAAApmB,EAAAvW,YAAA,CAAA4nB,EAAAoV,EAAAD,IAEAxmB,EAAA9I,IAAA,CAAA0sB,wBAAA,GACA5jB,EAAA7d,cAAA,GACA6d,EAAAghB,iBAAA,CAAA3P,CACA,EACA,KAAAsV,cAAA,GACA,EACA3G,EAAA1jC,SAAA,CAAAqhB,cAAA,UAAAjU,CAAA,EACA,IACA3N,EAAAmE,EADA8f,EAAA,KAEA,KAAAohB,eAAA,mBACA,OAAArlC,CAAAA,EAAA,KAAA8+B,gBAAA,GAAA9+B,KAAA,IAAAA,GAAAA,EAAAujB,IAAA,GACA,KAAA0f,YAAA,EACA,QAAA9+B,CAAAA,EAAA,KAAA8+B,YAAA,CAAAnE,gBAAA,GAAA36B,KAAA,IAAAA,GAAAA,EAAAof,IAAA,IAEA,KAAAkmB,gBAAA,GACAnuC,EAAA4yB,UAAA,CAAAT,MAAA,MAAAgc,gBAAA,EACA,KAAAA,gBAAA,CAAAzkC,KAAAA,GAOA,KAAAykC,gBAAA,CAAAjtC,EAAA,QAAAixB,MAAA,YACA/qB,EAAAC,sBAAA,IACAshB,EAAA6a,gBAAA,CAAAn9B,GAAA,EA9vBA,IA8vBA3G,EAAAiK,QAAA,CAAAjK,EAAAiK,QAAA,IAAqG0I,GAAA,CAAc8U,SAAA,SAAA4S,CAAA,EACnH,IAAAr1B,EACAikB,EAAA2mB,cAAA,CAAAvV,GACA,OAAAr1B,CAAAA,EAAA2N,EAAA8U,QAAA,GAAAziB,KAAA,IAAAA,GAAAA,EAAAS,IAAA,CAAAkN,EAAA0nB,EACA,EAAqBxT,WAAA,WACrB,IAAA7hB,CACA,QAAAA,CAAAA,EAAA2N,EAAAkU,UAAA,GAAA7hB,KAAA,IAAAA,GAAAA,EAAAS,IAAA,CAAAkN,GACAsW,EAAAonB,iBAAA,EACA,KACApnB,EAAAgf,YAAA,EACAhf,CAAAA,EAAAgf,YAAA,CAAAnE,gBAAA,CAAA7a,EAAA6a,gBAAA,EAEA7a,EAAAwlB,gBAAA,CAAAzkC,KAAAA,CACA,EACA,EACAi/B,EAAA1jC,SAAA,CAAA8qC,iBAAA,YACA,IAAArrC,CACA,MAAAijC,YAAA,GACA,KAAAA,YAAA,CAAAnE,gBAAA,CAAA95B,KAAAA,EACA,KAAAi+B,YAAA,CAAAT,eAAA,CAAAx9B,KAAAA,GAEA,OAAAhF,CAAAA,EAAA,KAAA4+B,QAAA,KAAA5+B,KAAA,IAAAA,GAAAA,EAAAgjC,qBAAA,GACA,KAAAC,YAAA,CACA,KAAAnE,gBAAA,CACA,KAAA4D,eAAA,CACA19B,KAAAA,EACA,KAAAqgC,eAAA,qBACA,EACApB,EAAA1jC,SAAA,CAAAqlC,eAAA,YACA,IAAA5lC,CACA,MAAA8+B,gBAAA,GACA,OAAA9+B,CAAAA,EAAA,KAAA4qC,cAAA,GAAA5qC,KAAA,IAAAA,GAAAA,EAAAS,IAAA,MA7xBA,KA8xBA,KAAAq+B,gBAAA,CAAAvb,IAAA,IAEA,KAAA8nB,iBAAA,EACA,EACApH,EAAA1jC,SAAA,CAAA+qC,uBAAA,YACA,IAAAtrC,EAAA,KAAA0pC,OAAA,GAAAH,EAAAvpC,EAAAupC,oBAAA,CAAAj6B,EAAAtP,EAAAsP,MAAA,CAAAjL,EAAArE,EAAAqE,MAAA,CAAAqJ,EAAA1N,EAAA0N,YAAA,CACA67B,GAAAj6B,GAAAjL,IAEA48B,GAAAsI,EAAAj6B,GAMA+hB,GAAAkY,EAAA77B,GAOAuhB,GAAA,KAAA8a,4BAAA,MAAA3B,eAAA,CAAAmB,EAAA77B,GACA,EACAu2B,EAAA1jC,SAAA,CAAAslC,kBAAA,UAAAzhC,CAAA,CAAA05B,CAAA,EAKA,IAJA99B,EAAAmE,EAAA0J,EACA,KAAAq3B,WAAA,CAAA19B,GAAA,CAAApD,IACA,KAAA8gC,WAAA,CAAAz9B,GAAA,CAAArD,EAAA,IAAA29B,IAGAwJ,IADA,CAAArG,WAAA,CAAA9oC,GAAA,CAAAgI,GACAqV,GAAA,CAAAqkB,GACAA,EAAAY,OAAA,EACA3qB,WAAA,OAAA/T,CAAAA,EAAA89B,EAAAnwB,OAAA,CAAAnJ,sBAAA,GAAAxE,KAAA,IAAAA,EAAA,OAAAA,EAAA+T,UAAA,CACAsuB,sBAAA,OAAAx0B,CAAAA,EAAA,OAAA1J,CAAAA,EAAA25B,EAAAnwB,OAAA,CAAAnJ,sBAAA,GAAAL,KAAA,IAAAA,EAAA,OAAAA,EAAAqnC,2BAAA,GAAA39B,KAAA,IAAAA,EAAA,OAAAA,EAAApN,IAAA,CAAA0D,EAAA25B,EACA,EACA,EACAmG,EAAA1jC,SAAA,CAAAw+B,MAAA,YACA,IAAAwM,EAAA,KAAA3M,QAAA,GACA,MAAA2M,CAAAA,GAAAA,EAAAtJ,IAAA,SAEAgC,EAAA1jC,SAAA,CAAAmpC,OAAA,YAEA,IADA1pC,EAEA,OAAAoE,IADA,CAAAuJ,OAAA,CAAAvJ,QAAA,EACA,QAAApE,CAAAA,EAAA,KAAA4+B,QAAA,KAAA5+B,KAAA,IAAAA,EAAA,OAAAA,EAAAiiC,IAAA,SAEAgC,EAAA1jC,SAAA,CAAAkrC,WAAA,YAEA,IADAzrC,EAEA,OAAAoE,IADA,CAAAuJ,OAAA,CAAAvJ,QAAA,CACA,OAAApE,CAAAA,EAAA,KAAA4+B,QAAA,KAAA5+B,KAAA,IAAAA,EAAA,OAAAA,EAAAgiC,QAAA,CAAAh9B,KAAAA,CACA,EACAi/B,EAAA1jC,SAAA,CAAAq+B,QAAA,YACA,IAAAx6B,EAAA,KAAAuJ,OAAA,CAAAvJ,QAAA,CACA,GAAAA,EACA,YAAA+W,IAAA,CAAA+pB,WAAA,CAAA9oC,GAAA,CAAAgI,EACA,EACA6/B,EAAA1jC,SAAA,CAAAm+B,OAAA,UAAA1+B,CAAA,EACA,IAAAmE,EAAAnE,KAAA,IAAAA,EAAA,GAAwCA,EAAAskC,EAAAngC,EAAAmgC,UAAA,CAAAvwB,EAAA5P,EAAA4P,UAAA,CAAAsuB,EAAAl+B,EAAAk+B,qBAAA,CACxCkJ,EAAA,KAAA3M,QAAA,GACA2M,GACAA,EAAA7M,OAAA,MAAA2D,GACAiC,IACA,KAAA/E,eAAA,CAAAv6B,KAAAA,EACA,KAAAs/B,UAAA,KAEAvwB,GACA,KAAA7N,UAAA,EAAkC6N,WAAAA,CAAA,EAClC,EACAkwB,EAAA1jC,SAAA,CAAAo+B,QAAA,YACA,IAAA4M,EAAA,KAAA3M,QAAA,SACA,EAAA2M,GACAA,EAAA5M,QAAA,MAKA,EACAsF,EAAA1jC,SAAA,CAAA2mC,aAAA,YACA,IAAApoC,EAAA,KAAA6O,OAAA,CAAA7O,aAAA,CACA,GAAAA,GAOA,QAJA4sC,EAAA,GAEAC,EAAA,GAEAnlC,EAAA,EAA4BA,EAAA2B,GAAA9J,MAAA,CAA0BmI,IAAA,CAEtD,IAAA3I,EAAA,SADAsK,EAAA,CAAA3B,EAAA,CAIA1H,EAAA85B,cAAA,CAAA/6B,KAGA6tC,EAAA,GAEAC,CAAA,CAAA9tC,EAAA,CAAAiB,EAAA85B,cAAA,CAAA/6B,GACAiB,EAAA+5B,cAAA,CAAAh7B,EAAA,GACA,CAEA,GAAA6tC,GAMA,QAAA7tC,KAFAiB,MAAAA,GAAAA,EAAA8G,UAAA,GAEA+lC,EACA7sC,EAAA+5B,cAAA,CAAAh7B,EAAA8tC,CAAA,CAAA9tC,EAAA,EAIAiB,EAAAsH,cAAA,IACA,EACA69B,EAAA1jC,SAAA,CAAAuR,mBAAA,UAAAD,CAAA,EAEA,SAAAA,GAAwCA,CAAAA,EAAA,IAExC,IAHA7R,EAAAmE,EAAA0J,EAAAC,EAAAwb,EAAAC,EAGAqiB,EAAA,GACA,SAAA9kC,QAAA,OAAAu9B,KAAA,CACA,OAAAuH,EACA,SAAAxT,SAAA,CACA,OAAyBW,WAAA,SAGzB6S,CAAAA,EAAA7S,UAAA,IAEA,IAAAnrB,EAAA,OAAA5N,CAAAA,EAAA,KAAA2N,OAAA,CAAA7O,aAAA,GAAAkB,KAAA,IAAAA,EAAA,OAAAA,EAAAuB,QAAA,GAAAqM,iBAAA,CACA,QAAA02B,UAAA,CAQA,OAPA,KAAAA,UAAA,IACAsH,EAAA9+B,OAAA,IACA8+B,EAAAC,aAAA,CACAj5B,GAAAf,EAAAg6B,aAAA,MACAD,EAAAliC,SAAA,CAAAkE,EACAA,EAAA,KAAAF,YAAA,KACA,OACAk+B,EAEA,IAAA3J,EAAA,KAAAyH,OAAA,GACA,SAAAnK,eAAA,QAAAl7B,MAAA,GAAA49B,EAAA3yB,MAAA,EACA,IAAAw8B,EAAA,GAYA,OAXA,KAAAn+B,OAAA,CAAAvJ,QAAA,GACA0nC,EAAAh/B,OAAA,QAAA3I,CAAAA,EAAA,KAAAuJ,YAAA,CAAAZ,OAAA,GAAA3I,KAAA,IAAAA,EAAAA,EAAA,EACA2nC,EAAAD,aAAA,CACAj5B,GAAAf,EAAAg6B,aAAA,OAEA,KAAA7G,YAAA,GAAA72B,GAAA,KAAAT,YAAA,IACAo+B,EAAApiC,SAAA,CAAAkE,EACAA,EAAA,GAA8C,IAC9C,OACA,KAAAo3B,YAAA,KAEA8G,CACA,CACA,IAAAC,EAAA9J,EAAAS,eAAA,EAAAT,EAAAv0B,YAAA,CACA,KAAA49B,uBAAA,GACAM,EAAAliC,SAAA,CAAAy5B,GAAA,KAAA4G,4BAAA,MAAAzK,SAAA,CAAAyM,GACAn+B,GACAg+B,CAAAA,EAAAliC,SAAA,CAAAkE,EAAAm+B,EAAAH,EAAAliC,SAAA,GAEA,IAAA08B,EAAA,KAAA7G,eAAA,CAAAr2B,EAAAk9B,EAAAl9B,CAAA,CAAAC,EAAAi9B,EAAAj9B,CAAA,CA2BA,QAAAtL,KA1BA+tC,EAAA19B,eAAA,IAAAgB,MAAA,CAAAhG,IAAAA,EAAAiH,MAAA,OAAAjB,MAAA,CAAA/F,IAAAA,EAAAgH,MAAA,QACA8xB,EAAAS,eAAA,CAKAkJ,EAAA9+B,OAAA,CACAm1B,IAAA,KACA,OAAAn0B,CAAAA,EAAA,OAAAD,CAAAA,EAAAk+B,EAAAj/B,OAAA,GAAAe,KAAA,IAAAA,EAAAA,EAAA,KAAAH,YAAA,CAAAZ,OAAA,GAAAgB,KAAA,IAAAA,EAAAA,EAAA,EACA,KAAA00B,eAAA,CACA,KAAA90B,YAAA,CAAAZ,OAAA,CACAi/B,EAAAd,WAAA,CAOAW,EAAA9+B,OAAA,CACAm1B,IAAA,KACA,OAAA3Y,CAAAA,EAAAyiB,EAAAj/B,OAAA,GAAAwc,KAAA,IAAAA,EAAAA,EAAA,GACA,OAAAC,CAAAA,EAAAwiB,EAAAd,WAAA,GAAA1hB,KAAA,IAAAA,EAAAA,EAAA,EAKAxhB,EACA,GAAAgkC,KAAA/mC,IAAA+mC,CAAA,CAAAluC,EAAA,EAEA,IAAAmuC,EAAAjkC,CAAA,CAAAlK,EAAA,CAAAggC,EAAAmO,EAAAnO,OAAA,CAAAuB,EAAA4M,EAAA5M,OAAA,CACA6M,EAAApO,EAAAkO,CAAA,CAAAluC,EAAA,CAAAokC,GACA,GAAA7C,EAEA,QADA8M,EAAA9M,EAAA/gC,MAAA,CACAmI,EAAA,EAAoCA,EAAA0lC,EAAS1lC,IAC7ColC,CAAA,CAAAxM,CAAA,CAAA54B,EAAA,EAAAylC,OAIAL,CAAA,CAAA/tC,EAAA,CAAAouC,EAcA,OANA,KAAAt+B,OAAA,CAAAvJ,QAAA,EACAwnC,CAAAA,EAAAC,aAAA,CACA5J,IAAA,KACArvB,GAAAf,EAAAg6B,aAAA,MACA,QAEAD,CACA,EACA3H,EAAA1jC,SAAA,CAAAonC,aAAA,YACA,KAAApF,UAAA,MAAAE,QAAA,CAAAz9B,KAAAA,CACA,EAEAi/B,EAAA1jC,SAAA,CAAA4rC,SAAA,YACA,KAAAhxB,IAAA,CAAA0pB,KAAA,CAAA7oC,OAAA,UAAA8hC,CAAA,EAAsD,IAAA99B,EAAQ,cAAAA,CAAAA,EAAA89B,EAAAgB,gBAAA,GAAA9+B,KAAA,IAAAA,EAAA,OAAAA,EAAAujB,IAAA,KAC9D,KAAApI,IAAA,CAAA0pB,KAAA,CAAA7oC,OAAA,CAAAsrC,IACA,KAAAnsB,IAAA,CAAA+pB,WAAA,CAAA5gB,KAAA,EACA,EACA2f,CACA,GACA,CACA,SAAAxO,GAAAqI,CAAA,EACAA,EAAArI,YAAA,EACA,CACA,SAAAgS,GAAA3J,CAAA,EAEA,IADA99B,EAAAmE,EAAA0J,EAAAC,EACA20B,EAAA,OAAAt+B,CAAAA,EAAA,OAAAnE,CAAAA,EAAA89B,EAAAyE,UAAA,GAAAviC,KAAA,IAAAA,EAAA,OAAAA,EAAAyiC,QAAA,GAAAt+B,KAAA,IAAAA,EAAAA,EAAA25B,EAAA2E,QAAA,CACA,GAAA3E,EAAAiB,MAAA,IACAjB,EAAAz5B,MAAA,EACAo+B,GACA3E,EAAAyH,YAAA,eACA,IAAAjc,EAAAwU,EAAAz5B,MAAA,CAAA+nC,EAAA9iB,EAAAqJ,MAAA,CAAA0Z,EAAA/iB,EAAAwe,QAAA,CAGA,SAAAhK,EAAAnwB,OAAA,CAAAtH,aAAA,CACA+pB,GAAA,SAAA3B,CAAA,EACA,IAAA6d,EAAA7J,EAAAE,QAAA,CACAF,EAAAqF,QAAA,CAAArZ,EAAA,CACAgU,EAAAp+B,MAAA,CAAAoqB,EAAA,CACApwB,EAAAmwB,GAAA8d,EACAA,CAAAA,EAAA3d,GAAA,CAAAyd,CAAA,CAAA3d,EAAA,CAAAE,GAAA,CACA2d,EAAA5d,GAAA,CAAA4d,EAAA3d,GAAA,CAAAtwB,CACA,GAEA,aAAAy/B,EAAAnwB,OAAA,CAAAtH,aAAA,EACA+pB,GAAA,SAAA3B,CAAA,EACA,IAAA6d,EAAA7J,EAAAE,QAAA,CACAF,EAAAqF,QAAA,CAAArZ,EAAA,CACAgU,EAAAp+B,MAAA,CAAAoqB,EAAA,CACApwB,EAAAmwB,GAAA4d,CAAA,CAAA3d,EAAA,CACA6d,CAAAA,EAAA5d,GAAA,CAAA4d,EAAA3d,GAAA,CAAAtwB,CACA,GAEA,IAAAkuC,EAAAtc,KACAhB,GAAAsd,EAAAH,EAAA3J,EAAAp+B,MAAA,EACA,IAAAmoC,EAAAvc,IACAwS,CAAAA,EAAAE,QAAA,CACA1T,GAAAud,EAAA1O,EAAAgL,cAAA,CAAAuD,EAAA,IAAA5J,EAAAqF,QAAA,EAGA7Y,GAAAud,EAAAJ,EAAA3J,EAAAp+B,MAAA,EAEA,IAAA0xB,EAAA,CAAA8L,GAAA0K,GACAzG,EAAA,GACA,IAAAhI,EAAAyE,UAAA,GACAzE,EAAAsL,cAAA,CAAAtL,EAAAuL,0BAAA,GAKAvL,EAAAsL,cAAA,GAAAtL,EAAAsL,cAAA,CAAA7G,UAAA,GACA,IAAAhZ,EAAAuU,EAAAsL,cAAA,CAAAqD,EAAAljB,EAAAkZ,QAAA,CAAAiK,EAAAnjB,EAAAllB,MAAA,CACA,GAAAooC,GAAAC,EAAA,CACA,IAAAC,EAAAxc,KACAd,GAAAsd,EAAAlK,EAAAp+B,MAAA,CAAAooC,EAAApoC,MAAA,EACA,IAAAkmC,EAAApa,KACAd,GAAAkb,EAAA6B,EAAAM,EAAA/Z,MAAA,EACAmP,GAAA6K,EAAApC,IACAzE,CAAAA,EAAA,GAEA,CACA,CAEAhI,EAAAuH,eAAA,cACAhhC,OAAA+nC,EACA3J,SAAAA,EACAxd,MAAAunB,EACAD,YAAAA,EACAxW,iBAAAA,EACA+P,yBAAAA,CACA,EACA,MACAhI,EAAAiB,MAAA,IACA,QAAAjxB,CAAAA,EAAA,CAAAD,EAAAiwB,EAAAnwB,OAAA,EAAA4P,cAAA,GAAAzP,KAAA,IAAAA,GAAAA,EAAArN,IAAA,CAAAoN,EAAA,CAOAiwB,CAAAA,EAAAnwB,OAAA,CAAAoG,UAAA,CAAA/O,KAAAA,CACA,CACA,SAAA2iC,GAAA7J,CAAA,EACAA,EAAA6J,aAAA,EACA,CACA,SAAAL,GAAAxJ,CAAA,EACAA,EAAAwJ,iBAAA,EACA,CACA,SAAAE,GAAA1J,CAAA,EACA,IAAAh/B,EAAAg/B,EAAAnwB,OAAA,CAAA7O,aAAA,CACAA,CAAAA,MAAAA,EAAA,OAAAA,EAAAyC,QAAA,GAAAqrC,qBAAA,GACA9tC,EAAA+tC,yBAAA,GAEA/O,EAAAb,cAAA,EACA,CACA,SAAA2I,GAAA9H,CAAA,EACAA,EAAA8H,eAAA,GACA9H,EAAAqL,WAAA,CAAArL,EAAAmI,cAAA,CAAAnI,EAAAxuB,MAAA,CAAAtK,KAAAA,CACA,CACA,SAAA8/B,GAAAhH,CAAA,EACAA,EAAAgH,kBAAA,EACA,CACA,SAAAC,GAAAjH,CAAA,EACAA,EAAAiH,cAAA,EACA,CACA,SAAAmC,GAAApJ,CAAA,EACAA,EAAAoJ,aAAA,EACA,CACA,SAAAU,GAAA2D,CAAA,EACAA,EAAArI,kBAAA,EACA,CACA,SAAA2H,GAAA5K,CAAA,CAAAhb,CAAA,CAAAzmB,CAAA,EACAyhC,EAAAjR,SAAA,CAAA3zB,EAAA0X,GAAA,CAAAkS,EAAA+J,SAAA,GAAAxwB,GACAyhC,EAAA/zB,KAAA,CAAA7Q,EAAA0X,GAAA,CAAAkS,EAAA/Y,KAAA,GAAA1N,GACAyhC,EAAA9vB,MAAA,CAAA8U,EAAA9U,MAAA,CACA8vB,EAAAlR,WAAA,CAAA9J,EAAA8J,WAAA,CAEA,SAAA+b,GAAA7K,CAAA,CAAA9d,CAAA,CAAAxC,CAAA,CAAAnhB,CAAA,EACAyhC,EAAAtR,GAAA,CAAAtzB,EAAA0X,GAAA,CAAAoP,EAAAwM,GAAA,CAAAhP,EAAAgP,GAAA,CAAAnwB,GACAyhC,EAAAvR,GAAA,CAAArzB,EAAA0X,GAAA,CAAAoP,EAAAuM,GAAA,CAAA/O,EAAA+O,GAAA,CAAAlwB,EACA,CAKA,SAAAmsC,GAAA7M,CAAA,EACA,OAAAA,EAAA4E,eAAA,EAAA5E,KAAA94B,IAAA84B,EAAA4E,eAAA,CAAAuI,WAAA,CAEA,IAAA9E,GAAA,CACApmB,SAAA,IACAD,KAAA,aAEA,SAAAynB,GAAAzJ,CAAA,CAAA/4B,CAAA,EAMA,QADA+nC,EAAAhP,EAAA3iB,IAAA,CACA3U,EAAAs3B,EAAAqH,IAAA,CAAA9mC,MAAA,GAAuCmI,GAAA,EAAQA,IAC/C,GAAAs3B,EAAAqH,IAAA,CAAA3+B,EAAA,CAAAM,QAAA,EACAgmC,EAAAhP,EAAAqH,IAAA,CAAA3+B,EAAA,CACA,KACA,CALA,IAQAoL,EAAAm7B,CADAD,GAAAA,IAAAhP,EAAA3iB,IAAA,CAAA2xB,EAAAhmC,QAAA,CAAA7H,QAAA,EACA+tC,aAAA,yBAAA99B,MAAA,CAAAnK,EAAA,OACA6M,GACAksB,EAAA/2B,KAAA,CAAA6K,EAAA,GACA,CACA,SAAAq7B,GAAAxe,CAAA,EACAA,EAAAE,GAAA,CAAAhlB,KAAAC,KAAA,CAAA6kB,EAAAE,GAAA,EACAF,EAAAC,GAAA,CAAA/kB,KAAAC,KAAA,CAAA6kB,EAAAC,GAAA,CACA,CACA,SAAAwZ,GAAAtX,CAAA,EACAqc,GAAArc,EAAA1nB,CAAA,EACA+jC,GAAArc,EAAAznB,CAAA,CACA,CAEA,IAAA+jC,GAAAtJ,GAAA,CACAC,qBAAA,SAAAvjC,CAAA,CAAA4jB,CAAA,EAAmD,OAAA7O,GAAA/U,EAAA,SAAA4jB,EAAA,EACnD6f,cAAA,WAAiC,OACjC76B,EAAAjK,SAAAkuC,eAAA,CAAAC,UAAA,EAAAnuC,SAAAouC,IAAA,CAAAD,UAAA,CACAjkC,EAAAlK,SAAAkuC,eAAA,CAAAG,SAAA,EAAAruC,SAAAouC,IAAA,CAAAC,SAAA,CACK,EACLtJ,kBAAA,WAAqC,SACrC,GAEA/P,GAAA,CACA30B,QAAA0F,KAAAA,CACA,EACAuoC,GAAA3J,GAAA,CACAG,cAAA,SAAAj9B,CAAA,EAAyC,OACzCoC,EAAApC,EAAAsmC,UAAA,CACAjkC,EAAArC,EAAAwmC,SAAA,CACK,EACLxJ,cAAA,WACA,IAAA7P,GAAA30B,OAAA,EACA,IAAAkuC,EAAA,IAAAN,GAAA,MACAM,EAAAzmC,KAAA,CAAArH,QACA8tC,EAAAtnC,UAAA,EAAsC3B,aAAA,KACtC0vB,GAAA30B,OAAA,CAAAkuC,CACA,CACA,OAAAvZ,GAAA30B,OAAA,EAEA29B,eAAA,SAAAn2B,CAAA,CAAA/L,CAAA,EACA+L,EAAAiH,KAAA,CAAArE,SAAA,CAAA3O,MAAAA,EAAAA,EAAA,MACA,EACAipC,kBAAA,SAAAl9B,CAAA,EACA,MAAApH,UAAAA,OAAAy6B,gBAAA,CAAArzB,GAAA2mC,QAAA,CAEA,GAEAC,GAAA1yC,EAAAiK,QAAA,CAAAjK,EAAAiK,QAAA,CAAAjK,EAAAiK,QAAA,CAAAjK,EAAAiK,QAAA,IAAkF+jB,IAAA3O,IAAAhd,IAAA+iC,IAOlFuN,GAAA1mC,EAAA,SAAAlJ,CAAA,CAAAmH,CAAA,EACA,OAAAqP,GAAAxW,EAAAmH,EAAAwoC,GAAAjQ,GAAA8P,GACA,GAuBAK,GAAA3mC,EAAAsN,IAEA,SAAAs5B,KACA,IAAA5W,EAAA/7B,EAAAuH,MAAA,KAOA,OANAvD,EAAA,WAEA,OADA+3B,EAAA33B,OAAA,IACA,WACA23B,EAAA33B,OAAA,GACA,CACA,EAAK,IACL23B,CACA,CAEA,SAAA6W,KACA,IAAA7W,EAAA4W,KACA7tC,EAAAhF,EAAAiF,MAAA,CAAA/E,EAAAgF,QAAA,OAAA6tC,EAAA/tC,CAAA,IAAAguC,EAAAhuC,CAAA,IACAiuC,EAAA/yC,EAAA2L,WAAA,YACAowB,EAAA33B,OAAA,EAAA0uC,EAAAD,EAAA,EACA,EAAK,CAAAA,EAAA,EAML,OADA7yC,EAAA2L,WAAA,YAA8D,OAAArK,EAAA,QAAA2oB,UAAA,CAAA8oB,EAAA,EAA0D,CAAAA,EAAA,EACxHF,EAAA,CAGA,IAAAG,GAAA,SAAAluC,CAAA,EACA,IAAA0D,EAAA1D,EAAA0D,QAAA,CAAA7B,EAAA7B,EAAA6B,OAAA,CAAAyb,EAAAtd,EAAAsd,SAAA,CAAAC,EAAAvd,EAAAud,cAAA,CAAAtc,EAAAjB,EAAAiB,MAAA,CAAAktC,EAAAnuC,EAAAmuC,qBAAA,CACAC,EAAA7rC,EAAA8rC,IACAtpC,EAAAqY,KACAjY,EAAAjK,EAAAoK,OAAA,YAA8C,OAC9CP,GAAAA,EACAlD,QAAAA,EACAyb,UAAAA,EACArc,OAAAA,EACAsc,eAAA,SAAA+wB,CAAA,EACA,IAAAC,EAAAvuC,EACAouC,EAAA3mC,GAAA,CAAA6mC,EAAA,IACA,IACA,QAAAnqC,EAAAnJ,EAAAwzC,QAAA,CAAAJ,EAAA96B,MAAA,IAAAzF,EAAA1J,EAAAuZ,IAAA,GAAyF,CAAA7P,EAAA4gC,IAAA,CAAU5gC,EAAA1J,EAAAuZ,IAAA,GAEnG,IADA7P,EAAA9S,KAAA,CAEA,MAEA,CACA,MAAA2zC,EAAA,CAA4BH,EAAA,CAAQI,MAAAD,CAAA,SACpC,CACA,IACA7gC,GAAA,CAAAA,EAAA4gC,IAAA,EAAAzuC,CAAAA,EAAAmE,EAAAyqC,MAAA,GAAA5uC,EAAAS,IAAA,CAAA0D,EACA,QACA,CAA0B,GAAAoqC,EAAA,MAAAA,EAAAI,KAAA,CAC1B,CACApxB,MAAAA,GAAAA,GACA,EACAC,SAAA,SAAA8wB,CAAA,EAEA,OADAF,EAAA3mC,GAAA,CAAA6mC,EAAA,IACA,WAAiC,OAAAF,EAAAryB,MAAA,CAAAuyB,EAAA,CACjC,CACA,CAAK,EAMLH,EAAAnpC,KAAAA,EAAA,CAAAsY,EAAA,EAWA,OAVApiB,EAAAoK,OAAA,YACA8oC,EAAApyC,OAAA,UAAA6yC,CAAA,CAAAhxC,CAAA,EAAqD,OAAAuwC,EAAA3mC,GAAA,CAAA5J,EAAA,KACrD,EAAK,CAAAyf,EAAA,EAKL5hB,EAAA0D,SAAA,YACA,GAAAgvC,EAAAtjC,IAAA,EAAAyS,MAAAA,GAAAA,GACA,EAAK,CAAAD,EAAA,EACL5hB,EAAAiL,aAAA,CAAA5H,EAAA6H,QAAA,EAAuE7L,MAAAoK,CAAA,EAAgBzB,EACvF,EACA,SAAA2qC,KACA,WAAA/mC,GACA,CAEA,IAAAwnC,GAAA,SAAA91B,CAAA,EAAqC,OAAAA,EAAAnb,GAAA,MAoJrCkxC,GAAA7zC,EAAA+C,aAAA,OAEAimB,GAAA,SAAA4Z,CAAA,EACA,OAAAA,EAAA+E,aAAA,EAAA/E,EAAAW,UAAA,IACA,EAqBAuQ,GAAA,SAAA3pC,CAAA,EAA8C,MAAAA,CAAA,IAAAA,CAAA,EAI9C4pC,GAAA,SAAAjvC,CAAA,EAEA,IAzBA6kC,EACA7gB,EACAkrB,EAkBA7pC,EAIAlB,EAAA0J,EACAnK,EAAA1D,EAAA0D,QAAA,CAAAqB,EAAA/E,EAAA+E,EAAA,CAAAoqC,EAAAnvC,EAAAmvC,SAAA,CAAArhC,EAAA9N,EAAAqF,OAAA,CAAAA,EAAAyI,KAAA,IAAAA,GAAAA,CAEA9I,MAAAA,IAAAmqC,GACA9pC,CAAAA,EAAA8pC,CAAA,EACA,IAAAC,EAAAl0C,EAAA2D,UAAA,CAAAiE,GACAusC,EAAAn0C,EAAA2D,UAAA,CAAAkwC,IACAzlB,EAAAtuB,EAAAiF,MAAA,CAAA6tC,KAAA,GAAAG,EAAA3kB,CAAA,IAAAzrB,EAAAyrB,CAAA,IACAnkB,EAAAjK,EAAAuH,MAAA,OACA6sC,EAAA,OAAAnrC,CAAAA,EAAAirC,EAAArqC,EAAA,GAAAZ,KAAA,IAAAA,EAAAA,EAAAkrC,CACA,QAAAlqC,EAAA7F,OAAA,GAbA0vC,CAAAA,GAAA3pC,CAAA,KADAA,EAeAA,KAdAA,OAAAA,CAAA,GAcAiqC,GACAvqC,CAAAA,EAAAA,EAAAuqC,EAAA,IAAAvqC,EAAAuqC,CAAA,EAEAnqC,EAAA7F,OAAA,EACAyF,GAAAA,EACAs5B,KAAA,CAAA2Q,GAAA3pC,IACA,OAAAwI,CAAAA,EAAAuhC,MAAAA,EAAA,OAAAA,EAAA/Q,KAAA,GAAAxwB,KAAA,IAAAA,EAAAA,GAzCAg3B,EAAA,IAAAj8B,IACAob,EAAA,IAAArK,QAEA,CACAF,IAAA,SAAAqkB,CAAA,EACA+G,EAAAprB,GAAA,CAAAqkB,GACA9Z,EAAAvc,GAAA,CAAAq2B,EAAAA,EAAAroB,gBAAA,cAAAy5B,GACA,EACA3W,OAAA,SAAAuF,CAAA,EACA,IAAA99B,EACA6kC,EAAA9oB,MAAA,CAAA+hB,GACA,OAAA99B,CAAAA,EAAAgkB,EAAA5nB,GAAA,CAAA0hC,EAAA,GAAA99B,KAAA,IAAAA,GAAAA,IACAgkB,EAAAjI,MAAA,CAAA+hB,GACAoR,GACA,EACAK,KAAA,CAbAL,EAAA,WAAiC,OAAArK,EAAA7oC,OAAA,CAAAkoB,GAAA,CAcjC,EA2BA,GAEA,IAAAsrB,EAAAt0C,EAAAoK,OAAA,YAAsD,OAAAtK,EAAAiK,QAAA,CAAAjK,EAAAiK,QAAA,IAAwCE,EAAA7F,OAAA,GAAsB2uC,YAAAA,CAAA,EAA0B,EAAK,CAAApwC,EAAA,EACnJ,OAAAnC,EAAAiL,aAAA,CAAA7D,EAAA8D,QAAA,EAA0E7L,MAAAy0C,CAAA,EAAwB9rC,EAClG,EAEAqB,GAAA,EAyGA,SAAA0qC,GAAA7xC,CAAA,EACA,yBAAAA,CACA,CAEA,IAAA8xC,GAAAx0C,EAAA+C,aAAA,OA0DA0xC,GAAAz0C,EAAA8I,UAAA,CApCA,SAAAhE,CAAA,CAAAiE,CAAA,EACA,IAAAP,EAAA1D,EAAA0D,QAAA,CAAAS,EAAAnE,EAAA4vC,EAAA,CAAAA,EAAAzrC,KAAA,IAAAA,EAAA,KAAAA,EAAA0J,EAAA7N,EAAAyuB,IAAA,CAAAA,EAAA5gB,KAAA,IAAAA,EAAA,IAAAA,EAAAgiC,EAAA7vC,EAAA6vC,SAAA,CAAAv8B,EAAAtT,EAAAsT,MAAA,CAAAxW,EAAA9B,EAAAkW,MAAA,CAAAlR,EAAA,+CACAjC,EAAAwE,EAAA,WAA8C,OAAAorC,GAAAiC,EAAA,GAC9CpnC,EAAA,GACAsnC,EAAA50C,EAAAuH,MAAA,YACAtH,EAAAoL,SAAA,CAAApE,CAAAA,CAAAmR,EAAA,gDAyBApY,EAAAkE,SAAA,YACA0wC,EAAAxwC,OAAA,GACA,GACA5D,EAAAiL,aAAA,CAAA5I,EAAA/C,EAAAiK,QAAA,IAAuEnI,EAAA,CAAWwD,IAAA2D,CAAA,GAClFvI,EAAAiL,aAAA,CAAA+oC,GAAA9oC,QAAA,EAAkE7L,MA5BlE,CACA0zB,KAAAA,EACAshB,aAAA,SAAAh1C,CAAA,CAAAsJ,CAAA,EAIAA,GACAmE,KAAAA,EAAA25B,SAAA,UAAAroB,CAAA,EAAmD,OAAA/e,IAAA+e,EAAA/e,KAAA,KACnDyN,EAAA9B,IAAA,EAA6B3L,MAAAA,EAAAsJ,OAAAA,CAAA,CAAAoqB,EAAA,GAC7BjmB,EAAAuG,IAAA,CAAAihC,IAEA,EACAC,YAAA,SAAAlrC,CAAA,CAAAqL,CAAA,CAAA9O,CAAA,EACA,IAAAwuC,EAAAxwC,OAAA,EAEA,IAAA4wC,EAAAC,SAzCA3nC,CAAA,CAAAzN,CAAA,CAAAqV,CAAA,CAAA9O,CAAA,EACA,IAAAA,EACA,OAAAkH,EACA,IAAAyL,EAAAzL,EAAA25B,SAAA,UAAAve,CAAA,EAAkD,OAAAA,EAAA7oB,KAAA,GAAAA,CAAA,GAClD,GAAAkZ,KAAAA,EACA,OAAAzL,EACA,IAAA4nC,EAAA9uC,EAAA,OACA+uC,EAAA7nC,CAAA,CAAAyL,EAAAm8B,EAAA,CACA,IAAAC,EACA,OAAA7nC,EACA,IAAAob,EAAApb,CAAA,CAAAyL,EAAA,CACAq8B,EAAAD,EAAAhsC,MAAA,CACAksC,EAAAl1C,EAAA0X,GAAA,CAAAu9B,EAAA3hB,GAAA,CAAA2hB,EAAA5hB,GAAA,YACA,IAAA0hB,GAAAxsB,EAAAvf,MAAA,CAAAqqB,GAAA,CAAAte,EAAAmgC,GACAH,KAAAA,GAAAxsB,EAAAvf,MAAA,CAAAsqB,GAAA,CAAAve,EAAAmgC,EACAC,SA1kKAxwC,CAAA,CAAAk8B,CAAA,CAAAuU,CAAA,EACA,IAAA9sB,EAAAxf,EAAAlE,MAAA,CAAAD,GAAA0wC,KAAA,IACAC,EAAAzU,EAAA,EAAAvY,EAAAtlB,MAAA,CAAA69B,EAAAA,EACA,GAAAyU,GAAA,GAAAA,EAAAhtB,EAAAtlB,MAAA,EACA,IAAAuyC,EAAAH,EAAA,EAAA9sB,EAAAtlB,MAAA,CAAAoyC,EAAAA,EACA7sB,EAAA/V,EAAA5N,MAAA,CAAA0jB,EAAAG,MAAA,CAAAoY,EAAA,SACAvY,EAAAG,MAAA,CAAA8sB,EAAA,EAAAhtB,EACA,CACA,OAAAD,CACA,EAikKAnb,EAAAyL,EAAAA,EAAAm8B,GAEA5nC,CACA,EAuBAA,EAAAzD,EAAAqL,EAAA9O,GACAkH,IAAA0nC,IACAJ,EAAAxwC,OAAA,IACAuwC,EAAAK,EACA7sB,GAAA,CAAA+D,IACApG,MAAA,UAAAjmB,CAAA,EAA+C,OAAAuY,KAAAA,EAAAzL,OAAA,CAAA9M,EAAA,KAE/C,CACA,CAKkE,EAAgB2I,GAClF,GAEA,SAAA0jB,GAAAxD,CAAA,EACA,OAAAA,EAAA7oB,KAAA,CAEA,SAAAi1C,GAAA1nC,CAAA,CAAAC,CAAA,EACA,OAAAD,EAAAjE,MAAA,CAAAsqB,GAAA,CAAApmB,EAAAlE,MAAA,CAAAsqB,GAAA,CAoBA,SAAAkiB,GAAAhvC,CAAA,EACA,IAAA9G,EAAAwH,EAAA,WAA0C,OAAAgkB,GAAA1kB,EAAA,GAO1C,GADA3G,EAAA2D,UAAA,CAAAP,GAAAG,QAAA,CACA,CACA,IAAAqyC,EAAA9wC,EAAAC,MAAA,CAAA/E,EAAAgF,QAAA,CAAA2B,GAAA,MACA3G,EAAAkE,SAAA,YAAsC,OAAArE,EAAAyqB,QAAA,CAAAsrB,EAAA,EAAqC,GAC3E,CACA,OAAA/1C,CACA,CAMA,SAAA2O,KAEA,QAHA/I,EAEA42B,EAAA,GACAC,EAAA,EAAqBA,EAAAr0B,UAAA9E,MAAA,CAAuBm5B,IAC5CD,CAAA,CAAAC,EAAA,CAAAr0B,SAAA,CAAAq0B,EAAA,CAFA,IAIAuZ,EAAA,CAAAnwC,MAAAC,OAAA,CAAA02B,CAAA,KACAyZ,EAAAD,EAAA,KACAE,EAAA1Z,CAAA,GAAAyZ,EAAA,CACAE,EAAA3Z,CAAA,GAAAyZ,EAAA,CACAG,EAAA5Z,CAAA,GAAAyZ,EAAA,CACArjC,EAAA4pB,CAAA,GAAAyZ,EAAA,CACAI,EAAA/1C,EAAAg2C,WAAA,CAAAH,EAAAC,EAAAn2C,EAAAiK,QAAA,EAAuFqsC,MAZzDC,UAF9B,OAEA5wC,EAYuFwwC,CAAA,MAdvFxwC,EAAAoS,GAAA,CAE8BpS,EAAAoS,GAAA,CAAA/N,KAAAA,CAYyD,EAAiC2I,IACxH,OAAAojC,EAAAK,EAAAH,GAAAG,CACA,CAeA,SAAAI,GAAAl+B,CAAA,CAAAm+B,CAAA,EAIA,IAXAl8B,EAWAxa,EAAA81C,GAAAY,KAOAC,EAAA,WAAoC,OAAA32C,EAAA0M,GAAA,CAAAgqC,IAAA,EAWpC,OANAC,IAvBAn8B,EA4BA,WAA2C,OAAA/Y,EAAA,QAAAixB,MAAA,CAAAikB,EAAA,QA3B3CxyC,EAAA,WACA,IAAA8kB,EAAA1Q,EAAA+P,GAAA,UAAAtoB,CAAA,EAA0D,OAAAA,EAAAyqB,QAAA,CAAAjQ,EAAA,GAC1D,kBAA6B,OAAAyO,EAAAhoB,OAAA,UAAA21C,CAAA,EAAsD,OAAAA,GAAA,EAAuB,CAC1G,GAyBA52C,CACA,CAEA,SAAA62C,GAAAC,CAAA,CAAAC,CAAA,CAAAX,CAAA,CAAAxjC,CAAA,EACA,IAAAokC,EAAA,mBAAAD,EACAA,EACApoC,GAAAooC,EAAAX,EAAAxjC,GACA,OAAA/M,MAAAC,OAAA,CAAAgxC,GACAG,GAAAH,EAAAE,GACAC,GAAA,CAAAH,EAAA,UAAA7xC,CAAA,EAEA,OAAA+xC,EADA5tC,EAAAlE,MAAA,CAAAD,EAAA,MAEA,EACA,CACA,SAAAgyC,GAAA1+B,CAAA,CAAAy+B,CAAA,EACA,IAAA1c,EAAA9yB,EAAA,WAA2C,WAC3C,OAAAivC,GAAAl+B,EAAA,WACA+hB,EAAAh3B,MAAA,GAEA,QADA4zC,EAAA3+B,EAAAjV,MAAA,CACAmI,EAAA,EAAwBA,EAAAyrC,EAAezrC,IACvC6uB,CAAA,CAAA7uB,EAAA,CAAA8M,CAAA,CAAA9M,EAAA,CAAApK,GAAA,GAEA,OAAA21C,EAAA1c,EACA,EACA,CAEA,SAAA6c,GAAAn3C,CAAA,CAAAm+B,CAAA,EAEA,OADA,SAAAA,GAAmCA,CAAAA,EAAA,GACnClwB,GAAAjO,GAAAA,EAAA81C,GAAA3X,EACA,CA4BA,IAAAiZ,GAAAj3C,EAAA8I,UAAA,CA3BA,SAAAhE,CAAA,CAAAiE,CAAA,EACA,IAAAP,EAAA1D,EAAA0D,QAAA,CAAAqK,EAAA/N,EAAA+N,KAAA,CAAAhT,EAAAiF,EAAAjF,KAAA,CAAAoJ,EAAAnE,EAAA4vC,EAAA,CAAAA,EAAAzrC,KAAA,IAAAA,EAAA,KAAAA,EAAA4uB,EAAA/yB,EAAA+yB,MAAA,CAAAllB,EAAA7N,EAAAqE,MAAA,CAAAvH,EAAA9B,EAAAkW,MAAA,CAAAlR,EAAA,qDACAjC,EAAAwE,EAAA,WAA8C,OAAAorC,GAAAiC,EAAA,GAC9CzqC,EAAAjK,EAAA2D,UAAA,CAAA6wC,IACAp5B,EAAA,CACApN,EAAAgpC,GAAAnkC,MAAAA,EAAA,OAAAA,EAAA7E,CAAA,EACAC,EAAA+oC,GAAAnkC,MAAAA,EAAA,OAAAA,EAAA5E,CAAA,CACA,EACAiE,EAAAwkC,GAAA,CAAAt7B,EAAApN,CAAA,CAAAoN,EAAAnN,CAAA,WAAAnJ,CAAA,EACA,IAAAmE,EAAAnJ,EAAAiF,MAAA,CAAAD,EAAA,GAAAoyC,EAAAjuC,CAAA,IAAAkuC,EAAAluC,CAAA,IACA,OAAAiuC,GAAAC,EAAA,SACA,GACAhG,EAAAnxC,EAAAuH,MAAA,OACAtH,EAAAoL,SAAA,CAAApE,CAAAA,CAAAgD,EAAA,iDACA,IAAAspB,EAAA3gB,EAAA2gB,IAAA,CAAAshB,EAAAjiC,EAAAiiC,YAAA,CAAAE,EAAAniC,EAAAmiC,WAAA,CAIA,OAHA/0C,EAAAkE,SAAA,YACA2wC,EAAAh1C,EAAAsxC,EAAA/sC,OAAA,CACA,EAAK,CAAA6F,EAAA,EACLzJ,EAAAiL,aAAA,CAAA5I,EAAA/C,EAAAiK,QAAA,EAAuE5H,KAAAoxB,CAAA,EAAY3xB,EAAA,CAAW03B,iBAAA,GAAAzmB,MAAA/S,EAAAiK,QAAA,CAAAjK,EAAAiK,QAAA,IAA+D8I,GAAA,CAAY7E,EAAAoN,EAAApN,CAAA,CAAAC,EAAAmN,EAAAnN,CAAA,CAAAiE,OAAAA,CAAA,GAAwC/I,OAjBjNwJ,KAAA,IAAAA,GAAAA,EAiBiNklB,OAAA,SAAAld,CAAA,CAAAy8B,CAAA,EACjN,IAAAhxC,EAAAgxC,EAAAhxC,QAAA,CACAA,CAAA,CAAAmtB,EAAA,EACAwhB,EAAAl1C,EAAAub,CAAA,CAAAmY,EAAA,CAAAryB,GAAA,GAAAkF,CAAA,CAAAmtB,EAAA,EACAsE,MAAAA,GAAAA,EAAAld,EAAAy8B,EACA,EAASC,gBAAA,SAAAzK,CAAA,EACTuE,EAAA/sC,OAAA,CAAAwoC,CACA,EAASxnC,IAAA2D,CAAA,GAAoBP,EAC7B,GAWA8uC,GAAAx3C,EAAAiK,QAAA,CAAAjK,EAAAiK,QAAA,EAAmDQ,SAAAg4B,EAAA,EAAkCzU,IAAA3O,IAKrFo4B,GAAAz3C,EAAAiK,QAAA,CAAAjK,EAAAiK,QAAA,CAAAjK,EAAAiK,QAAA,CAAAjK,EAAAiK,QAAA,IAA2EutC,IAAAn1C,IAAA+iC,IAAA,CAA2CtiC,0BAAAyvC,EAAA,GA8GtHmF,GAAA,WAA6C,OAC7CC,QAAApsB,GAAA,GACAqsB,QAAArsB,GAAA,GACAssB,gBAAAtsB,GAAA,GACAusB,gBAAAvsB,GAAA,EACA,CAAC,EACD,SAAAwsB,GAAA/yC,CAAA,EACA,SAAAA,GAAyBA,CAAAA,EAAA,IACzB,IAAAgzC,EAAAhzC,EAAAgzC,SAAA,CAAA1jC,EAAAtP,EAAAsP,MAAA,CAAA3B,EAAA3S,EAAAkW,MAAA,CAAAlR,EAAA,wBACAsT,EAAA/Q,EAAAmwC,IAUA,OATAxzC,EAAA,WACA,OAAA3D,EAAA44B,MAAA,UAAAn0B,CAAA,EACA,IAAAkJ,EAAAlJ,EAAAkJ,CAAA,CAAAC,EAAAnJ,EAAAmJ,CAAA,CACAmK,EAAAq/B,OAAA,CAAAlrC,GAAA,CAAAyB,EAAA5J,OAAA,EACAgU,EAAAu/B,eAAA,CAAAprC,GAAA,CAAAyB,EAAAosB,QAAA,EACAhiB,EAAAs/B,OAAA,CAAAnrC,GAAA,CAAA0B,EAAA7J,OAAA,EACAgU,EAAAw/B,eAAA,CAAArrC,GAAA,CAAA0B,EAAAmsB,QAAA,CACA,EAASt6B,EAAAiK,QAAA,CAAAjK,EAAAiK,QAAA,IAAkC0I,GAAA,CAAcqlC,UAAA,CAAAA,MAAAA,EAAA,OAAAA,EAAA1zC,OAAA,GAAA0F,KAAAA,EAAAsK,OAAA,CAAAA,MAAAA,EAAA,OAAAA,EAAAhQ,OAAA,GAAA0F,KAAAA,CAAA,GACzD,EAAK,IACLsO,CACA,CAYA,IAAA2/B,GAAA,oBAAAC,YACA,WAAoB,OAAAA,YAAAC,GAAA,IACpB,WAAoB,OAAAC,KAAAD,GAAA,IACpB,SAAAE,GAAA16B,CAAA,EACA,IAAA26B,EAAA/wC,EAAA0wC,IACAx0C,EAAAvD,EAAA2D,UAAA,CAAAP,GAAAG,QAAA,CACAvD,EAAAkE,SAAA,YACA,IAAAX,GAEA,IAAA80C,EAAA,SAAAvzC,CAAA,EAEA2Y,EAAAuM,EADAA,SAAA,CACAouB,EACA,EAEA,OADA92C,EAAA,QAAAixB,MAAA,CAAA8lB,EAAA,IACA,WAA6B,OAAAj4C,EAAA4yB,UAAA,CAAAT,MAAA,CAAA8lB,EAAA,EAC7B,EAAK,CAAA56B,EAAA,CACL,CAWA,SAAA66B,KAIA,IAAAC,EAAA,GAKAC,EAAA,GAIAC,EAAA,IAAA/qC,IACAsZ,EAAA,CACAqK,UAAA,SAAAztB,CAAA,EAEA,OADA60C,EAAAl6B,GAAA,CAAA3a,GACA,WAAiC60C,EAAA53B,MAAA,CAAAjd,EAAA,CACjC,EACA8C,MAAA,SAAAZ,CAAA,CAAA4nB,CAAA,EAOA,IAAA6qB,EAUA,WAAAztB,QAAA,SAAAC,CAAA,EACAytB,EAAAhtC,IAAA,EACAvJ,UAAA,CAAA6D,EAAA4nB,EAAA,CACA3C,QAAAA,CACA,EACA,GAdA,IAAA2tB,EAAA,GAMA,OALAD,EAAA33C,OAAA,UAAA8C,CAAA,EACA80C,EAAAltC,IAAA,CAAA4hB,GAAAxpB,EAAAkC,EAAA,CACA4nB,mBAAAA,CACA,GACA,GACA5C,QAAA9L,GAAA,CAAA05B,EAUA,EACAnsC,IAAA,SAAAzG,CAAA,EAEA,OADA7F,EAAAoL,SAAA,CAAAktC,EAAA,iHACAE,EAAA33C,OAAA,UAAA8C,CAAA,EA1kKA,MAAA+B,OAAA,CA2kKAG,GA1kKAsmB,GA0kKAxoB,EAAAkC,GAxkKA,iBAwkKAA,EAvkKAsmB,GAukKAxoB,EAvkKA,CAukKAkC,EAvkKA,EAGAimB,GAokKAnoB,EAAAkC,EACA,EACA,EACAuiB,KAAA,WACAowB,EAAA33C,OAAA,UAAA8C,CAAA,GACAonB,SAj5JApnB,CAAA,EACAA,EAAA0C,YAAA,UAAAzG,CAAA,EAAkD,OAAAA,EAAAwoB,IAAA,IAClD,EA+4JAzkB,EACA,EACA,EACAiI,MAAA,WAMA,OALA0sC,EAAA,GACAC,EAAA13C,OAAA,UAAAgE,CAAA,EACA,IAAA7C,EAAA6C,EAAA7C,SAAA,CAAA8oB,EAAAjmB,EAAAimB,OAAA,CACA/D,EAAAtgB,KAAA,CAAAsB,KAAA,CAAAgf,EAAAlnB,EAAA2nB,aAAA,IAAA3nB,EAAAiF,MAAA,CAAA9C,GAAA,KAAAgpB,IAAA,CAAAF,EACA,GACA,WACAwtB,EAAA,GACAvxB,EAAAqB,IAAA,EACA,CACA,CACA,EACA,OAAArB,CACA,CA+BA,SAAA2xB,KACA,IAAA3xB,EAAA3f,EAAAixC,IAEA,OADAt4C,EAAAkE,SAAA,CAAA8iB,EAAAnb,KAAA,KACAmb,CACA,CAuFA,IAAA4xB,GAAA,WACA,SAAAA,IACA,KAAAC,iBAAA,KAAAnrC,GACA,CA+BA,OAzBAkrC,EAAAvzC,SAAA,CAAAgsB,SAAA,UAAArK,CAAA,EACA,IAAA+B,EAAA,KAEA,OADA,KAAA8vB,iBAAA,CAAAt6B,GAAA,CAAAyI,GACA,WAA6B,OAAA+B,EAAA8vB,iBAAA,CAAAh4B,MAAA,CAAAmG,EAAA,CAC7B,EAgBA4xB,EAAAvzC,SAAA,CAAAqB,KAAA,UAAAiU,CAAA,CAAAlI,CAAA,EACA,KAAAomC,iBAAA,CAAA/3C,OAAA,UAAAkmB,CAAA,EACAA,EAAAtgB,KAAA,CAAAiU,EAAAm+B,WAAA,EAAAn+B,EAAAlI,EACA,EACA,EACAmmC,CACA,IACAG,GAAA,WAAuC,WAAAH,EAAA,EAkCvC,SAAAI,GAAAC,CAAA,EACAlgB,GAAA30B,OAAA,GAEA20B,GAAA30B,OAAA,CAAAsjC,UAAA,IACA3O,GAAA30B,OAAA,CAAAwnC,WAAA,GACAqN,MAAAA,GAAAA,IACA,CAgCA,IAAAC,GAAA,WAAiC,QAAU,EAC3CC,GAAAv1C,GAAA,CACA23B,MAAA,aACAnF,mBAAAnB,GACA8M,eAAA,aACAC,iBAAA,aACAtG,2BAAA,aACAnzB,OAAA,aACA8O,4BAAA6hC,GACAzd,sBAAA,SAAA2d,CAAA,CAAAz2C,CAAA,CAAA8P,CAAA,EACA,OAAAA,EAAA4mC,YAAA,CAAA12C,EAAA,GACA,EACAqpB,qBAAA,SAAAtV,CAAA,CAAA5R,CAAA,EACA,IAAA+T,EAAA/T,EAAA+T,UAAA,CAAAD,EAAA9T,EAAA8T,aAAA,CAAAxE,EAAAtU,EAAAkW,MAAA,CAAAlR,EAAA,gCACAmQ,EAAAiY,GAAA9Y,EAAAyE,GAAA,GAAuDnC,GAEvD,OADAiW,GAAAjW,EAAAtC,EAAAa,GACAnV,EAAAiK,QAAA,EAAgC8O,WAAAA,EAAAD,cAAAA,CAAA,EAAsDxE,EACtF,CACA,GACAvL,GAAAmQ,GAAA,CACA3B,4BAAA6hC,GACAlhC,kBAAAkhC,EACA,GAgCAI,GAAA,SAAAtoC,CAAA,EACA,OAAAA,EAAA,OAAAA,EAFA,GAGA,EACAuoC,GAAA,EAwCA35C,CAAAA,EAAA45C,eAAuB,CA3hCvB,SAAA10C,CAAA,EACA,IA1CA20C,EA0CAjxC,EAAA1D,EAAA0D,QAAA,CAAAzC,EAAAjB,EAAAiB,MAAA,CAAAkD,EAAAnE,EAAA6B,OAAA,CAAAA,EAAAsC,KAAA,IAAAA,GAAAA,EAAAoZ,EAAAvd,EAAAud,cAAA,CAAAq3B,EAAA50C,EAAA40C,eAAA,CAAA/mC,EAAA7N,EAAAmuC,qBAAA,CAAAA,EAAAtgC,KAAA,IAAAA,GAAAA,EAGAogC,EAAAngC,EAAA7N,MAAA,CAAA6tC,KAAA,MACA+G,EAAA35C,EAAA2D,UAAA,CAAAiE,GAAAmrC,WAAA,CACA4G,GACA5G,CAAAA,EAAA4G,CAAA,EACA,IAAA5d,EAAA4W,KAEAiH,GAnDAH,EAAA,GAEAz5C,EAAA65C,QAAA,CAAA/4C,OAAA,CAiDA0H,EAjDA,SAAAsV,CAAA,EACA9d,EAAA85C,cAAA,CAAAh8B,IACA27B,EAAAjuC,IAAA,CAAAsS,EACA,GACA27B,GA8CAM,EAAAH,EACAI,EAAA,IAAAtsC,IAGAusC,EAAAj6C,EAAAuH,MAAA,CAAAwyC,GAEAG,EAAAl6C,EAAAuH,MAAA,KAAA6E,KAAAhI,OAAA,CAGAmrB,EAAAvvB,EAAAuH,MAAA,KAWA,GAVAvD,EAAA,WACAurB,EAAAnrB,OAAA,IACA+1C,SAvEA3xC,CAAA,CAAA0xC,CAAA,EACA1xC,EAAA1H,OAAA,UAAAgd,CAAA,EACA,IAAAnb,EAAAixC,GAAA91B,GACAo8B,EAAA3tC,GAAA,CAAA5J,EAAAmb,EACA,EACA,EAkEA87B,EAAAM,GACAD,EAAA71C,OAAA,CAAA21C,CACA,GACA/7B,GAAA,WACAuR,EAAAnrB,OAAA,IACA81C,EAAA9wB,KAAA,GACA4wB,EAAA5wB,KAAA,EACA,GACAmG,EAAAnrB,OAAA,CACA,OAAA5D,EAAAiL,aAAA,CAAAjL,EAAA45C,QAAA,MAAAL,EAAA5xB,GAAA,UAAArK,CAAA,EAAwH,OAAAtd,EAAAiL,aAAA,CAAAunC,GAAA,CAAwDrwC,IAAAixC,GAAA91B,GAAAsE,UAAA,GAAAzb,QAAAA,EAAAA,GAAAmD,KAAAA,EAAAmpC,sBAAAA,CAAA,EAA8Hn1B,EAAA,IAG9Si8B,EAAAj6C,EAAA2nB,aAAA,IAAA3nB,EAAAiF,MAAA,CAAAg1C,GAAA,IAOA,QAJAM,EAAAJ,EAAA71C,OAAA,CAAA+jB,GAAA,CAAAyrB,IACA0G,EAAAV,EAAAzxB,GAAA,CAAAyrB,IAEA2G,EAAAF,EAAAl3C,MAAA,CACAmI,EAAA,EAAoBA,EAAAivC,EAAgBjvC,IAAA,CACpC,IAAA3I,EAAA03C,CAAA,CAAA/uC,EAAA,CACA,KAAAgvC,EAAA3tC,OAAA,CAAAhK,IACAq3C,EAAAz7B,GAAA,CAAA5b,EAEA,CA4CA,OAzCA+2C,GAAAM,EAAApqC,IAAA,EACAmqC,CAAAA,EAAA,IAIAC,EAAAl5C,OAAA,UAAA6B,CAAA,EAEA,GAAA23C,KAAAA,EAAA3tC,OAAA,CAAAhK,IAEA,IAAAmb,EAAAo8B,EAAAh5C,GAAA,CAAAyB,GACA,GAAAmb,GAEA,IAAA08B,EAAAH,EAAA1tC,OAAA,CAAAhK,GAgBAo3C,EAAAnxB,MAAA,CAAA4xB,EAAA,EAAAh6C,EAAAiL,aAAA,CAAAunC,GAAA,CAAmGrwC,IAAAixC,GAAA91B,GAAAsE,UAAA,GAAAC,eAfnG,WACA63B,EAAAr5B,MAAA,CAAAle,GACAq3C,EAAAn5B,MAAA,CAAAle,GAEA,IAAA83C,EAAAR,EAAA71C,OAAA,CAAA6iC,SAAA,UAAAyT,CAAA,EAA0F,OAAAA,EAAA/3C,GAAA,GAAAA,CAAA,GAG1F,GAFAs3C,EAAA71C,OAAA,CAAAwkB,MAAA,CAAA6xB,EAAA,GAEA,CAAAT,EAAApqC,IAAA,EAEA,GADAqqC,EAAA71C,OAAA,CAAAw1C,EACA7d,CAAA,IAAAA,EAAA33B,OAAA,CACA,OACA2uC,IACA1wB,GAAAA,GACA,CACA,EACmGtc,OAAAA,EAAAktC,sBAAAA,CAAA,EAAiIn1B,KACpO,GAGAi8B,EAAAA,EAAA5xB,GAAA,UAAArK,CAAA,EACA,IAAAnb,EAAAmb,EAAAnb,GAAA,CACA,OAAAq3C,EAAA1tC,GAAA,CAAA3J,GAAAmb,EAAAtd,EAAAiL,aAAA,CAAAunC,GAAA,CAA6FrwC,IAAAixC,GAAA91B,GAAAsE,UAAA,GAAA6wB,sBAAAA,CAAA,EAAwFn1B,EACrL,GACA,eAAAvc,GACAm4C,GACAK,EAAA52C,MAAA,IACAkb,QAAAC,IAAA,gKAEA9d,EAAAiL,aAAA,CAAAjL,EAAA45C,QAAA,MAAAJ,EAAApqC,IAAA,CACAmqC,EACAA,EAAA5xB,GAAA,UAAArK,CAAA,EAAkD,OAAA9d,EAAA26C,YAAA,CAAA78B,EAAA,GAClD,EA87BAle,EAAAg7C,mBAA2B,CAj4B3B,SAAA91C,CAAA,EACA,IAAA0D,EAAA1D,EAAA0D,QAAA,CAIA,OAHAhI,EAAA0D,SAAA,YACAjE,EAAAinB,OAAA,8GACA,EAAK,IACL1mB,EAAAiL,aAAA,CAAAsoC,GAAA,CAA0DlqC,GAAAxC,EAAA,WAA8B,aAAA2M,MAAA,CAAAnK,KAAA,EAA6B,EAAGrB,EACxH,EA43BA5I,EAAAi0C,4BAAoC,CAAAA,GACpCj0C,EAAAg5C,YAAoB,CAAAA,GACpBh5C,EAAA4oC,QAAgB,CAAAA,GAChB5oC,EAAAm0C,WAAmB,CAAAA,GACnBn0C,EAAAgI,kBAA0B,CAAAA,EAC1BhI,EAAAi7C,UAAkB,CAvzBlB,SAAA/1C,CAAA,EACA,IAAA0D,EAAA1D,EAAA0D,QAAA,CAAA9F,EAAAoC,EAAApC,QAAA,CAAAuG,EAAAnE,EAAA9B,MAAA,CACA83C,EAAAnoC,EAAA5N,MAAA,CAAA/E,EAAAgF,QAAA,EAAAuvC,GAAA7xC,IAAA,MACAq4C,EAAA/6C,EAAAuH,MAAA,CAAAuC,KAAAA,GAIA,IAAAyqC,GAAA7xC,GAAA,CACA,IAAA6H,EAAA7H,EAAA6H,QAAA,CAAAywC,EAAAl7C,EAAAkW,MAAA,CAAAtT,EAAA,aACAq4C,CAAAA,EAAA32C,OAAA,CAAAmG,EACA9H,EAAAu4C,EACA,CAWA,OAVAh7C,EAAAkE,SAAA,YACAqwC,GAAA7xC,IACAA,IAAAuoB,IAAA,UAAAnmB,CAAA,EACA,IAAAyF,EAAAzF,EAAAyF,QAAA,CACA9H,EADA3C,EAAAkW,MAAA,CAAAlR,EAAA,eAEAi2C,EAAA32C,OAAA,CAAAmG,EACAuwC,EAAA,GACA,EAEA,EAAK,IACLt6C,EAAAiL,aAAA,CAAA3I,EAAA4I,QAAA,EAAmE7L,MAAA,CAAS0K,SAAAwwC,EAAA32C,OAAA,CAAApB,OArB5EiG,KAAA,IAAAA,GAAAA,CAqB4E,GAAoDT,EAChI,EAiyBA5I,EAAAq7C,YAAoB,CA/2BpB,SAAAn2C,CAAA,EACA,IAAA0D,EAAA1D,EAAA0D,QAAA,CAAAkM,EAAA5P,EAAA4P,WAAA,CAAA1K,EAAAlK,EAAAkW,MAAA,CAAAlR,EAAA,2BACA4P,CAAAA,GAAAD,GAAAC,GASA1K,CALAA,EAAAlK,EAAAiK,QAAA,CAAAjK,EAAAiK,QAAA,IAA6C/J,EAAA2D,UAAA,CAAAP,IAAA4G,EAAA,EAK7CzG,QAAA,CAAA8D,EAAA,WAAgD,OAAA2C,EAAAzG,QAAA,GAKhD,IAAA0G,EAAAjK,EAAAoK,OAAA,YAA8C,OAAAJ,CAAA,EAAgB,CAAAyW,KAAAC,SAAA,CAAA1W,EAAA6O,UAAA,EAAA7O,EAAA3G,kBAAA,CAAA2G,EAAAxG,aAAA,GAC9D,OAAAhD,EAAAiL,aAAA,CAAArI,EAAAsI,QAAA,EAA2E7L,MAAAoK,CAAA,EAAgBzB,EAC3F,EA81BA5I,EAAAwD,mBAA2B,CAAAA,EAC3BxD,EAAA6D,aAAqB,CAAAA,EACrB7D,EAAAypB,WAAmB,CAAAA,GACnBzpB,EAAAiE,eAAuB,CAAAA,EACvBjE,EAAAs7C,OAAe,CA9kBf,CACAzG,MAAAA,GACAwC,KAAAA,EACA,EA4kBAr3C,EAAAiI,wBAAgC,CAAAA,EAChCjI,EAAAgd,eAAuB,CAAAA,GACvBhd,EAAAkN,iBAAyB,CAAAA,GACzBlN,EAAA6G,OAAe,CAAAA,GACf7G,EAAAwtB,oBAA4B,CAAAA,GAC5BxtB,EAAA04C,iBAAyB,CAAAA,GACzB14C,EAAAkuB,UAAkB,CAAAA,GAClBluB,EAAA0zB,UAAkB,CAAAA,GAClB1zB,EAAA+sB,uBAA+B,CAAAA,GAC/B/sB,EAAAq1B,SAAiB,CAAAA,GACjBr1B,EAAAu7C,wBAAgC,CA7rChC,SAAAx4C,CAAA,EACA,OAAA8F,EAAA4Q,GAAA1W,EAAA,CAA8DmS,mBAAA,IAA2B09B,GAAAjQ,GAAA8P,IACzF,EA4rCAzyC,EAAA6I,qBAA6B,CAAAA,EAC7B7I,EAAA03C,YAAoB,CAAAA,GACpB13C,EAAA23C,MAAc,CAAAA,GACd33C,EAAAgV,WAAmB,CAAAA,GACnBhV,EAAAkE,SAAiB,CAAAA,EACjBlE,EAAAyd,YAAoB,CAAAA,GACpBzd,EAAAkO,aAAqB,CAAAA,GACrBlO,EAAA2U,iBAAyB,CAAAA,GACzB3U,EAAA8yC,CAAS,CAAAA,GACT9yC,EAAAoZ,kBAA0B,CAAAA,GAC1BpZ,EAAA6yC,MAAc,CAAAA,GACd7yC,EAAAyrB,WAAmB,CAAAA,GACnBzrB,EAAA8X,kBAA0B,CAAAA,GAC1B9X,EAAA4O,SAAiB,CAAAA,GACjB5O,EAAAw7C,YAAoB,CA1UpBzC,GA2UA/4C,EAAA+4C,oBAA4B,CAAAA,GAC5B/4C,EAAAu4C,iBAAyB,CAAAA,GACzBv4C,EAAAy7C,QAAgB,CAjThB,WAEA,QADAC,EAAA,GACAhf,EAAA,EAAqBA,EAAAr0B,UAAA9E,MAAA,CAAuBm5B,IAC5Cgf,CAAA,CAAAhf,EAAA,CAAAr0B,SAAA,CAAAq0B,EAAA,CAFA,IAIAvjB,EAAA/Y,EAAAuH,MAAA,IACAzC,EAAAhF,EAAAiF,MAAA,CAAA/E,EAAAgF,QAAA,CAAAs2C,CAAA,CAAAviC,EAAA3U,OAAA,MAAAskB,EAAA5jB,CAAA,IAAAy2C,EAAAz2C,CAAA,IAQA,OAAA4jB,EAPA1oB,EAAA2L,WAAA,UAAA6W,CAAA,EACAzJ,EAAA3U,OAAA,CACA,iBAAAoe,EACAriB,EAAAq7C,IAAA,GAAAF,EAAAn4C,MAAA,CAAA4V,EAAA3U,OAAA,IACAoe,EACA+4B,EAAAD,CAAA,CAAAviC,EAAA3U,OAAA,EACA,EAAKtE,EAAA2nB,aAAA,EAAA6zB,EAAAn4C,MAAA,EAAArD,EAAAiF,MAAA,CAAAu2C,GAAA,KACL,EAoSA17C,EAAA67C,0BAAkC,CAjHlC,SAAApC,CAAA,EACA,IAAAv0C,EAAAhF,EAAAiF,MAAA,CAAA/E,EAAAgF,QAAA,CAAAq0C,GAAA,GAAA1uC,EAAA7F,CAAA,IAAA42C,EAAA52C,CAAA,IACAwF,EAAAzB,GAAA,GAAuC,IACvC6N,EAAArP,EAAA,WACA,OAAA8xC,GAAA,CAAoCv3C,MAAA,GAAS0I,YAAAA,CAAA,EAA4B,CAAI+uC,aAAAA,CAAA,EAC7E,GAeA,OAdAr5C,EAAAkE,SAAA,YAEA,OADAwS,EAAA7K,KAAA,KACA6K,EAAA5K,OAAA,EACK,CAAA4K,EAAA,EACL1W,EAAAkE,SAAA,YACAwS,EAAApO,QAAA,EACAif,SAAA,SAAA9hB,CAAA,EACAi2C,EAAA57C,EAAAiK,QAAA,IAAmDtE,GACnD,CACA,EACA,EAAK,CAAAi2C,EAAAhlC,EAAA,EAIL,CAAA/L,EAHAtD,EAAA,WAAmD,gBAAAs0C,CAAA,EACnD,OAAAvuB,GAAA1W,EAAAilC,EACA,IACA,EA8FA/7C,EAAAg8C,0BAAkC,CAhElC,SAAA5qC,CAAA,EACA,IAAA6qC,EAAAlG,GAAA,GACAmG,EAAAnG,GAAA,GACA/xC,EAAAF,IAcA,OAbAzD,EAAAoL,SAAA,GAAA2F,CAAAA,GAAApN,CAAA,gHACA3D,EAAAinB,OAAA,CAAAqyB,GAAA,2FACAA,GAAA,GACAvoC,GACA6qC,EAAA7qC,EAAAC,MAAA,EAAA4qC,EACAC,EAAA9qC,EAAAE,MAAA,EAAA4qC,GAEAl4C,IACAi4C,EAAAj4C,EAAAsoB,QAAA,aACA4vB,EAAAl4C,EAAAsoB,QAAA,cAIA,CAAajb,OAFbylC,GAAAmF,EAAAvC,IAEapoC,OADbwlC,GAAAoF,EAAAxC,GACa,CACb,EA+CA15C,EAAA6a,WAAmB,CAAAA,GACnB7a,EAAAm8C,eAAuB,CA5LvB,WACA,OAAA10C,EAAA0xC,GACA,EA2LAn5C,EAAAo8C,gBAAwB,CA/dxB,SAAA52C,CAAA,EAEA,OADA8Y,GAAA,gFACA25B,GAAA,CAAuBC,UAAA1yC,CAAA,EACvB,EA6dAxF,EAAAgzC,cAAsB,CAAAA,GACtBhzC,EAAAq8C,SAAiB,CAvSjB,SAAA72C,CAAA,CAAAN,CAAA,EACA,IAAAmE,EAAAnE,KAAA,IAAAA,EAAA,GAAgCA,EAAAmb,EAAAhX,EAAAgX,IAAA,CAAA3P,EAAArH,EAAAqH,MAAA,CAAA6P,EAAAlX,EAAAkX,MAAA,CAAAxN,EAAA1J,EAAA0W,IAAA,CAAAA,EAAAhN,KAAA,IAAAA,GAAAA,EAChCC,EAAA9S,EAAAiF,MAAA,CAAA/E,EAAAgF,QAAA,QAAAya,EAAA7M,CAAA,IAAAspC,EAAAtpC,CAAA,IAgBA,OAfA5S,EAAAkE,SAAA,YAEA,KAAAE,OAAA,EAAAub,CAAAA,CAAAA,IAAAF,CAAA,GAMA,IAPA3a,EAOA2N,EAAA,CACAwN,KAAA,OAAAnb,CAAAA,EAAAmb,MAAAA,EAAA,OAAAA,EAAA7b,OAAA,GAAAU,KAAA,IAAAA,EAAAA,EAAAgF,KAAAA,EACAwG,OAAAA,EACA6P,OAAAA,SAAAA,EAAA,MAAAA,CACA,EACA,OAAA9f,EAAAmC,MAAA,CAAA4C,EAAAhB,OAAA,CATA,WAEA,OADA83C,EAAA,IACAv8B,EAAA7V,KAAAA,EAAA,WAAoD,OAAAoyC,EAAA,IACpD,EAMAzpC,GACA,EAAK,CAAAwN,EAAA7a,EAAAkL,EAAAqP,EAAA,EACLF,CACA,EAqRA7f,EAAAu8C,0BAAkC,CA5LlC,WACA,OAAAnD,EACA,EA2LAp5C,EAAAw8C,oBAA4B,CAlL5B,WACA,IAAAt3C,EAAAhF,EAAAiF,MAAA,CAAA6tC,KAAA,GAAAyJ,EAAAv3C,CAAA,IAAA+tC,EAAA/tC,CAAA,IAUA,OARA9E,EAAAkE,SAAA,YAIA5C,EAAA,QAAA2oB,UAAA,YACA,OAAA3oB,EAAA,QAAA2oB,UAAA,YAAqE,OAAA9D,GAAA/hB,OAAA,KACrE,EACA,EAAK,CAAAyuC,EAAA,EACL,SAAAp1B,CAAA,EACA6+B,GAAA,WACAn2B,GAAA/hB,OAAA,IACAi4C,IACA5+B,GACA,EACA,CACA,EAiKA7d,EAAA28C,YAAoB,CA5vMpB,eAGAtyC,EAFA,OAGAA,QADAA,EAFAjK,EAAA2D,UAAA,CAAAE,KAGAoG,EAAAmY,SAAA,EAyvMAxiB,EAAAoE,yBAAiC,CAAAA,EACjCpE,EAAA48C,iBAAyB,CAllBzB,SAAAC,CAAA,EAEA,QADArkC,EAAA,GACAkkB,EAAA,EAAqBA,EAAAr0B,UAAA9E,MAAA,CAAuBm5B,IAC5ClkB,CAAA,CAAAkkB,EAAA,GAAAr0B,SAAA,CAAAq0B,EAAA,CAFA,IAOAogB,EAAAD,EAAAt5C,MAAA,CAWA,OAAAmzC,GAAAl+B,EAVA,WAEA,QADA2sB,EAAA,GACAz5B,EAAA,EAAwBA,EAAAoxC,EAAkBpxC,IAC1Cy5B,GAAA0X,CAAA,CAAAnxC,EAAA,CACA8M,CAAA,CAAA9M,EAAA,EAEAy5B,CAAAA,GAAA3sB,CAAA,CAAA9M,EAAA,CAAApK,GAAA,IAEA,OAAA6jC,CACA,EAEA,EA+jBAnlC,EAAA+1C,cAAsB,CAAAA,GACtB/1C,EAAAuiB,WAAmB,CAAAA,GACnBviB,EAAA0E,gBAAwB,CAAAA,EACxB1E,EAAAqF,sBAA8B,CAAAA,EAC9BrF,EAAA+8C,kBAA0B,CAtK1B,WAOA,OANAn8C,EAAAmL,WAAA,YACA,IAAAsU,EAAA8Y,GAAA30B,OAAA,CACA6b,GAEAA,EAAAgxB,SAAA,EACA,EAAK,GAEL,EA+JArxC,EAAAi4C,SAAiB,CAAAA,GACjBj4C,EAAAg9C,SAAiB,CAhjBjB,SAAAvoC,CAAA,CAAArK,CAAA,EACA,SAAAA,GAA6BA,CAAAA,EAAA,IAC7B,IA9KAyT,EA8KAla,EAAAvD,EAAA2D,UAAA,CAAAP,GAAAG,QAAA,CACAs5C,EAAA78C,EAAAuH,MAAA,OACA1H,EAAA81C,GAAA7nC,GAAAuG,GAAAA,EAAAnT,GAAA,GAAAmT,GAiBA,OAhBArU,EAAAoK,OAAA,YACA,OAAAvK,EAAA6qB,MAAA,UAAAjlB,CAAA,CAAA8G,CAAA,SAKA,EACAA,EAAA9G,IACAo3C,EAAAz4C,OAAA,EACAy4C,EAAAz4C,OAAA,CAAAikB,IAAA,GAEAw0B,EAAAz4C,OAAA,CAAAjE,EAAAsG,OAAA,CAAA3G,EAAAiK,QAAA,CAAAjK,EAAAiK,QAAA,EAA8Fkd,KAAApnB,EAAAqB,GAAA,GAAAujB,GAAAhf,EAAAW,SAAAvG,EAAA0G,WAAA,IAAyDyD,GAAA,CAAaud,SAAAhb,CAAA,IACpK1M,EAAAqB,GAAA,GACA,EACA,EAAK,CAAAuf,KAAAC,SAAA,CAAA1W,GAAA,EA9LLhG,EAAA,WACA,GAAA8J,GA8LAuG,GA7LA,OAAAxU,EAAAyqB,QAAA,CAAA7M,EACA,EAAK,CAJLA,EAgMA,SAAAhY,CAAA,EAAuC,OAAA5F,EAAA0M,GAAA,CAAA+Z,WAAA7gB,GAAA,EA5LlC,EA6LL5F,CACA,EA2hBAD,EAAAk9C,OAAe,CAldf,WACA,IAAAzpB,EAAAsiB,GAAA,GAEA,OADAwC,GAAA,SAAA4E,CAAA,EAAqC,OAAA1pB,EAAA9mB,GAAA,CAAAwwC,EAAA,GACrC1pB,CACA,EA+cAzzB,EAAA82C,YAAoB,CAAAA,GACpB92C,EAAAoe,gBAAwB,CAAAA,GACxBpe,EAAAo9C,WAAmB,CAjhBnB,SAAAn9C,CAAA,EACA,IAAAuG,EAAAuvC,GAAA91C,EAAA0G,WAAA,IAMA,OALAvG,EAAAkE,SAAA,YACA,OAAArE,EAAA6pB,yBAAA,CAAAnL,GAAA,UAAA0+B,CAAA,EACA72C,EAAAmG,GAAA,CAAA0wC,EACA,EACA,EAAK,CAAAp9C,EAAA,EACLuG,CACA,EA0gBAxG,EAAAs9C,iBAAyB,CA7ezB,WAEA,OADAh/B,GAAA,+DACA25B,IACA,EA2eAj4C,EAAA8D,uBAA+B,CAAAA,EAC/B9D,EAAAgE,aAAqB,CAAAA,GACrBhE,EAAA6b,WAAmB,CAAAA","sources":["webpack://_N_E/./node_modules/framer-motion/dist/cjs/index.js","webpack://_N_E/<anon>"],"sourcesContent":["'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar tslib = require('tslib');\nvar React = require('react');\nvar heyListen = require('hey-listen');\nvar styleValueTypes = require('style-value-types');\nvar popmotion = require('popmotion');\nvar sync = require('framesync');\nvar dom = require('@motionone/dom');\n\nfunction _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }\n\nfunction _interopNamespace(e) {\n    if (e && e.__esModule) return e;\n    var n = Object.create(null);\n    if (e) {\n        Object.keys(e).forEach(function (k) {\n            if (k !== 'default') {\n                var d = Object.getOwnPropertyDescriptor(e, k);\n                Object.defineProperty(n, k, d.get ? d : {\n                    enumerable: true,\n                    get: function () { return e[k]; }\n                });\n            }\n        });\n    }\n    n[\"default\"] = e;\n    return Object.freeze(n);\n}\n\nvar React__namespace = /*#__PURE__*/_interopNamespace(React);\nvar React__default = /*#__PURE__*/_interopDefaultLegacy(React);\nvar sync__default = /*#__PURE__*/_interopDefaultLegacy(sync);\n\n/**\n * Browser-safe usage of process\n */\nvar defaultEnvironment = \"production\";\nvar env = typeof process === \"undefined\" || process.env === undefined\n    ? defaultEnvironment\n    : process.env.NODE_ENV || defaultEnvironment;\n\nvar createDefinition = function (propNames) { return ({\n    isEnabled: function (props) { return propNames.some(function (name) { return !!props[name]; }); },\n}); };\nvar featureDefinitions = {\n    measureLayout: createDefinition([\"layout\", \"layoutId\", \"drag\"]),\n    animation: createDefinition([\n        \"animate\",\n        \"exit\",\n        \"variants\",\n        \"whileHover\",\n        \"whileTap\",\n        \"whileFocus\",\n        \"whileDrag\",\n        \"whileInView\",\n    ]),\n    exit: createDefinition([\"exit\"]),\n    drag: createDefinition([\"drag\", \"dragControls\"]),\n    focus: createDefinition([\"whileFocus\"]),\n    hover: createDefinition([\"whileHover\", \"onHoverStart\", \"onHoverEnd\"]),\n    tap: createDefinition([\"whileTap\", \"onTap\", \"onTapStart\", \"onTapCancel\"]),\n    pan: createDefinition([\n        \"onPan\",\n        \"onPanStart\",\n        \"onPanSessionStart\",\n        \"onPanEnd\",\n    ]),\n    inView: createDefinition([\n        \"whileInView\",\n        \"onViewportEnter\",\n        \"onViewportLeave\",\n    ]),\n};\nfunction loadFeatures(features) {\n    for (var key in features) {\n        if (features[key] === null)\n            continue;\n        if (key === \"projectionNodeConstructor\") {\n            featureDefinitions.projectionNodeConstructor = features[key];\n        }\n        else {\n            featureDefinitions[key].Component = features[key];\n        }\n    }\n}\n\nvar LazyContext = React.createContext({ strict: false });\n\nvar featureNames = Object.keys(featureDefinitions);\nvar numFeatures = featureNames.length;\n/**\n * Load features via renderless components based on the provided MotionProps.\n */\nfunction useFeatures(props, visualElement, preloadedFeatures) {\n    var features = [];\n    var lazyContext = React.useContext(LazyContext);\n    if (!visualElement)\n        return null;\n    /**\n     * If we're in development mode, check to make sure we're not rendering a motion component\n     * as a child of LazyMotion, as this will break the file-size benefits of using it.\n     */\n    if (env !== \"production\" && preloadedFeatures && lazyContext.strict) {\n        heyListen.invariant(false, \"You have rendered a `motion` component within a `LazyMotion` component. This will break tree shaking. Import and render a `m` component instead.\");\n    }\n    for (var i = 0; i < numFeatures; i++) {\n        var name_1 = featureNames[i];\n        var _a = featureDefinitions[name_1], isEnabled = _a.isEnabled, Component = _a.Component;\n        /**\n         * It might be possible in the future to use this moment to\n         * dynamically request functionality. In initial tests this\n         * was producing a lot of duplication amongst bundles.\n         */\n        if (isEnabled(props) && Component) {\n            features.push(React__namespace.createElement(Component, tslib.__assign({ key: name_1 }, props, { visualElement: visualElement })));\n        }\n    }\n    return features;\n}\n\n/**\n * @public\n */\nvar MotionConfigContext = React.createContext({\n    transformPagePoint: function (p) { return p; },\n    isStatic: false,\n    reducedMotion: \"never\",\n});\n\nvar MotionContext = React.createContext({});\nfunction useVisualElementContext() {\n    return React.useContext(MotionContext).visualElement;\n}\n\n/**\n * @public\n */\nvar PresenceContext = React.createContext(null);\n\nvar isBrowser = typeof document !== \"undefined\";\n\nvar useIsomorphicLayoutEffect = isBrowser ? React.useLayoutEffect : React.useEffect;\n\n// Does this device prefer reduced motion? Returns `null` server-side.\nvar prefersReducedMotion = { current: null };\nvar hasDetected = false;\nfunction initPrefersReducedMotion() {\n    hasDetected = true;\n    if (!isBrowser)\n        return;\n    if (window.matchMedia) {\n        var motionMediaQuery_1 = window.matchMedia(\"(prefers-reduced-motion)\");\n        var setReducedMotionPreferences = function () {\n            return (prefersReducedMotion.current = motionMediaQuery_1.matches);\n        };\n        motionMediaQuery_1.addListener(setReducedMotionPreferences);\n        setReducedMotionPreferences();\n    }\n    else {\n        prefersReducedMotion.current = false;\n    }\n}\n/**\n * A hook that returns `true` if we should be using reduced motion based on the current device's Reduced Motion setting.\n *\n * This can be used to implement changes to your UI based on Reduced Motion. For instance, replacing motion-sickness inducing\n * `x`/`y` animations with `opacity`, disabling the autoplay of background videos, or turning off parallax motion.\n *\n * It will actively respond to changes and re-render your components with the latest setting.\n *\n * ```jsx\n * export function Sidebar({ isOpen }) {\n *   const shouldReduceMotion = useReducedMotion()\n *   const closedX = shouldReduceMotion ? 0 : \"-100%\"\n *\n *   return (\n *     <motion.div animate={{\n *       opacity: isOpen ? 1 : 0,\n *       x: isOpen ? 0 : closedX\n *     }} />\n *   )\n * }\n * ```\n *\n * @return boolean\n *\n * @public\n */\nfunction useReducedMotion() {\n    /**\n     * Lazy initialisation of prefersReducedMotion\n     */\n    !hasDetected && initPrefersReducedMotion();\n    var _a = tslib.__read(React.useState(prefersReducedMotion.current), 1), shouldReduceMotion = _a[0];\n    /**\n     * TODO See if people miss automatically updating shouldReduceMotion setting\n     */\n    return shouldReduceMotion;\n}\nfunction useReducedMotionConfig() {\n    var reducedMotionPreference = useReducedMotion();\n    var reducedMotion = React.useContext(MotionConfigContext).reducedMotion;\n    if (reducedMotion === \"never\") {\n        return false;\n    }\n    else if (reducedMotion === \"always\") {\n        return true;\n    }\n    else {\n        return reducedMotionPreference;\n    }\n}\n\nfunction useVisualElement(Component, visualState, props, createVisualElement) {\n    var lazyContext = React.useContext(LazyContext);\n    var parent = useVisualElementContext();\n    var presenceContext = React.useContext(PresenceContext);\n    var shouldReduceMotion = useReducedMotionConfig();\n    var visualElementRef = React.useRef(undefined);\n    /**\n     * If we haven't preloaded a renderer, check to see if we have one lazy-loaded\n     */\n    if (!createVisualElement)\n        createVisualElement = lazyContext.renderer;\n    if (!visualElementRef.current && createVisualElement) {\n        visualElementRef.current = createVisualElement(Component, {\n            visualState: visualState,\n            parent: parent,\n            props: props,\n            presenceId: presenceContext === null || presenceContext === void 0 ? void 0 : presenceContext.id,\n            blockInitialAnimation: (presenceContext === null || presenceContext === void 0 ? void 0 : presenceContext.initial) === false,\n            shouldReduceMotion: shouldReduceMotion,\n        });\n    }\n    var visualElement = visualElementRef.current;\n    useIsomorphicLayoutEffect(function () {\n        visualElement === null || visualElement === void 0 ? void 0 : visualElement.syncRender();\n    });\n    React.useEffect(function () {\n        var _a;\n        (_a = visualElement === null || visualElement === void 0 ? void 0 : visualElement.animationState) === null || _a === void 0 ? void 0 : _a.animateChanges();\n    });\n    useIsomorphicLayoutEffect(function () { return function () { return visualElement === null || visualElement === void 0 ? void 0 : visualElement.notifyUnmount(); }; }, []);\n    return visualElement;\n}\n\nfunction isRefObject(ref) {\n    return (typeof ref === \"object\" &&\n        Object.prototype.hasOwnProperty.call(ref, \"current\"));\n}\n\n/**\n * Creates a ref function that, when called, hydrates the provided\n * external ref and VisualElement.\n */\nfunction useMotionRef(visualState, visualElement, externalRef) {\n    return React.useCallback(function (instance) {\n        var _a;\n        instance && ((_a = visualState.mount) === null || _a === void 0 ? void 0 : _a.call(visualState, instance));\n        if (visualElement) {\n            instance\n                ? visualElement.mount(instance)\n                : visualElement.unmount();\n        }\n        if (externalRef) {\n            if (typeof externalRef === \"function\") {\n                externalRef(instance);\n            }\n            else if (isRefObject(externalRef)) {\n                externalRef.current = instance;\n            }\n        }\n    }, \n    /**\n     * Only pass a new ref callback to React if we've received a visual element\n     * factory. Otherwise we'll be mounting/remounting every time externalRef\n     * or other dependencies change.\n     */\n    [visualElement]);\n}\n\n/**\n * Decides if the supplied variable is an array of variant labels\n */\nfunction isVariantLabels(v) {\n    return Array.isArray(v);\n}\n/**\n * Decides if the supplied variable is variant label\n */\nfunction isVariantLabel(v) {\n    return typeof v === \"string\" || isVariantLabels(v);\n}\n/**\n * Creates an object containing the latest state of every MotionValue on a VisualElement\n */\nfunction getCurrent(visualElement) {\n    var current = {};\n    visualElement.forEachValue(function (value, key) { return (current[key] = value.get()); });\n    return current;\n}\n/**\n * Creates an object containing the latest velocity of every MotionValue on a VisualElement\n */\nfunction getVelocity$1(visualElement) {\n    var velocity = {};\n    visualElement.forEachValue(function (value, key) { return (velocity[key] = value.getVelocity()); });\n    return velocity;\n}\nfunction resolveVariantFromProps(props, definition, custom, currentValues, currentVelocity) {\n    var _a;\n    if (currentValues === void 0) { currentValues = {}; }\n    if (currentVelocity === void 0) { currentVelocity = {}; }\n    /**\n     * If the variant definition is a function, resolve.\n     */\n    if (typeof definition === \"function\") {\n        definition = definition(custom !== null && custom !== void 0 ? custom : props.custom, currentValues, currentVelocity);\n    }\n    /**\n     * If the variant definition is a variant label, or\n     * the function returned a variant label, resolve.\n     */\n    if (typeof definition === \"string\") {\n        definition = (_a = props.variants) === null || _a === void 0 ? void 0 : _a[definition];\n    }\n    /**\n     * At this point we've resolved both functions and variant labels,\n     * but the resolved variant label might itself have been a function.\n     * If so, resolve. This can only have returned a valid target object.\n     */\n    if (typeof definition === \"function\") {\n        definition = definition(custom !== null && custom !== void 0 ? custom : props.custom, currentValues, currentVelocity);\n    }\n    return definition;\n}\nfunction resolveVariant(visualElement, definition, custom) {\n    var props = visualElement.getProps();\n    return resolveVariantFromProps(props, definition, custom !== null && custom !== void 0 ? custom : props.custom, getCurrent(visualElement), getVelocity$1(visualElement));\n}\nfunction checkIfControllingVariants(props) {\n    var _a;\n    return (typeof ((_a = props.animate) === null || _a === void 0 ? void 0 : _a.start) === \"function\" ||\n        isVariantLabel(props.initial) ||\n        isVariantLabel(props.animate) ||\n        isVariantLabel(props.whileHover) ||\n        isVariantLabel(props.whileDrag) ||\n        isVariantLabel(props.whileTap) ||\n        isVariantLabel(props.whileFocus) ||\n        isVariantLabel(props.exit));\n}\nfunction checkIfVariantNode(props) {\n    return Boolean(checkIfControllingVariants(props) || props.variants);\n}\n\nfunction getCurrentTreeVariants(props, context) {\n    if (checkIfControllingVariants(props)) {\n        var initial = props.initial, animate = props.animate;\n        return {\n            initial: initial === false || isVariantLabel(initial)\n                ? initial\n                : undefined,\n            animate: isVariantLabel(animate) ? animate : undefined,\n        };\n    }\n    return props.inherit !== false ? context : {};\n}\n\nfunction useCreateMotionContext(props) {\n    var _a = getCurrentTreeVariants(props, React.useContext(MotionContext)), initial = _a.initial, animate = _a.animate;\n    return React.useMemo(function () { return ({ initial: initial, animate: animate }); }, [variantLabelsAsDependency(initial), variantLabelsAsDependency(animate)]);\n}\nfunction variantLabelsAsDependency(prop) {\n    return Array.isArray(prop) ? prop.join(\" \") : prop;\n}\n\n/**\n * Creates a constant value over the lifecycle of a component.\n *\n * Even if `useMemo` is provided an empty array as its final argument, it doesn't offer\n * a guarantee that it won't re-run for performance reasons later on. By using `useConstant`\n * you can ensure that initialisers don't execute twice or more.\n */\nfunction useConstant(init) {\n    var ref = React.useRef(null);\n    if (ref.current === null) {\n        ref.current = init();\n    }\n    return ref.current;\n}\n\n/**\n * This should only ever be modified on the client otherwise it'll\n * persist through server requests. If we need instanced states we\n * could lazy-init via root.\n */\nvar globalProjectionState = {\n    /**\n     * Global flag as to whether the tree has animated since the last time\n     * we resized the window\n     */\n    hasAnimatedSinceResize: true,\n    /**\n     * We set this to true once, on the first update. Any nodes added to the tree beyond that\n     * update will be given a `data-projection-id` attribute.\n     */\n    hasEverUpdated: false,\n};\n\nvar id$1 = 1;\nfunction useProjectionId() {\n    return useConstant(function () {\n        if (globalProjectionState.hasEverUpdated) {\n            return id$1++;\n        }\n    });\n}\n\nvar LayoutGroupContext = React.createContext({});\n\n/**\n * Internal, exported only for usage in Framer\n */\nvar SwitchLayoutGroupContext = React.createContext({});\n\nfunction useProjection(projectionId, _a, visualElement, ProjectionNodeConstructor) {\n    var _b;\n    var layoutId = _a.layoutId, layout = _a.layout, drag = _a.drag, dragConstraints = _a.dragConstraints, layoutScroll = _a.layoutScroll;\n    var initialPromotionConfig = React.useContext(SwitchLayoutGroupContext);\n    if (!ProjectionNodeConstructor ||\n        !visualElement ||\n        (visualElement === null || visualElement === void 0 ? void 0 : visualElement.projection)) {\n        return;\n    }\n    visualElement.projection = new ProjectionNodeConstructor(projectionId, visualElement.getLatestValues(), (_b = visualElement.parent) === null || _b === void 0 ? void 0 : _b.projection);\n    visualElement.projection.setOptions({\n        layoutId: layoutId,\n        layout: layout,\n        alwaysMeasureLayout: Boolean(drag) || (dragConstraints && isRefObject(dragConstraints)),\n        visualElement: visualElement,\n        scheduleRender: function () { return visualElement.scheduleRender(); },\n        /**\n         * TODO: Update options in an effect. This could be tricky as it'll be too late\n         * to update by the time layout animations run.\n         * We also need to fix this safeToRemove by linking it up to the one returned by usePresence,\n         * ensuring it gets called if there's no potential layout animations.\n         *\n         */\n        animationType: typeof layout === \"string\" ? layout : \"both\",\n        initialPromotionConfig: initialPromotionConfig,\n        layoutScroll: layoutScroll,\n    });\n}\n\nvar VisualElementHandler = /** @class */ (function (_super) {\n    tslib.__extends(VisualElementHandler, _super);\n    function VisualElementHandler() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    /**\n     * Update visual element props as soon as we know this update is going to be commited.\n     */\n    VisualElementHandler.prototype.getSnapshotBeforeUpdate = function () {\n        this.updateProps();\n        return null;\n    };\n    VisualElementHandler.prototype.componentDidUpdate = function () { };\n    VisualElementHandler.prototype.updateProps = function () {\n        var _a = this.props, visualElement = _a.visualElement, props = _a.props;\n        if (visualElement)\n            visualElement.setProps(props);\n    };\n    VisualElementHandler.prototype.render = function () {\n        return this.props.children;\n    };\n    return VisualElementHandler;\n}(React__default[\"default\"].Component));\n\n/**\n * Create a `motion` component.\n *\n * This function accepts a Component argument, which can be either a string (ie \"div\"\n * for `motion.div`), or an actual React component.\n *\n * Alongside this is a config option which provides a way of rendering the provided\n * component \"offline\", or outside the React render cycle.\n */\nfunction createMotionComponent(_a) {\n    var preloadedFeatures = _a.preloadedFeatures, createVisualElement = _a.createVisualElement, projectionNodeConstructor = _a.projectionNodeConstructor, useRender = _a.useRender, useVisualState = _a.useVisualState, Component = _a.Component;\n    preloadedFeatures && loadFeatures(preloadedFeatures);\n    function MotionComponent(props, externalRef) {\n        var layoutId = useLayoutId(props);\n        props = tslib.__assign(tslib.__assign({}, props), { layoutId: layoutId });\n        /**\n         * If we're rendering in a static environment, we only visually update the component\n         * as a result of a React-rerender rather than interactions or animations. This\n         * means we don't need to load additional memory structures like VisualElement,\n         * or any gesture/animation features.\n         */\n        var config = React.useContext(MotionConfigContext);\n        var features = null;\n        var context = useCreateMotionContext(props);\n        /**\n         * Create a unique projection ID for this component. If a new component is added\n         * during a layout animation we'll use this to query the DOM and hydrate its ref early, allowing\n         * us to measure it as soon as any layout effect flushes pending layout animations.\n         *\n         * Performance note: It'd be better not to have to search the DOM for these elements.\n         * For newly-entering components it could be enough to only correct treeScale, in which\n         * case we could mount in a scale-correction mode. This wouldn't be enough for\n         * shared element transitions however. Perhaps for those we could revert to a root node\n         * that gets forceRendered and layout animations are triggered on its layout effect.\n         */\n        var projectionId = config.isStatic ? undefined : useProjectionId();\n        /**\n         *\n         */\n        var visualState = useVisualState(props, config.isStatic);\n        if (!config.isStatic && isBrowser) {\n            /**\n             * Create a VisualElement for this component. A VisualElement provides a common\n             * interface to renderer-specific APIs (ie DOM/Three.js etc) as well as\n             * providing a way of rendering to these APIs outside of the React render loop\n             * for more performant animations and interactions\n             */\n            context.visualElement = useVisualElement(Component, visualState, tslib.__assign(tslib.__assign({}, config), props), createVisualElement);\n            useProjection(projectionId, props, context.visualElement, projectionNodeConstructor ||\n                featureDefinitions.projectionNodeConstructor);\n            /**\n             * Load Motion gesture and animation features. These are rendered as renderless\n             * components so each feature can optionally make use of React lifecycle methods.\n             */\n            features = useFeatures(props, context.visualElement, preloadedFeatures);\n        }\n        /**\n         * The mount order and hierarchy is specific to ensure our element ref\n         * is hydrated by the time features fire their effects.\n         */\n        return (React__namespace.createElement(VisualElementHandler, { visualElement: context.visualElement, props: tslib.__assign(tslib.__assign({}, config), props) },\n            features,\n            React__namespace.createElement(MotionContext.Provider, { value: context }, useRender(Component, props, projectionId, useMotionRef(visualState, context.visualElement, externalRef), visualState, config.isStatic, context.visualElement))));\n    }\n    return React.forwardRef(MotionComponent);\n}\nfunction useLayoutId(_a) {\n    var _b;\n    var layoutId = _a.layoutId;\n    var layoutGroupId = (_b = React.useContext(LayoutGroupContext)) === null || _b === void 0 ? void 0 : _b.id;\n    return layoutGroupId && layoutId !== undefined\n        ? layoutGroupId + \"-\" + layoutId\n        : layoutId;\n}\n\n/**\n * Convert any React component into a `motion` component. The provided component\n * **must** use `React.forwardRef` to the underlying DOM component you want to animate.\n *\n * ```jsx\n * const Component = React.forwardRef((props, ref) => {\n *   return <div ref={ref} />\n * })\n *\n * const MotionComponent = motion(Component)\n * ```\n *\n * @public\n */\nfunction createMotionProxy(createConfig) {\n    function custom(Component, customMotionComponentConfig) {\n        if (customMotionComponentConfig === void 0) { customMotionComponentConfig = {}; }\n        return createMotionComponent(createConfig(Component, customMotionComponentConfig));\n    }\n    if (typeof Proxy === \"undefined\") {\n        return custom;\n    }\n    /**\n     * A cache of generated `motion` components, e.g `motion.div`, `motion.input` etc.\n     * Rather than generating them anew every render.\n     */\n    var componentCache = new Map();\n    return new Proxy(custom, {\n        /**\n         * Called when `motion` is referenced with a prop: `motion.div`, `motion.input` etc.\n         * The prop name is passed through as `key` and we can use that to generate a `motion`\n         * DOM component with that name.\n         */\n        get: function (_target, key) {\n            /**\n             * If this element doesn't exist in the component cache, create it and cache.\n             */\n            if (!componentCache.has(key)) {\n                componentCache.set(key, custom(key));\n            }\n            return componentCache.get(key);\n        },\n    });\n}\n\n/**\n * We keep these listed seperately as we use the lowercase tag names as part\n * of the runtime bundle to detect SVG components\n */\nvar lowercaseSVGElements = [\n    \"animate\",\n    \"circle\",\n    \"defs\",\n    \"desc\",\n    \"ellipse\",\n    \"g\",\n    \"image\",\n    \"line\",\n    \"filter\",\n    \"marker\",\n    \"mask\",\n    \"metadata\",\n    \"path\",\n    \"pattern\",\n    \"polygon\",\n    \"polyline\",\n    \"rect\",\n    \"stop\",\n    \"svg\",\n    \"switch\",\n    \"symbol\",\n    \"text\",\n    \"tspan\",\n    \"use\",\n    \"view\",\n];\n\nfunction isSVGComponent(Component) {\n    if (\n    /**\n     * If it's not a string, it's a custom React component. Currently we only support\n     * HTML custom React components.\n     */\n    typeof Component !== \"string\" ||\n        /**\n         * If it contains a dash, the element is a custom HTML webcomponent.\n         */\n        Component.includes(\"-\")) {\n        return false;\n    }\n    else if (\n    /**\n     * If it's in our list of lowercase SVG tags, it's an SVG component\n     */\n    lowercaseSVGElements.indexOf(Component) > -1 ||\n        /**\n         * If it contains a capital letter, it's an SVG component\n         */\n        /[A-Z]/.test(Component)) {\n        return true;\n    }\n    return false;\n}\n\nvar scaleCorrectors = {};\nfunction addScaleCorrector(correctors) {\n    Object.assign(scaleCorrectors, correctors);\n}\n\n/**\n * A list of all transformable axes. We'll use this list to generated a version\n * of each axes for each transform.\n */\nvar transformAxes = [\"\", \"X\", \"Y\", \"Z\"];\n/**\n * An ordered array of each transformable value. By default, transform values\n * will be sorted to this order.\n */\nvar order = [\"translate\", \"scale\", \"rotate\", \"skew\"];\n/**\n * Generate a list of every possible transform key.\n */\nvar transformProps = [\"transformPerspective\", \"x\", \"y\", \"z\"];\norder.forEach(function (operationKey) {\n    return transformAxes.forEach(function (axesKey) {\n        return transformProps.push(operationKey + axesKey);\n    });\n});\n/**\n * A function to use with Array.sort to sort transform keys by their default order.\n */\nfunction sortTransformProps(a, b) {\n    return transformProps.indexOf(a) - transformProps.indexOf(b);\n}\n/**\n * A quick lookup for transform props.\n */\nvar transformPropSet = new Set(transformProps);\nfunction isTransformProp(key) {\n    return transformPropSet.has(key);\n}\n/**\n * A quick lookup for transform origin props\n */\nvar transformOriginProps = new Set([\"originX\", \"originY\", \"originZ\"]);\nfunction isTransformOriginProp(key) {\n    return transformOriginProps.has(key);\n}\n\nfunction isForcedMotionValue(key, _a) {\n    var layout = _a.layout, layoutId = _a.layoutId;\n    return (isTransformProp(key) ||\n        isTransformOriginProp(key) ||\n        ((layout || layoutId !== undefined) &&\n            (!!scaleCorrectors[key] || key === \"opacity\")));\n}\n\nvar isMotionValue = function (value) {\n    return Boolean(value !== null && typeof value === \"object\" && value.getVelocity);\n};\n\nvar translateAlias = {\n    x: \"translateX\",\n    y: \"translateY\",\n    z: \"translateZ\",\n    transformPerspective: \"perspective\",\n};\n/**\n * Build a CSS transform style from individual x/y/scale etc properties.\n *\n * This outputs with a default order of transforms/scales/rotations, this can be customised by\n * providing a transformTemplate function.\n */\nfunction buildTransform(_a, _b, transformIsDefault, transformTemplate) {\n    var transform = _a.transform, transformKeys = _a.transformKeys;\n    var _c = _b.enableHardwareAcceleration, enableHardwareAcceleration = _c === void 0 ? true : _c, _d = _b.allowTransformNone, allowTransformNone = _d === void 0 ? true : _d;\n    // The transform string we're going to build into.\n    var transformString = \"\";\n    // Transform keys into their default order - this will determine the output order.\n    transformKeys.sort(sortTransformProps);\n    // Track whether the defined transform has a defined z so we don't add a\n    // second to enable hardware acceleration\n    var transformHasZ = false;\n    // Loop over each transform and build them into transformString\n    var numTransformKeys = transformKeys.length;\n    for (var i = 0; i < numTransformKeys; i++) {\n        var key = transformKeys[i];\n        transformString += \"\".concat(translateAlias[key] || key, \"(\").concat(transform[key], \") \");\n        if (key === \"z\")\n            transformHasZ = true;\n    }\n    if (!transformHasZ && enableHardwareAcceleration) {\n        transformString += \"translateZ(0)\";\n    }\n    else {\n        transformString = transformString.trim();\n    }\n    // If we have a custom `transform` template, pass our transform values and\n    // generated transformString to that before returning\n    if (transformTemplate) {\n        transformString = transformTemplate(transform, transformIsDefault ? \"\" : transformString);\n    }\n    else if (allowTransformNone && transformIsDefault) {\n        transformString = \"none\";\n    }\n    return transformString;\n}\n/**\n * Build a transformOrigin style. Uses the same defaults as the browser for\n * undefined origins.\n */\nfunction buildTransformOrigin(_a) {\n    var _b = _a.originX, originX = _b === void 0 ? \"50%\" : _b, _c = _a.originY, originY = _c === void 0 ? \"50%\" : _c, _d = _a.originZ, originZ = _d === void 0 ? 0 : _d;\n    return \"\".concat(originX, \" \").concat(originY, \" \").concat(originZ);\n}\n\n/**\n * Returns true if the provided key is a CSS variable\n */\nfunction isCSSVariable$1(key) {\n    return key.startsWith(\"--\");\n}\n\n/**\n * Provided a value and a ValueType, returns the value as that value type.\n */\nvar getValueAsType = function (value, type) {\n    return type && typeof value === \"number\"\n        ? type.transform(value)\n        : value;\n};\n\nvar int = tslib.__assign(tslib.__assign({}, styleValueTypes.number), { transform: Math.round });\n\nvar numberValueTypes = {\n    // Border props\n    borderWidth: styleValueTypes.px,\n    borderTopWidth: styleValueTypes.px,\n    borderRightWidth: styleValueTypes.px,\n    borderBottomWidth: styleValueTypes.px,\n    borderLeftWidth: styleValueTypes.px,\n    borderRadius: styleValueTypes.px,\n    radius: styleValueTypes.px,\n    borderTopLeftRadius: styleValueTypes.px,\n    borderTopRightRadius: styleValueTypes.px,\n    borderBottomRightRadius: styleValueTypes.px,\n    borderBottomLeftRadius: styleValueTypes.px,\n    // Positioning props\n    width: styleValueTypes.px,\n    maxWidth: styleValueTypes.px,\n    height: styleValueTypes.px,\n    maxHeight: styleValueTypes.px,\n    size: styleValueTypes.px,\n    top: styleValueTypes.px,\n    right: styleValueTypes.px,\n    bottom: styleValueTypes.px,\n    left: styleValueTypes.px,\n    // Spacing props\n    padding: styleValueTypes.px,\n    paddingTop: styleValueTypes.px,\n    paddingRight: styleValueTypes.px,\n    paddingBottom: styleValueTypes.px,\n    paddingLeft: styleValueTypes.px,\n    margin: styleValueTypes.px,\n    marginTop: styleValueTypes.px,\n    marginRight: styleValueTypes.px,\n    marginBottom: styleValueTypes.px,\n    marginLeft: styleValueTypes.px,\n    // Transform props\n    rotate: styleValueTypes.degrees,\n    rotateX: styleValueTypes.degrees,\n    rotateY: styleValueTypes.degrees,\n    rotateZ: styleValueTypes.degrees,\n    scale: styleValueTypes.scale,\n    scaleX: styleValueTypes.scale,\n    scaleY: styleValueTypes.scale,\n    scaleZ: styleValueTypes.scale,\n    skew: styleValueTypes.degrees,\n    skewX: styleValueTypes.degrees,\n    skewY: styleValueTypes.degrees,\n    distance: styleValueTypes.px,\n    translateX: styleValueTypes.px,\n    translateY: styleValueTypes.px,\n    translateZ: styleValueTypes.px,\n    x: styleValueTypes.px,\n    y: styleValueTypes.px,\n    z: styleValueTypes.px,\n    perspective: styleValueTypes.px,\n    transformPerspective: styleValueTypes.px,\n    opacity: styleValueTypes.alpha,\n    originX: styleValueTypes.progressPercentage,\n    originY: styleValueTypes.progressPercentage,\n    originZ: styleValueTypes.px,\n    // Misc\n    zIndex: int,\n    // SVG\n    fillOpacity: styleValueTypes.alpha,\n    strokeOpacity: styleValueTypes.alpha,\n    numOctaves: int,\n};\n\nfunction buildHTMLStyles(state, latestValues, options, transformTemplate) {\n    var _a;\n    var style = state.style, vars = state.vars, transform = state.transform, transformKeys = state.transformKeys, transformOrigin = state.transformOrigin;\n    // Empty the transformKeys array. As we're throwing out refs to its items\n    // this might not be as cheap as suspected. Maybe using the array as a buffer\n    // with a manual incrementation would be better.\n    transformKeys.length = 0;\n    // Track whether we encounter any transform or transformOrigin values.\n    var hasTransform = false;\n    var hasTransformOrigin = false;\n    // Does the calculated transform essentially equal \"none\"?\n    var transformIsNone = true;\n    /**\n     * Loop over all our latest animated values and decide whether to handle them\n     * as a style or CSS variable.\n     *\n     * Transforms and transform origins are kept seperately for further processing.\n     */\n    for (var key in latestValues) {\n        var value = latestValues[key];\n        /**\n         * If this is a CSS variable we don't do any further processing.\n         */\n        if (isCSSVariable$1(key)) {\n            vars[key] = value;\n            continue;\n        }\n        // Convert the value to its default value type, ie 0 -> \"0px\"\n        var valueType = numberValueTypes[key];\n        var valueAsType = getValueAsType(value, valueType);\n        if (isTransformProp(key)) {\n            // If this is a transform, flag to enable further transform processing\n            hasTransform = true;\n            transform[key] = valueAsType;\n            transformKeys.push(key);\n            // If we already know we have a non-default transform, early return\n            if (!transformIsNone)\n                continue;\n            // Otherwise check to see if this is a default transform\n            if (value !== ((_a = valueType.default) !== null && _a !== void 0 ? _a : 0))\n                transformIsNone = false;\n        }\n        else if (isTransformOriginProp(key)) {\n            transformOrigin[key] = valueAsType;\n            // If this is a transform origin, flag and enable further transform-origin processing\n            hasTransformOrigin = true;\n        }\n        else {\n            style[key] = valueAsType;\n        }\n    }\n    if (hasTransform) {\n        style.transform = buildTransform(state, options, transformIsNone, transformTemplate);\n    }\n    else if (transformTemplate) {\n        style.transform = transformTemplate({}, \"\");\n    }\n    else if (!latestValues.transform && style.transform) {\n        style.transform = \"none\";\n    }\n    if (hasTransformOrigin) {\n        style.transformOrigin = buildTransformOrigin(transformOrigin);\n    }\n}\n\nvar createHtmlRenderState = function () { return ({\n    style: {},\n    transform: {},\n    transformKeys: [],\n    transformOrigin: {},\n    vars: {},\n}); };\n\nfunction copyRawValuesOnly(target, source, props) {\n    for (var key in source) {\n        if (!isMotionValue(source[key]) && !isForcedMotionValue(key, props)) {\n            target[key] = source[key];\n        }\n    }\n}\nfunction useInitialMotionValues(_a, visualState, isStatic) {\n    var transformTemplate = _a.transformTemplate;\n    return React.useMemo(function () {\n        var state = createHtmlRenderState();\n        buildHTMLStyles(state, visualState, { enableHardwareAcceleration: !isStatic }, transformTemplate);\n        var vars = state.vars, style = state.style;\n        return tslib.__assign(tslib.__assign({}, vars), style);\n    }, [visualState]);\n}\nfunction useStyle(props, visualState, isStatic) {\n    var styleProp = props.style || {};\n    var style = {};\n    /**\n     * Copy non-Motion Values straight into style\n     */\n    copyRawValuesOnly(style, styleProp, props);\n    Object.assign(style, useInitialMotionValues(props, visualState, isStatic));\n    if (props.transformValues) {\n        style = props.transformValues(style);\n    }\n    return style;\n}\nfunction useHTMLProps(props, visualState, isStatic) {\n    // The `any` isn't ideal but it is the type of createElement props argument\n    var htmlProps = {};\n    var style = useStyle(props, visualState, isStatic);\n    if (Boolean(props.drag) && props.dragListener !== false) {\n        // Disable the ghost element when a user drags\n        htmlProps.draggable = false;\n        // Disable text selection\n        style.userSelect =\n            style.WebkitUserSelect =\n                style.WebkitTouchCallout =\n                    \"none\";\n        // Disable scrolling on the draggable direction\n        style.touchAction =\n            props.drag === true\n                ? \"none\"\n                : \"pan-\".concat(props.drag === \"x\" ? \"y\" : \"x\");\n    }\n    htmlProps.style = style;\n    return htmlProps;\n}\n\n/**\n * A list of all valid MotionProps.\n *\n * @privateRemarks\n * This doesn't throw if a `MotionProp` name is missing - it should.\n */\nvar validMotionProps = new Set([\n    \"initial\",\n    \"animate\",\n    \"exit\",\n    \"style\",\n    \"variants\",\n    \"transition\",\n    \"transformTemplate\",\n    \"transformValues\",\n    \"custom\",\n    \"inherit\",\n    \"layout\",\n    \"layoutId\",\n    \"layoutDependency\",\n    \"onLayoutAnimationStart\",\n    \"onLayoutAnimationComplete\",\n    \"onLayoutMeasure\",\n    \"onBeforeLayoutMeasure\",\n    \"onAnimationStart\",\n    \"onAnimationComplete\",\n    \"onUpdate\",\n    \"onDragStart\",\n    \"onDrag\",\n    \"onDragEnd\",\n    \"onMeasureDragConstraints\",\n    \"onDirectionLock\",\n    \"onDragTransitionEnd\",\n    \"drag\",\n    \"dragControls\",\n    \"dragListener\",\n    \"dragConstraints\",\n    \"dragDirectionLock\",\n    \"dragSnapToOrigin\",\n    \"_dragX\",\n    \"_dragY\",\n    \"dragElastic\",\n    \"dragMomentum\",\n    \"dragPropagation\",\n    \"dragTransition\",\n    \"whileDrag\",\n    \"onPan\",\n    \"onPanStart\",\n    \"onPanEnd\",\n    \"onPanSessionStart\",\n    \"onTap\",\n    \"onTapStart\",\n    \"onTapCancel\",\n    \"onHoverStart\",\n    \"onHoverEnd\",\n    \"whileFocus\",\n    \"whileTap\",\n    \"whileHover\",\n    \"whileInView\",\n    \"onViewportEnter\",\n    \"onViewportLeave\",\n    \"viewport\",\n    \"layoutScroll\",\n]);\n/**\n * Check whether a prop name is a valid `MotionProp` key.\n *\n * @param key - Name of the property to check\n * @returns `true` is key is a valid `MotionProp`.\n *\n * @public\n */\nfunction isValidMotionProp(key) {\n    return validMotionProps.has(key);\n}\n\nvar shouldForward = function (key) { return !isValidMotionProp(key); };\nfunction loadExternalIsValidProp(isValidProp) {\n    if (!isValidProp)\n        return;\n    // Explicitly filter our events\n    shouldForward = function (key) {\n        return key.startsWith(\"on\") ? !isValidMotionProp(key) : isValidProp(key);\n    };\n}\n/**\n * Emotion and Styled Components both allow users to pass through arbitrary props to their components\n * to dynamically generate CSS. They both use the `@emotion/is-prop-valid` package to determine which\n * of these should be passed to the underlying DOM node.\n *\n * However, when styling a Motion component `styled(motion.div)`, both packages pass through *all* props\n * as it's seen as an arbitrary component rather than a DOM node. Motion only allows arbitrary props\n * passed through the `custom` prop so it doesn't *need* the payload or computational overhead of\n * `@emotion/is-prop-valid`, however to fix this problem we need to use it.\n *\n * By making it an optionalDependency we can offer this functionality only in the situations where it's\n * actually required.\n */\ntry {\n    /**\n     * We attempt to import this package but require won't be defined in esm environments, in that case\n     * isPropValid will have to be provided via `MotionContext`. In a 6.0.0 this should probably be removed\n     * in favour of explicit injection.\n     */\n    loadExternalIsValidProp(require(\"@emotion/is-prop-valid\").default);\n}\ncatch (_a) {\n    // We don't need to actually do anything here - the fallback is the existing `isPropValid`.\n}\nfunction filterProps(props, isDom, forwardMotionProps) {\n    var filteredProps = {};\n    for (var key in props) {\n        if (shouldForward(key) ||\n            (forwardMotionProps === true && isValidMotionProp(key)) ||\n            (!isDom && !isValidMotionProp(key)) ||\n            // If trying to use native HTML drag events, forward drag listeners\n            (props[\"draggable\"] && key.startsWith(\"onDrag\"))) {\n            filteredProps[key] = props[key];\n        }\n    }\n    return filteredProps;\n}\n\nfunction calcOrigin$1(origin, offset, size) {\n    return typeof origin === \"string\"\n        ? origin\n        : styleValueTypes.px.transform(offset + size * origin);\n}\n/**\n * The SVG transform origin defaults are different to CSS and is less intuitive,\n * so we use the measured dimensions of the SVG to reconcile these.\n */\nfunction calcSVGTransformOrigin(dimensions, originX, originY) {\n    var pxOriginX = calcOrigin$1(originX, dimensions.x, dimensions.width);\n    var pxOriginY = calcOrigin$1(originY, dimensions.y, dimensions.height);\n    return \"\".concat(pxOriginX, \" \").concat(pxOriginY);\n}\n\nvar dashKeys = {\n    offset: \"stroke-dashoffset\",\n    array: \"stroke-dasharray\",\n};\nvar camelKeys = {\n    offset: \"strokeDashoffset\",\n    array: \"strokeDasharray\",\n};\n/**\n * Build SVG path properties. Uses the path's measured length to convert\n * our custom pathLength, pathSpacing and pathOffset into stroke-dashoffset\n * and stroke-dasharray attributes.\n *\n * This function is mutative to reduce per-frame GC.\n */\nfunction buildSVGPath(attrs, length, spacing, offset, useDashCase) {\n    if (spacing === void 0) { spacing = 1; }\n    if (offset === void 0) { offset = 0; }\n    if (useDashCase === void 0) { useDashCase = true; }\n    // Normalise path length by setting SVG attribute pathLength to 1\n    attrs.pathLength = 1;\n    // We use dash case when setting attributes directly to the DOM node and camel case\n    // when defining props on a React component.\n    var keys = useDashCase ? dashKeys : camelKeys;\n    // Build the dash offset\n    attrs[keys.offset] = styleValueTypes.px.transform(-offset);\n    // Build the dash array\n    var pathLength = styleValueTypes.px.transform(length);\n    var pathSpacing = styleValueTypes.px.transform(spacing);\n    attrs[keys.array] = \"\".concat(pathLength, \" \").concat(pathSpacing);\n}\n\n/**\n * Build SVG visual attrbutes, like cx and style.transform\n */\nfunction buildSVGAttrs(state, _a, options, transformTemplate) {\n    var attrX = _a.attrX, attrY = _a.attrY, originX = _a.originX, originY = _a.originY, pathLength = _a.pathLength, _b = _a.pathSpacing, pathSpacing = _b === void 0 ? 1 : _b, _c = _a.pathOffset, pathOffset = _c === void 0 ? 0 : _c, \n    // This is object creation, which we try to avoid per-frame.\n    latest = tslib.__rest(_a, [\"attrX\", \"attrY\", \"originX\", \"originY\", \"pathLength\", \"pathSpacing\", \"pathOffset\"]);\n    buildHTMLStyles(state, latest, options, transformTemplate);\n    state.attrs = state.style;\n    state.style = {};\n    var attrs = state.attrs, style = state.style, dimensions = state.dimensions;\n    /**\n     * However, we apply transforms as CSS transforms. So if we detect a transform we take it from attrs\n     * and copy it into style.\n     */\n    if (attrs.transform) {\n        if (dimensions)\n            style.transform = attrs.transform;\n        delete attrs.transform;\n    }\n    // Parse transformOrigin\n    if (dimensions &&\n        (originX !== undefined || originY !== undefined || style.transform)) {\n        style.transformOrigin = calcSVGTransformOrigin(dimensions, originX !== undefined ? originX : 0.5, originY !== undefined ? originY : 0.5);\n    }\n    // Treat x/y not as shortcuts but as actual attributes\n    if (attrX !== undefined)\n        attrs.x = attrX;\n    if (attrY !== undefined)\n        attrs.y = attrY;\n    // Build SVG path if one has been defined\n    if (pathLength !== undefined) {\n        buildSVGPath(attrs, pathLength, pathSpacing, pathOffset, false);\n    }\n}\n\nvar createSvgRenderState = function () { return (tslib.__assign(tslib.__assign({}, createHtmlRenderState()), { attrs: {} })); };\n\nfunction useSVGProps(props, visualState) {\n    var visualProps = React.useMemo(function () {\n        var state = createSvgRenderState();\n        buildSVGAttrs(state, visualState, { enableHardwareAcceleration: false }, props.transformTemplate);\n        return tslib.__assign(tslib.__assign({}, state.attrs), { style: tslib.__assign({}, state.style) });\n    }, [visualState]);\n    if (props.style) {\n        var rawStyles = {};\n        copyRawValuesOnly(rawStyles, props.style, props);\n        visualProps.style = tslib.__assign(tslib.__assign({}, rawStyles), visualProps.style);\n    }\n    return visualProps;\n}\n\nfunction createUseRender(forwardMotionProps) {\n    if (forwardMotionProps === void 0) { forwardMotionProps = false; }\n    var useRender = function (Component, props, projectionId, ref, _a, isStatic) {\n        var latestValues = _a.latestValues;\n        var useVisualProps = isSVGComponent(Component)\n            ? useSVGProps\n            : useHTMLProps;\n        var visualProps = useVisualProps(props, latestValues, isStatic);\n        var filteredProps = filterProps(props, typeof Component === \"string\", forwardMotionProps);\n        var elementProps = tslib.__assign(tslib.__assign(tslib.__assign({}, filteredProps), visualProps), { ref: ref });\n        if (projectionId) {\n            elementProps[\"data-projection-id\"] = projectionId;\n        }\n        return React.createElement(Component, elementProps);\n    };\n    return useRender;\n}\n\nvar CAMEL_CASE_PATTERN = /([a-z])([A-Z])/g;\nvar REPLACE_TEMPLATE = \"$1-$2\";\n/**\n * Convert camelCase to dash-case properties.\n */\nvar camelToDash = function (str) {\n    return str.replace(CAMEL_CASE_PATTERN, REPLACE_TEMPLATE).toLowerCase();\n};\n\nfunction renderHTML(element, _a, styleProp, projection) {\n    var style = _a.style, vars = _a.vars;\n    Object.assign(element.style, style, projection && projection.getProjectionStyles(styleProp));\n    // Loop over any CSS variables and assign those.\n    for (var key in vars) {\n        element.style.setProperty(key, vars[key]);\n    }\n}\n\n/**\n * A set of attribute names that are always read/written as camel case.\n */\nvar camelCaseAttributes = new Set([\n    \"baseFrequency\",\n    \"diffuseConstant\",\n    \"kernelMatrix\",\n    \"kernelUnitLength\",\n    \"keySplines\",\n    \"keyTimes\",\n    \"limitingConeAngle\",\n    \"markerHeight\",\n    \"markerWidth\",\n    \"numOctaves\",\n    \"targetX\",\n    \"targetY\",\n    \"surfaceScale\",\n    \"specularConstant\",\n    \"specularExponent\",\n    \"stdDeviation\",\n    \"tableValues\",\n    \"viewBox\",\n    \"gradientTransform\",\n    \"pathLength\",\n]);\n\nfunction renderSVG(element, renderState, _styleProp, projection) {\n    renderHTML(element, renderState, undefined, projection);\n    for (var key in renderState.attrs) {\n        element.setAttribute(!camelCaseAttributes.has(key) ? camelToDash(key) : key, renderState.attrs[key]);\n    }\n}\n\nfunction scrapeMotionValuesFromProps$1(props) {\n    var style = props.style;\n    var newValues = {};\n    for (var key in style) {\n        if (isMotionValue(style[key]) || isForcedMotionValue(key, props)) {\n            newValues[key] = style[key];\n        }\n    }\n    return newValues;\n}\n\nfunction scrapeMotionValuesFromProps(props) {\n    var newValues = scrapeMotionValuesFromProps$1(props);\n    for (var key in props) {\n        if (isMotionValue(props[key])) {\n            var targetKey = key === \"x\" || key === \"y\" ? \"attr\" + key.toUpperCase() : key;\n            newValues[targetKey] = props[key];\n        }\n    }\n    return newValues;\n}\n\nfunction isAnimationControls(v) {\n    return typeof v === \"object\" && typeof v.start === \"function\";\n}\n\nvar isKeyframesTarget = function (v) {\n    return Array.isArray(v);\n};\n\nvar isCustomValue = function (v) {\n    return Boolean(v && typeof v === \"object\" && v.mix && v.toValue);\n};\nvar resolveFinalValueInKeyframes = function (v) {\n    // TODO maybe throw if v.length - 1 is placeholder token?\n    return isKeyframesTarget(v) ? v[v.length - 1] || 0 : v;\n};\n\n/**\n * If the provided value is a MotionValue, this returns the actual value, otherwise just the value itself\n *\n * TODO: Remove and move to library\n */\nfunction resolveMotionValue(value) {\n    var unwrappedValue = isMotionValue(value) ? value.get() : value;\n    return isCustomValue(unwrappedValue)\n        ? unwrappedValue.toValue()\n        : unwrappedValue;\n}\n\nfunction makeState(_a, props, context, presenceContext) {\n    var scrapeMotionValuesFromProps = _a.scrapeMotionValuesFromProps, createRenderState = _a.createRenderState, onMount = _a.onMount;\n    var state = {\n        latestValues: makeLatestValues(props, context, presenceContext, scrapeMotionValuesFromProps),\n        renderState: createRenderState(),\n    };\n    if (onMount) {\n        state.mount = function (instance) { return onMount(props, instance, state); };\n    }\n    return state;\n}\nvar makeUseVisualState = function (config) {\n    return function (props, isStatic) {\n        var context = React.useContext(MotionContext);\n        var presenceContext = React.useContext(PresenceContext);\n        return isStatic\n            ? makeState(config, props, context, presenceContext)\n            : useConstant(function () {\n                return makeState(config, props, context, presenceContext);\n            });\n    };\n};\nfunction makeLatestValues(props, context, presenceContext, scrapeMotionValues) {\n    var values = {};\n    var blockInitialAnimation = (presenceContext === null || presenceContext === void 0 ? void 0 : presenceContext.initial) === false;\n    var motionValues = scrapeMotionValues(props);\n    for (var key in motionValues) {\n        values[key] = resolveMotionValue(motionValues[key]);\n    }\n    var initial = props.initial, animate = props.animate;\n    var isControllingVariants = checkIfControllingVariants(props);\n    var isVariantNode = checkIfVariantNode(props);\n    if (context &&\n        isVariantNode &&\n        !isControllingVariants &&\n        props.inherit !== false) {\n        initial !== null && initial !== void 0 ? initial : (initial = context.initial);\n        animate !== null && animate !== void 0 ? animate : (animate = context.animate);\n    }\n    var initialAnimationIsBlocked = blockInitialAnimation || initial === false;\n    var variantToSet = initialAnimationIsBlocked ? animate : initial;\n    if (variantToSet &&\n        typeof variantToSet !== \"boolean\" &&\n        !isAnimationControls(variantToSet)) {\n        var list = Array.isArray(variantToSet) ? variantToSet : [variantToSet];\n        list.forEach(function (definition) {\n            var resolved = resolveVariantFromProps(props, definition);\n            if (!resolved)\n                return;\n            var transitionEnd = resolved.transitionEnd; resolved.transition; var target = tslib.__rest(resolved, [\"transitionEnd\", \"transition\"]);\n            for (var key in target) {\n                var valueTarget = target[key];\n                if (Array.isArray(valueTarget)) {\n                    /**\n                     * Take final keyframe if the initial animation is blocked because\n                     * we want to initialise at the end of that blocked animation.\n                     */\n                    var index = initialAnimationIsBlocked\n                        ? valueTarget.length - 1\n                        : 0;\n                    valueTarget = valueTarget[index];\n                }\n                if (valueTarget !== null) {\n                    values[key] = valueTarget;\n                }\n            }\n            for (var key in transitionEnd)\n                values[key] = transitionEnd[key];\n        });\n    }\n    return values;\n}\n\nvar svgMotionConfig = {\n    useVisualState: makeUseVisualState({\n        scrapeMotionValuesFromProps: scrapeMotionValuesFromProps,\n        createRenderState: createSvgRenderState,\n        onMount: function (props, instance, _a) {\n            var renderState = _a.renderState, latestValues = _a.latestValues;\n            try {\n                renderState.dimensions =\n                    typeof instance.getBBox ===\n                        \"function\"\n                        ? instance.getBBox()\n                        : instance.getBoundingClientRect();\n            }\n            catch (e) {\n                // Most likely trying to measure an unrendered element under Firefox\n                renderState.dimensions = {\n                    x: 0,\n                    y: 0,\n                    width: 0,\n                    height: 0,\n                };\n            }\n            buildSVGAttrs(renderState, latestValues, { enableHardwareAcceleration: false }, props.transformTemplate);\n            renderSVG(instance, renderState);\n        },\n    }),\n};\n\nvar htmlMotionConfig = {\n    useVisualState: makeUseVisualState({\n        scrapeMotionValuesFromProps: scrapeMotionValuesFromProps$1,\n        createRenderState: createHtmlRenderState,\n    }),\n};\n\nfunction createDomMotionConfig(Component, _a, preloadedFeatures, createVisualElement, projectionNodeConstructor) {\n    var _b = _a.forwardMotionProps, forwardMotionProps = _b === void 0 ? false : _b;\n    var baseConfig = isSVGComponent(Component)\n        ? svgMotionConfig\n        : htmlMotionConfig;\n    return tslib.__assign(tslib.__assign({}, baseConfig), { preloadedFeatures: preloadedFeatures, useRender: createUseRender(forwardMotionProps), createVisualElement: createVisualElement, projectionNodeConstructor: projectionNodeConstructor, Component: Component });\n}\n\nexports.AnimationType = void 0;\n(function (AnimationType) {\n    AnimationType[\"Animate\"] = \"animate\";\n    AnimationType[\"Hover\"] = \"whileHover\";\n    AnimationType[\"Tap\"] = \"whileTap\";\n    AnimationType[\"Drag\"] = \"whileDrag\";\n    AnimationType[\"Focus\"] = \"whileFocus\";\n    AnimationType[\"InView\"] = \"whileInView\";\n    AnimationType[\"Exit\"] = \"exit\";\n})(exports.AnimationType || (exports.AnimationType = {}));\n\nfunction addDomEvent(target, eventName, handler, options) {\n    if (options === void 0) { options = { passive: true }; }\n    target.addEventListener(eventName, handler, options);\n    return function () { return target.removeEventListener(eventName, handler); };\n}\n/**\n * Attaches an event listener directly to the provided DOM element.\n *\n * Bypassing React's event system can be desirable, for instance when attaching non-passive\n * event handlers.\n *\n * ```jsx\n * const ref = useRef(null)\n *\n * useDomEvent(ref, 'wheel', onWheel, { passive: false })\n *\n * return <div ref={ref} />\n * ```\n *\n * @param ref - React.RefObject that's been provided to the element you want to bind the listener to.\n * @param eventName - Name of the event you want listen for.\n * @param handler - Function to fire when receiving the event.\n * @param options - Options to pass to `Event.addEventListener`.\n *\n * @public\n */\nfunction useDomEvent(ref, eventName, handler, options) {\n    React.useEffect(function () {\n        var element = ref.current;\n        if (handler && element) {\n            return addDomEvent(element, eventName, handler, options);\n        }\n    }, [ref, eventName, handler, options]);\n}\n\n/**\n *\n * @param props\n * @param ref\n * @internal\n */\nfunction useFocusGesture(_a) {\n    var whileFocus = _a.whileFocus, visualElement = _a.visualElement;\n    var onFocus = function () {\n        var _a;\n        (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(exports.AnimationType.Focus, true);\n    };\n    var onBlur = function () {\n        var _a;\n        (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(exports.AnimationType.Focus, false);\n    };\n    useDomEvent(visualElement, \"focus\", whileFocus ? onFocus : undefined);\n    useDomEvent(visualElement, \"blur\", whileFocus ? onBlur : undefined);\n}\n\nfunction isMouseEvent(event) {\n    // PointerEvent inherits from MouseEvent so we can't use a straight instanceof check.\n    if (typeof PointerEvent !== \"undefined\" && event instanceof PointerEvent) {\n        return !!(event.pointerType === \"mouse\");\n    }\n    return event instanceof MouseEvent;\n}\nfunction isTouchEvent(event) {\n    var hasTouches = !!event.touches;\n    return hasTouches;\n}\n\n/**\n * Filters out events not attached to the primary pointer (currently left mouse button)\n * @param eventHandler\n */\nfunction filterPrimaryPointer(eventHandler) {\n    return function (event) {\n        var isMouseEvent = event instanceof MouseEvent;\n        var isPrimaryPointer = !isMouseEvent ||\n            (isMouseEvent && event.button === 0);\n        if (isPrimaryPointer) {\n            eventHandler(event);\n        }\n    };\n}\nvar defaultPagePoint = { pageX: 0, pageY: 0 };\nfunction pointFromTouch(e, pointType) {\n    if (pointType === void 0) { pointType = \"page\"; }\n    var primaryTouch = e.touches[0] || e.changedTouches[0];\n    var point = primaryTouch || defaultPagePoint;\n    return {\n        x: point[pointType + \"X\"],\n        y: point[pointType + \"Y\"],\n    };\n}\nfunction pointFromMouse(point, pointType) {\n    if (pointType === void 0) { pointType = \"page\"; }\n    return {\n        x: point[pointType + \"X\"],\n        y: point[pointType + \"Y\"],\n    };\n}\nfunction extractEventInfo(event, pointType) {\n    if (pointType === void 0) { pointType = \"page\"; }\n    return {\n        point: isTouchEvent(event)\n            ? pointFromTouch(event, pointType)\n            : pointFromMouse(event, pointType),\n    };\n}\nvar wrapHandler = function (handler, shouldFilterPrimaryPointer) {\n    if (shouldFilterPrimaryPointer === void 0) { shouldFilterPrimaryPointer = false; }\n    var listener = function (event) {\n        return handler(event, extractEventInfo(event));\n    };\n    return shouldFilterPrimaryPointer\n        ? filterPrimaryPointer(listener)\n        : listener;\n};\n\n// We check for event support via functions in case they've been mocked by a testing suite.\nvar supportsPointerEvents = function () {\n    return isBrowser && window.onpointerdown === null;\n};\nvar supportsTouchEvents = function () {\n    return isBrowser && window.ontouchstart === null;\n};\nvar supportsMouseEvents = function () {\n    return isBrowser && window.onmousedown === null;\n};\n\nvar mouseEventNames = {\n    pointerdown: \"mousedown\",\n    pointermove: \"mousemove\",\n    pointerup: \"mouseup\",\n    pointercancel: \"mousecancel\",\n    pointerover: \"mouseover\",\n    pointerout: \"mouseout\",\n    pointerenter: \"mouseenter\",\n    pointerleave: \"mouseleave\",\n};\nvar touchEventNames = {\n    pointerdown: \"touchstart\",\n    pointermove: \"touchmove\",\n    pointerup: \"touchend\",\n    pointercancel: \"touchcancel\",\n};\nfunction getPointerEventName(name) {\n    if (supportsPointerEvents()) {\n        return name;\n    }\n    else if (supportsTouchEvents()) {\n        return touchEventNames[name];\n    }\n    else if (supportsMouseEvents()) {\n        return mouseEventNames[name];\n    }\n    return name;\n}\nfunction addPointerEvent(target, eventName, handler, options) {\n    return addDomEvent(target, getPointerEventName(eventName), wrapHandler(handler, eventName === \"pointerdown\"), options);\n}\nfunction usePointerEvent(ref, eventName, handler, options) {\n    return useDomEvent(ref, getPointerEventName(eventName), handler && wrapHandler(handler, eventName === \"pointerdown\"), options);\n}\n\nfunction createLock(name) {\n    var lock = null;\n    return function () {\n        var openLock = function () {\n            lock = null;\n        };\n        if (lock === null) {\n            lock = name;\n            return openLock;\n        }\n        return false;\n    };\n}\nvar globalHorizontalLock = createLock(\"dragHorizontal\");\nvar globalVerticalLock = createLock(\"dragVertical\");\nfunction getGlobalLock(drag) {\n    var lock = false;\n    if (drag === \"y\") {\n        lock = globalVerticalLock();\n    }\n    else if (drag === \"x\") {\n        lock = globalHorizontalLock();\n    }\n    else {\n        var openHorizontal_1 = globalHorizontalLock();\n        var openVertical_1 = globalVerticalLock();\n        if (openHorizontal_1 && openVertical_1) {\n            lock = function () {\n                openHorizontal_1();\n                openVertical_1();\n            };\n        }\n        else {\n            // Release the locks because we don't use them\n            if (openHorizontal_1)\n                openHorizontal_1();\n            if (openVertical_1)\n                openVertical_1();\n        }\n    }\n    return lock;\n}\nfunction isDragActive() {\n    // Check the gesture lock - if we get it, it means no drag gesture is active\n    // and we can safely fire the tap gesture.\n    var openGestureLock = getGlobalLock(true);\n    if (!openGestureLock)\n        return true;\n    openGestureLock();\n    return false;\n}\n\nfunction createHoverEvent(visualElement, isActive, callback) {\n    return function (event, info) {\n        var _a;\n        if (!isMouseEvent(event) || isDragActive())\n            return;\n        /**\n         * Ensure we trigger animations before firing event callback\n         */\n        (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(exports.AnimationType.Hover, isActive);\n        callback === null || callback === void 0 ? void 0 : callback(event, info);\n    };\n}\nfunction useHoverGesture(_a) {\n    var onHoverStart = _a.onHoverStart, onHoverEnd = _a.onHoverEnd, whileHover = _a.whileHover, visualElement = _a.visualElement;\n    usePointerEvent(visualElement, \"pointerenter\", onHoverStart || whileHover\n        ? createHoverEvent(visualElement, true, onHoverStart)\n        : undefined, { passive: !onHoverStart });\n    usePointerEvent(visualElement, \"pointerleave\", onHoverEnd || whileHover\n        ? createHoverEvent(visualElement, false, onHoverEnd)\n        : undefined, { passive: !onHoverEnd });\n}\n\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 */\nvar isNodeOrChild = function (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\nfunction useUnmountEffect(callback) {\n    return React.useEffect(function () { return function () { return callback(); }; }, []);\n}\n\n/**\n * @param handlers -\n * @internal\n */\nfunction useTapGesture(_a) {\n    var onTap = _a.onTap, onTapStart = _a.onTapStart, onTapCancel = _a.onTapCancel, whileTap = _a.whileTap, visualElement = _a.visualElement;\n    var hasPressListeners = onTap || onTapStart || onTapCancel || whileTap;\n    var isPressing = React.useRef(false);\n    var cancelPointerEndListeners = React.useRef(null);\n    /**\n     * Only set listener to passive if there are no external listeners.\n     */\n    var eventOptions = {\n        passive: !(onTapStart || onTap || onTapCancel || onPointerDown),\n    };\n    function removePointerEndListener() {\n        var _a;\n        (_a = cancelPointerEndListeners.current) === null || _a === void 0 ? void 0 : _a.call(cancelPointerEndListeners);\n        cancelPointerEndListeners.current = null;\n    }\n    function checkPointerEnd() {\n        var _a;\n        removePointerEndListener();\n        isPressing.current = false;\n        (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(exports.AnimationType.Tap, false);\n        return !isDragActive();\n    }\n    function onPointerUp(event, info) {\n        if (!checkPointerEnd())\n            return;\n        /**\n         * We only count this as a tap gesture if the event.target is the same\n         * as, or a child of, this component's element\n         */\n        !isNodeOrChild(visualElement.getInstance(), event.target)\n            ? onTapCancel === null || onTapCancel === void 0 ? void 0 : onTapCancel(event, info)\n            : onTap === null || onTap === void 0 ? void 0 : onTap(event, info);\n    }\n    function onPointerCancel(event, info) {\n        if (!checkPointerEnd())\n            return;\n        onTapCancel === null || onTapCancel === void 0 ? void 0 : onTapCancel(event, info);\n    }\n    function onPointerDown(event, info) {\n        var _a;\n        removePointerEndListener();\n        if (isPressing.current)\n            return;\n        isPressing.current = true;\n        cancelPointerEndListeners.current = popmotion.pipe(addPointerEvent(window, \"pointerup\", onPointerUp, eventOptions), addPointerEvent(window, \"pointercancel\", onPointerCancel, eventOptions));\n        /**\n         * Ensure we trigger animations before firing event callback\n         */\n        (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(exports.AnimationType.Tap, true);\n        onTapStart === null || onTapStart === void 0 ? void 0 : onTapStart(event, info);\n    }\n    usePointerEvent(visualElement, \"pointerdown\", hasPressListeners ? onPointerDown : undefined, eventOptions);\n    useUnmountEffect(removePointerEndListener);\n}\n\nvar warned = new Set();\nfunction warnOnce(condition, message, element) {\n    if (condition || warned.has(message))\n        return;\n    console.warn(message);\n    if (element)\n        console.warn(element);\n    warned.add(message);\n}\n\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 */\nvar 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 */\nvar observers = new WeakMap();\nvar fireObserverCallback = function (entry) {\n    var _a;\n    (_a = observerCallbacks.get(entry.target)) === null || _a === void 0 ? void 0 : _a(entry);\n};\nvar fireAllObserverCallbacks = function (entries) {\n    entries.forEach(fireObserverCallback);\n};\nfunction initIntersectionObserver(_a) {\n    var root = _a.root, options = tslib.__rest(_a, [\"root\"]);\n    var 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    var rootObservers = observers.get(lookupRoot);\n    var 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, tslib.__assign({ root: root }, options));\n    }\n    return rootObservers[key];\n}\nfunction observeIntersection(element, options, callback) {\n    var rootInteresectionObserver = initIntersectionObserver(options);\n    observerCallbacks.set(element, callback);\n    rootInteresectionObserver.observe(element);\n    return function () {\n        observerCallbacks.delete(element);\n        rootInteresectionObserver.unobserve(element);\n    };\n}\n\nfunction useViewport(_a) {\n    var visualElement = _a.visualElement, whileInView = _a.whileInView, onViewportEnter = _a.onViewportEnter, onViewportLeave = _a.onViewportLeave, _b = _a.viewport, viewport = _b === void 0 ? {} : _b;\n    var state = React.useRef({\n        hasEnteredView: false,\n        isInView: false,\n    });\n    var shouldObserve = Boolean(whileInView || onViewportEnter || onViewportLeave);\n    if (viewport.once && state.current.hasEnteredView)\n        shouldObserve = false;\n    var useObserver = typeof IntersectionObserver === \"undefined\"\n        ? useMissingIntersectionObserver\n        : useIntersectionObserver;\n    useObserver(shouldObserve, state.current, visualElement, viewport);\n}\nvar thresholdNames = {\n    some: 0,\n    all: 1,\n};\nfunction useIntersectionObserver(shouldObserve, state, visualElement, _a) {\n    var root = _a.root, rootMargin = _a.margin, _b = _a.amount, amount = _b === void 0 ? \"some\" : _b, once = _a.once;\n    React.useEffect(function () {\n        if (!shouldObserve)\n            return;\n        var options = {\n            root: root === null || root === void 0 ? void 0 : root.current,\n            rootMargin: rootMargin,\n            threshold: typeof amount === \"number\" ? amount : thresholdNames[amount],\n        };\n        var intersectionCallback = function (entry) {\n            var _a;\n            var isIntersecting = entry.isIntersecting;\n            /**\n             * If there's been no change in the viewport state, early return.\n             */\n            if (state.isInView === isIntersecting)\n                return;\n            state.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 && state.hasEnteredView) {\n                return;\n            }\n            else if (isIntersecting) {\n                state.hasEnteredView = true;\n            }\n            (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(exports.AnimationType.InView, isIntersecting);\n            /**\n             * Use the latest committed props rather than the ones in scope\n             * when this observer is created\n             */\n            var props = visualElement.getProps();\n            var callback = isIntersecting\n                ? props.onViewportEnter\n                : props.onViewportLeave;\n            callback === null || callback === void 0 ? void 0 : callback(entry);\n        };\n        return observeIntersection(visualElement.getInstance(), options, intersectionCallback);\n    }, [shouldObserve, root, rootMargin, amount]);\n}\n/**\n * If IntersectionObserver is missing, we activate inView and fire onViewportEnter\n * on mount. This way, the page will be in the state the author expects users\n * to see it in for everyone.\n */\nfunction useMissingIntersectionObserver(shouldObserve, state, visualElement, _a) {\n    var _b = _a.fallback, fallback = _b === void 0 ? true : _b;\n    React.useEffect(function () {\n        if (!shouldObserve || !fallback)\n            return;\n        if (env !== \"production\") {\n            warnOnce(false, \"IntersectionObserver not available on this device. whileInView animations will trigger on mount.\");\n        }\n        /**\n         * Fire this in an rAF because, at this point, the animation state\n         * won't have flushed for the first time and there's certain logic in\n         * there that behaves differently on the initial animation.\n         *\n         * This hook should be quite rarely called so setting this in an rAF\n         * is preferred to changing the behaviour of the animation state.\n         */\n        requestAnimationFrame(function () {\n            var _a;\n            state.hasEnteredView = true;\n            var onViewportEnter = visualElement.getProps().onViewportEnter;\n            onViewportEnter === null || onViewportEnter === void 0 ? void 0 : onViewportEnter(null);\n            (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(exports.AnimationType.InView, true);\n        });\n    }, [shouldObserve]);\n}\n\nvar makeRenderlessComponent = function (hook) { return function (props) {\n    hook(props);\n    return null;\n}; };\n\nvar gestureAnimations = {\n    inView: makeRenderlessComponent(useViewport),\n    tap: makeRenderlessComponent(useTapGesture),\n    focus: makeRenderlessComponent(useFocusGesture),\n    hover: makeRenderlessComponent(useHoverGesture),\n};\n\nvar counter = 0;\nvar incrementId = function () { return counter++; };\nvar useId = function () { return useConstant(incrementId); };\n/**\n * Ideally we'd use the following code to support React 18 optionally.\n * But this fairly fails in Webpack (otherwise treeshaking wouldn't work at all).\n * Need to come up with a different way of figuring this out.\n */\n// export const useId = (React as any).useId\n//     ? (React as any).useId\n//     : () => useConstant(incrementId)\n\n/**\n * When a component is the child of `AnimatePresence`, it can use `usePresence`\n * to access information about whether it's still present in the React tree.\n *\n * ```jsx\n * import { usePresence } from \"framer-motion\"\n *\n * export const Component = () => {\n *   const [isPresent, safeToRemove] = usePresence()\n *\n *   useEffect(() => {\n *     !isPresent && setTimeout(safeToRemove, 1000)\n *   }, [isPresent])\n *\n *   return <div />\n * }\n * ```\n *\n * If `isPresent` is `false`, it means that a component has been removed the tree, but\n * `AnimatePresence` won't really remove it until `safeToRemove` has been called.\n *\n * @public\n */\nfunction usePresence() {\n    var context = React.useContext(PresenceContext);\n    if (context === null)\n        return [true, null];\n    var isPresent = context.isPresent, onExitComplete = context.onExitComplete, register = context.register;\n    // It's safe to call the following hooks conditionally (after an early return) because the context will always\n    // either be null or non-null for the lifespan of the component.\n    // Replace with useId when released in React\n    var id = useId();\n    React.useEffect(function () { return register(id); }, []);\n    var safeToRemove = function () { return onExitComplete === null || onExitComplete === void 0 ? void 0 : onExitComplete(id); };\n    return !isPresent && onExitComplete ? [false, safeToRemove] : [true];\n}\n/**\n * Similar to `usePresence`, except `useIsPresent` simply returns whether or not the component is present.\n * There is no `safeToRemove` function.\n *\n * ```jsx\n * import { useIsPresent } from \"framer-motion\"\n *\n * export const Component = () => {\n *   const isPresent = useIsPresent()\n *\n *   useEffect(() => {\n *     !isPresent && console.log(\"I've been removed!\")\n *   }, [isPresent])\n *\n *   return <div />\n * }\n * ```\n *\n * @public\n */\nfunction useIsPresent() {\n    return isPresent(React.useContext(PresenceContext));\n}\nfunction isPresent(context) {\n    return context === null ? true : context.isPresent;\n}\n\nfunction shallowCompare(next, prev) {\n    if (!Array.isArray(prev))\n        return false;\n    var prevLength = prev.length;\n    if (prevLength !== next.length)\n        return false;\n    for (var i = 0; i < prevLength; i++) {\n        if (prev[i] !== next[i])\n            return false;\n    }\n    return true;\n}\n\n/**\n * Converts seconds to milliseconds\n *\n * @param seconds - Time in seconds.\n * @return milliseconds - Converted time in milliseconds.\n */\nvar secondsToMilliseconds = function (seconds) { return seconds * 1000; };\n\nvar easingLookup = {\n    linear: popmotion.linear,\n    easeIn: popmotion.easeIn,\n    easeInOut: popmotion.easeInOut,\n    easeOut: popmotion.easeOut,\n    circIn: popmotion.circIn,\n    circInOut: popmotion.circInOut,\n    circOut: popmotion.circOut,\n    backIn: popmotion.backIn,\n    backInOut: popmotion.backInOut,\n    backOut: popmotion.backOut,\n    anticipate: popmotion.anticipate,\n    bounceIn: popmotion.bounceIn,\n    bounceInOut: popmotion.bounceInOut,\n    bounceOut: popmotion.bounceOut,\n};\nvar easingDefinitionToFunction = function (definition) {\n    if (Array.isArray(definition)) {\n        // If cubic bezier definition, create bezier curve\n        heyListen.invariant(definition.length === 4, \"Cubic bezier arrays must contain four numerical values.\");\n        var _a = tslib.__read(definition, 4), x1 = _a[0], y1 = _a[1], x2 = _a[2], y2 = _a[3];\n        return popmotion.cubicBezier(x1, y1, x2, y2);\n    }\n    else if (typeof definition === \"string\") {\n        // Else lookup from table\n        heyListen.invariant(easingLookup[definition] !== undefined, \"Invalid easing type '\".concat(definition, \"'\"));\n        return easingLookup[definition];\n    }\n    return definition;\n};\nvar isEasingArray = function (ease) {\n    return Array.isArray(ease) && typeof ease[0] !== \"number\";\n};\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 */\nvar isAnimatable = function (key, value) {\n    // If the list of keys tat might be non-animatable grows, replace with Set\n    if (key === \"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        styleValueTypes.complex.test(value) && // And it contains numbers and/or colors\n        !value.startsWith(\"url(\") // Unless it starts with \"url(\"\n    ) {\n        return true;\n    }\n    return false;\n};\n\nvar underDampedSpring = function () { return ({\n    type: \"spring\",\n    stiffness: 500,\n    damping: 25,\n    restSpeed: 10,\n}); };\nvar criticallyDampedSpring = function (to) { return ({\n    type: \"spring\",\n    stiffness: 550,\n    damping: to === 0 ? 2 * Math.sqrt(550) : 30,\n    restSpeed: 10,\n}); };\nvar linearTween = function () { return ({\n    type: \"keyframes\",\n    ease: \"linear\",\n    duration: 0.3,\n}); };\nvar keyframes = function (values) { return ({\n    type: \"keyframes\",\n    duration: 0.8,\n    values: values,\n}); };\nvar defaultTransitions = {\n    x: underDampedSpring,\n    y: underDampedSpring,\n    z: underDampedSpring,\n    rotate: underDampedSpring,\n    rotateX: underDampedSpring,\n    rotateY: underDampedSpring,\n    rotateZ: underDampedSpring,\n    scaleX: criticallyDampedSpring,\n    scaleY: criticallyDampedSpring,\n    scale: criticallyDampedSpring,\n    opacity: linearTween,\n    backgroundColor: linearTween,\n    color: linearTween,\n    default: criticallyDampedSpring,\n};\nvar getDefaultTransition = function (valueKey, to) {\n    var transitionFactory;\n    if (isKeyframesTarget(to)) {\n        transitionFactory = keyframes;\n    }\n    else {\n        transitionFactory =\n            defaultTransitions[valueKey] || defaultTransitions.default;\n    }\n    return tslib.__assign({ to: to }, transitionFactory(to));\n};\n\n/**\n * A map of default value types for common values\n */\nvar defaultValueTypes = tslib.__assign(tslib.__assign({}, numberValueTypes), { \n    // Color props\n    color: styleValueTypes.color, backgroundColor: styleValueTypes.color, outlineColor: styleValueTypes.color, fill: styleValueTypes.color, stroke: styleValueTypes.color, \n    // Border props\n    borderColor: styleValueTypes.color, borderTopColor: styleValueTypes.color, borderRightColor: styleValueTypes.color, borderBottomColor: styleValueTypes.color, borderLeftColor: styleValueTypes.color, filter: styleValueTypes.filter, WebkitFilter: styleValueTypes.filter });\n/**\n * Gets the default ValueType for the provided value key\n */\nvar getDefaultValueType = function (key) { return defaultValueTypes[key]; };\n\nfunction getAnimatableNone(key, value) {\n    var _a;\n    var defaultValueType = getDefaultValueType(key);\n    if (defaultValueType !== styleValueTypes.filter)\n        defaultValueType = styleValueTypes.complex;\n    // If value is not recognised as animatable, ie \"none\", create an animatable version origin based on the target\n    return (_a = defaultValueType.getAnimatableNone) === null || _a === void 0 ? void 0 : _a.call(defaultValueType, value);\n}\n\nvar instantAnimationState = {\n    current: false,\n};\n\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(_a) {\n    _a.when; _a.delay; _a.delayChildren; _a.staggerChildren; _a.staggerDirection; _a.repeat; _a.repeatType; _a.repeatDelay; _a.from; var transition = tslib.__rest(_a, [\"when\", \"delay\", \"delayChildren\", \"staggerChildren\", \"staggerDirection\", \"repeat\", \"repeatType\", \"repeatDelay\", \"from\"]);\n    return !!Object.keys(transition).length;\n}\nvar legacyRepeatWarning = false;\n/**\n * Convert Framer Motion's Transition type into Popmotion-compatible options.\n */\nfunction convertTransitionToAnimationOptions(_a) {\n    var ease = _a.ease, times = _a.times, yoyo = _a.yoyo, flip = _a.flip, loop = _a.loop, transition = tslib.__rest(_a, [\"ease\", \"times\", \"yoyo\", \"flip\", \"loop\"]);\n    var options = tslib.__assign({}, transition);\n    if (times)\n        options[\"offset\"] = times;\n    /**\n     * Convert any existing durations from seconds to milliseconds\n     */\n    if (transition.duration)\n        options[\"duration\"] = secondsToMilliseconds(transition.duration);\n    if (transition.repeatDelay)\n        options.repeatDelay = secondsToMilliseconds(transition.repeatDelay);\n    /**\n     * Map easing names to Popmotion's easing functions\n     */\n    if (ease) {\n        options[\"ease\"] = isEasingArray(ease)\n            ? ease.map(easingDefinitionToFunction)\n            : easingDefinitionToFunction(ease);\n    }\n    /**\n     * Support legacy transition API\n     */\n    if (transition.type === \"tween\")\n        options.type = \"keyframes\";\n    /**\n     * TODO: These options are officially removed from the API.\n     */\n    if (yoyo || loop || flip) {\n        heyListen.warning(!legacyRepeatWarning, \"yoyo, loop and flip have been removed from the API. Replace with repeat and repeatType options.\");\n        legacyRepeatWarning = true;\n        if (yoyo) {\n            options.repeatType = \"reverse\";\n        }\n        else if (loop) {\n            options.repeatType = \"loop\";\n        }\n        else if (flip) {\n            options.repeatType = \"mirror\";\n        }\n        options.repeat = loop || yoyo || flip || transition.repeat;\n    }\n    /**\n     * TODO: Popmotion 9 has the ability to automatically detect whether to use\n     * a keyframes or spring animation, but does so by detecting velocity and other spring options.\n     * It'd be good to introduce a similar thing here.\n     */\n    if (transition.type !== \"spring\")\n        options.type = \"keyframes\";\n    return options;\n}\n/**\n * Get the delay for a value by checking Transition with decreasing specificity.\n */\nfunction getDelayFromTransition(transition, key) {\n    var _a, _b;\n    var valueTransition = getValueTransition(transition, key) || {};\n    return (_b = (_a = valueTransition.delay) !== null && _a !== void 0 ? _a : transition.delay) !== null && _b !== void 0 ? _b : 0;\n}\nfunction hydrateKeyframes(options) {\n    if (Array.isArray(options.to) && options.to[0] === null) {\n        options.to = tslib.__spreadArray([], tslib.__read(options.to), false);\n        options.to[0] = options.from;\n    }\n    return options;\n}\nfunction getPopmotionAnimationOptions(transition, options, key) {\n    var _a;\n    if (Array.isArray(options.to)) {\n        (_a = transition.duration) !== null && _a !== void 0 ? _a : (transition.duration = 0.8);\n    }\n    hydrateKeyframes(options);\n    /**\n     * Get a default transition if none is determined to be defined.\n     */\n    if (!isTransitionDefined(transition)) {\n        transition = tslib.__assign(tslib.__assign({}, transition), getDefaultTransition(key, options.to));\n    }\n    return tslib.__assign(tslib.__assign({}, options), convertTransitionToAnimationOptions(transition));\n}\n/**\n *\n */\nfunction getAnimation(key, value, target, transition, onComplete) {\n    var _a;\n    var valueTransition = getValueTransition(transition, key);\n    var origin = (_a = valueTransition.from) !== null && _a !== void 0 ? _a : value.get();\n    var isTargetAnimatable = isAnimatable(key, target);\n    if (origin === \"none\" && isTargetAnimatable && typeof target === \"string\") {\n        /**\n         * If we're trying to animate from \"none\", try and get an animatable version\n         * of the target. This could be improved to work both ways.\n         */\n        origin = getAnimatableNone(key, target);\n    }\n    else if (isZero(origin) && typeof target === \"string\") {\n        origin = getZeroUnit(target);\n    }\n    else if (!Array.isArray(target) &&\n        isZero(target) &&\n        typeof origin === \"string\") {\n        target = getZeroUnit(origin);\n    }\n    var isOriginAnimatable = isAnimatable(key, origin);\n    heyListen.warning(isOriginAnimatable === isTargetAnimatable, \"You are trying to animate \".concat(key, \" from \\\"\").concat(origin, \"\\\" to \\\"\").concat(target, \"\\\". \").concat(origin, \" is not an animatable value - to enable this animation set \").concat(origin, \" to a value animatable to \").concat(target, \" via the `style` property.\"));\n    function start() {\n        var options = {\n            from: origin,\n            to: target,\n            velocity: value.getVelocity(),\n            onComplete: onComplete,\n            onUpdate: function (v) { return value.set(v); },\n        };\n        return valueTransition.type === \"inertia\" ||\n            valueTransition.type === \"decay\"\n            ? popmotion.inertia(tslib.__assign(tslib.__assign({}, options), valueTransition))\n            : popmotion.animate(tslib.__assign(tslib.__assign({}, getPopmotionAnimationOptions(valueTransition, options, key)), { onUpdate: function (v) {\n                    var _a;\n                    options.onUpdate(v);\n                    (_a = valueTransition.onUpdate) === null || _a === void 0 ? void 0 : _a.call(valueTransition, v);\n                }, onComplete: function () {\n                    var _a;\n                    options.onComplete();\n                    (_a = valueTransition.onComplete) === null || _a === void 0 ? void 0 : _a.call(valueTransition);\n                } }));\n    }\n    function set() {\n        var _a, _b;\n        var finalTarget = resolveFinalValueInKeyframes(target);\n        value.set(finalTarget);\n        onComplete();\n        (_a = valueTransition === null || valueTransition === void 0 ? void 0 : valueTransition.onUpdate) === null || _a === void 0 ? void 0 : _a.call(valueTransition, finalTarget);\n        (_b = valueTransition === null || valueTransition === void 0 ? void 0 : valueTransition.onComplete) === null || _b === void 0 ? void 0 : _b.call(valueTransition);\n        return { stop: function () { } };\n    }\n    return !isOriginAnimatable ||\n        !isTargetAnimatable ||\n        valueTransition.type === false\n        ? set\n        : start;\n}\nfunction isZero(value) {\n    return (value === 0 ||\n        (typeof value === \"string\" &&\n            parseFloat(value) === 0 &&\n            value.indexOf(\" \") === -1));\n}\nfunction getZeroUnit(potentialUnitType) {\n    return typeof potentialUnitType === \"number\"\n        ? 0\n        : getAnimatableNone(\"\", potentialUnitType);\n}\nfunction getValueTransition(transition, key) {\n    return transition[key] || transition[\"default\"] || transition;\n}\n/**\n * Start animation on a MotionValue. This function is an interface between\n * Framer Motion and Popmotion\n */\nfunction startAnimation(key, value, target, transition) {\n    if (transition === void 0) { transition = {}; }\n    if (instantAnimationState.current) {\n        transition = { type: false };\n    }\n    return value.start(function (onComplete) {\n        var delayTimer;\n        var controls;\n        var animation = getAnimation(key, value, target, transition, onComplete);\n        var delay = getDelayFromTransition(transition, key);\n        var start = function () { return (controls = animation()); };\n        if (delay) {\n            delayTimer = window.setTimeout(start, secondsToMilliseconds(delay));\n        }\n        else {\n            start();\n        }\n        return function () {\n            clearTimeout(delayTimer);\n            controls === null || controls === void 0 ? void 0 : controls.stop();\n        };\n    });\n}\n\n/**\n * Check if value is a numerical string, ie a string that is purely a number eg \"100\" or \"-100.1\"\n */\nvar isNumericalString = function (v) { return /^\\-?\\d*\\.?\\d+$/.test(v); };\n\n/**\n * Check if the value is a zero value string like \"0px\" or \"0%\"\n */\nvar isZeroValueString = function (v) { return /^0[^.\\s]+$/.test(v); };\n\nfunction addUniqueItem(arr, item) {\n    arr.indexOf(item) === -1 && arr.push(item);\n}\nfunction removeItem(arr, item) {\n    var index = arr.indexOf(item);\n    index > -1 && arr.splice(index, 1);\n}\n// Adapted from array-move\nfunction moveItem(_a, fromIndex, toIndex) {\n    var _b = tslib.__read(_a), arr = _b.slice(0);\n    var startIndex = fromIndex < 0 ? arr.length + fromIndex : fromIndex;\n    if (startIndex >= 0 && startIndex < arr.length) {\n        var endIndex = toIndex < 0 ? arr.length + toIndex : toIndex;\n        var _c = tslib.__read(arr.splice(fromIndex, 1), 1), item = _c[0];\n        arr.splice(endIndex, 0, item);\n    }\n    return arr;\n}\n\nvar SubscriptionManager = /** @class */ (function () {\n    function SubscriptionManager() {\n        this.subscriptions = [];\n    }\n    SubscriptionManager.prototype.add = function (handler) {\n        var _this = this;\n        addUniqueItem(this.subscriptions, handler);\n        return function () { return removeItem(_this.subscriptions, handler); };\n    };\n    SubscriptionManager.prototype.notify = function (a, b, c) {\n        var 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 (var 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                var handler = this.subscriptions[i];\n                handler && handler(a, b, c);\n            }\n        }\n    };\n    SubscriptionManager.prototype.getSize = function () {\n        return this.subscriptions.length;\n    };\n    SubscriptionManager.prototype.clear = function () {\n        this.subscriptions.length = 0;\n    };\n    return SubscriptionManager;\n}());\n\nvar isFloat = function (value) {\n    return !isNaN(parseFloat(value));\n};\n/**\n * `MotionValue` is used to track the state and velocity of motion values.\n *\n * @public\n */\nvar MotionValue = /** @class */ (function () {\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    function MotionValue(init) {\n        var _this = this;\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 = \"6.5.1\";\n        /**\n         * Duration, in milliseconds, since last updating frame.\n         *\n         * @internal\n         */\n        this.timeDelta = 0;\n        /**\n         * Timestamp of the last time this `MotionValue` was updated.\n         *\n         * @internal\n         */\n        this.lastUpdated = 0;\n        /**\n         * Functions to notify when the `MotionValue` updates.\n         *\n         * @internal\n         */\n        this.updateSubscribers = new SubscriptionManager();\n        /**\n         * Functions to notify when the velocity updates.\n         *\n         * @internal\n         */\n        this.velocityUpdateSubscribers = new SubscriptionManager();\n        /**\n         * Functions to notify when the `MotionValue` updates and `render` is set to `true`.\n         *\n         * @internal\n         */\n        this.renderSubscribers = new SubscriptionManager();\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 = false;\n        this.updateAndNotify = function (v, render) {\n            if (render === void 0) { render = true; }\n            _this.prev = _this.current;\n            _this.current = v;\n            // Update timestamp\n            var _a = sync.getFrameData(), delta = _a.delta, timestamp = _a.timestamp;\n            if (_this.lastUpdated !== timestamp) {\n                _this.timeDelta = delta;\n                _this.lastUpdated = timestamp;\n                sync__default[\"default\"].postRender(_this.scheduleVelocityCheck);\n            }\n            // Update update subscribers\n            if (_this.prev !== _this.current) {\n                _this.updateSubscribers.notify(_this.current);\n            }\n            // Update velocity subscribers\n            if (_this.velocityUpdateSubscribers.getSize()) {\n                _this.velocityUpdateSubscribers.notify(_this.getVelocity());\n            }\n            // Update render subscribers\n            if (render) {\n                _this.renderSubscribers.notify(_this.current);\n            }\n        };\n        /**\n         * Schedule a velocity check for the next frame.\n         *\n         * This is an instanced and bound function to prevent generating a new\n         * function once per frame.\n         *\n         * @internal\n         */\n        this.scheduleVelocityCheck = function () { return sync__default[\"default\"].postRender(_this.velocityCheck); };\n        /**\n         * Updates `prev` with `current` if the value hasn't been updated this frame.\n         * This ensures velocity calculations return `0`.\n         *\n         * This is an instanced and bound function to prevent generating a new\n         * function once per frame.\n         *\n         * @internal\n         */\n        this.velocityCheck = function (_a) {\n            var timestamp = _a.timestamp;\n            if (timestamp !== _this.lastUpdated) {\n                _this.prev = _this.current;\n                _this.velocityUpdateSubscribers.notify(_this.getVelocity());\n            }\n        };\n        this.hasAnimated = false;\n        this.prev = this.current = init;\n        this.canTrackVelocity = isFloat(this.current);\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.onChange(updateOpacity)\n     *     const unsubscribeY = y.onChange(updateOpacity)\n     *\n     *     return () => {\n     *       unsubscribeX()\n     *       unsubscribeY()\n     *     }\n     *   }, [])\n     *\n     *   return <motion.div style={{ x }} />\n     * }\n     * ```\n     *\n     * @privateRemarks\n     *\n     * We could look into a `useOnChange` hook if the above lifecycle management proves confusing.\n     *\n     * ```jsx\n     * useOnChange(x, () => {})\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     * @public\n     */\n    MotionValue.prototype.onChange = function (subscription) {\n        return this.updateSubscribers.add(subscription);\n    };\n    MotionValue.prototype.clearListeners = function () {\n        this.updateSubscribers.clear();\n    };\n    /**\n     * Adds a function that will be notified when the `MotionValue` requests a render.\n     *\n     * @param subscriber - A function that's provided the latest value.\n     * @returns A function that, when called, will cancel this subscription.\n     *\n     * @internal\n     */\n    MotionValue.prototype.onRenderRequest = function (subscription) {\n        // Render immediately\n        subscription(this.get());\n        return this.renderSubscribers.add(subscription);\n    };\n    /**\n     * Attaches a passive effect to the `MotionValue`.\n     *\n     * @internal\n     */\n    MotionValue.prototype.attach = function (passiveEffect) {\n        this.passiveEffect = passiveEffect;\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    MotionValue.prototype.set = function (v, render) {\n        if (render === void 0) { render = true; }\n        if (!render || !this.passiveEffect) {\n            this.updateAndNotify(v, render);\n        }\n        else {\n            this.passiveEffect(v, this.updateAndNotify);\n        }\n    };\n    /**\n     * Returns the latest state of `MotionValue`\n     *\n     * @returns - The latest state of `MotionValue`\n     *\n     * @public\n     */\n    MotionValue.prototype.get = function () {\n        return this.current;\n    };\n    /**\n     * @public\n     */\n    MotionValue.prototype.getPrevious = function () {\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    MotionValue.prototype.getVelocity = function () {\n        // This could be isFloat(this.prev) && isFloat(this.current), but that would be wasteful\n        return this.canTrackVelocity\n            ? // These casts could be avoided if parseFloat would be typed better\n                popmotion.velocityPerSecond(parseFloat(this.current) -\n                    parseFloat(this.prev), this.timeDelta)\n            : 0;\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    MotionValue.prototype.start = function (animation) {\n        var _this = this;\n        this.stop();\n        return new Promise(function (resolve) {\n            _this.hasAnimated = true;\n            _this.stopAnimation = animation(resolve);\n        }).then(function () { return _this.clearAnimation(); });\n    };\n    /**\n     * Stop the currently active animation.\n     *\n     * @public\n     */\n    MotionValue.prototype.stop = function () {\n        if (this.stopAnimation)\n            this.stopAnimation();\n        this.clearAnimation();\n    };\n    /**\n     * Returns `true` if this value is currently animating.\n     *\n     * @public\n     */\n    MotionValue.prototype.isAnimating = function () {\n        return !!this.stopAnimation;\n    };\n    MotionValue.prototype.clearAnimation = function () {\n        this.stopAnimation = null;\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    MotionValue.prototype.destroy = function () {\n        this.updateSubscribers.clear();\n        this.renderSubscribers.clear();\n        this.stop();\n    };\n    return MotionValue;\n}());\nfunction motionValue(init) {\n    return new MotionValue(init);\n}\n\n/**\n * Tests a provided value against a ValueType\n */\nvar testValueType = function (v) { return function (type) { return type.test(v); }; };\n\n/**\n * ValueType for \"auto\"\n */\nvar auto = {\n    test: function (v) { return v === \"auto\"; },\n    parse: function (v) { return v; },\n};\n\n/**\n * A list of value types commonly used for dimensions\n */\nvar dimensionValueTypes = [styleValueTypes.number, styleValueTypes.px, styleValueTypes.percent, styleValueTypes.degrees, styleValueTypes.vw, styleValueTypes.vh, auto];\n/**\n * Tests a dimensional value against the list of dimension ValueTypes\n */\nvar findDimensionValueType = function (v) {\n    return dimensionValueTypes.find(testValueType(v));\n};\n\n/**\n * A list of all ValueTypes\n */\nvar valueTypes = tslib.__spreadArray(tslib.__spreadArray([], tslib.__read(dimensionValueTypes), false), [styleValueTypes.color, styleValueTypes.complex], false);\n/**\n * Tests a value against the list of ValueTypes\n */\nvar findValueType = function (v) { return valueTypes.find(testValueType(v)); };\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    var resolved = resolveVariant(visualElement, definition);\n    var _a = resolved ? visualElement.makeTargetAnimatable(resolved, false) : {}, _b = _a.transitionEnd, transitionEnd = _b === void 0 ? {} : _b; _a.transition; var target = tslib.__rest(_a, [\"transitionEnd\", \"transition\"]);\n    target = tslib.__assign(tslib.__assign({}, target), transitionEnd);\n    for (var key in target) {\n        var value = resolveFinalValueInKeyframes(target[key]);\n        setMotionValue(visualElement, key, value);\n    }\n}\nfunction setVariants(visualElement, variantLabels) {\n    var reversedLabels = tslib.__spreadArray([], tslib.__read(variantLabels), false).reverse();\n    reversedLabels.forEach(function (key) {\n        var _a;\n        var variant = visualElement.getVariant(key);\n        variant && setTarget(visualElement, variant);\n        (_a = visualElement.variantChildren) === null || _a === void 0 ? void 0 : _a.forEach(function (child) {\n            setVariants(child, variantLabels);\n        });\n    });\n}\nfunction setValues(visualElement, definition) {\n    if (Array.isArray(definition)) {\n        return setVariants(visualElement, definition);\n    }\n    else if (typeof definition === \"string\") {\n        return setVariants(visualElement, [definition]);\n    }\n    else {\n        setTarget(visualElement, definition);\n    }\n}\nfunction checkTargetForNewValues(visualElement, target, origin) {\n    var _a, _b, _c;\n    var _d;\n    var newValueKeys = Object.keys(target).filter(function (key) { return !visualElement.hasValue(key); });\n    var numNewValues = newValueKeys.length;\n    if (!numNewValues)\n        return;\n    for (var i = 0; i < numNewValues; i++) {\n        var key = newValueKeys[i];\n        var targetValue = target[key];\n        var value = null;\n        /**\n         * If the target is a series of keyframes, we can use the first value\n         * in the array. If this first value is null, we'll still need to read from the DOM.\n         */\n        if (Array.isArray(targetValue)) {\n            value = targetValue[0];\n        }\n        /**\n         * If the target isn't keyframes, or the first keyframe was null, we need to\n         * first check if an origin value was explicitly defined in the transition as \"from\",\n         * if not read the value from the DOM. As an absolute fallback, take the defined target value.\n         */\n        if (value === null) {\n            value = (_b = (_a = origin[key]) !== null && _a !== void 0 ? _a : visualElement.readValue(key)) !== null && _b !== void 0 ? _b : target[key];\n        }\n        /**\n         * If value is still undefined or null, ignore it. Preferably this would throw,\n         * but this was causing issues in Framer.\n         */\n        if (value === undefined || value === null)\n            continue;\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) && styleValueTypes.complex.test(targetValue)) {\n            value = getAnimatableNone(key, targetValue);\n        }\n        visualElement.addValue(key, motionValue(value));\n        (_c = (_d = origin)[key]) !== null && _c !== void 0 ? _c : (_d[key] = value);\n        visualElement.setBaseTarget(key, value);\n    }\n}\nfunction getOriginFromTransition(key, transition) {\n    if (!transition)\n        return;\n    var valueTransition = transition[key] || transition[\"default\"] || transition;\n    return valueTransition.from;\n}\nfunction getOrigin(target, transition, visualElement) {\n    var _a, _b;\n    var origin = {};\n    for (var key in target) {\n        origin[key] =\n            (_a = getOriginFromTransition(key, transition)) !== null && _a !== void 0 ? _a : (_b = visualElement.getValue(key)) === null || _b === void 0 ? void 0 : _b.get();\n    }\n    return origin;\n}\n\nfunction animateVisualElement(visualElement, definition, options) {\n    if (options === void 0) { options = {}; }\n    visualElement.notifyAnimationStart(definition);\n    var animation;\n    if (Array.isArray(definition)) {\n        var animations = definition.map(function (variant) {\n            return animateVariant(visualElement, variant, options);\n        });\n        animation = Promise.all(animations);\n    }\n    else if (typeof definition === \"string\") {\n        animation = animateVariant(visualElement, definition, options);\n    }\n    else {\n        var resolvedDefinition = typeof definition === \"function\"\n            ? resolveVariant(visualElement, definition, options.custom)\n            : definition;\n        animation = animateTarget(visualElement, resolvedDefinition, options);\n    }\n    return animation.then(function () {\n        return visualElement.notifyAnimationComplete(definition);\n    });\n}\nfunction animateVariant(visualElement, variant, options) {\n    var _a;\n    if (options === void 0) { options = {}; }\n    var resolved = resolveVariant(visualElement, variant, options.custom);\n    var _b = (resolved || {}).transition, transition = _b === void 0 ? visualElement.getDefaultTransition() || {} : _b;\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    var getAnimation = resolved\n        ? function () { return animateTarget(visualElement, resolved, options); }\n        : function () { return 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    var getChildAnimations = ((_a = visualElement.variantChildren) === null || _a === void 0 ? void 0 : _a.size)\n        ? function (forwardDelay) {\n            if (forwardDelay === void 0) { forwardDelay = 0; }\n            var _a = transition.delayChildren, delayChildren = _a === void 0 ? 0 : _a, staggerChildren = transition.staggerChildren, staggerDirection = transition.staggerDirection;\n            return animateChildren(visualElement, variant, delayChildren + forwardDelay, staggerChildren, staggerDirection, options);\n        }\n        : function () { return 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    var when = transition.when;\n    if (when) {\n        var _c = tslib.__read(when === \"beforeChildren\"\n            ? [getAnimation, getChildAnimations]\n            : [getChildAnimations, getAnimation], 2), first = _c[0], last = _c[1];\n        return first().then(last);\n    }\n    else {\n        return Promise.all([getAnimation(), getChildAnimations(options.delay)]);\n    }\n}\n/**\n * @internal\n */\nfunction animateTarget(visualElement, definition, _a) {\n    var _b;\n    var _c = _a === void 0 ? {} : _a, _d = _c.delay, delay = _d === void 0 ? 0 : _d, transitionOverride = _c.transitionOverride, type = _c.type;\n    var _e = visualElement.makeTargetAnimatable(definition), _f = _e.transition, transition = _f === void 0 ? visualElement.getDefaultTransition() : _f, transitionEnd = _e.transitionEnd, target = tslib.__rest(_e, [\"transition\", \"transitionEnd\"]);\n    if (transitionOverride)\n        transition = transitionOverride;\n    var animations = [];\n    var animationTypeState = type && ((_b = visualElement.animationState) === null || _b === void 0 ? void 0 : _b.getState()[type]);\n    for (var key in target) {\n        var value = visualElement.getValue(key);\n        var valueTarget = target[key];\n        if (!value ||\n            valueTarget === undefined ||\n            (animationTypeState &&\n                shouldBlockAnimation(animationTypeState, key))) {\n            continue;\n        }\n        var valueTransition = tslib.__assign({ delay: delay }, transition);\n        /**\n         * Make animation instant if this is a transform prop and we should reduce motion.\n         */\n        if (visualElement.shouldReduceMotion && isTransformProp(key)) {\n            valueTransition = tslib.__assign(tslib.__assign({}, valueTransition), { type: false, delay: 0 });\n        }\n        var animation = startAnimation(key, value, valueTarget, valueTransition);\n        animations.push(animation);\n    }\n    return Promise.all(animations).then(function () {\n        transitionEnd && setTarget(visualElement, transitionEnd);\n    });\n}\nfunction animateChildren(visualElement, variant, delayChildren, staggerChildren, staggerDirection, options) {\n    if (delayChildren === void 0) { delayChildren = 0; }\n    if (staggerChildren === void 0) { staggerChildren = 0; }\n    if (staggerDirection === void 0) { staggerDirection = 1; }\n    var animations = [];\n    var maxStaggerDuration = (visualElement.variantChildren.size - 1) * staggerChildren;\n    var generateStaggerDuration = staggerDirection === 1\n        ? function (i) {\n            if (i === void 0) { i = 0; }\n            return i * staggerChildren;\n        }\n        : function (i) {\n            if (i === void 0) { i = 0; }\n            return maxStaggerDuration - i * staggerChildren;\n        };\n    Array.from(visualElement.variantChildren)\n        .sort(sortByTreeOrder)\n        .forEach(function (child, i) {\n        animations.push(animateVariant(child, variant, tslib.__assign(tslib.__assign({}, options), { delay: delayChildren + generateStaggerDuration(i) })).then(function () { return child.notifyAnimationComplete(variant); }));\n    });\n    return Promise.all(animations);\n}\nfunction stopAnimation(visualElement) {\n    visualElement.forEachValue(function (value) { return value.stop(); });\n}\nfunction sortByTreeOrder(a, b) {\n    return a.sortNodePosition(b);\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(_a, key) {\n    var protectedKeys = _a.protectedKeys, needsAnimating = _a.needsAnimating;\n    var shouldBlock = protectedKeys.hasOwnProperty(key) && needsAnimating[key] !== true;\n    needsAnimating[key] = false;\n    return shouldBlock;\n}\n\nvar variantPriorityOrder = [\n    exports.AnimationType.Animate,\n    exports.AnimationType.InView,\n    exports.AnimationType.Focus,\n    exports.AnimationType.Hover,\n    exports.AnimationType.Tap,\n    exports.AnimationType.Drag,\n    exports.AnimationType.Exit,\n];\nvar reversePriorityOrder = tslib.__spreadArray([], tslib.__read(variantPriorityOrder), false).reverse();\nvar numAnimationTypes = variantPriorityOrder.length;\nfunction animateList(visualElement) {\n    return function (animations) {\n        return Promise.all(animations.map(function (_a) {\n            var animation = _a.animation, options = _a.options;\n            return animateVisualElement(visualElement, animation, options);\n        }));\n    };\n}\nfunction createAnimationState(visualElement) {\n    var animate = animateList(visualElement);\n    var state = createState();\n    var allAnimatedKeys = {};\n    var 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    var buildResolvedTypeValues = function (acc, definition) {\n        var resolved = resolveVariant(visualElement, definition);\n        if (resolved) {\n            resolved.transition; var transitionEnd = resolved.transitionEnd, target = tslib.__rest(resolved, [\"transition\", \"transitionEnd\"]);\n            acc = tslib.__assign(tslib.__assign(tslib.__assign({}, acc), target), transitionEnd);\n        }\n        return acc;\n    };\n    function isAnimated(key) {\n        return allAnimatedKeys[key] !== undefined;\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(options, changedActiveType) {\n        var _a;\n        var props = visualElement.getProps();\n        var context = visualElement.getVariantContext(true) || {};\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        var 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        var 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        var 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        var removedVariantIndex = Infinity;\n        var _loop_1 = function (i) {\n            var type = reversePriorityOrder[i];\n            var typeState = state[type];\n            var prop = (_a = props[type]) !== null && _a !== void 0 ? _a : context[type];\n            var 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            var 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            var isInherited = prop === context[type] && prop !== props[type] && 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 = tslib.__assign({}, 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                return \"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            var variantDidChange = checkVariantsDidChange(typeState.prevProp, prop);\n            var 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            /**\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            var 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            var resolvedValues = definitionList.reduce(buildResolvedTypeValues, {});\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            var _b = typeState.prevResolvedValues, prevResolvedValues = _b === void 0 ? {} : _b;\n            var allKeys = tslib.__assign(tslib.__assign({}, prevResolvedValues), resolvedValues);\n            var markToAnimate = function (key) {\n                shouldAnimateType = true;\n                removedKeys.delete(key);\n                typeState.needsAnimating[key] = true;\n            };\n            for (var key in allKeys) {\n                var next = resolvedValues[key];\n                var 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                if (next !== prev) {\n                    /**\n                     * If both values are keyframes, we need to shallow compare them to\n                     * detect whether any value has changed. If it has, we animate it.\n                     */\n                    if (isKeyframesTarget(next) && isKeyframesTarget(prev)) {\n                        if (!shallowCompare(next, prev) || variantDidChange) {\n                            markToAnimate(key);\n                        }\n                        else {\n                            /**\n                             * If it hasn't changed, we want to ensure it doesn't animate by\n                             * adding it to the list of protected keys.\n                             */\n                            typeState.protectedKeys[key] = true;\n                        }\n                    }\n                    else if (next !== undefined) {\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 = tslib.__assign(tslib.__assign({}, encounteredKeys), resolvedValues);\n            }\n            if (isInitialRender && visualElement.blockInitialAnimation) {\n                shouldAnimateType = false;\n            }\n            /**\n             * If this is an inherited prop we want to hard-block animations\n             * TODO: Test as this should probably still handle animations triggered\n             * by removed values?\n             */\n            if (shouldAnimateType && !isInherited) {\n                animations.push.apply(animations, tslib.__spreadArray([], tslib.__read(definitionList.map(function (animation) { return ({\n                    animation: animation,\n                    options: tslib.__assign({ type: type }, options),\n                }); })), false));\n            }\n        };\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 (var i = 0; i < numAnimationTypes; i++) {\n            _loop_1(i);\n        }\n        allAnimatedKeys = tslib.__assign({}, encounteredKeys);\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            var fallbackAnimation_1 = {};\n            removedKeys.forEach(function (key) {\n                var fallbackTarget = visualElement.getBaseTarget(key);\n                if (fallbackTarget !== undefined) {\n                    fallbackAnimation_1[key] = fallbackTarget;\n                }\n            });\n            animations.push({ animation: fallbackAnimation_1 });\n        }\n        var shouldAnimate = Boolean(animations.length);\n        if (isInitialRender &&\n            props.initial === false &&\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, options) {\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(function (child) { var _a; return (_a = child.animationState) === null || _a === void 0 ? void 0 : _a.setActive(type, isActive); });\n        state[type].isActive = isActive;\n        var animations = animateChanges(options, type);\n        for (var key in state) {\n            state[key].protectedKeys = {};\n        }\n        return animations;\n    }\n    return {\n        isAnimated: isAnimated,\n        animateChanges: animateChanges,\n        setActive: setActive,\n        setAnimateFunction: setAnimateFunction,\n        getState: function () { return state; },\n    };\n}\nfunction checkVariantsDidChange(prev, next) {\n    if (typeof next === \"string\") {\n        return next !== prev;\n    }\n    else if (isVariantLabels(next)) {\n        return !shallowCompare(next, prev);\n    }\n    return false;\n}\nfunction createTypeState(isActive) {\n    if (isActive === void 0) { isActive = false; }\n    return {\n        isActive: isActive,\n        protectedKeys: {},\n        needsAnimating: {},\n        prevResolvedValues: {},\n    };\n}\nfunction createState() {\n    var _a;\n    return _a = {},\n        _a[exports.AnimationType.Animate] = createTypeState(true),\n        _a[exports.AnimationType.InView] = createTypeState(),\n        _a[exports.AnimationType.Hover] = createTypeState(),\n        _a[exports.AnimationType.Tap] = createTypeState(),\n        _a[exports.AnimationType.Drag] = createTypeState(),\n        _a[exports.AnimationType.Focus] = createTypeState(),\n        _a[exports.AnimationType.Exit] = createTypeState(),\n        _a;\n}\n\nvar animations = {\n    animation: makeRenderlessComponent(function (_a) {\n        var visualElement = _a.visualElement, animate = _a.animate;\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        visualElement.animationState || (visualElement.animationState = createAnimationState(visualElement));\n        /**\n         * Subscribe any provided AnimationControls to the component's VisualElement\n         */\n        if (isAnimationControls(animate)) {\n            React.useEffect(function () { return animate.subscribe(visualElement); }, [animate]);\n        }\n    }),\n    exit: makeRenderlessComponent(function (props) {\n        var custom = props.custom, visualElement = props.visualElement;\n        var _a = tslib.__read(usePresence(), 2), isPresent = _a[0], safeToRemove = _a[1];\n        var presenceContext = React.useContext(PresenceContext);\n        React.useEffect(function () {\n            var _a, _b;\n            visualElement.isPresent = isPresent;\n            var animation = (_a = visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(exports.AnimationType.Exit, !isPresent, { custom: (_b = presenceContext === null || presenceContext === void 0 ? void 0 : presenceContext.custom) !== null && _b !== void 0 ? _b : custom });\n            !isPresent && (animation === null || animation === void 0 ? void 0 : animation.then(safeToRemove));\n        }, [isPresent]);\n    }),\n};\n\n/**\n * @internal\n */\nvar PanSession = /** @class */ (function () {\n    function PanSession(event, handlers, _a) {\n        var _this = this;\n        var _b = _a === void 0 ? {} : _a, transformPagePoint = _b.transformPagePoint;\n        /**\n         * @internal\n         */\n        this.startEvent = null;\n        /**\n         * @internal\n         */\n        this.lastMoveEvent = null;\n        /**\n         * @internal\n         */\n        this.lastMoveEventInfo = null;\n        /**\n         * @internal\n         */\n        this.handlers = {};\n        this.updatePoint = function () {\n            if (!(_this.lastMoveEvent && _this.lastMoveEventInfo))\n                return;\n            var info = getPanInfo(_this.lastMoveEventInfo, _this.history);\n            var isPanStarted = _this.startEvent !== null;\n            // Only start panning if the offset is larger than 3 pixels. If we make it\n            // any larger than this we'll want to reset the pointer history\n            // on the first update to avoid visual snapping to the cursoe.\n            var isDistancePastThreshold = popmotion.distance(info.offset, { x: 0, y: 0 }) >= 3;\n            if (!isPanStarted && !isDistancePastThreshold)\n                return;\n            var point = info.point;\n            var timestamp = sync.getFrameData().timestamp;\n            _this.history.push(tslib.__assign(tslib.__assign({}, point), { timestamp: timestamp }));\n            var _a = _this.handlers, onStart = _a.onStart, onMove = _a.onMove;\n            if (!isPanStarted) {\n                onStart && onStart(_this.lastMoveEvent, info);\n                _this.startEvent = _this.lastMoveEvent;\n            }\n            onMove && onMove(_this.lastMoveEvent, info);\n        };\n        this.handlePointerMove = function (event, info) {\n            _this.lastMoveEvent = event;\n            _this.lastMoveEventInfo = transformPoint(info, _this.transformPagePoint);\n            // Because Safari doesn't trigger mouseup events when it's above a `<select>`\n            if (isMouseEvent(event) && event.buttons === 0) {\n                _this.handlePointerUp(event, info);\n                return;\n            }\n            // Throttle mouse move event to once per frame\n            sync__default[\"default\"].update(_this.updatePoint, true);\n        };\n        this.handlePointerUp = function (event, info) {\n            _this.end();\n            var _a = _this.handlers, onEnd = _a.onEnd, onSessionEnd = _a.onSessionEnd;\n            var panInfo = getPanInfo(transformPoint(info, _this.transformPagePoint), _this.history);\n            if (_this.startEvent && onEnd) {\n                onEnd(event, panInfo);\n            }\n            onSessionEnd && onSessionEnd(event, panInfo);\n        };\n        // If we have more than one touch, don't start detecting this gesture\n        if (isTouchEvent(event) && event.touches.length > 1)\n            return;\n        this.handlers = handlers;\n        this.transformPagePoint = transformPagePoint;\n        var info = extractEventInfo(event);\n        var initialInfo = transformPoint(info, this.transformPagePoint);\n        var point = initialInfo.point;\n        var timestamp = sync.getFrameData().timestamp;\n        this.history = [tslib.__assign(tslib.__assign({}, point), { timestamp: timestamp })];\n        var onSessionStart = handlers.onSessionStart;\n        onSessionStart &&\n            onSessionStart(event, getPanInfo(initialInfo, this.history));\n        this.removeListeners = popmotion.pipe(addPointerEvent(window, \"pointermove\", this.handlePointerMove), addPointerEvent(window, \"pointerup\", this.handlePointerUp), addPointerEvent(window, \"pointercancel\", this.handlePointerUp));\n    }\n    PanSession.prototype.updateHandlers = function (handlers) {\n        this.handlers = handlers;\n    };\n    PanSession.prototype.end = function () {\n        this.removeListeners && this.removeListeners();\n        sync.cancelSync.update(this.updatePoint);\n    };\n    return PanSession;\n}());\nfunction transformPoint(info, transformPagePoint) {\n    return transformPagePoint ? { point: transformPagePoint(info.point) } : info;\n}\nfunction subtractPoint(a, b) {\n    return { x: a.x - b.x, y: a.y - b.y };\n}\nfunction getPanInfo(_a, history) {\n    var point = _a.point;\n    return {\n        point: point,\n        delta: subtractPoint(point, lastDevicePoint(history)),\n        offset: subtractPoint(point, startDevicePoint(history)),\n        velocity: getVelocity(history, 0.1),\n    };\n}\nfunction startDevicePoint(history) {\n    return history[0];\n}\nfunction lastDevicePoint(history) {\n    return history[history.length - 1];\n}\nfunction getVelocity(history, timeDelta) {\n    if (history.length < 2) {\n        return { x: 0, y: 0 };\n    }\n    var i = history.length - 1;\n    var timestampedPoint = null;\n    var lastPoint = lastDevicePoint(history);\n    while (i >= 0) {\n        timestampedPoint = history[i];\n        if (lastPoint.timestamp - timestampedPoint.timestamp >\n            secondsToMilliseconds(timeDelta)) {\n            break;\n        }\n        i--;\n    }\n    if (!timestampedPoint) {\n        return { x: 0, y: 0 };\n    }\n    var time = (lastPoint.timestamp - timestampedPoint.timestamp) / 1000;\n    if (time === 0) {\n        return { x: 0, y: 0 };\n    }\n    var currentVelocity = {\n        x: (lastPoint.x - timestampedPoint.x) / time,\n        y: (lastPoint.y - timestampedPoint.y) / time,\n    };\n    if (currentVelocity.x === Infinity) {\n        currentVelocity.x = 0;\n    }\n    if (currentVelocity.y === Infinity) {\n        currentVelocity.y = 0;\n    }\n    return currentVelocity;\n}\n\nfunction calcLength(axis) {\n    return axis.max - axis.min;\n}\nfunction isNear(value, target, maxDistance) {\n    if (target === void 0) { target = 0; }\n    if (maxDistance === void 0) { maxDistance = 0.01; }\n    return popmotion.distance(value, target) < maxDistance;\n}\nfunction calcAxisDelta(delta, source, target, origin) {\n    if (origin === void 0) { origin = 0.5; }\n    delta.origin = origin;\n    delta.originPoint = popmotion.mix(source.min, source.max, delta.origin);\n    delta.scale = calcLength(target) / calcLength(source);\n    if (isNear(delta.scale, 1, 0.0001) || isNaN(delta.scale))\n        delta.scale = 1;\n    delta.translate =\n        popmotion.mix(target.min, target.max, delta.origin) - delta.originPoint;\n    if (isNear(delta.translate) || isNaN(delta.translate))\n        delta.translate = 0;\n}\nfunction calcBoxDelta(delta, source, target, origin) {\n    calcAxisDelta(delta.x, source.x, target.x, origin === null || origin === void 0 ? void 0 : origin.originX);\n    calcAxisDelta(delta.y, source.y, target.y, origin === null || origin === void 0 ? void 0 : origin.originY);\n}\nfunction calcRelativeAxis(target, relative, parent) {\n    target.min = parent.min + relative.min;\n    target.max = target.min + calcLength(relative);\n}\nfunction calcRelativeBox(target, relative, parent) {\n    calcRelativeAxis(target.x, relative.x, parent.x);\n    calcRelativeAxis(target.y, relative.y, parent.y);\n}\nfunction calcRelativeAxisPosition(target, layout, parent) {\n    target.min = layout.min - parent.min;\n    target.max = target.min + calcLength(layout);\n}\nfunction calcRelativePosition(target, layout, parent) {\n    calcRelativeAxisPosition(target.x, layout.x, parent.x);\n    calcRelativeAxisPosition(target.y, layout.y, parent.y);\n}\n\n/**\n * Apply constraints to a point. These constraints are both physical along an\n * axis, and an elastic factor that determines how much to constrain the point\n * by if it does lie outside the defined parameters.\n */\nfunction applyConstraints(point, _a, elastic) {\n    var min = _a.min, max = _a.max;\n    if (min !== undefined && point < min) {\n        // If we have a min point defined, and this is outside of that, constrain\n        point = elastic ? popmotion.mix(min, point, elastic.min) : Math.max(point, min);\n    }\n    else if (max !== undefined && point > max) {\n        // If we have a max point defined, and this is outside of that, constrain\n        point = elastic ? popmotion.mix(max, point, elastic.max) : Math.min(point, max);\n    }\n    return point;\n}\n/**\n * Calculate constraints in terms of the viewport when defined relatively to the\n * measured axis. This is measured from the nearest edge, so a max constraint of 200\n * on an axis with a max value of 300 would return a constraint of 500 - axis length\n */\nfunction calcRelativeAxisConstraints(axis, min, max) {\n    return {\n        min: min !== undefined ? axis.min + min : undefined,\n        max: max !== undefined\n            ? axis.max + max - (axis.max - axis.min)\n            : undefined,\n    };\n}\n/**\n * Calculate constraints in terms of the viewport when\n * defined relatively to the measured bounding box.\n */\nfunction calcRelativeConstraints(layoutBox, _a) {\n    var top = _a.top, left = _a.left, bottom = _a.bottom, right = _a.right;\n    return {\n        x: calcRelativeAxisConstraints(layoutBox.x, left, right),\n        y: calcRelativeAxisConstraints(layoutBox.y, top, bottom),\n    };\n}\n/**\n * Calculate viewport constraints when defined as another viewport-relative axis\n */\nfunction calcViewportAxisConstraints(layoutAxis, constraintsAxis) {\n    var _a;\n    var min = constraintsAxis.min - layoutAxis.min;\n    var max = constraintsAxis.max - layoutAxis.max;\n    // If the constraints axis is actually smaller than the layout axis then we can\n    // flip the constraints\n    if (constraintsAxis.max - constraintsAxis.min <\n        layoutAxis.max - layoutAxis.min) {\n        _a = tslib.__read([max, min], 2), min = _a[0], max = _a[1];\n    }\n    return { min: min, max: max };\n}\n/**\n * Calculate viewport constraints when defined as another viewport-relative box\n */\nfunction calcViewportConstraints(layoutBox, constraintsBox) {\n    return {\n        x: calcViewportAxisConstraints(layoutBox.x, constraintsBox.x),\n        y: calcViewportAxisConstraints(layoutBox.y, constraintsBox.y),\n    };\n}\n/**\n * Calculate a transform origin relative to the source axis, between 0-1, that results\n * in an asthetically pleasing scale/transform needed to project from source to target.\n */\nfunction calcOrigin(source, target) {\n    var origin = 0.5;\n    var sourceLength = calcLength(source);\n    var targetLength = calcLength(target);\n    if (targetLength > sourceLength) {\n        origin = popmotion.progress(target.min, target.max - sourceLength, source.min);\n    }\n    else if (sourceLength > targetLength) {\n        origin = popmotion.progress(source.min, source.max - targetLength, target.min);\n    }\n    return popmotion.clamp(0, 1, origin);\n}\n/**\n * Rebase the calculated viewport constraints relative to the layout.min point.\n */\nfunction rebaseAxisConstraints(layout, constraints) {\n    var relativeConstraints = {};\n    if (constraints.min !== undefined) {\n        relativeConstraints.min = constraints.min - layout.min;\n    }\n    if (constraints.max !== undefined) {\n        relativeConstraints.max = constraints.max - layout.min;\n    }\n    return relativeConstraints;\n}\nvar defaultElastic = 0.35;\n/**\n * Accepts a dragElastic prop and returns resolved elastic values for each axis.\n */\nfunction resolveDragElastic(dragElastic) {\n    if (dragElastic === void 0) { dragElastic = defaultElastic; }\n    if (dragElastic === false) {\n        dragElastic = 0;\n    }\n    else if (dragElastic === true) {\n        dragElastic = defaultElastic;\n    }\n    return {\n        x: resolveAxisElastic(dragElastic, \"left\", \"right\"),\n        y: resolveAxisElastic(dragElastic, \"top\", \"bottom\"),\n    };\n}\nfunction resolveAxisElastic(dragElastic, minLabel, maxLabel) {\n    return {\n        min: resolvePointElastic(dragElastic, minLabel),\n        max: resolvePointElastic(dragElastic, maxLabel),\n    };\n}\nfunction resolvePointElastic(dragElastic, label) {\n    var _a;\n    return typeof dragElastic === \"number\"\n        ? dragElastic\n        : (_a = dragElastic[label]) !== null && _a !== void 0 ? _a : 0;\n}\n\nvar createAxisDelta = function () { return ({\n    translate: 0,\n    scale: 1,\n    origin: 0,\n    originPoint: 0,\n}); };\nvar createDelta = function () { return ({\n    x: createAxisDelta(),\n    y: createAxisDelta(),\n}); };\nvar createAxis = function () { return ({ min: 0, max: 0 }); };\nvar createBox = function () { return ({\n    x: createAxis(),\n    y: createAxis(),\n}); };\n\nfunction eachAxis(callback) {\n    return [callback(\"x\"), callback(\"y\")];\n}\n\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(_a) {\n    var top = _a.top, left = _a.left, right = _a.right, bottom = _a.bottom;\n    return {\n        x: { min: left, max: right },\n        y: { min: top, max: bottom },\n    };\n}\nfunction convertBoxToBoundingBox(_a) {\n    var x = _a.x, y = _a.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    var topLeft = transformPoint({ x: point.left, y: point.top });\n    var 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\nfunction isIdentityScale(scale) {\n    return scale === undefined || scale === 1;\n}\nfunction hasScale(_a) {\n    var scale = _a.scale, scaleX = _a.scaleX, scaleY = _a.scaleY;\n    return (!isIdentityScale(scale) ||\n        !isIdentityScale(scaleX) ||\n        !isIdentityScale(scaleY));\n}\nfunction hasTransform(values) {\n    return (hasScale(values) ||\n        hasTranslate(values.x) ||\n        hasTranslate(values.y) ||\n        values.z ||\n        values.rotate ||\n        values.rotateX ||\n        values.rotateY);\n}\nfunction hasTranslate(value) {\n    return value && value !== \"0%\";\n}\n\n/**\n * Scales a point based on a factor and an originPoint\n */\nfunction scalePoint(point, scale, originPoint) {\n    var distanceFromOrigin = point - originPoint;\n    var 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, scale, originPoint, boxScale) {\n    if (translate === void 0) { translate = 0; }\n    if (scale === void 0) { scale = 1; }\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, _a) {\n    var x = _a.x, y = _a.y;\n    applyAxisDelta(box.x, x.translate, x.scale, x.originPoint);\n    applyAxisDelta(box.y, y.translate, y.scale, y.originPoint);\n}\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) {\n    var _a, _b;\n    if (isSharedTransition === void 0) { isSharedTransition = false; }\n    var treeLength = treePath.length;\n    if (!treeLength)\n        return;\n    // Reset the treeScale\n    treeScale.x = treeScale.y = 1;\n    var node;\n    var delta;\n    for (var i = 0; i < treeLength; i++) {\n        node = treePath[i];\n        delta = node.projectionDelta;\n        if (((_b = (_a = node.instance) === null || _a === void 0 ? void 0 : _a.style) === null || _b === void 0 ? void 0 : _b.display) === \"contents\")\n            continue;\n        if (isSharedTransition &&\n            node.options.layoutScroll &&\n            node.scroll &&\n            node !== node.root) {\n            transformBox(box, { x: -node.scroll.x, y: -node.scroll.y });\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}\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, transforms, _a) {\n    var _b = tslib.__read(_a, 3), key = _b[0], scaleKey = _b[1], originKey = _b[2];\n    var axisOrigin = transforms[originKey] !== undefined ? transforms[originKey] : 0.5;\n    var originPoint = popmotion.mix(axis.min, axis.max, axisOrigin);\n    // Apply the axis delta to the final axis\n    applyAxisDelta(axis, transforms[key], transforms[scaleKey], originPoint, transforms.scale);\n}\n/**\n * The names of the motion values we want to apply as translation, scale and origin.\n */\nvar xKeys$1 = [\"x\", \"scaleX\", \"originX\"];\nvar yKeys$1 = [\"y\", \"scaleY\", \"originY\"];\n/**\n * Apply a transform to a box from the latest resolved motion values.\n */\nfunction transformBox(box, transform) {\n    transformAxis(box.x, transform, xKeys$1);\n    transformAxis(box.y, transform, yKeys$1);\n}\n\nfunction measureViewportBox(instance, transformPoint) {\n    return convertBoundingBoxToBox(transformBoxPoints(instance.getBoundingClientRect(), transformPoint));\n}\nfunction measurePageBox(element, rootProjectionNode, transformPagePoint) {\n    var viewportBox = measureViewportBox(element, transformPagePoint);\n    var scroll = rootProjectionNode.scroll;\n    if (scroll) {\n        translateAxis(viewportBox.x, scroll.x);\n        translateAxis(viewportBox.y, scroll.y);\n    }\n    return viewportBox;\n}\n\nvar elementDragControls = new WeakMap();\n/**\n *\n */\n// let latestPointerEvent: AnyPointerEvent\nvar VisualElementDragControls = /** @class */ (function () {\n    function VisualElementDragControls(visualElement) {\n        // This is a reference to the global drag gesture lock, ensuring only one component\n        // can \"capture\" the drag of one or both axes.\n        // TODO: Look into moving this into pansession?\n        this.openGlobalLock = null;\n        this.isDragging = false;\n        this.currentDirection = null;\n        this.originPoint = { x: 0, y: 0 };\n        /**\n         * The permitted boundaries of travel, in pixels.\n         */\n        this.constraints = false;\n        this.hasMutatedConstraints = false;\n        /**\n         * The per-axis resolved elastic values.\n         */\n        this.elastic = createBox();\n        this.visualElement = visualElement;\n    }\n    VisualElementDragControls.prototype.start = function (originEvent, _a) {\n        var _this = this;\n        var _b = _a === void 0 ? {} : _a, _c = _b.snapToCursor, snapToCursor = _c === void 0 ? false : _c;\n        /**\n         * Don't start dragging if this component is exiting\n         */\n        if (this.visualElement.isPresent === false)\n            return;\n        var onSessionStart = function (event) {\n            // Stop any animations on both axis values immediately. This allows the user to throw and catch\n            // the component.\n            _this.stopAnimation();\n            if (snapToCursor) {\n                _this.snapToCursor(extractEventInfo(event, \"page\").point);\n            }\n        };\n        var onStart = function (event, info) {\n            var _a;\n            // Attempt to grab the global drag gesture lock - maybe make this part of PanSession\n            var _b = _this.getProps(), drag = _b.drag, dragPropagation = _b.dragPropagation, onDragStart = _b.onDragStart;\n            if (drag && !dragPropagation) {\n                if (_this.openGlobalLock)\n                    _this.openGlobalLock();\n                _this.openGlobalLock = getGlobalLock(drag);\n                // If we don 't have the lock, don't start dragging\n                if (!_this.openGlobalLock)\n                    return;\n            }\n            _this.isDragging = true;\n            _this.currentDirection = null;\n            _this.resolveConstraints();\n            if (_this.visualElement.projection) {\n                _this.visualElement.projection.isAnimationBlocked = true;\n                _this.visualElement.projection.target = undefined;\n            }\n            /**\n             * Record gesture origin\n             */\n            eachAxis(function (axis) {\n                var _a, _b;\n                var current = _this.getAxisMotionValue(axis).get() || 0;\n                /**\n                 * If the MotionValue is a percentage value convert to px\n                 */\n                if (styleValueTypes.percent.test(current)) {\n                    var measuredAxis = (_b = (_a = _this.visualElement.projection) === null || _a === void 0 ? void 0 : _a.layout) === null || _b === void 0 ? void 0 : _b.actual[axis];\n                    if (measuredAxis) {\n                        var length_1 = calcLength(measuredAxis);\n                        current = length_1 * (parseFloat(current) / 100);\n                    }\n                }\n                _this.originPoint[axis] = current;\n            });\n            // Fire onDragStart event\n            onDragStart === null || onDragStart === void 0 ? void 0 : onDragStart(event, info);\n            (_a = _this.visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(exports.AnimationType.Drag, true);\n        };\n        var onMove = function (event, info) {\n            // latestPointerEvent = event\n            var _a = _this.getProps(), dragPropagation = _a.dragPropagation, dragDirectionLock = _a.dragDirectionLock, onDirectionLock = _a.onDirectionLock, onDrag = _a.onDrag;\n            // If we didn't successfully receive the gesture lock, early return.\n            if (!dragPropagation && !_this.openGlobalLock)\n                return;\n            var offset = info.offset;\n            // Attempt to detect drag direction if directionLock is true\n            if (dragDirectionLock && _this.currentDirection === null) {\n                _this.currentDirection = getCurrentDirection(offset);\n                // If we've successfully set a direction, notify listener\n                if (_this.currentDirection !== null) {\n                    onDirectionLock === null || onDirectionLock === void 0 ? void 0 : onDirectionLock(_this.currentDirection);\n                }\n                return;\n            }\n            // Update each point with the latest position\n            _this.updateAxis(\"x\", info.point, offset);\n            _this.updateAxis(\"y\", info.point, offset);\n            /**\n             * Ideally we would leave the renderer to fire naturally at the end of\n             * this frame but if the element is about to change layout as the result\n             * of a re-render we want to ensure the browser can read the latest\n             * bounding box to ensure the pointer and element don't fall out of sync.\n             */\n            _this.visualElement.syncRender();\n            /**\n             * This must fire after the syncRender call as it might trigger a state\n             * change which itself might trigger a layout update.\n             */\n            onDrag === null || onDrag === void 0 ? void 0 : onDrag(event, info);\n        };\n        var onSessionEnd = function (event, info) {\n            return _this.stop(event, info);\n        };\n        this.panSession = new PanSession(originEvent, {\n            onSessionStart: onSessionStart,\n            onStart: onStart,\n            onMove: onMove,\n            onSessionEnd: onSessionEnd,\n        }, { transformPagePoint: this.visualElement.getTransformPagePoint() });\n    };\n    VisualElementDragControls.prototype.stop = function (event, info) {\n        var isDragging = this.isDragging;\n        this.cancel();\n        if (!isDragging)\n            return;\n        var velocity = info.velocity;\n        this.startAnimation(velocity);\n        var onDragEnd = this.getProps().onDragEnd;\n        onDragEnd === null || onDragEnd === void 0 ? void 0 : onDragEnd(event, info);\n    };\n    VisualElementDragControls.prototype.cancel = function () {\n        var _a, _b;\n        this.isDragging = false;\n        if (this.visualElement.projection) {\n            this.visualElement.projection.isAnimationBlocked = false;\n        }\n        (_a = this.panSession) === null || _a === void 0 ? void 0 : _a.end();\n        this.panSession = undefined;\n        var dragPropagation = this.getProps().dragPropagation;\n        if (!dragPropagation && this.openGlobalLock) {\n            this.openGlobalLock();\n            this.openGlobalLock = null;\n        }\n        (_b = this.visualElement.animationState) === null || _b === void 0 ? void 0 : _b.setActive(exports.AnimationType.Drag, false);\n    };\n    VisualElementDragControls.prototype.updateAxis = function (axis, _point, offset) {\n        var drag = this.getProps().drag;\n        // If we're not dragging this axis, do an early return.\n        if (!offset || !shouldDrag(axis, drag, this.currentDirection))\n            return;\n        var axisValue = this.getAxisMotionValue(axis);\n        var next = this.originPoint[axis] + offset[axis];\n        // Apply constraints\n        if (this.constraints && this.constraints[axis]) {\n            next = applyConstraints(next, this.constraints[axis], this.elastic[axis]);\n        }\n        axisValue.set(next);\n    };\n    VisualElementDragControls.prototype.resolveConstraints = function () {\n        var _this = this;\n        var _a = this.getProps(), dragConstraints = _a.dragConstraints, dragElastic = _a.dragElastic;\n        var layout = (this.visualElement.projection || {}).layout;\n        var prevConstraints = this.constraints;\n        if (dragConstraints && isRefObject(dragConstraints)) {\n            if (!this.constraints) {\n                this.constraints = this.resolveRefConstraints();\n            }\n        }\n        else {\n            if (dragConstraints && layout) {\n                this.constraints = calcRelativeConstraints(layout.actual, dragConstraints);\n            }\n            else {\n                this.constraints = false;\n            }\n        }\n        this.elastic = resolveDragElastic(dragElastic);\n        /**\n         * If we're outputting to external MotionValues, we want to rebase the measured constraints\n         * from viewport-relative to component-relative.\n         */\n        if (prevConstraints !== this.constraints &&\n            layout &&\n            this.constraints &&\n            !this.hasMutatedConstraints) {\n            eachAxis(function (axis) {\n                if (_this.getAxisMotionValue(axis)) {\n                    _this.constraints[axis] = rebaseAxisConstraints(layout.actual[axis], _this.constraints[axis]);\n                }\n            });\n        }\n    };\n    VisualElementDragControls.prototype.resolveRefConstraints = function () {\n        var _a = this.getProps(), constraints = _a.dragConstraints, onMeasureDragConstraints = _a.onMeasureDragConstraints;\n        if (!constraints || !isRefObject(constraints))\n            return false;\n        var constraintsElement = constraints.current;\n        heyListen.invariant(constraintsElement !== null, \"If `dragConstraints` is set as a React ref, that ref must be passed to another component's `ref` prop.\");\n        var projection = this.visualElement.projection;\n        // TODO\n        if (!projection || !projection.layout)\n            return false;\n        var constraintsBox = measurePageBox(constraintsElement, projection.root, this.visualElement.getTransformPagePoint());\n        var measuredConstraints = calcViewportConstraints(projection.layout.actual, constraintsBox);\n        /**\n         * If there's an onMeasureDragConstraints listener we call it and\n         * if different constraints are returned, set constraints to that\n         */\n        if (onMeasureDragConstraints) {\n            var userConstraints = onMeasureDragConstraints(convertBoxToBoundingBox(measuredConstraints));\n            this.hasMutatedConstraints = !!userConstraints;\n            if (userConstraints) {\n                measuredConstraints = convertBoundingBoxToBox(userConstraints);\n            }\n        }\n        return measuredConstraints;\n    };\n    VisualElementDragControls.prototype.startAnimation = function (velocity) {\n        var _this = this;\n        var _a = this.getProps(), drag = _a.drag, dragMomentum = _a.dragMomentum, dragElastic = _a.dragElastic, dragTransition = _a.dragTransition, dragSnapToOrigin = _a.dragSnapToOrigin, onDragTransitionEnd = _a.onDragTransitionEnd;\n        var constraints = this.constraints || {};\n        var momentumAnimations = eachAxis(function (axis) {\n            var _a;\n            if (!shouldDrag(axis, drag, _this.currentDirection)) {\n                return;\n            }\n            var transition = (_a = constraints === null || constraints === void 0 ? void 0 : constraints[axis]) !== null && _a !== void 0 ? _a : {};\n            if (dragSnapToOrigin)\n                transition = { min: 0, max: 0 };\n            /**\n             * Overdamp the boundary spring if `dragElastic` is disabled. There's still a frame\n             * of spring animations so we should look into adding a disable spring option to `inertia`.\n             * We could do something here where we affect the `bounceStiffness` and `bounceDamping`\n             * using the value of `dragElastic`.\n             */\n            var bounceStiffness = dragElastic ? 200 : 1000000;\n            var bounceDamping = dragElastic ? 40 : 10000000;\n            var inertia = tslib.__assign(tslib.__assign({ type: \"inertia\", velocity: dragMomentum ? velocity[axis] : 0, bounceStiffness: bounceStiffness, bounceDamping: bounceDamping, timeConstant: 750, restDelta: 1, restSpeed: 10 }, dragTransition), transition);\n            // If we're not animating on an externally-provided `MotionValue` we can use the\n            // component's animation controls which will handle interactions with whileHover (etc),\n            // otherwise we just have to animate the `MotionValue` itself.\n            return _this.startAxisValueAnimation(axis, inertia);\n        });\n        // Run all animations and then resolve the new drag constraints.\n        return Promise.all(momentumAnimations).then(onDragTransitionEnd);\n    };\n    VisualElementDragControls.prototype.startAxisValueAnimation = function (axis, transition) {\n        var axisValue = this.getAxisMotionValue(axis);\n        return startAnimation(axis, axisValue, 0, transition);\n    };\n    VisualElementDragControls.prototype.stopAnimation = function () {\n        var _this = this;\n        eachAxis(function (axis) { return _this.getAxisMotionValue(axis).stop(); });\n    };\n    /**\n     * Drag works differently depending on which props are provided.\n     *\n     * - If _dragX and _dragY are provided, we output the gesture delta directly to those motion values.\n     * - Otherwise, we apply the delta to the x/y motion values.\n     */\n    VisualElementDragControls.prototype.getAxisMotionValue = function (axis) {\n        var _a, _b;\n        var dragKey = \"_drag\" + axis.toUpperCase();\n        var externalMotionValue = this.visualElement.getProps()[dragKey];\n        return externalMotionValue\n            ? externalMotionValue\n            : this.visualElement.getValue(axis, (_b = (_a = this.visualElement.getProps().initial) === null || _a === void 0 ? void 0 : _a[axis]) !== null && _b !== void 0 ? _b : 0);\n    };\n    VisualElementDragControls.prototype.snapToCursor = function (point) {\n        var _this = this;\n        eachAxis(function (axis) {\n            var drag = _this.getProps().drag;\n            // If we're not dragging this axis, do an early return.\n            if (!shouldDrag(axis, drag, _this.currentDirection))\n                return;\n            var projection = _this.visualElement.projection;\n            var axisValue = _this.getAxisMotionValue(axis);\n            if (projection && projection.layout) {\n                var _a = projection.layout.actual[axis], min = _a.min, max = _a.max;\n                axisValue.set(point[axis] - popmotion.mix(min, max, 0.5));\n            }\n        });\n    };\n    /**\n     * When the viewport resizes we want to check if the measured constraints\n     * have changed and, if so, reposition the element within those new constraints\n     * relative to where it was before the resize.\n     */\n    VisualElementDragControls.prototype.scalePositionWithinConstraints = function () {\n        var _this = this;\n        var _a;\n        var _b = this.getProps(), drag = _b.drag, dragConstraints = _b.dragConstraints;\n        var projection = this.visualElement.projection;\n        if (!isRefObject(dragConstraints) || !projection || !this.constraints)\n            return;\n        /**\n         * Stop current animations as there can be visual glitching if we try to do\n         * this mid-animation\n         */\n        this.stopAnimation();\n        /**\n         * Record the relative position of the dragged element relative to the\n         * constraints box and save as a progress value.\n         */\n        var boxProgress = { x: 0, y: 0 };\n        eachAxis(function (axis) {\n            var axisValue = _this.getAxisMotionValue(axis);\n            if (axisValue) {\n                var latest = axisValue.get();\n                boxProgress[axis] = calcOrigin({ min: latest, max: latest }, _this.constraints[axis]);\n            }\n        });\n        /**\n         * Update the layout of this element and resolve the latest drag constraints\n         */\n        var transformTemplate = this.visualElement.getProps().transformTemplate;\n        this.visualElement.getInstance().style.transform = transformTemplate\n            ? transformTemplate({}, \"\")\n            : \"none\";\n        (_a = projection.root) === null || _a === void 0 ? void 0 : _a.updateScroll();\n        projection.updateLayout();\n        this.resolveConstraints();\n        /**\n         * For each axis, calculate the current progress of the layout axis\n         * within the new constraints.\n         */\n        eachAxis(function (axis) {\n            if (!shouldDrag(axis, drag, null))\n                return;\n            /**\n             * Calculate a new transform based on the previous box progress\n             */\n            var axisValue = _this.getAxisMotionValue(axis);\n            var _a = _this.constraints[axis], min = _a.min, max = _a.max;\n            axisValue.set(popmotion.mix(min, max, boxProgress[axis]));\n        });\n    };\n    VisualElementDragControls.prototype.addListeners = function () {\n        var _this = this;\n        var _a;\n        elementDragControls.set(this.visualElement, this);\n        var element = this.visualElement.getInstance();\n        /**\n         * Attach a pointerdown event listener on this DOM element to initiate drag tracking.\n         */\n        var stopPointerListener = addPointerEvent(element, \"pointerdown\", function (event) {\n            var _a = _this.getProps(), drag = _a.drag, _b = _a.dragListener, dragListener = _b === void 0 ? true : _b;\n            drag && dragListener && _this.start(event);\n        });\n        var measureDragConstraints = function () {\n            var dragConstraints = _this.getProps().dragConstraints;\n            if (isRefObject(dragConstraints)) {\n                _this.constraints = _this.resolveRefConstraints();\n            }\n        };\n        var projection = this.visualElement.projection;\n        var stopMeasureLayoutListener = projection.addEventListener(\"measure\", measureDragConstraints);\n        if (projection && !projection.layout) {\n            (_a = projection.root) === null || _a === void 0 ? void 0 : _a.updateScroll();\n            projection.updateLayout();\n        }\n        measureDragConstraints();\n        /**\n         * Attach a window resize listener to scale the draggable target within its defined\n         * constraints as the window resizes.\n         */\n        var stopResizeListener = addDomEvent(window, \"resize\", function () {\n            return _this.scalePositionWithinConstraints();\n        });\n        /**\n         * If the element's layout changes, calculate the delta and apply that to\n         * the drag gesture's origin point.\n         */\n        projection.addEventListener(\"didUpdate\", (function (_a) {\n            var delta = _a.delta, hasLayoutChanged = _a.hasLayoutChanged;\n            if (_this.isDragging && hasLayoutChanged) {\n                eachAxis(function (axis) {\n                    var motionValue = _this.getAxisMotionValue(axis);\n                    if (!motionValue)\n                        return;\n                    _this.originPoint[axis] += delta[axis].translate;\n                    motionValue.set(motionValue.get() + delta[axis].translate);\n                });\n                _this.visualElement.syncRender();\n            }\n        }));\n        return function () {\n            stopResizeListener();\n            stopPointerListener();\n            stopMeasureLayoutListener();\n        };\n    };\n    VisualElementDragControls.prototype.getProps = function () {\n        var props = this.visualElement.getProps();\n        var _a = props.drag, drag = _a === void 0 ? false : _a, _b = props.dragDirectionLock, dragDirectionLock = _b === void 0 ? false : _b, _c = props.dragPropagation, dragPropagation = _c === void 0 ? false : _c, _d = props.dragConstraints, dragConstraints = _d === void 0 ? false : _d, _e = props.dragElastic, dragElastic = _e === void 0 ? defaultElastic : _e, _f = props.dragMomentum, dragMomentum = _f === void 0 ? true : _f;\n        return tslib.__assign(tslib.__assign({}, props), { drag: drag, dragDirectionLock: dragDirectionLock, dragPropagation: dragPropagation, dragConstraints: dragConstraints, dragElastic: dragElastic, dragMomentum: dragMomentum });\n    };\n    return VisualElementDragControls;\n}());\nfunction shouldDrag(direction, drag, currentDirection) {\n    return ((drag === true || drag === direction) &&\n        (currentDirection === null || currentDirection === direction));\n}\n/**\n * Based on an x/y offset determine the current drag direction. If both axis' offsets are lower\n * than the provided threshold, return `null`.\n *\n * @param offset - The x/y offset from origin.\n * @param lockThreshold - (Optional) - the minimum absolute offset before we can determine a drag direction.\n */\nfunction getCurrentDirection(offset, lockThreshold) {\n    if (lockThreshold === void 0) { lockThreshold = 10; }\n    var direction = null;\n    if (Math.abs(offset.y) > lockThreshold) {\n        direction = \"y\";\n    }\n    else if (Math.abs(offset.x) > lockThreshold) {\n        direction = \"x\";\n    }\n    return direction;\n}\n\n/**\n * A hook that allows an element to be dragged.\n *\n * @internal\n */\nfunction useDrag(props) {\n    var groupDragControls = props.dragControls, visualElement = props.visualElement;\n    var dragControls = useConstant(function () { return new VisualElementDragControls(visualElement); });\n    // If we've been provided a DragControls for manual control over the drag gesture,\n    // subscribe this component to it on mount.\n    React.useEffect(function () { return groupDragControls && groupDragControls.subscribe(dragControls); }, [dragControls, groupDragControls]);\n    // Apply the event listeners to the element\n    React.useEffect(function () { return dragControls.addListeners(); }, [dragControls]);\n}\n\n/**\n *\n * @param handlers -\n * @param ref -\n *\n * @privateRemarks\n * Currently this sets new pan gesture functions every render. The memo route has been explored\n * in the past but ultimately we're still creating new functions every render. An optimisation\n * to explore is creating the pan gestures and loading them into a `ref`.\n *\n * @internal\n */\nfunction usePanGesture(_a) {\n    var onPan = _a.onPan, onPanStart = _a.onPanStart, onPanEnd = _a.onPanEnd, onPanSessionStart = _a.onPanSessionStart, visualElement = _a.visualElement;\n    var hasPanEvents = onPan || onPanStart || onPanEnd || onPanSessionStart;\n    var panSession = React.useRef(null);\n    var transformPagePoint = React.useContext(MotionConfigContext).transformPagePoint;\n    var handlers = {\n        onSessionStart: onPanSessionStart,\n        onStart: onPanStart,\n        onMove: onPan,\n        onEnd: function (event, info) {\n            panSession.current = null;\n            onPanEnd && onPanEnd(event, info);\n        },\n    };\n    React.useEffect(function () {\n        if (panSession.current !== null) {\n            panSession.current.updateHandlers(handlers);\n        }\n    });\n    function onPointerDown(event) {\n        panSession.current = new PanSession(event, handlers, {\n            transformPagePoint: transformPagePoint,\n        });\n    }\n    usePointerEvent(visualElement, \"pointerdown\", hasPanEvents && onPointerDown);\n    useUnmountEffect(function () { return panSession.current && panSession.current.end(); });\n}\n\nvar drag = {\n    pan: makeRenderlessComponent(usePanGesture),\n    drag: makeRenderlessComponent(useDrag),\n};\n\nvar names = [\n    \"LayoutMeasure\",\n    \"BeforeLayoutMeasure\",\n    \"LayoutUpdate\",\n    \"ViewportBoxUpdate\",\n    \"Update\",\n    \"Render\",\n    \"AnimationComplete\",\n    \"LayoutAnimationComplete\",\n    \"AnimationStart\",\n    \"LayoutAnimationStart\",\n    \"SetAxisTarget\",\n    \"Unmount\",\n];\nfunction createLifecycles() {\n    var managers = names.map(function () { return new SubscriptionManager(); });\n    var propSubscriptions = {};\n    var lifecycles = {\n        clearAllListeners: function () { return managers.forEach(function (manager) { return manager.clear(); }); },\n        updatePropListeners: function (props) {\n            names.forEach(function (name) {\n                var _a;\n                var on = \"on\" + name;\n                var propListener = props[on];\n                // Unsubscribe existing subscription\n                (_a = propSubscriptions[name]) === null || _a === void 0 ? void 0 : _a.call(propSubscriptions);\n                // Add new subscription\n                if (propListener) {\n                    propSubscriptions[name] = lifecycles[on](propListener);\n                }\n            });\n        },\n    };\n    managers.forEach(function (manager, i) {\n        lifecycles[\"on\" + names[i]] = function (handler) { return manager.add(handler); };\n        lifecycles[\"notify\" + names[i]] = function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            return manager.notify.apply(manager, tslib.__spreadArray([], tslib.__read(args), false));\n        };\n    });\n    return lifecycles;\n}\n\nfunction updateMotionValuesFromProps(element, next, prev) {\n    var _a;\n    for (var key in next) {\n        var nextValue = next[key];\n        var 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 === \"6.5.1\", \"Attempting to mix Framer Motion versions \".concat(nextValue.version, \" with 6.5.1 may not work as expected.\"));\n            }\n        }\n        else if (isMotionValue(prevValue)) {\n            /**\n             * If we're swapping to a new motion value, create a new motion value\n             * from that\n             */\n            element.addValue(key, motionValue(nextValue));\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                var existingValue = element.getValue(key);\n                // TODO: Only update values that aren't being animated or even looked at\n                !existingValue.hasAnimated && existingValue.set(nextValue);\n            }\n            else {\n                element.addValue(key, motionValue((_a = element.getStaticValue(key)) !== null && _a !== void 0 ? _a : nextValue));\n            }\n        }\n    }\n    // Handle removed values\n    for (var key in prev) {\n        if (next[key] === undefined)\n            element.removeValue(key);\n    }\n    return next;\n}\n\nvar visualElement = function (_a) {\n    var _b = _a.treeType, treeType = _b === void 0 ? \"\" : _b, build = _a.build, getBaseTarget = _a.getBaseTarget, makeTargetAnimatable = _a.makeTargetAnimatable, measureViewportBox = _a.measureViewportBox, renderInstance = _a.render, readValueFromInstance = _a.readValueFromInstance, removeValueFromRenderState = _a.removeValueFromRenderState, sortNodePosition = _a.sortNodePosition, scrapeMotionValuesFromProps = _a.scrapeMotionValuesFromProps;\n    return function (_a, options) {\n        var parent = _a.parent, props = _a.props, presenceId = _a.presenceId, blockInitialAnimation = _a.blockInitialAnimation, visualState = _a.visualState, shouldReduceMotion = _a.shouldReduceMotion;\n        if (options === void 0) { options = {}; }\n        var isMounted = false;\n        var latestValues = visualState.latestValues, renderState = visualState.renderState;\n        /**\n         * The instance of the render-specific node that will be hydrated by the\n         * exposed React ref. So for example, this visual element can host a\n         * HTMLElement, plain object, or Three.js object. The functions provided\n         * in VisualElementConfig allow us to interface with this instance.\n         */\n        var instance;\n        /**\n         * Manages the subscriptions for a visual element's lifecycle, for instance\n         * onRender\n         */\n        var lifecycles = createLifecycles();\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        var values = new Map();\n        /**\n         * A map of every subscription that binds the provided or generated\n         * motion values onChange listeners to this visual element.\n         */\n        var 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        var prevMotionValues = {};\n        /**\n         * When values are removed from all animation props we need to search\n         * for a fallback value to animate to. These values are tracked in baseTarget.\n         */\n        var baseTarget = tslib.__assign({}, latestValues);\n        // Internal methods ========================\n        /**\n         * On mount, this will be hydrated with a callback to disconnect\n         * this visual element from its parent on unmount.\n         */\n        var removeFromVariantTree;\n        /**\n         * Render the element with the latest styles outside of the React\n         * render lifecycle\n         */\n        function render() {\n            if (!instance || !isMounted)\n                return;\n            triggerBuild();\n            renderInstance(instance, renderState, props.style, element.projection);\n        }\n        function triggerBuild() {\n            build(element, renderState, latestValues, options, props);\n        }\n        function update() {\n            lifecycles.notifyUpdate(latestValues);\n        }\n        /**\n         *\n         */\n        function bindToMotionValue(key, value) {\n            var removeOnChange = value.onChange(function (latestValue) {\n                latestValues[key] = latestValue;\n                props.onUpdate && sync__default[\"default\"].update(update, false, true);\n            });\n            var removeOnRenderRequest = value.onRenderRequest(element.scheduleRender);\n            valueSubscriptions.set(key, function () {\n                removeOnChange();\n                removeOnRenderRequest();\n            });\n        }\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 neccessarily a breaking change,\n         * more a reflection of the test.\n         */\n        var initialMotionValues = scrapeMotionValuesFromProps(props);\n        for (var key in initialMotionValues) {\n            var value = initialMotionValues[key];\n            if (latestValues[key] !== undefined && isMotionValue(value)) {\n                value.set(latestValues[key], false);\n            }\n        }\n        /**\n         * Determine what role this visual element should take in the variant tree.\n         */\n        var isControllingVariants = checkIfControllingVariants(props);\n        var isVariantNode = checkIfVariantNode(props);\n        var element = tslib.__assign(tslib.__assign({ treeType: treeType, \n            /**\n             * This is a mirror of the internal instance prop, which keeps\n             * VisualElement type-compatible with React's RefObject.\n             */\n            current: null, \n            /**\n             * The depth of this visual element within the visual element tree.\n             */\n            depth: parent ? parent.depth + 1 : 0, parent: parent, children: new Set(), \n            /**\n             *\n             */\n            presenceId: presenceId, shouldReduceMotion: shouldReduceMotion, \n            /**\n             * If this component is part of the variant tree, it should track\n             * any children that are also part of the tree. This is essentially\n             * a shadow tree to simplify logic around how to stagger over children.\n             */\n            variantChildren: isVariantNode ? new Set() : undefined, \n            /**\n             * Whether this instance is visible. This can be changed imperatively\n             * by the projection tree, is analogous to CSS's visibility in that\n             * hidden elements should take up layout, and needs enacting by the configured\n             * render function.\n             */\n            isVisible: undefined, \n            /**\n             * Normally, if a component is controlled by a parent's variants, it can\n             * rely on that ancestor to trigger animations further down the tree.\n             * However, if a component is created after its parent is mounted, the parent\n             * won't trigger that mount animation so the child needs to.\n             *\n             * TODO: This might be better replaced with a method isParentMounted\n             */\n            manuallyAnimateOnMount: Boolean(parent === null || parent === void 0 ? void 0 : parent.isMounted()), \n            /**\n             * This can be set by AnimatePresence to force components that mount\n             * at the same time as it to mount as if they have initial={false} set.\n             */\n            blockInitialAnimation: blockInitialAnimation, \n            /**\n             * Determine whether this component has mounted yet. This is mostly used\n             * by variant children to determine whether they need to trigger their\n             * own animations on mount.\n             */\n            isMounted: function () { return Boolean(instance); }, mount: function (newInstance) {\n                isMounted = true;\n                instance = element.current = newInstance;\n                if (element.projection) {\n                    element.projection.mount(newInstance);\n                }\n                if (isVariantNode && parent && !isControllingVariants) {\n                    removeFromVariantTree = parent === null || parent === void 0 ? void 0 : parent.addVariantChild(element);\n                }\n                values.forEach(function (value, key) { return bindToMotionValue(key, value); });\n                parent === null || parent === void 0 ? void 0 : parent.children.add(element);\n                element.setProps(props);\n            }, \n            /**\n             *\n             */\n            unmount: function () {\n                var _a;\n                (_a = element.projection) === null || _a === void 0 ? void 0 : _a.unmount();\n                sync.cancelSync.update(update);\n                sync.cancelSync.render(render);\n                valueSubscriptions.forEach(function (remove) { return remove(); });\n                removeFromVariantTree === null || removeFromVariantTree === void 0 ? void 0 : removeFromVariantTree();\n                parent === null || parent === void 0 ? void 0 : parent.children.delete(element);\n                lifecycles.clearAllListeners();\n                instance = undefined;\n                isMounted = false;\n            }, \n            /**\n             * Add a child visual element to our set of children.\n             */\n            addVariantChild: function (child) {\n                var _a;\n                var closestVariantNode = element.getClosestVariantNode();\n                if (closestVariantNode) {\n                    (_a = closestVariantNode.variantChildren) === null || _a === void 0 ? void 0 : _a.add(child);\n                    return function () {\n                        return closestVariantNode.variantChildren.delete(child);\n                    };\n                }\n            }, sortNodePosition: function (other) {\n                /**\n                 * If these nodes aren't even of the same type we can't compare their depth.\n                 */\n                if (!sortNodePosition || treeType !== other.treeType)\n                    return 0;\n                return sortNodePosition(element.getInstance(), other.getInstance());\n            }, \n            /**\n             * Returns the closest variant node in the tree starting from\n             * this visual element.\n             */\n            getClosestVariantNode: function () {\n                return isVariantNode ? element : parent === null || parent === void 0 ? void 0 : parent.getClosestVariantNode();\n            }, \n            /**\n             * Expose the latest layoutId prop.\n             */\n            getLayoutId: function () { return props.layoutId; }, \n            /**\n             * Returns the current instance.\n             */\n            getInstance: function () { return instance; }, \n            /**\n             * Get/set the latest static values.\n             */\n            getStaticValue: function (key) { return latestValues[key]; }, setStaticValue: function (key, value) { return (latestValues[key] = value); }, \n            /**\n             * Returns the latest motion value state. Currently only used to take\n             * a snapshot of the visual element - perhaps this can return the whole\n             * visual state\n             */\n            getLatestValues: function () { return latestValues; }, \n            /**\n             * Set the visiblity of the visual element. If it's changed, schedule\n             * a render to reflect these changes.\n             */\n            setVisibility: function (visibility) {\n                if (element.isVisible === visibility)\n                    return;\n                element.isVisible = visibility;\n                element.scheduleRender();\n            }, \n            /**\n             * Make a target animatable by Popmotion. For instance, if we're\n             * trying to animate width from 100px to 100vw we need to measure 100vw\n             * in pixels to determine what we really need to animate to. This is also\n             * pluggable to support Framer's custom value types like Color,\n             * and CSS variables.\n             */\n            makeTargetAnimatable: function (target, canMutate) {\n                if (canMutate === void 0) { canMutate = true; }\n                return makeTargetAnimatable(element, target, props, canMutate);\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: function () {\n                return measureViewportBox(instance, props);\n            }, \n            // Motion values ========================\n            /**\n             * Add a motion value and bind it to this visual element.\n             */\n            addValue: function (key, value) {\n                // Remove existing value if it exists\n                if (element.hasValue(key))\n                    element.removeValue(key);\n                values.set(key, value);\n                latestValues[key] = value.get();\n                bindToMotionValue(key, value);\n            }, \n            /**\n             * Remove a motion value and unbind any active subscriptions.\n             */\n            removeValue: function (key) {\n                var _a;\n                values.delete(key);\n                (_a = valueSubscriptions.get(key)) === null || _a === void 0 ? void 0 : _a();\n                valueSubscriptions.delete(key);\n                delete latestValues[key];\n                removeValueFromRenderState(key, renderState);\n            }, \n            /**\n             * Check whether we have a motion value for this key\n             */\n            hasValue: function (key) { return values.has(key); }, \n            /**\n             * Get a motion value for this key. If called with a default\n             * value, we'll create one if none exists.\n             */\n            getValue: function (key, defaultValue) {\n                var value = values.get(key);\n                if (value === undefined && defaultValue !== undefined) {\n                    value = motionValue(defaultValue);\n                    element.addValue(key, value);\n                }\n                return value;\n            }, \n            /**\n             * Iterate over our motion values.\n             */\n            forEachValue: function (callback) { return values.forEach(callback); }, \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: function (key) {\n                var _a;\n                return (_a = latestValues[key]) !== null && _a !== void 0 ? _a : readValueFromInstance(instance, key, options);\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: function (key, value) {\n                baseTarget[key] = value;\n            }, \n            /**\n             * Find the base target for a value thats been removed from all animation\n             * props.\n             */\n            getBaseTarget: function (key) {\n                if (getBaseTarget) {\n                    var target = getBaseTarget(props, key);\n                    if (target !== undefined && !isMotionValue(target))\n                        return target;\n                }\n                return baseTarget[key];\n            } }, lifecycles), { \n            /**\n             * Build the renderer state based on the latest visual state.\n             */\n            build: function () {\n                triggerBuild();\n                return renderState;\n            }, \n            /**\n             * Schedule a render on the next animation frame.\n             */\n            scheduleRender: function () {\n                sync__default[\"default\"].render(render, false, true);\n            }, \n            /**\n             * Synchronously fire render. It's prefered that we batch renders but\n             * in many circumstances, like layout measurement, we need to run this\n             * synchronously. However in those instances other measures should be taken\n             * to batch reads/writes.\n             */\n            syncRender: render, \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            setProps: function (newProps) {\n                if (newProps.transformTemplate || props.transformTemplate) {\n                    element.scheduleRender();\n                }\n                props = newProps;\n                lifecycles.updatePropListeners(newProps);\n                prevMotionValues = updateMotionValuesFromProps(element, scrapeMotionValuesFromProps(props), prevMotionValues);\n            }, getProps: function () { return props; }, \n            // Variants ==============================\n            /**\n             * Returns the variant definition with a given name.\n             */\n            getVariant: function (name) { var _a; return (_a = props.variants) === null || _a === void 0 ? void 0 : _a[name]; }, \n            /**\n             * Returns the defined default transition on this component.\n             */\n            getDefaultTransition: function () { return props.transition; }, getTransformPagePoint: function () {\n                return props.transformPagePoint;\n            }, \n            /**\n             * Used by child variant nodes to get the closest ancestor variant props.\n             */\n            getVariantContext: function (startAtParent) {\n                if (startAtParent === void 0) { startAtParent = false; }\n                if (startAtParent)\n                    return parent === null || parent === void 0 ? void 0 : parent.getVariantContext();\n                if (!isControllingVariants) {\n                    var context_1 = (parent === null || parent === void 0 ? void 0 : parent.getVariantContext()) || {};\n                    if (props.initial !== undefined) {\n                        context_1.initial = props.initial;\n                    }\n                    return context_1;\n                }\n                var context = {};\n                for (var i = 0; i < numVariantProps; i++) {\n                    var name_1 = variantProps[i];\n                    var prop = props[name_1];\n                    if (isVariantLabel(prop) || prop === false) {\n                        context[name_1] = prop;\n                    }\n                }\n                return context;\n            } });\n        return element;\n    };\n};\nvar variantProps = tslib.__spreadArray([\"initial\"], tslib.__read(variantPriorityOrder), false);\nvar numVariantProps = variantProps.length;\n\nfunction isCSSVariable(value) {\n    return typeof value === \"string\" && value.startsWith(\"var(--\");\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 */\nvar cssVariableRegex = /var\\((--[a-zA-Z0-9-_]+),? ?([a-zA-Z0-9 ()%#.,-]+)?\\)/;\nfunction parseCSSVariable(current) {\n    var match = cssVariableRegex.exec(current);\n    if (!match)\n        return [,];\n    var _a = tslib.__read(match, 3), token = _a[1], fallback = _a[2];\n    return [token, fallback];\n}\nvar maxDepth = 4;\nfunction getVariableValue(current, element, depth) {\n    if (depth === void 0) { depth = 1; }\n    heyListen.invariant(depth <= maxDepth, \"Max CSS variable fallback depth detected in property \\\"\".concat(current, \"\\\". This may indicate a circular fallback dependency.\"));\n    var _a = tslib.__read(parseCSSVariable(current), 2), token = _a[0], fallback = _a[1];\n    // No CSS variable detected\n    if (!token)\n        return;\n    // Attempt to read this CSS variable off the element\n    var resolved = window.getComputedStyle(element).getPropertyValue(token);\n    if (resolved) {\n        return resolved.trim();\n    }\n    else if (isCSSVariable(fallback)) {\n        // The fallback might itself be a CSS variable, in which case we attempt to resolve it too.\n        return getVariableValue(fallback, element, depth + 1);\n    }\n    else {\n        return fallback;\n    }\n}\n/**\n * Resolve CSS variables from\n *\n * @internal\n */\nfunction resolveCSSVariables(visualElement, _a, transitionEnd) {\n    var _b;\n    var target = tslib.__rest(_a, []);\n    var element = visualElement.getInstance();\n    if (!(element instanceof Element))\n        return { target: target, transitionEnd: transitionEnd };\n    // If `transitionEnd` isn't `undefined`, clone it. We could clone `target` and `transitionEnd`\n    // only if they change but I think this reads clearer and this isn't a performance-critical path.\n    if (transitionEnd) {\n        transitionEnd = tslib.__assign({}, transitionEnd);\n    }\n    // Go through existing `MotionValue`s and ensure any existing CSS variables are resolved\n    visualElement.forEachValue(function (value) {\n        var current = value.get();\n        if (!isCSSVariable(current))\n            return;\n        var resolved = getVariableValue(current, element);\n        if (resolved)\n            value.set(resolved);\n    });\n    // Cycle through every target property and resolve CSS variables. Currently\n    // we only read single-var properties like `var(--foo)`, not `calc(var(--foo) + 20px)`\n    for (var key in target) {\n        var current = target[key];\n        if (!isCSSVariable(current))\n            continue;\n        var resolved = getVariableValue(current, element);\n        if (!resolved)\n            continue;\n        // Clone target if it hasn't already been\n        target[key] = resolved;\n        // If the user hasn't already set this key on `transitionEnd`, set it to the unresolved\n        // CSS variable. This will ensure that after the animation the component will reflect\n        // changes in the value of the CSS variable.\n        if (transitionEnd)\n            (_b = transitionEnd[key]) !== null && _b !== void 0 ? _b : (transitionEnd[key] = current);\n    }\n    return { target: target, transitionEnd: transitionEnd };\n}\n\nvar positionalKeys = new Set([\n    \"width\",\n    \"height\",\n    \"top\",\n    \"left\",\n    \"right\",\n    \"bottom\",\n    \"x\",\n    \"y\",\n]);\nvar isPositionalKey = function (key) { return positionalKeys.has(key); };\nvar hasPositionalKey = function (target) {\n    return Object.keys(target).some(isPositionalKey);\n};\nvar setAndResetVelocity = function (value, to) {\n    // Looks odd but setting it twice doesn't render, it'll just\n    // set both prev and current to the latest value\n    value.set(to, false);\n    value.set(to);\n};\nvar isNumOrPxType = function (v) {\n    return v === styleValueTypes.number || v === styleValueTypes.px;\n};\nvar BoundingBoxDimension;\n(function (BoundingBoxDimension) {\n    BoundingBoxDimension[\"width\"] = \"width\";\n    BoundingBoxDimension[\"height\"] = \"height\";\n    BoundingBoxDimension[\"left\"] = \"left\";\n    BoundingBoxDimension[\"right\"] = \"right\";\n    BoundingBoxDimension[\"top\"] = \"top\";\n    BoundingBoxDimension[\"bottom\"] = \"bottom\";\n})(BoundingBoxDimension || (BoundingBoxDimension = {}));\nvar getPosFromMatrix = function (matrix, pos) {\n    return parseFloat(matrix.split(\", \")[pos]);\n};\nvar getTranslateFromMatrix = function (pos2, pos3) {\n    return function (_bbox, _a) {\n        var transform = _a.transform;\n        if (transform === \"none\" || !transform)\n            return 0;\n        var matrix3d = transform.match(/^matrix3d\\((.+)\\)$/);\n        if (matrix3d) {\n            return getPosFromMatrix(matrix3d[1], pos3);\n        }\n        else {\n            var matrix = transform.match(/^matrix\\((.+)\\)$/);\n            if (matrix) {\n                return getPosFromMatrix(matrix[1], pos2);\n            }\n            else {\n                return 0;\n            }\n        }\n    };\n};\nvar transformKeys = new Set([\"x\", \"y\", \"z\"]);\nvar nonTranslationalTransformKeys = transformProps.filter(function (key) { return !transformKeys.has(key); });\nfunction removeNonTranslationalTransform(visualElement) {\n    var removedTransforms = [];\n    nonTranslationalTransformKeys.forEach(function (key) {\n        var 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    // Apply changes to element before measurement\n    if (removedTransforms.length)\n        visualElement.syncRender();\n    return removedTransforms;\n}\nvar positionalValues = {\n    // Dimensions\n    width: function (_a, _b) {\n        var x = _a.x;\n        var _c = _b.paddingLeft, paddingLeft = _c === void 0 ? \"0\" : _c, _d = _b.paddingRight, paddingRight = _d === void 0 ? \"0\" : _d;\n        return x.max - x.min - parseFloat(paddingLeft) - parseFloat(paddingRight);\n    },\n    height: function (_a, _b) {\n        var y = _a.y;\n        var _c = _b.paddingTop, paddingTop = _c === void 0 ? \"0\" : _c, _d = _b.paddingBottom, paddingBottom = _d === void 0 ? \"0\" : _d;\n        return y.max - y.min - parseFloat(paddingTop) - parseFloat(paddingBottom);\n    },\n    top: function (_bbox, _a) {\n        var top = _a.top;\n        return parseFloat(top);\n    },\n    left: function (_bbox, _a) {\n        var left = _a.left;\n        return parseFloat(left);\n    },\n    bottom: function (_a, _b) {\n        var y = _a.y;\n        var top = _b.top;\n        return parseFloat(top) + (y.max - y.min);\n    },\n    right: function (_a, _b) {\n        var x = _a.x;\n        var left = _b.left;\n        return parseFloat(left) + (x.max - x.min);\n    },\n    // Transform\n    x: getTranslateFromMatrix(4, 13),\n    y: getTranslateFromMatrix(5, 14),\n};\nvar convertChangedValueTypes = function (target, visualElement, changedKeys) {\n    var originBbox = visualElement.measureViewportBox();\n    var element = visualElement.getInstance();\n    var elementComputedStyle = getComputedStyle(element);\n    var display = elementComputedStyle.display;\n    var origin = {};\n    // If the element is currently set to display: \"none\", make it visible before\n    // measuring the target bounding box\n    if (display === \"none\") {\n        visualElement.setStaticValue(\"display\", target.display || \"block\");\n    }\n    /**\n     * Record origins before we render and update styles\n     */\n    changedKeys.forEach(function (key) {\n        origin[key] = positionalValues[key](originBbox, elementComputedStyle);\n    });\n    // Apply the latest values (as set in checkAndConvertChangedValueTypes)\n    visualElement.syncRender();\n    var targetBbox = visualElement.measureViewportBox();\n    changedKeys.forEach(function (key) {\n        // Restore styles to their **calculated computed style**, not their actual\n        // originally set style. This allows us to animate between equivalent pixel units.\n        var value = visualElement.getValue(key);\n        setAndResetVelocity(value, origin[key]);\n        target[key] = positionalValues[key](targetBbox, elementComputedStyle);\n    });\n    return target;\n};\nvar checkAndConvertChangedValueTypes = function (visualElement, target, origin, transitionEnd) {\n    if (origin === void 0) { origin = {}; }\n    if (transitionEnd === void 0) { transitionEnd = {}; }\n    target = tslib.__assign({}, target);\n    transitionEnd = tslib.__assign({}, transitionEnd);\n    var targetPositionalKeys = Object.keys(target).filter(isPositionalKey);\n    // We want to remove any transform values that could affect the element's bounding box before\n    // it's measured. We'll reapply these later.\n    var removedTransformValues = [];\n    var hasAttemptedToRemoveTransformValues = false;\n    var changedValueTypeKeys = [];\n    targetPositionalKeys.forEach(function (key) {\n        var value = visualElement.getValue(key);\n        if (!visualElement.hasValue(key))\n            return;\n        var from = origin[key];\n        var fromType = findDimensionValueType(from);\n        var to = target[key];\n        var toType;\n        // TODO: The current implementation of this basically throws an error\n        // if you try and do value conversion via keyframes. There's probably\n        // a way of doing this but the performance implications would need greater scrutiny,\n        // as it'd be doing multiple resize-remeasure operations.\n        if (isKeyframesTarget(to)) {\n            var numKeyframes = to.length;\n            var fromIndex = to[0] === null ? 1 : 0;\n            from = to[fromIndex];\n            fromType = findDimensionValueType(from);\n            for (var i = fromIndex; i < numKeyframes; i++) {\n                if (!toType) {\n                    toType = findDimensionValueType(to[i]);\n                    heyListen.invariant(toType === fromType ||\n                        (isNumOrPxType(fromType) && isNumOrPxType(toType)), \"Keyframes must be of the same dimension as the current value\");\n                }\n                else {\n                    heyListen.invariant(findDimensionValueType(to[i]) === toType, \"All keyframes must be of the same type\");\n                }\n            }\n        }\n        else {\n            toType = findDimensionValueType(to);\n        }\n        if (fromType !== toType) {\n            // If they're both just number or px, convert them both to numbers rather than\n            // relying on resize/remeasure to convert (which is wasteful in this situation)\n            if (isNumOrPxType(fromType) && isNumOrPxType(toType)) {\n                var current = value.get();\n                if (typeof current === \"string\") {\n                    value.set(parseFloat(current));\n                }\n                if (typeof to === \"string\") {\n                    target[key] = parseFloat(to);\n                }\n                else if (Array.isArray(to) && toType === styleValueTypes.px) {\n                    target[key] = to.map(parseFloat);\n                }\n            }\n            else if ((fromType === null || fromType === void 0 ? void 0 : fromType.transform) &&\n                (toType === null || toType === void 0 ? void 0 : toType.transform) &&\n                (from === 0 || to === 0)) {\n                // If one or the other value is 0, it's safe to coerce it to the\n                // type of the other without measurement\n                if (from === 0) {\n                    value.set(toType.transform(from));\n                }\n                else {\n                    target[key] = fromType.transform(to);\n                }\n            }\n            else {\n                // If we're going to do value conversion via DOM measurements, we first\n                // need to remove non-positional transform values that could affect the bbox measurements.\n                if (!hasAttemptedToRemoveTransformValues) {\n                    removedTransformValues =\n                        removeNonTranslationalTransform(visualElement);\n                    hasAttemptedToRemoveTransformValues = true;\n                }\n                changedValueTypeKeys.push(key);\n                transitionEnd[key] =\n                    transitionEnd[key] !== undefined\n                        ? transitionEnd[key]\n                        : target[key];\n                setAndResetVelocity(value, to);\n            }\n        }\n    });\n    if (changedValueTypeKeys.length) {\n        var scrollY_1 = changedValueTypeKeys.indexOf(\"height\") >= 0\n            ? window.pageYOffset\n            : null;\n        var convertedTarget = convertChangedValueTypes(target, visualElement, changedValueTypeKeys);\n        // If we removed transform values, reapply them before the next render\n        if (removedTransformValues.length) {\n            removedTransformValues.forEach(function (_a) {\n                var _b = tslib.__read(_a, 2), key = _b[0], value = _b[1];\n                visualElement.getValue(key).set(value);\n            });\n        }\n        // Reapply original values\n        visualElement.syncRender();\n        // Restore scroll position\n        if (scrollY_1 !== null)\n            window.scrollTo({ top: scrollY_1 });\n        return { target: convertedTarget, transitionEnd: transitionEnd };\n    }\n    else {\n        return { target: target, transitionEnd: transitionEnd };\n    }\n};\n/**\n * Convert value types for x/y/width/height/top/left/bottom/right\n *\n * Allows animation between `'auto'` -> `'100%'` or `0` -> `'calc(50% - 10vw)'`\n *\n * @internal\n */\nfunction unitConversion(visualElement, target, origin, transitionEnd) {\n    return hasPositionalKey(target)\n        ? checkAndConvertChangedValueTypes(visualElement, target, origin, transitionEnd)\n        : { target: target, transitionEnd: transitionEnd };\n}\n\n/**\n * Parse a DOM variant to make it animatable. This involves resolving CSS variables\n * and ensuring animations like \"20%\" => \"calc(50vw)\" are performed in pixels.\n */\nvar parseDomVariant = function (visualElement, target, origin, transitionEnd) {\n    var resolved = resolveCSSVariables(visualElement, target, transitionEnd);\n    target = resolved.target;\n    transitionEnd = resolved.transitionEnd;\n    return unitConversion(visualElement, target, origin, transitionEnd);\n};\n\nfunction getComputedStyle$1(element) {\n    return window.getComputedStyle(element);\n}\nvar htmlConfig = {\n    treeType: \"dom\",\n    readValueFromInstance: function (domElement, key) {\n        if (isTransformProp(key)) {\n            var defaultType = getDefaultValueType(key);\n            return defaultType ? defaultType.default || 0 : 0;\n        }\n        else {\n            var computedStyle = getComputedStyle$1(domElement);\n            return ((isCSSVariable$1(key)\n                ? computedStyle.getPropertyValue(key)\n                : computedStyle[key]) || 0);\n        }\n    },\n    sortNodePosition: function (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    getBaseTarget: function (props, key) {\n        var _a;\n        return (_a = props.style) === null || _a === void 0 ? void 0 : _a[key];\n    },\n    measureViewportBox: function (element, _a) {\n        var transformPagePoint = _a.transformPagePoint;\n        return measureViewportBox(element, transformPagePoint);\n    },\n    /**\n     * Reset the transform on the current Element. This is called as part\n     * of a batched process across the entire layout tree. To remove this write\n     * cycle it'd be interesting to see if it's possible to \"undo\" all the current\n     * layout transforms up the tree in the same way this.getBoundingBoxWithoutTransforms\n     * works\n     */\n    resetTransform: function (element, domElement, props) {\n        var transformTemplate = props.transformTemplate;\n        domElement.style.transform = transformTemplate\n            ? transformTemplate({}, \"\")\n            : \"none\";\n        // Ensure that whatever happens next, we restore our transform on the next frame\n        element.scheduleRender();\n    },\n    restoreTransform: function (instance, mutableState) {\n        instance.style.transform = mutableState.style.transform;\n    },\n    removeValueFromRenderState: function (key, _a) {\n        var vars = _a.vars, style = _a.style;\n        delete vars[key];\n        delete style[key];\n    },\n    /**\n     * Ensure that HTML and Framer-specific value types like `px`->`%` and `Color`\n     * can be animated by Motion.\n     */\n    makeTargetAnimatable: function (element, _a, _b, isMounted) {\n        var transformValues = _b.transformValues;\n        if (isMounted === void 0) { isMounted = true; }\n        var transition = _a.transition, transitionEnd = _a.transitionEnd, target = tslib.__rest(_a, [\"transition\", \"transitionEnd\"]);\n        var origin = getOrigin(target, transition || {}, element);\n        /**\n         * If Framer has provided a function to convert `Color` etc value types, convert them\n         */\n        if (transformValues) {\n            if (transitionEnd)\n                transitionEnd = transformValues(transitionEnd);\n            if (target)\n                target = transformValues(target);\n            if (origin)\n                origin = transformValues(origin);\n        }\n        if (isMounted) {\n            checkTargetForNewValues(element, target, origin);\n            var parsed = parseDomVariant(element, target, origin, transitionEnd);\n            transitionEnd = parsed.transitionEnd;\n            target = parsed.target;\n        }\n        return tslib.__assign({ transition: transition, transitionEnd: transitionEnd }, target);\n    },\n    scrapeMotionValuesFromProps: scrapeMotionValuesFromProps$1,\n    build: function (element, renderState, latestValues, options, props) {\n        if (element.isVisible !== undefined) {\n            renderState.style.visibility = element.isVisible\n                ? \"visible\"\n                : \"hidden\";\n        }\n        buildHTMLStyles(renderState, latestValues, options, props.transformTemplate);\n    },\n    render: renderHTML,\n};\nvar htmlVisualElement = visualElement(htmlConfig);\n\nvar svgVisualElement = visualElement(tslib.__assign(tslib.__assign({}, htmlConfig), { getBaseTarget: function (props, key) {\n        return props[key];\n    }, readValueFromInstance: function (domElement, key) {\n        var _a;\n        if (isTransformProp(key)) {\n            return ((_a = getDefaultValueType(key)) === null || _a === void 0 ? void 0 : _a.default) || 0;\n        }\n        key = !camelCaseAttributes.has(key) ? camelToDash(key) : key;\n        return domElement.getAttribute(key);\n    }, scrapeMotionValuesFromProps: scrapeMotionValuesFromProps, build: function (_element, renderState, latestValues, options, props) {\n        buildSVGAttrs(renderState, latestValues, options, props.transformTemplate);\n    }, render: renderSVG }));\n\nvar createDomVisualElement = function (Component, options) {\n    return isSVGComponent(Component)\n        ? svgVisualElement(options, { enableHardwareAcceleration: false })\n        : htmlVisualElement(options, { enableHardwareAcceleration: true });\n};\n\nfunction pixelsToPercent(pixels, axis) {\n    if (axis.max === axis.min)\n        return 0;\n    return (pixels / (axis.max - axis.min)) * 100;\n}\n/**\n * We always correct borderRadius as a percentage rather than pixels to reduce paints.\n * For example, if you are projecting a box that is 100px wide with a 10px borderRadius\n * into a box that is 200px wide with a 20px borderRadius, that is actually a 10%\n * borderRadius in both states. If we animate between the two in pixels that will trigger\n * a paint each time. If we animate between the two in percentage we'll avoid a paint.\n */\nvar correctBorderRadius = {\n    correct: function (latest, node) {\n        if (!node.target)\n            return latest;\n        /**\n         * If latest is a string, if it's a percentage we can return immediately as it's\n         * going to be stretched appropriately. Otherwise, if it's a pixel, convert it to a number.\n         */\n        if (typeof latest === \"string\") {\n            if (styleValueTypes.px.test(latest)) {\n                latest = parseFloat(latest);\n            }\n            else {\n                return latest;\n            }\n        }\n        /**\n         * If latest is a number, it's a pixel value. We use the current viewportBox to calculate that\n         * pixel value as a percentage of each axis\n         */\n        var x = pixelsToPercent(latest, node.target.x);\n        var y = pixelsToPercent(latest, node.target.y);\n        return \"\".concat(x, \"% \").concat(y, \"%\");\n    },\n};\n\nvar varToken = \"_$css\";\nvar correctBoxShadow = {\n    correct: function (latest, _a) {\n        var treeScale = _a.treeScale, projectionDelta = _a.projectionDelta;\n        var original = latest;\n        /**\n         * We need to first strip and store CSS variables from the string.\n         */\n        var containsCSSVariables = latest.includes(\"var(\");\n        var cssVariables = [];\n        if (containsCSSVariables) {\n            latest = latest.replace(cssVariableRegex, function (match) {\n                cssVariables.push(match);\n                return varToken;\n            });\n        }\n        var shadow = styleValueTypes.complex.parse(latest);\n        // TODO: Doesn't support multiple shadows\n        if (shadow.length > 5)\n            return original;\n        var template = styleValueTypes.complex.createTransformer(latest);\n        var offset = typeof shadow[0] !== \"number\" ? 1 : 0;\n        // Calculate the overall context scale\n        var xScale = projectionDelta.x.scale * treeScale.x;\n        var yScale = projectionDelta.y.scale * treeScale.y;\n        shadow[0 + offset] /= xScale;\n        shadow[1 + offset] /= yScale;\n        /**\n         * Ideally we'd correct x and y scales individually, but because blur and\n         * spread apply to both we have to take a scale average and apply that instead.\n         * We could potentially improve the outcome of this by incorporating the ratio between\n         * the two scales.\n         */\n        var averageScale = popmotion.mix(xScale, yScale, 0.5);\n        // Blur\n        if (typeof shadow[2 + offset] === \"number\")\n            shadow[2 + offset] /= averageScale;\n        // Spread\n        if (typeof shadow[3 + offset] === \"number\")\n            shadow[3 + offset] /= averageScale;\n        var output = template(shadow);\n        if (containsCSSVariables) {\n            var i_1 = 0;\n            output = output.replace(varToken, function () {\n                var cssVariable = cssVariables[i_1];\n                i_1++;\n                return cssVariable;\n            });\n        }\n        return output;\n    },\n};\n\nvar MeasureLayoutWithContext = /** @class */ (function (_super) {\n    tslib.__extends(MeasureLayoutWithContext, _super);\n    function MeasureLayoutWithContext() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    /**\n     * This only mounts projection nodes for components that\n     * need measuring, we might want to do it for all components\n     * in order to incorporate transforms\n     */\n    MeasureLayoutWithContext.prototype.componentDidMount = function () {\n        var _this = this;\n        var _a = this.props, visualElement = _a.visualElement, layoutGroup = _a.layoutGroup, switchLayoutGroup = _a.switchLayoutGroup, layoutId = _a.layoutId;\n        var projection = visualElement.projection;\n        addScaleCorrector(defaultScaleCorrectors);\n        if (projection) {\n            if (layoutGroup === null || layoutGroup === void 0 ? void 0 : layoutGroup.group)\n                layoutGroup.group.add(projection);\n            if ((switchLayoutGroup === null || switchLayoutGroup === void 0 ? void 0 : switchLayoutGroup.register) && layoutId) {\n                switchLayoutGroup.register(projection);\n            }\n            projection.root.didUpdate();\n            projection.addEventListener(\"animationComplete\", function () {\n                _this.safeToRemove();\n            });\n            projection.setOptions(tslib.__assign(tslib.__assign({}, projection.options), { onExitComplete: function () { return _this.safeToRemove(); } }));\n        }\n        globalProjectionState.hasEverUpdated = true;\n    };\n    MeasureLayoutWithContext.prototype.getSnapshotBeforeUpdate = function (prevProps) {\n        var _this = this;\n        var _a = this.props, layoutDependency = _a.layoutDependency, visualElement = _a.visualElement, drag = _a.drag, isPresent = _a.isPresent;\n        var projection = visualElement.projection;\n        if (!projection)\n            return null;\n        /**\n         * TODO: We use this data in relegate to determine whether to\n         * promote a previous element. There's no guarantee its presence data\n         * will have updated by this point - if a bug like this arises it will\n         * have to be that we markForRelegation and then find a new lead some other way,\n         * perhaps in didUpdate\n         */\n        projection.isPresent = isPresent;\n        if (drag ||\n            prevProps.layoutDependency !== layoutDependency ||\n            layoutDependency === undefined) {\n            projection.willUpdate();\n        }\n        else {\n            this.safeToRemove();\n        }\n        if (prevProps.isPresent !== isPresent) {\n            if (isPresent) {\n                projection.promote();\n            }\n            else if (!projection.relegate()) {\n                /**\n                 * If there's another stack member taking over from this one,\n                 * it's in charge of the exit animation and therefore should\n                 * be in charge of the safe to remove. Otherwise we call it here.\n                 */\n                sync__default[\"default\"].postRender(function () {\n                    var _a;\n                    if (!((_a = projection.getStack()) === null || _a === void 0 ? void 0 : _a.members.length)) {\n                        _this.safeToRemove();\n                    }\n                });\n            }\n        }\n        return null;\n    };\n    MeasureLayoutWithContext.prototype.componentDidUpdate = function () {\n        var projection = this.props.visualElement.projection;\n        if (projection) {\n            projection.root.didUpdate();\n            if (!projection.currentAnimation && projection.isLead()) {\n                this.safeToRemove();\n            }\n        }\n    };\n    MeasureLayoutWithContext.prototype.componentWillUnmount = function () {\n        var _a = this.props, visualElement = _a.visualElement, layoutGroup = _a.layoutGroup, promoteContext = _a.switchLayoutGroup;\n        var projection = visualElement.projection;\n        if (projection) {\n            projection.scheduleCheckAfterUnmount();\n            if (layoutGroup === null || layoutGroup === void 0 ? void 0 : layoutGroup.group)\n                layoutGroup.group.remove(projection);\n            if (promoteContext === null || promoteContext === void 0 ? void 0 : promoteContext.deregister)\n                promoteContext.deregister(projection);\n        }\n    };\n    MeasureLayoutWithContext.prototype.safeToRemove = function () {\n        var safeToRemove = this.props.safeToRemove;\n        safeToRemove === null || safeToRemove === void 0 ? void 0 : safeToRemove();\n    };\n    MeasureLayoutWithContext.prototype.render = function () {\n        return null;\n    };\n    return MeasureLayoutWithContext;\n}(React__default[\"default\"].Component));\nfunction MeasureLayout(props) {\n    var _a = tslib.__read(usePresence(), 2), isPresent = _a[0], safeToRemove = _a[1];\n    var layoutGroup = React.useContext(LayoutGroupContext);\n    return (React__default[\"default\"].createElement(MeasureLayoutWithContext, tslib.__assign({}, props, { layoutGroup: layoutGroup, switchLayoutGroup: React.useContext(SwitchLayoutGroupContext), isPresent: isPresent, safeToRemove: safeToRemove })));\n}\nvar defaultScaleCorrectors = {\n    borderRadius: tslib.__assign(tslib.__assign({}, correctBorderRadius), { applyTo: [\n            \"borderTopLeftRadius\",\n            \"borderTopRightRadius\",\n            \"borderBottomLeftRadius\",\n            \"borderBottomRightRadius\",\n        ] }),\n    borderTopLeftRadius: correctBorderRadius,\n    borderTopRightRadius: correctBorderRadius,\n    borderBottomLeftRadius: correctBorderRadius,\n    borderBottomRightRadius: correctBorderRadius,\n    boxShadow: correctBoxShadow,\n};\n\nvar layoutFeatures = {\n    measureLayout: MeasureLayout,\n};\n\n/**\n * Animate a single value or a `MotionValue`.\n *\n * The first argument is either a `MotionValue` to animate, or an initial animation value.\n *\n * The second is either a value to animate to, or an array of keyframes to animate through.\n *\n * The third argument can be either tween or spring options, and optional lifecycle methods: `onUpdate`, `onPlay`, `onComplete`, `onRepeat` and `onStop`.\n *\n * Returns `AnimationPlaybackControls`, currently just a `stop` method.\n *\n * ```javascript\n * const x = useMotionValue(0)\n *\n * useEffect(() => {\n *   const controls = animate(x, 100, {\n *     type: \"spring\",\n *     stiffness: 2000,\n *     onComplete: v => {}\n *   })\n *\n *   return controls.stop\n * })\n * ```\n *\n * @public\n */\nfunction animate(from, to, transition) {\n    if (transition === void 0) { transition = {}; }\n    var value = isMotionValue(from) ? from : motionValue(from);\n    startAnimation(\"\", value, to, transition);\n    return {\n        stop: function () { return value.stop(); },\n        isAnimating: function () { return value.isAnimating(); },\n    };\n}\n\nvar borders = [\"TopLeft\", \"TopRight\", \"BottomLeft\", \"BottomRight\"];\nvar numBorders = borders.length;\nvar asNumber = function (value) {\n    return typeof value === \"string\" ? parseFloat(value) : value;\n};\nvar isPx = function (value) {\n    return typeof value === \"number\" || styleValueTypes.px.test(value);\n};\nfunction mixValues(target, follow, lead, progress, shouldCrossfadeOpacity, isOnlyMember) {\n    var _a, _b, _c, _d;\n    if (shouldCrossfadeOpacity) {\n        target.opacity = popmotion.mix(0, \n        // (follow?.opacity as number) ?? 0,\n        // TODO Reinstate this if only child\n        (_a = lead.opacity) !== null && _a !== void 0 ? _a : 1, easeCrossfadeIn(progress));\n        target.opacityExit = popmotion.mix((_b = follow.opacity) !== null && _b !== void 0 ? _b : 1, 0, easeCrossfadeOut(progress));\n    }\n    else if (isOnlyMember) {\n        target.opacity = popmotion.mix((_c = follow.opacity) !== null && _c !== void 0 ? _c : 1, (_d = lead.opacity) !== null && _d !== void 0 ? _d : 1, progress);\n    }\n    /**\n     * Mix border radius\n     */\n    for (var i = 0; i < numBorders; i++) {\n        var borderLabel = \"border\".concat(borders[i], \"Radius\");\n        var followRadius = getRadius(follow, borderLabel);\n        var leadRadius = getRadius(lead, borderLabel);\n        if (followRadius === undefined && leadRadius === undefined)\n            continue;\n        followRadius || (followRadius = 0);\n        leadRadius || (leadRadius = 0);\n        var canMix = followRadius === 0 ||\n            leadRadius === 0 ||\n            isPx(followRadius) === isPx(leadRadius);\n        if (canMix) {\n            target[borderLabel] = Math.max(popmotion.mix(asNumber(followRadius), asNumber(leadRadius), progress), 0);\n            if (styleValueTypes.percent.test(leadRadius) || styleValueTypes.percent.test(followRadius)) {\n                target[borderLabel] += \"%\";\n            }\n        }\n        else {\n            target[borderLabel] = leadRadius;\n        }\n    }\n    /**\n     * Mix rotation\n     */\n    if (follow.rotate || lead.rotate) {\n        target.rotate = popmotion.mix(follow.rotate || 0, lead.rotate || 0, progress);\n    }\n}\nfunction getRadius(values, radiusName) {\n    var _a;\n    return (_a = values[radiusName]) !== null && _a !== void 0 ? _a : values.borderRadius;\n}\n// /**\n//  * We only want to mix the background color if there's a follow element\n//  * that we're not crossfading opacity between. For instance with switch\n//  * AnimateSharedLayout animations, this helps the illusion of a continuous\n//  * element being animated but also cuts down on the number of paints triggered\n//  * for elements where opacity is doing that work for us.\n//  */\n// if (\n//     !hasFollowElement &&\n//     latestLeadValues.backgroundColor &&\n//     latestFollowValues.backgroundColor\n// ) {\n//     /**\n//      * This isn't ideal performance-wise as mixColor is creating a new function every frame.\n//      * We could probably create a mixer that runs at the start of the animation but\n//      * the idea behind the crossfader is that it runs dynamically between two potentially\n//      * changing targets (ie opacity or borderRadius may be animating independently via variants)\n//      */\n//     leadState.backgroundColor = followState.backgroundColor = mixColor(\n//         latestFollowValues.backgroundColor as string,\n//         latestLeadValues.backgroundColor as string\n//     )(p)\n// }\nvar easeCrossfadeIn = compress(0, 0.5, popmotion.circOut);\nvar easeCrossfadeOut = compress(0.5, 0.95, popmotion.linear);\nfunction compress(min, max, easing) {\n    return function (p) {\n        // Could replace ifs with clamp\n        if (p < min)\n            return 0;\n        if (p > max)\n            return 1;\n        return easing(popmotion.progress(min, max, p));\n    };\n}\n\n/**\n * Reset an axis to the provided origin box.\n *\n * This is a mutative operation.\n */\nfunction copyAxisInto(axis, originAxis) {\n    axis.min = originAxis.min;\n    axis.max = originAxis.max;\n}\n/**\n * Reset a box to the provided origin box.\n *\n * This is a mutative operation.\n */\nfunction copyBoxInto(box, originBox) {\n    copyAxisInto(box.x, originBox.x);\n    copyAxisInto(box.y, originBox.y);\n}\n\n/**\n * Remove a delta from a point. This is essentially the steps of applyPointDelta in reverse\n */\nfunction removePointDelta(point, translate, scale, originPoint, boxScale) {\n    point -= translate;\n    point = scalePoint(point, 1 / scale, originPoint);\n    if (boxScale !== undefined) {\n        point = scalePoint(point, 1 / boxScale, originPoint);\n    }\n    return point;\n}\n/**\n * Remove a delta from an axis. This is essentially the steps of applyAxisDelta in reverse\n */\nfunction removeAxisDelta(axis, translate, scale, origin, boxScale, originAxis, sourceAxis) {\n    if (translate === void 0) { translate = 0; }\n    if (scale === void 0) { scale = 1; }\n    if (origin === void 0) { origin = 0.5; }\n    if (originAxis === void 0) { originAxis = axis; }\n    if (sourceAxis === void 0) { sourceAxis = axis; }\n    if (styleValueTypes.percent.test(translate)) {\n        translate = parseFloat(translate);\n        var relativeProgress = popmotion.mix(sourceAxis.min, sourceAxis.max, translate / 100);\n        translate = relativeProgress - sourceAxis.min;\n    }\n    if (typeof translate !== \"number\")\n        return;\n    var originPoint = popmotion.mix(originAxis.min, originAxis.max, origin);\n    if (axis === originAxis)\n        originPoint -= translate;\n    axis.min = removePointDelta(axis.min, translate, scale, originPoint, boxScale);\n    axis.max = removePointDelta(axis.max, translate, scale, originPoint, boxScale);\n}\n/**\n * Remove a transforms from an axis. This is essentially the steps of applyAxisTransforms in reverse\n * and acts as a bridge between motion values and removeAxisDelta\n */\nfunction removeAxisTransforms(axis, transforms, _a, origin, sourceAxis) {\n    var _b = tslib.__read(_a, 3), key = _b[0], scaleKey = _b[1], originKey = _b[2];\n    removeAxisDelta(axis, transforms[key], transforms[scaleKey], transforms[originKey], transforms.scale, origin, sourceAxis);\n}\n/**\n * The names of the motion values we want to apply as translation, scale and origin.\n */\nvar xKeys = [\"x\", \"scaleX\", \"originX\"];\nvar yKeys = [\"y\", \"scaleY\", \"originY\"];\n/**\n * Remove a transforms from an box. This is essentially the steps of applyAxisBox in reverse\n * and acts as a bridge between motion values and removeAxisDelta\n */\nfunction removeBoxTransforms(box, transforms, originBox, sourceBox) {\n    removeAxisTransforms(box.x, transforms, xKeys, originBox === null || originBox === void 0 ? void 0 : originBox.x, sourceBox === null || sourceBox === void 0 ? void 0 : sourceBox.x);\n    removeAxisTransforms(box.y, transforms, yKeys, originBox === null || originBox === void 0 ? void 0 : originBox.y, sourceBox === null || sourceBox === void 0 ? void 0 : sourceBox.y);\n}\n\nfunction isAxisDeltaZero(delta) {\n    return delta.translate === 0 && delta.scale === 1;\n}\nfunction isDeltaZero(delta) {\n    return isAxisDeltaZero(delta.x) && isAxisDeltaZero(delta.y);\n}\nfunction boxEquals(a, b) {\n    return (a.x.min === b.x.min &&\n        a.x.max === b.x.max &&\n        a.y.min === b.y.min &&\n        a.y.max === b.y.max);\n}\n\nvar NodeStack = /** @class */ (function () {\n    function NodeStack() {\n        this.members = [];\n    }\n    NodeStack.prototype.add = function (node) {\n        addUniqueItem(this.members, node);\n        node.scheduleRender();\n    };\n    NodeStack.prototype.remove = function (node) {\n        removeItem(this.members, node);\n        if (node === this.prevLead) {\n            this.prevLead = undefined;\n        }\n        if (node === this.lead) {\n            var prevLead = this.members[this.members.length - 1];\n            if (prevLead) {\n                this.promote(prevLead);\n            }\n        }\n    };\n    NodeStack.prototype.relegate = function (node) {\n        var indexOfNode = this.members.findIndex(function (member) { return node === member; });\n        if (indexOfNode === 0)\n            return false;\n        /**\n         * Find the next projection node that is present\n         */\n        var prevLead;\n        for (var i = indexOfNode; i >= 0; i--) {\n            var member = this.members[i];\n            if (member.isPresent !== false) {\n                prevLead = member;\n                break;\n            }\n        }\n        if (prevLead) {\n            this.promote(prevLead);\n            return true;\n        }\n        else {\n            return false;\n        }\n    };\n    NodeStack.prototype.promote = function (node, preserveFollowOpacity) {\n        var _a;\n        var prevLead = this.lead;\n        if (node === prevLead)\n            return;\n        this.prevLead = prevLead;\n        this.lead = node;\n        node.show();\n        if (prevLead) {\n            prevLead.instance && prevLead.scheduleRender();\n            node.scheduleRender();\n            node.resumeFrom = prevLead;\n            if (preserveFollowOpacity) {\n                node.resumeFrom.preserveOpacity = true;\n            }\n            if (prevLead.snapshot) {\n                node.snapshot = prevLead.snapshot;\n                node.snapshot.latestValues =\n                    prevLead.animationValues || prevLead.latestValues;\n                node.snapshot.isShared = true;\n            }\n            if ((_a = node.root) === null || _a === void 0 ? void 0 : _a.isUpdating) {\n                node.isLayoutDirty = true;\n            }\n            var crossfade = node.options.crossfade;\n            if (crossfade === false) {\n                prevLead.hide();\n            }\n            /**\n             * TODO:\n             *   - Test border radius when previous node was deleted\n             *   - boxShadow mixing\n             *   - Shared between element A in scrolled container and element B (scroll stays the same or changes)\n             *   - Shared between element A in transformed container and element B (transform stays the same or changes)\n             *   - Shared between element A in scrolled page and element B (scroll stays the same or changes)\n             * ---\n             *   - Crossfade opacity of root nodes\n             *   - layoutId changes after animation\n             *   - layoutId changes mid animation\n             */\n        }\n    };\n    NodeStack.prototype.exitAnimationComplete = function () {\n        this.members.forEach(function (node) {\n            var _a, _b, _c, _d, _e;\n            (_b = (_a = node.options).onExitComplete) === null || _b === void 0 ? void 0 : _b.call(_a);\n            (_e = (_c = node.resumingFrom) === null || _c === void 0 ? void 0 : (_d = _c.options).onExitComplete) === null || _e === void 0 ? void 0 : _e.call(_d);\n        });\n    };\n    NodeStack.prototype.scheduleRender = function () {\n        this.members.forEach(function (node) {\n            node.instance && node.scheduleRender(false);\n        });\n    };\n    /**\n     * Clear any leads that have been removed this render to prevent them from being\n     * used in future animations and to prevent memory leaks\n     */\n    NodeStack.prototype.removeLeadSnapshot = function () {\n        if (this.lead && this.lead.snapshot) {\n            this.lead.snapshot = undefined;\n        }\n    };\n    return NodeStack;\n}());\n\nvar identityProjection = \"translate3d(0px, 0px, 0) scale(1, 1) scale(1, 1)\";\nfunction buildProjectionTransform(delta, treeScale, latestTransform) {\n    /**\n     * The translations we use to calculate are always relative to the viewport coordinate space.\n     * But when we apply scales, we also scale the coordinate space of an element and its children.\n     * For instance if we have a treeScale (the culmination of all parent scales) of 0.5 and we need\n     * to move an element 100 pixels, we actually need to move it 200 in within that scaled space.\n     */\n    var xTranslate = delta.x.translate / treeScale.x;\n    var yTranslate = delta.y.translate / treeScale.y;\n    var transform = \"translate3d(\".concat(xTranslate, \"px, \").concat(yTranslate, \"px, 0) \");\n    /**\n     * Apply scale correction for the tree transform.\n     * This will apply scale to the screen-orientated axes.\n     */\n    transform += \"scale(\".concat(1 / treeScale.x, \", \").concat(1 / treeScale.y, \") \");\n    if (latestTransform) {\n        var rotate = latestTransform.rotate, rotateX = latestTransform.rotateX, rotateY = latestTransform.rotateY;\n        if (rotate)\n            transform += \"rotate(\".concat(rotate, \"deg) \");\n        if (rotateX)\n            transform += \"rotateX(\".concat(rotateX, \"deg) \");\n        if (rotateY)\n            transform += \"rotateY(\".concat(rotateY, \"deg) \");\n    }\n    /**\n     * Apply scale to match the size of the element to the size we want it.\n     * This will apply scale to the element-orientated axes.\n     */\n    var elementScaleX = delta.x.scale * treeScale.x;\n    var elementScaleY = delta.y.scale * treeScale.y;\n    transform += \"scale(\".concat(elementScaleX, \", \").concat(elementScaleY, \")\");\n    return transform === identityProjection ? \"none\" : transform;\n}\n\nvar compareByDepth = function (a, b) {\n    return a.depth - b.depth;\n};\n\nvar FlatTree = /** @class */ (function () {\n    function FlatTree() {\n        this.children = [];\n        this.isDirty = false;\n    }\n    FlatTree.prototype.add = function (child) {\n        addUniqueItem(this.children, child);\n        this.isDirty = true;\n    };\n    FlatTree.prototype.remove = function (child) {\n        removeItem(this.children, child);\n        this.isDirty = true;\n    };\n    FlatTree.prototype.forEach = function (callback) {\n        this.isDirty && this.children.sort(compareByDepth);\n        this.isDirty = false;\n        this.children.forEach(callback);\n    };\n    return FlatTree;\n}());\n\n/**\n * We use 1000 as the animation target as 0-1000 maps better to pixels than 0-1\n * which has a noticeable difference in spring animations\n */\nvar animationTarget = 1000;\nfunction createProjectionNode(_a) {\n    var attachResizeListener = _a.attachResizeListener, defaultParent = _a.defaultParent, measureScroll = _a.measureScroll, checkIsScrollRoot = _a.checkIsScrollRoot, resetTransform = _a.resetTransform;\n    return /** @class */ (function () {\n        function ProjectionNode(id, latestValues, parent) {\n            var _this = this;\n            if (latestValues === void 0) { latestValues = {}; }\n            if (parent === void 0) { parent = defaultParent === null || defaultParent === void 0 ? void 0 : defaultParent(); }\n            /**\n             * A Set containing all this component's children. This is used to iterate\n             * through the children.\n             *\n             * TODO: This could be faster to iterate as a flat array stored on the root node.\n             */\n            this.children = new Set();\n            /**\n             * Options for the node. We use this to configure what kind of layout animations\n             * we should perform (if any).\n             */\n            this.options = {};\n            /**\n             * We use this to detect when its safe to shut down part of a projection tree.\n             * We have to keep projecting children for scale correction and relative projection\n             * until all their parents stop performing layout animations.\n             */\n            this.isTreeAnimating = false;\n            this.isAnimationBlocked = false;\n            /**\n             * Flag to true if we think this layout has been changed. We can't always know this,\n             * currently we set it to true every time a component renders, or if it has a layoutDependency\n             * if that has changed between renders. Additionally, components can be grouped by LayoutGroup\n             * and if one node is dirtied, they all are.\n             */\n            this.isLayoutDirty = false;\n            /**\n             * Block layout updates for instant layout transitions throughout the tree.\n             */\n            this.updateManuallyBlocked = false;\n            this.updateBlockedByResize = false;\n            /**\n             * Set to true between the start of the first `willUpdate` call and the end of the `didUpdate`\n             * call.\n             */\n            this.isUpdating = false;\n            /**\n             * If this is an SVG element we currently disable projection transforms\n             */\n            this.isSVG = false;\n            /**\n             * Flag to true (during promotion) if a node doing an instant layout transition needs to reset\n             * its projection styles.\n             */\n            this.needsReset = false;\n            /**\n             * Flags whether this node should have its transform reset prior to measuring.\n             */\n            this.shouldResetTransform = false;\n            /**\n             * An object representing the calculated contextual/accumulated/tree scale.\n             * This will be used to scale calculcated projection transforms, as these are\n             * calculated in screen-space but need to be scaled for elements to actually\n             * make it to their calculated destinations.\n             *\n             * TODO: Lazy-init\n             */\n            this.treeScale = { x: 1, y: 1 };\n            /**\n             *\n             */\n            this.eventHandlers = new Map();\n            // Note: Currently only running on root node\n            this.potentialNodes = new Map();\n            this.checkUpdateFailed = function () {\n                if (_this.isUpdating) {\n                    _this.isUpdating = false;\n                    _this.clearAllSnapshots();\n                }\n            };\n            this.updateProjection = function () {\n                _this.nodes.forEach(resolveTargetDelta);\n                _this.nodes.forEach(calcProjection);\n            };\n            this.hasProjected = false;\n            this.isVisible = true;\n            this.animationProgress = 0;\n            /**\n             * Shared layout\n             */\n            // TODO Only running on root node\n            this.sharedNodes = new Map();\n            this.id = id;\n            this.latestValues = latestValues;\n            this.root = parent ? parent.root || parent : this;\n            this.path = parent ? tslib.__spreadArray(tslib.__spreadArray([], tslib.__read(parent.path), false), [parent], false) : [];\n            this.parent = parent;\n            this.depth = parent ? parent.depth + 1 : 0;\n            id && this.root.registerPotentialNode(id, this);\n            for (var i = 0; i < this.path.length; i++) {\n                this.path[i].shouldResetTransform = true;\n            }\n            if (this.root === this)\n                this.nodes = new FlatTree();\n        }\n        ProjectionNode.prototype.addEventListener = function (name, handler) {\n            if (!this.eventHandlers.has(name)) {\n                this.eventHandlers.set(name, new SubscriptionManager());\n            }\n            return this.eventHandlers.get(name).add(handler);\n        };\n        ProjectionNode.prototype.notifyListeners = function (name) {\n            var args = [];\n            for (var _i = 1; _i < arguments.length; _i++) {\n                args[_i - 1] = arguments[_i];\n            }\n            var subscriptionManager = this.eventHandlers.get(name);\n            subscriptionManager === null || subscriptionManager === void 0 ? void 0 : subscriptionManager.notify.apply(subscriptionManager, tslib.__spreadArray([], tslib.__read(args), false));\n        };\n        ProjectionNode.prototype.hasListeners = function (name) {\n            return this.eventHandlers.has(name);\n        };\n        ProjectionNode.prototype.registerPotentialNode = function (id, node) {\n            this.potentialNodes.set(id, node);\n        };\n        /**\n         * Lifecycles\n         */\n        ProjectionNode.prototype.mount = function (instance, isLayoutDirty) {\n            var _this = this;\n            var _a;\n            if (isLayoutDirty === void 0) { isLayoutDirty = false; }\n            if (this.instance)\n                return;\n            this.isSVG =\n                instance instanceof SVGElement && instance.tagName !== \"svg\";\n            this.instance = instance;\n            var _b = this.options, layoutId = _b.layoutId, layout = _b.layout, visualElement = _b.visualElement;\n            if (visualElement && !visualElement.getInstance()) {\n                visualElement.mount(instance);\n            }\n            this.root.nodes.add(this);\n            (_a = this.parent) === null || _a === void 0 ? void 0 : _a.children.add(this);\n            this.id && this.root.potentialNodes.delete(this.id);\n            if (isLayoutDirty && (layout || layoutId)) {\n                this.isLayoutDirty = true;\n            }\n            if (attachResizeListener) {\n                var unblockTimeout_1;\n                var resizeUnblockUpdate_1 = function () {\n                    return (_this.root.updateBlockedByResize = false);\n                };\n                attachResizeListener(instance, function () {\n                    _this.root.updateBlockedByResize = true;\n                    clearTimeout(unblockTimeout_1);\n                    unblockTimeout_1 = window.setTimeout(resizeUnblockUpdate_1, 250);\n                    if (globalProjectionState.hasAnimatedSinceResize) {\n                        globalProjectionState.hasAnimatedSinceResize = false;\n                        _this.nodes.forEach(finishAnimation);\n                    }\n                });\n            }\n            if (layoutId) {\n                this.root.registerSharedNode(layoutId, this);\n            }\n            // Only register the handler if it requires layout animation\n            if (this.options.animate !== false &&\n                visualElement &&\n                (layoutId || layout)) {\n                this.addEventListener(\"didUpdate\", function (_a) {\n                    var _b, _c, _d, _e, _f;\n                    var delta = _a.delta, hasLayoutChanged = _a.hasLayoutChanged, hasRelativeTargetChanged = _a.hasRelativeTargetChanged, newLayout = _a.layout;\n                    if (_this.isTreeAnimationBlocked()) {\n                        _this.target = undefined;\n                        _this.relativeTarget = undefined;\n                        return;\n                    }\n                    // TODO: Check here if an animation exists\n                    var layoutTransition = (_c = (_b = _this.options.transition) !== null && _b !== void 0 ? _b : visualElement.getDefaultTransition()) !== null && _c !== void 0 ? _c : defaultLayoutTransition;\n                    var _g = visualElement.getProps(), onLayoutAnimationStart = _g.onLayoutAnimationStart, onLayoutAnimationComplete = _g.onLayoutAnimationComplete;\n                    /**\n                     * The target layout of the element might stay the same,\n                     * but its position relative to its parent has changed.\n                     */\n                    var targetChanged = !_this.targetLayout ||\n                        !boxEquals(_this.targetLayout, newLayout) ||\n                        hasRelativeTargetChanged;\n                    /**\n                     * If the layout hasn't seemed to have changed, it might be that the\n                     * element is visually in the same place in the document but its position\n                     * relative to its parent has indeed changed. So here we check for that.\n                     */\n                    var hasOnlyRelativeTargetChanged = !hasLayoutChanged && hasRelativeTargetChanged;\n                    if (((_d = _this.resumeFrom) === null || _d === void 0 ? void 0 : _d.instance) ||\n                        hasOnlyRelativeTargetChanged ||\n                        (hasLayoutChanged &&\n                            (targetChanged || !_this.currentAnimation))) {\n                        if (_this.resumeFrom) {\n                            _this.resumingFrom = _this.resumeFrom;\n                            _this.resumingFrom.resumingFrom = undefined;\n                        }\n                        _this.setAnimationOrigin(delta, hasOnlyRelativeTargetChanged);\n                        var animationOptions = tslib.__assign(tslib.__assign({}, getValueTransition(layoutTransition, \"layout\")), { onPlay: onLayoutAnimationStart, onComplete: onLayoutAnimationComplete });\n                        if (visualElement.shouldReduceMotion) {\n                            animationOptions.delay = 0;\n                            animationOptions.type = false;\n                        }\n                        _this.startAnimation(animationOptions);\n                    }\n                    else {\n                        /**\n                         * If the layout hasn't changed and we have an animation that hasn't started yet,\n                         * finish it immediately. Otherwise it will be animating from a location\n                         * that was probably never commited to screen and look like a jumpy box.\n                         */\n                        if (!hasLayoutChanged &&\n                            _this.animationProgress === 0) {\n                            _this.finishAnimation();\n                        }\n                        _this.isLead() && ((_f = (_e = _this.options).onExitComplete) === null || _f === void 0 ? void 0 : _f.call(_e));\n                    }\n                    _this.targetLayout = newLayout;\n                });\n            }\n        };\n        ProjectionNode.prototype.unmount = function () {\n            var _a, _b;\n            this.options.layoutId && this.willUpdate();\n            this.root.nodes.remove(this);\n            (_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.remove(this);\n            (_b = this.parent) === null || _b === void 0 ? void 0 : _b.children.delete(this);\n            this.instance = undefined;\n            sync.cancelSync.preRender(this.updateProjection);\n        };\n        // only on the root\n        ProjectionNode.prototype.blockUpdate = function () {\n            this.updateManuallyBlocked = true;\n        };\n        ProjectionNode.prototype.unblockUpdate = function () {\n            this.updateManuallyBlocked = false;\n        };\n        ProjectionNode.prototype.isUpdateBlocked = function () {\n            return this.updateManuallyBlocked || this.updateBlockedByResize;\n        };\n        ProjectionNode.prototype.isTreeAnimationBlocked = function () {\n            var _a;\n            return (this.isAnimationBlocked ||\n                ((_a = this.parent) === null || _a === void 0 ? void 0 : _a.isTreeAnimationBlocked()) ||\n                false);\n        };\n        // Note: currently only running on root node\n        ProjectionNode.prototype.startUpdate = function () {\n            var _a;\n            if (this.isUpdateBlocked())\n                return;\n            this.isUpdating = true;\n            (_a = this.nodes) === null || _a === void 0 ? void 0 : _a.forEach(resetRotation);\n        };\n        ProjectionNode.prototype.willUpdate = function (shouldNotifyListeners) {\n            var _a, _b, _c;\n            if (shouldNotifyListeners === void 0) { shouldNotifyListeners = true; }\n            if (this.root.isUpdateBlocked()) {\n                (_b = (_a = this.options).onExitComplete) === null || _b === void 0 ? void 0 : _b.call(_a);\n                return;\n            }\n            !this.root.isUpdating && this.root.startUpdate();\n            if (this.isLayoutDirty)\n                return;\n            this.isLayoutDirty = true;\n            for (var i = 0; i < this.path.length; i++) {\n                var node = this.path[i];\n                node.shouldResetTransform = true;\n                /**\n                 * TODO: Check we haven't updated the scroll\n                 * since the last didUpdate\n                 */\n                node.updateScroll();\n            }\n            var _d = this.options, layoutId = _d.layoutId, layout = _d.layout;\n            if (layoutId === undefined && !layout)\n                return;\n            var transformTemplate = (_c = this.options.visualElement) === null || _c === void 0 ? void 0 : _c.getProps().transformTemplate;\n            this.prevTransformTemplateValue = transformTemplate === null || transformTemplate === void 0 ? void 0 : transformTemplate(this.latestValues, \"\");\n            this.updateSnapshot();\n            shouldNotifyListeners && this.notifyListeners(\"willUpdate\");\n        };\n        // Note: Currently only running on root node\n        ProjectionNode.prototype.didUpdate = function () {\n            var updateWasBlocked = this.isUpdateBlocked();\n            // When doing an instant transition, we skip the layout update,\n            // but should still clean up the measurements so that the next\n            // snapshot could be taken correctly.\n            if (updateWasBlocked) {\n                this.unblockUpdate();\n                this.clearAllSnapshots();\n                this.nodes.forEach(clearMeasurements);\n                return;\n            }\n            if (!this.isUpdating)\n                return;\n            this.isUpdating = false;\n            /**\n             * Search for and mount newly-added projection elements.\n             *\n             * TODO: Every time a new component is rendered we could search up the tree for\n             * the closest mounted node and query from there rather than document.\n             */\n            if (this.potentialNodes.size) {\n                this.potentialNodes.forEach(mountNodeEarly);\n                this.potentialNodes.clear();\n            }\n            /**\n             * Write\n             */\n            this.nodes.forEach(resetTransformStyle);\n            /**\n             * Read ==================\n             */\n            // Update layout measurements of updated children\n            this.nodes.forEach(updateLayout);\n            /**\n             * Write\n             */\n            // Notify listeners that the layout is updated\n            this.nodes.forEach(notifyLayoutUpdate);\n            this.clearAllSnapshots();\n            // Flush any scheduled updates\n            sync.flushSync.update();\n            sync.flushSync.preRender();\n            sync.flushSync.render();\n        };\n        ProjectionNode.prototype.clearAllSnapshots = function () {\n            this.nodes.forEach(clearSnapshot);\n            this.sharedNodes.forEach(removeLeadSnapshots);\n        };\n        ProjectionNode.prototype.scheduleUpdateProjection = function () {\n            sync__default[\"default\"].preRender(this.updateProjection, false, true);\n        };\n        ProjectionNode.prototype.scheduleCheckAfterUnmount = function () {\n            var _this = this;\n            /**\n             * If the unmounting node is in a layoutGroup and did trigger a willUpdate,\n             * we manually call didUpdate to give a chance to the siblings to animate.\n             * Otherwise, cleanup all snapshots to prevents future nodes from reusing them.\n             */\n            sync__default[\"default\"].postRender(function () {\n                if (_this.isLayoutDirty) {\n                    _this.root.didUpdate();\n                }\n                else {\n                    _this.root.checkUpdateFailed();\n                }\n            });\n        };\n        /**\n         * Update measurements\n         */\n        ProjectionNode.prototype.updateSnapshot = function () {\n            if (this.snapshot || !this.instance)\n                return;\n            var measured = this.measure();\n            var layout = this.removeTransform(this.removeElementScroll(measured));\n            roundBox(layout);\n            this.snapshot = {\n                measured: measured,\n                layout: layout,\n                latestValues: {},\n            };\n        };\n        ProjectionNode.prototype.updateLayout = function () {\n            var _a;\n            if (!this.instance)\n                return;\n            // TODO: Incorporate into a forwarded scroll offset\n            this.updateScroll();\n            if (!(this.options.alwaysMeasureLayout && this.isLead()) &&\n                !this.isLayoutDirty) {\n                return;\n            }\n            /**\n             * When a node is mounted, it simply resumes from the prevLead's\n             * snapshot instead of taking a new one, but the ancestors scroll\n             * might have updated while the prevLead is unmounted. We need to\n             * update the scroll again to make sure the layout we measure is\n             * up to date.\n             */\n            if (this.resumeFrom && !this.resumeFrom.instance) {\n                for (var i = 0; i < this.path.length; i++) {\n                    var node = this.path[i];\n                    node.updateScroll();\n                }\n            }\n            var measured = this.measure();\n            roundBox(measured);\n            var prevLayout = this.layout;\n            this.layout = {\n                measured: measured,\n                actual: this.removeElementScroll(measured),\n            };\n            this.layoutCorrected = createBox();\n            this.isLayoutDirty = false;\n            this.projectionDelta = undefined;\n            this.notifyListeners(\"measure\", this.layout.actual);\n            (_a = this.options.visualElement) === null || _a === void 0 ? void 0 : _a.notifyLayoutMeasure(this.layout.actual, prevLayout === null || prevLayout === void 0 ? void 0 : prevLayout.actual);\n        };\n        ProjectionNode.prototype.updateScroll = function () {\n            if (this.options.layoutScroll && this.instance) {\n                this.isScrollRoot = checkIsScrollRoot(this.instance);\n                this.scroll = measureScroll(this.instance);\n            }\n        };\n        ProjectionNode.prototype.resetTransform = function () {\n            var _a;\n            if (!resetTransform)\n                return;\n            var isResetRequested = this.isLayoutDirty || this.shouldResetTransform;\n            var hasProjection = this.projectionDelta && !isDeltaZero(this.projectionDelta);\n            var transformTemplate = (_a = this.options.visualElement) === null || _a === void 0 ? void 0 : _a.getProps().transformTemplate;\n            var transformTemplateValue = transformTemplate === null || transformTemplate === void 0 ? void 0 : transformTemplate(this.latestValues, \"\");\n            var transformTemplateHasChanged = transformTemplateValue !== this.prevTransformTemplateValue;\n            if (isResetRequested &&\n                (hasProjection ||\n                    hasTransform(this.latestValues) ||\n                    transformTemplateHasChanged)) {\n                resetTransform(this.instance, transformTemplateValue);\n                this.shouldResetTransform = false;\n                this.scheduleRender();\n            }\n        };\n        ProjectionNode.prototype.measure = function () {\n            var visualElement = this.options.visualElement;\n            if (!visualElement)\n                return createBox();\n            var box = visualElement.measureViewportBox();\n            // Remove viewport scroll to give page-relative coordinates\n            var scroll = this.root.scroll;\n            if (scroll) {\n                translateAxis(box.x, scroll.x);\n                translateAxis(box.y, scroll.y);\n            }\n            return box;\n        };\n        ProjectionNode.prototype.removeElementScroll = function (box) {\n            var boxWithoutScroll = createBox();\n            copyBoxInto(boxWithoutScroll, box);\n            /**\n             * Performance TODO: Keep a cumulative scroll offset down the tree\n             * rather than loop back up the path.\n             */\n            for (var i = 0; i < this.path.length; i++) {\n                var node = this.path[i];\n                var scroll_1 = node.scroll, options = node.options, isScrollRoot = node.isScrollRoot;\n                if (node !== this.root && scroll_1 && options.layoutScroll) {\n                    /**\n                     * If this is a new scroll root, we want to remove all previous scrolls\n                     * from the viewport box.\n                     */\n                    if (isScrollRoot) {\n                        copyBoxInto(boxWithoutScroll, box);\n                        var rootScroll = this.root.scroll;\n                        /**\n                         * Undo the application of page scroll that was originally added\n                         * to the measured bounding box.\n                         */\n                        if (rootScroll) {\n                            translateAxis(boxWithoutScroll.x, -rootScroll.x);\n                            translateAxis(boxWithoutScroll.y, -rootScroll.y);\n                        }\n                    }\n                    translateAxis(boxWithoutScroll.x, scroll_1.x);\n                    translateAxis(boxWithoutScroll.y, scroll_1.y);\n                }\n            }\n            return boxWithoutScroll;\n        };\n        ProjectionNode.prototype.applyTransform = function (box, transformOnly) {\n            if (transformOnly === void 0) { transformOnly = false; }\n            var withTransforms = createBox();\n            copyBoxInto(withTransforms, box);\n            for (var i = 0; i < this.path.length; i++) {\n                var node = this.path[i];\n                if (!transformOnly &&\n                    node.options.layoutScroll &&\n                    node.scroll &&\n                    node !== node.root) {\n                    transformBox(withTransforms, {\n                        x: -node.scroll.x,\n                        y: -node.scroll.y,\n                    });\n                }\n                if (!hasTransform(node.latestValues))\n                    continue;\n                transformBox(withTransforms, node.latestValues);\n            }\n            if (hasTransform(this.latestValues)) {\n                transformBox(withTransforms, this.latestValues);\n            }\n            return withTransforms;\n        };\n        ProjectionNode.prototype.removeTransform = function (box) {\n            var _a;\n            var boxWithoutTransform = createBox();\n            copyBoxInto(boxWithoutTransform, box);\n            for (var i = 0; i < this.path.length; i++) {\n                var node = this.path[i];\n                if (!node.instance)\n                    continue;\n                if (!hasTransform(node.latestValues))\n                    continue;\n                hasScale(node.latestValues) && node.updateSnapshot();\n                var sourceBox = createBox();\n                var nodeBox = node.measure();\n                copyBoxInto(sourceBox, nodeBox);\n                removeBoxTransforms(boxWithoutTransform, node.latestValues, (_a = node.snapshot) === null || _a === void 0 ? void 0 : _a.layout, sourceBox);\n            }\n            if (hasTransform(this.latestValues)) {\n                removeBoxTransforms(boxWithoutTransform, this.latestValues);\n            }\n            return boxWithoutTransform;\n        };\n        /**\n         *\n         */\n        ProjectionNode.prototype.setTargetDelta = function (delta) {\n            this.targetDelta = delta;\n            this.root.scheduleUpdateProjection();\n        };\n        ProjectionNode.prototype.setOptions = function (options) {\n            var _a;\n            this.options = tslib.__assign(tslib.__assign(tslib.__assign({}, this.options), options), { crossfade: (_a = options.crossfade) !== null && _a !== void 0 ? _a : true });\n        };\n        ProjectionNode.prototype.clearMeasurements = function () {\n            this.scroll = undefined;\n            this.layout = undefined;\n            this.snapshot = undefined;\n            this.prevTransformTemplateValue = undefined;\n            this.targetDelta = undefined;\n            this.target = undefined;\n            this.isLayoutDirty = false;\n        };\n        /**\n         * Frame calculations\n         */\n        ProjectionNode.prototype.resolveTargetDelta = function () {\n            var _a;\n            var _b = this.options, layout = _b.layout, layoutId = _b.layoutId;\n            /**\n             * If we have no layout, we can't perform projection, so early return\n             */\n            if (!this.layout || !(layout || layoutId))\n                return;\n            /**\n             * If we don't have a targetDelta but do have a layout, we can attempt to resolve\n             * a relativeParent. This will allow a component to perform scale correction\n             * even if no animation has started.\n             */\n            // TODO If this is unsuccessful this currently happens every frame\n            if (!this.targetDelta && !this.relativeTarget) {\n                // TODO: This is a semi-repetition of further down this function, make DRY\n                this.relativeParent = this.getClosestProjectingParent();\n                if (this.relativeParent && this.relativeParent.layout) {\n                    this.relativeTarget = createBox();\n                    this.relativeTargetOrigin = createBox();\n                    calcRelativePosition(this.relativeTargetOrigin, this.layout.actual, this.relativeParent.layout.actual);\n                    copyBoxInto(this.relativeTarget, this.relativeTargetOrigin);\n                }\n            }\n            /**\n             * If we have no relative target or no target delta our target isn't valid\n             * for this frame.\n             */\n            if (!this.relativeTarget && !this.targetDelta)\n                return;\n            /**\n             * Lazy-init target data structure\n             */\n            if (!this.target) {\n                this.target = createBox();\n                this.targetWithTransforms = createBox();\n            }\n            /**\n             * If we've got a relative box for this component, resolve it into a target relative to the parent.\n             */\n            if (this.relativeTarget &&\n                this.relativeTargetOrigin &&\n                ((_a = this.relativeParent) === null || _a === void 0 ? void 0 : _a.target)) {\n                calcRelativeBox(this.target, this.relativeTarget, this.relativeParent.target);\n                /**\n                 * If we've only got a targetDelta, resolve it into a target\n                 */\n            }\n            else if (this.targetDelta) {\n                if (Boolean(this.resumingFrom)) {\n                    // TODO: This is creating a new object every frame\n                    this.target = this.applyTransform(this.layout.actual);\n                }\n                else {\n                    copyBoxInto(this.target, this.layout.actual);\n                }\n                applyBoxDelta(this.target, this.targetDelta);\n            }\n            else {\n                /**\n                 * If no target, use own layout as target\n                 */\n                copyBoxInto(this.target, this.layout.actual);\n            }\n            /**\n             * If we've been told to attempt to resolve a relative target, do so.\n             */\n            if (this.attemptToResolveRelativeTarget) {\n                this.attemptToResolveRelativeTarget = false;\n                this.relativeParent = this.getClosestProjectingParent();\n                if (this.relativeParent &&\n                    Boolean(this.relativeParent.resumingFrom) ===\n                        Boolean(this.resumingFrom) &&\n                    !this.relativeParent.options.layoutScroll &&\n                    this.relativeParent.target) {\n                    this.relativeTarget = createBox();\n                    this.relativeTargetOrigin = createBox();\n                    calcRelativePosition(this.relativeTargetOrigin, this.target, this.relativeParent.target);\n                    copyBoxInto(this.relativeTarget, this.relativeTargetOrigin);\n                }\n            }\n        };\n        ProjectionNode.prototype.getClosestProjectingParent = function () {\n            if (!this.parent || hasTransform(this.parent.latestValues))\n                return undefined;\n            if ((this.parent.relativeTarget || this.parent.targetDelta) &&\n                this.parent.layout) {\n                return this.parent;\n            }\n            else {\n                return this.parent.getClosestProjectingParent();\n            }\n        };\n        ProjectionNode.prototype.calcProjection = function () {\n            var _a;\n            var _b = this.options, layout = _b.layout, layoutId = _b.layoutId;\n            /**\n             * If this section of the tree isn't animating we can\n             * delete our target sources for the following frame.\n             */\n            this.isTreeAnimating = Boolean(((_a = this.parent) === null || _a === void 0 ? void 0 : _a.isTreeAnimating) ||\n                this.currentAnimation ||\n                this.pendingAnimation);\n            if (!this.isTreeAnimating) {\n                this.targetDelta = this.relativeTarget = undefined;\n            }\n            if (!this.layout || !(layout || layoutId))\n                return;\n            var lead = this.getLead();\n            /**\n             * Reset the corrected box with the latest values from box, as we're then going\n             * to perform mutative operations on it.\n             */\n            copyBoxInto(this.layoutCorrected, this.layout.actual);\n            /**\n             * Apply all the parent deltas to this box to produce the corrected box. This\n             * is the layout box, as it will appear on screen as a result of the transforms of its parents.\n             */\n            applyTreeDeltas(this.layoutCorrected, this.treeScale, this.path, Boolean(this.resumingFrom) || this !== lead);\n            var target = lead.target;\n            if (!target)\n                return;\n            if (!this.projectionDelta) {\n                this.projectionDelta = createDelta();\n                this.projectionDeltaWithTransform = createDelta();\n            }\n            var prevTreeScaleX = this.treeScale.x;\n            var prevTreeScaleY = this.treeScale.y;\n            var prevProjectionTransform = this.projectionTransform;\n            /**\n             * Update the delta between the corrected box and the target box before user-set transforms were applied.\n             * This will allow us to calculate the corrected borderRadius and boxShadow to compensate\n             * for our layout reprojection, but still allow them to be scaled correctly by the user.\n             * It might be that to simplify this we may want to accept that user-set scale is also corrected\n             * and we wouldn't have to keep and calc both deltas, OR we could support a user setting\n             * to allow people to choose whether these styles are corrected based on just the\n             * layout reprojection or the final bounding box.\n             */\n            calcBoxDelta(this.projectionDelta, this.layoutCorrected, target, this.latestValues);\n            this.projectionTransform = buildProjectionTransform(this.projectionDelta, this.treeScale);\n            if (this.projectionTransform !== prevProjectionTransform ||\n                this.treeScale.x !== prevTreeScaleX ||\n                this.treeScale.y !== prevTreeScaleY) {\n                this.hasProjected = true;\n                this.scheduleRender();\n                this.notifyListeners(\"projectionUpdate\", target);\n            }\n        };\n        ProjectionNode.prototype.hide = function () {\n            this.isVisible = false;\n            // TODO: Schedule render\n        };\n        ProjectionNode.prototype.show = function () {\n            this.isVisible = true;\n            // TODO: Schedule render\n        };\n        ProjectionNode.prototype.scheduleRender = function (notifyAll) {\n            var _a, _b, _c;\n            if (notifyAll === void 0) { notifyAll = true; }\n            (_b = (_a = this.options).scheduleRender) === null || _b === void 0 ? void 0 : _b.call(_a);\n            notifyAll && ((_c = this.getStack()) === null || _c === void 0 ? void 0 : _c.scheduleRender());\n            if (this.resumingFrom && !this.resumingFrom.instance) {\n                this.resumingFrom = undefined;\n            }\n        };\n        ProjectionNode.prototype.setAnimationOrigin = function (delta, hasOnlyRelativeTargetChanged) {\n            var _this = this;\n            var _a;\n            if (hasOnlyRelativeTargetChanged === void 0) { hasOnlyRelativeTargetChanged = false; }\n            var snapshot = this.snapshot;\n            var snapshotLatestValues = (snapshot === null || snapshot === void 0 ? void 0 : snapshot.latestValues) || {};\n            var mixedValues = tslib.__assign({}, this.latestValues);\n            var targetDelta = createDelta();\n            this.relativeTarget = this.relativeTargetOrigin = undefined;\n            this.attemptToResolveRelativeTarget = !hasOnlyRelativeTargetChanged;\n            var relativeLayout = createBox();\n            var isSharedLayoutAnimation = snapshot === null || snapshot === void 0 ? void 0 : snapshot.isShared;\n            var isOnlyMember = (((_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.members.length) || 0) <= 1;\n            var shouldCrossfadeOpacity = Boolean(isSharedLayoutAnimation &&\n                !isOnlyMember &&\n                this.options.crossfade === true &&\n                !this.path.some(hasOpacityCrossfade));\n            this.animationProgress = 0;\n            this.mixTargetDelta = function (latest) {\n                var _a;\n                var progress = latest / 1000;\n                mixAxisDelta(targetDelta.x, delta.x, progress);\n                mixAxisDelta(targetDelta.y, delta.y, progress);\n                _this.setTargetDelta(targetDelta);\n                if (_this.relativeTarget &&\n                    _this.relativeTargetOrigin &&\n                    _this.layout &&\n                    ((_a = _this.relativeParent) === null || _a === void 0 ? void 0 : _a.layout)) {\n                    calcRelativePosition(relativeLayout, _this.layout.actual, _this.relativeParent.layout.actual);\n                    mixBox(_this.relativeTarget, _this.relativeTargetOrigin, relativeLayout, progress);\n                }\n                if (isSharedLayoutAnimation) {\n                    _this.animationValues = mixedValues;\n                    mixValues(mixedValues, snapshotLatestValues, _this.latestValues, progress, shouldCrossfadeOpacity, isOnlyMember);\n                }\n                _this.root.scheduleUpdateProjection();\n                _this.scheduleRender();\n                _this.animationProgress = progress;\n            };\n            this.mixTargetDelta(0);\n        };\n        ProjectionNode.prototype.startAnimation = function (options) {\n            var _this = this;\n            var _a, _b;\n            this.notifyListeners(\"animationStart\");\n            (_a = this.currentAnimation) === null || _a === void 0 ? void 0 : _a.stop();\n            if (this.resumingFrom) {\n                (_b = this.resumingFrom.currentAnimation) === null || _b === void 0 ? void 0 : _b.stop();\n            }\n            if (this.pendingAnimation) {\n                sync.cancelSync.update(this.pendingAnimation);\n                this.pendingAnimation = undefined;\n            }\n            /**\n             * Start the animation in the next frame to have a frame with progress 0,\n             * where the target is the same as when the animation started, so we can\n             * calculate the relative positions correctly for instant transitions.\n             */\n            this.pendingAnimation = sync__default[\"default\"].update(function () {\n                globalProjectionState.hasAnimatedSinceResize = true;\n                _this.currentAnimation = animate(0, animationTarget, tslib.__assign(tslib.__assign({}, options), { onUpdate: function (latest) {\n                        var _a;\n                        _this.mixTargetDelta(latest);\n                        (_a = options.onUpdate) === null || _a === void 0 ? void 0 : _a.call(options, latest);\n                    }, onComplete: function () {\n                        var _a;\n                        (_a = options.onComplete) === null || _a === void 0 ? void 0 : _a.call(options);\n                        _this.completeAnimation();\n                    } }));\n                if (_this.resumingFrom) {\n                    _this.resumingFrom.currentAnimation = _this.currentAnimation;\n                }\n                _this.pendingAnimation = undefined;\n            });\n        };\n        ProjectionNode.prototype.completeAnimation = function () {\n            var _a;\n            if (this.resumingFrom) {\n                this.resumingFrom.currentAnimation = undefined;\n                this.resumingFrom.preserveOpacity = undefined;\n            }\n            (_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.exitAnimationComplete();\n            this.resumingFrom =\n                this.currentAnimation =\n                    this.animationValues =\n                        undefined;\n            this.notifyListeners(\"animationComplete\");\n        };\n        ProjectionNode.prototype.finishAnimation = function () {\n            var _a;\n            if (this.currentAnimation) {\n                (_a = this.mixTargetDelta) === null || _a === void 0 ? void 0 : _a.call(this, animationTarget);\n                this.currentAnimation.stop();\n            }\n            this.completeAnimation();\n        };\n        ProjectionNode.prototype.applyTransformsToTarget = function () {\n            var _a = this.getLead(), targetWithTransforms = _a.targetWithTransforms, target = _a.target, layout = _a.layout, latestValues = _a.latestValues;\n            if (!targetWithTransforms || !target || !layout)\n                return;\n            copyBoxInto(targetWithTransforms, target);\n            /**\n             * Apply the latest user-set transforms to the targetBox to produce the targetBoxFinal.\n             * This is the final box that we will then project into by calculating a transform delta and\n             * applying it to the corrected box.\n             */\n            transformBox(targetWithTransforms, latestValues);\n            /**\n             * Update the delta between the corrected box and the final target box, after\n             * user-set transforms are applied to it. This will be used by the renderer to\n             * create a transform style that will reproject the element from its actual layout\n             * into the desired bounding box.\n             */\n            calcBoxDelta(this.projectionDeltaWithTransform, this.layoutCorrected, targetWithTransforms, latestValues);\n        };\n        ProjectionNode.prototype.registerSharedNode = function (layoutId, node) {\n            var _a, _b, _c;\n            if (!this.sharedNodes.has(layoutId)) {\n                this.sharedNodes.set(layoutId, new NodeStack());\n            }\n            var stack = this.sharedNodes.get(layoutId);\n            stack.add(node);\n            node.promote({\n                transition: (_a = node.options.initialPromotionConfig) === null || _a === void 0 ? void 0 : _a.transition,\n                preserveFollowOpacity: (_c = (_b = node.options.initialPromotionConfig) === null || _b === void 0 ? void 0 : _b.shouldPreserveFollowOpacity) === null || _c === void 0 ? void 0 : _c.call(_b, node),\n            });\n        };\n        ProjectionNode.prototype.isLead = function () {\n            var stack = this.getStack();\n            return stack ? stack.lead === this : true;\n        };\n        ProjectionNode.prototype.getLead = function () {\n            var _a;\n            var layoutId = this.options.layoutId;\n            return layoutId ? ((_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.lead) || this : this;\n        };\n        ProjectionNode.prototype.getPrevLead = function () {\n            var _a;\n            var layoutId = this.options.layoutId;\n            return layoutId ? (_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.prevLead : undefined;\n        };\n        ProjectionNode.prototype.getStack = function () {\n            var layoutId = this.options.layoutId;\n            if (layoutId)\n                return this.root.sharedNodes.get(layoutId);\n        };\n        ProjectionNode.prototype.promote = function (_a) {\n            var _b = _a === void 0 ? {} : _a, needsReset = _b.needsReset, transition = _b.transition, preserveFollowOpacity = _b.preserveFollowOpacity;\n            var stack = this.getStack();\n            if (stack)\n                stack.promote(this, preserveFollowOpacity);\n            if (needsReset) {\n                this.projectionDelta = undefined;\n                this.needsReset = true;\n            }\n            if (transition)\n                this.setOptions({ transition: transition });\n        };\n        ProjectionNode.prototype.relegate = function () {\n            var stack = this.getStack();\n            if (stack) {\n                return stack.relegate(this);\n            }\n            else {\n                return false;\n            }\n        };\n        ProjectionNode.prototype.resetRotation = function () {\n            var visualElement = this.options.visualElement;\n            if (!visualElement)\n                return;\n            // If there's no detected rotation values, we can early return without a forced render.\n            var hasRotate = false;\n            // Keep a record of all the values we've reset\n            var resetValues = {};\n            // Check the rotate value of all axes and reset to 0\n            for (var i = 0; i < transformAxes.length; i++) {\n                var axis = transformAxes[i];\n                var key = \"rotate\" + axis;\n                // If this rotation doesn't exist as a motion value, then we don't\n                // need to reset it\n                if (!visualElement.getStaticValue(key)) {\n                    continue;\n                }\n                hasRotate = true;\n                // Record the rotation and then temporarily set it to 0\n                resetValues[key] = visualElement.getStaticValue(key);\n                visualElement.setStaticValue(key, 0);\n            }\n            // If there's no rotation values, we don't need to do any more.\n            if (!hasRotate)\n                return;\n            // Force a render of this element to apply the transform with all rotations\n            // set to 0.\n            visualElement === null || visualElement === void 0 ? void 0 : visualElement.syncRender();\n            // Put back all the values we reset\n            for (var key in resetValues) {\n                visualElement.setStaticValue(key, resetValues[key]);\n            }\n            // Schedule a render for the next frame. This ensures we won't visually\n            // see the element with the reset rotate value applied.\n            visualElement.scheduleRender();\n        };\n        ProjectionNode.prototype.getProjectionStyles = function (styleProp) {\n            var _a, _b, _c, _d, _e, _f;\n            if (styleProp === void 0) { styleProp = {}; }\n            // TODO: Return lifecycle-persistent object\n            var styles = {};\n            if (!this.instance || this.isSVG)\n                return styles;\n            if (!this.isVisible) {\n                return { visibility: \"hidden\" };\n            }\n            else {\n                styles.visibility = \"\";\n            }\n            var transformTemplate = (_a = this.options.visualElement) === null || _a === void 0 ? void 0 : _a.getProps().transformTemplate;\n            if (this.needsReset) {\n                this.needsReset = false;\n                styles.opacity = \"\";\n                styles.pointerEvents =\n                    resolveMotionValue(styleProp.pointerEvents) || \"\";\n                styles.transform = transformTemplate\n                    ? transformTemplate(this.latestValues, \"\")\n                    : \"none\";\n                return styles;\n            }\n            var lead = this.getLead();\n            if (!this.projectionDelta || !this.layout || !lead.target) {\n                var emptyStyles = {};\n                if (this.options.layoutId) {\n                    emptyStyles.opacity = (_b = this.latestValues.opacity) !== null && _b !== void 0 ? _b : 1;\n                    emptyStyles.pointerEvents =\n                        resolveMotionValue(styleProp.pointerEvents) || \"\";\n                }\n                if (this.hasProjected && !hasTransform(this.latestValues)) {\n                    emptyStyles.transform = transformTemplate\n                        ? transformTemplate({}, \"\")\n                        : \"none\";\n                    this.hasProjected = false;\n                }\n                return emptyStyles;\n            }\n            var valuesToRender = lead.animationValues || lead.latestValues;\n            this.applyTransformsToTarget();\n            styles.transform = buildProjectionTransform(this.projectionDeltaWithTransform, this.treeScale, valuesToRender);\n            if (transformTemplate) {\n                styles.transform = transformTemplate(valuesToRender, styles.transform);\n            }\n            var _g = this.projectionDelta, x = _g.x, y = _g.y;\n            styles.transformOrigin = \"\".concat(x.origin * 100, \"% \").concat(y.origin * 100, \"% 0\");\n            if (lead.animationValues) {\n                /**\n                 * If the lead component is animating, assign this either the entering/leaving\n                 * opacity\n                 */\n                styles.opacity =\n                    lead === this\n                        ? (_d = (_c = valuesToRender.opacity) !== null && _c !== void 0 ? _c : this.latestValues.opacity) !== null && _d !== void 0 ? _d : 1\n                        : this.preserveOpacity\n                            ? this.latestValues.opacity\n                            : valuesToRender.opacityExit;\n            }\n            else {\n                /**\n                 * Or we're not animating at all, set the lead component to its actual\n                 * opacity and other components to hidden.\n                 */\n                styles.opacity =\n                    lead === this\n                        ? (_e = valuesToRender.opacity) !== null && _e !== void 0 ? _e : \"\"\n                        : (_f = valuesToRender.opacityExit) !== null && _f !== void 0 ? _f : 0;\n            }\n            /**\n             * Apply scale correction\n             */\n            for (var key in scaleCorrectors) {\n                if (valuesToRender[key] === undefined)\n                    continue;\n                var _h = scaleCorrectors[key], correct = _h.correct, applyTo = _h.applyTo;\n                var corrected = correct(valuesToRender[key], lead);\n                if (applyTo) {\n                    var num = applyTo.length;\n                    for (var i = 0; i < num; i++) {\n                        styles[applyTo[i]] = corrected;\n                    }\n                }\n                else {\n                    styles[key] = corrected;\n                }\n            }\n            /**\n             * Disable pointer events on follow components. This is to ensure\n             * that if a follow component covers a lead component it doesn't block\n             * pointer events on the lead.\n             */\n            if (this.options.layoutId) {\n                styles.pointerEvents =\n                    lead === this\n                        ? resolveMotionValue(styleProp.pointerEvents) || \"\"\n                        : \"none\";\n            }\n            return styles;\n        };\n        ProjectionNode.prototype.clearSnapshot = function () {\n            this.resumeFrom = this.snapshot = undefined;\n        };\n        // Only run on root\n        ProjectionNode.prototype.resetTree = function () {\n            this.root.nodes.forEach(function (node) { var _a; return (_a = node.currentAnimation) === null || _a === void 0 ? void 0 : _a.stop(); });\n            this.root.nodes.forEach(clearMeasurements);\n            this.root.sharedNodes.clear();\n        };\n        return ProjectionNode;\n    }());\n}\nfunction updateLayout(node) {\n    node.updateLayout();\n}\nfunction notifyLayoutUpdate(node) {\n    var _a, _b, _c, _d;\n    var snapshot = (_b = (_a = node.resumeFrom) === null || _a === void 0 ? void 0 : _a.snapshot) !== null && _b !== void 0 ? _b : node.snapshot;\n    if (node.isLead() &&\n        node.layout &&\n        snapshot &&\n        node.hasListeners(\"didUpdate\")) {\n        var _e = node.layout, layout_1 = _e.actual, measuredLayout = _e.measured;\n        // TODO Maybe we want to also resize the layout snapshot so we don't trigger\n        // animations for instance if layout=\"size\" and an element has only changed position\n        if (node.options.animationType === \"size\") {\n            eachAxis(function (axis) {\n                var axisSnapshot = snapshot.isShared\n                    ? snapshot.measured[axis]\n                    : snapshot.layout[axis];\n                var length = calcLength(axisSnapshot);\n                axisSnapshot.min = layout_1[axis].min;\n                axisSnapshot.max = axisSnapshot.min + length;\n            });\n        }\n        else if (node.options.animationType === \"position\") {\n            eachAxis(function (axis) {\n                var axisSnapshot = snapshot.isShared\n                    ? snapshot.measured[axis]\n                    : snapshot.layout[axis];\n                var length = calcLength(layout_1[axis]);\n                axisSnapshot.max = axisSnapshot.min + length;\n            });\n        }\n        var layoutDelta = createDelta();\n        calcBoxDelta(layoutDelta, layout_1, snapshot.layout);\n        var visualDelta = createDelta();\n        if (snapshot.isShared) {\n            calcBoxDelta(visualDelta, node.applyTransform(measuredLayout, true), snapshot.measured);\n        }\n        else {\n            calcBoxDelta(visualDelta, layout_1, snapshot.layout);\n        }\n        var hasLayoutChanged = !isDeltaZero(layoutDelta);\n        var hasRelativeTargetChanged = false;\n        if (!node.resumeFrom) {\n            node.relativeParent = node.getClosestProjectingParent();\n            /**\n             * If the relativeParent is itself resuming from a different element then\n             * the relative snapshot is not relavent\n             */\n            if (node.relativeParent && !node.relativeParent.resumeFrom) {\n                var _f = node.relativeParent, parentSnapshot = _f.snapshot, parentLayout = _f.layout;\n                if (parentSnapshot && parentLayout) {\n                    var relativeSnapshot = createBox();\n                    calcRelativePosition(relativeSnapshot, snapshot.layout, parentSnapshot.layout);\n                    var relativeLayout = createBox();\n                    calcRelativePosition(relativeLayout, layout_1, parentLayout.actual);\n                    if (!boxEquals(relativeSnapshot, relativeLayout)) {\n                        hasRelativeTargetChanged = true;\n                    }\n                }\n            }\n        }\n        node.notifyListeners(\"didUpdate\", {\n            layout: layout_1,\n            snapshot: snapshot,\n            delta: visualDelta,\n            layoutDelta: layoutDelta,\n            hasLayoutChanged: hasLayoutChanged,\n            hasRelativeTargetChanged: hasRelativeTargetChanged,\n        });\n    }\n    else if (node.isLead()) {\n        (_d = (_c = node.options).onExitComplete) === null || _d === void 0 ? void 0 : _d.call(_c);\n    }\n    /**\n     * Clearing transition\n     * TODO: Investigate why this transition is being passed in as {type: false } from Framer\n     * and why we need it at all\n     */\n    node.options.transition = undefined;\n}\nfunction clearSnapshot(node) {\n    node.clearSnapshot();\n}\nfunction clearMeasurements(node) {\n    node.clearMeasurements();\n}\nfunction resetTransformStyle(node) {\n    var visualElement = node.options.visualElement;\n    if (visualElement === null || visualElement === void 0 ? void 0 : visualElement.getProps().onBeforeLayoutMeasure) {\n        visualElement.notifyBeforeLayoutMeasure();\n    }\n    node.resetTransform();\n}\nfunction finishAnimation(node) {\n    node.finishAnimation();\n    node.targetDelta = node.relativeTarget = node.target = undefined;\n}\nfunction resolveTargetDelta(node) {\n    node.resolveTargetDelta();\n}\nfunction calcProjection(node) {\n    node.calcProjection();\n}\nfunction resetRotation(node) {\n    node.resetRotation();\n}\nfunction removeLeadSnapshots(stack) {\n    stack.removeLeadSnapshot();\n}\nfunction mixAxisDelta(output, delta, p) {\n    output.translate = popmotion.mix(delta.translate, 0, p);\n    output.scale = popmotion.mix(delta.scale, 1, p);\n    output.origin = delta.origin;\n    output.originPoint = delta.originPoint;\n}\nfunction mixAxis(output, from, to, p) {\n    output.min = popmotion.mix(from.min, to.min, p);\n    output.max = popmotion.mix(from.max, to.max, p);\n}\nfunction mixBox(output, from, to, p) {\n    mixAxis(output.x, from.x, to.x, p);\n    mixAxis(output.y, from.y, to.y, p);\n}\nfunction hasOpacityCrossfade(node) {\n    return (node.animationValues && node.animationValues.opacityExit !== undefined);\n}\nvar defaultLayoutTransition = {\n    duration: 0.45,\n    ease: [0.4, 0, 0.1, 1],\n};\nfunction mountNodeEarly(node, id) {\n    /**\n     * Rather than searching the DOM from document we can search the\n     * path for the deepest mounted ancestor and search from there\n     */\n    var searchNode = node.root;\n    for (var i = node.path.length - 1; i >= 0; i--) {\n        if (Boolean(node.path[i].instance)) {\n            searchNode = node.path[i];\n            break;\n        }\n    }\n    var searchElement = searchNode && searchNode !== node.root ? searchNode.instance : document;\n    var element = searchElement.querySelector(\"[data-projection-id=\\\"\".concat(id, \"\\\"]\"));\n    if (element)\n        node.mount(element, true);\n}\nfunction roundAxis(axis) {\n    axis.min = Math.round(axis.min);\n    axis.max = Math.round(axis.max);\n}\nfunction roundBox(box) {\n    roundAxis(box.x);\n    roundAxis(box.y);\n}\n\nvar DocumentProjectionNode = createProjectionNode({\n    attachResizeListener: function (ref, notify) { return addDomEvent(ref, \"resize\", notify); },\n    measureScroll: function () { return ({\n        x: document.documentElement.scrollLeft || document.body.scrollLeft,\n        y: document.documentElement.scrollTop || document.body.scrollTop,\n    }); },\n    checkIsScrollRoot: function () { return true; },\n});\n\nvar rootProjectionNode = {\n    current: undefined,\n};\nvar HTMLProjectionNode = createProjectionNode({\n    measureScroll: function (instance) { return ({\n        x: instance.scrollLeft,\n        y: instance.scrollTop,\n    }); },\n    defaultParent: function () {\n        if (!rootProjectionNode.current) {\n            var documentNode = new DocumentProjectionNode(0, {});\n            documentNode.mount(window);\n            documentNode.setOptions({ layoutScroll: true });\n            rootProjectionNode.current = documentNode;\n        }\n        return rootProjectionNode.current;\n    },\n    resetTransform: function (instance, value) {\n        instance.style.transform = value !== null && value !== void 0 ? value : \"none\";\n    },\n    checkIsScrollRoot: function (instance) {\n        return Boolean(window.getComputedStyle(instance).position === \"fixed\");\n    },\n});\n\nvar featureBundle = tslib.__assign(tslib.__assign(tslib.__assign(tslib.__assign({}, animations), gestureAnimations), drag), layoutFeatures);\n/**\n * HTML & SVG components, optimised for use with gestures and animation. These can be used as\n * drop-in replacements for any HTML & SVG component, all CSS & SVG properties are supported.\n *\n * @public\n */\nvar motion = /*@__PURE__*/ createMotionProxy(function (Component, config) {\n    return createDomMotionConfig(Component, config, featureBundle, createDomVisualElement, HTMLProjectionNode);\n});\n/**\n * Create a DOM `motion` component with the provided string. This is primarily intended\n * as a full alternative to `motion` for consumers who have to support environments that don't\n * support `Proxy`.\n *\n * ```javascript\n * import { createDomMotionComponent } from \"framer-motion\"\n *\n * const motion = {\n *   div: createDomMotionComponent('div')\n * }\n * ```\n *\n * @public\n */\nfunction createDomMotionComponent(key) {\n    return createMotionComponent(createDomMotionConfig(key, { forwardMotionProps: false }, featureBundle, createDomVisualElement, HTMLProjectionNode));\n}\n\n/**\n * @public\n */\nvar m = createMotionProxy(createDomMotionConfig);\n\nfunction useIsMounted() {\n    var isMounted = React.useRef(false);\n    useIsomorphicLayoutEffect(function () {\n        isMounted.current = true;\n        return function () {\n            isMounted.current = false;\n        };\n    }, []);\n    return isMounted;\n}\n\nfunction useForceUpdate() {\n    var isMounted = useIsMounted();\n    var _a = tslib.__read(React.useState(0), 2), forcedRenderCount = _a[0], setForcedRenderCount = _a[1];\n    var forceRender = React.useCallback(function () {\n        isMounted.current && setForcedRenderCount(forcedRenderCount + 1);\n    }, [forcedRenderCount]);\n    /**\n     * Defer this to the end of the next animation frame in case there are multiple\n     * synchronous calls.\n     */\n    var deferredForceRender = React.useCallback(function () { return sync__default[\"default\"].postRender(forceRender); }, [forceRender]);\n    return [deferredForceRender, forcedRenderCount];\n}\n\nvar PresenceChild = function (_a) {\n    var children = _a.children, initial = _a.initial, isPresent = _a.isPresent, onExitComplete = _a.onExitComplete, custom = _a.custom, presenceAffectsLayout = _a.presenceAffectsLayout;\n    var presenceChildren = useConstant(newChildrenMap);\n    var id = useId();\n    var context = React.useMemo(function () { return ({\n        id: id,\n        initial: initial,\n        isPresent: isPresent,\n        custom: custom,\n        onExitComplete: function (childId) {\n            var e_1, _a;\n            presenceChildren.set(childId, true);\n            try {\n                for (var _b = tslib.__values(presenceChildren.values()), _c = _b.next(); !_c.done; _c = _b.next()) {\n                    var isComplete = _c.value;\n                    if (!isComplete)\n                        return; // can stop searching when any is incomplete\n                }\n            }\n            catch (e_1_1) { e_1 = { error: e_1_1 }; }\n            finally {\n                try {\n                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);\n                }\n                finally { if (e_1) throw e_1.error; }\n            }\n            onExitComplete === null || onExitComplete === void 0 ? void 0 : onExitComplete();\n        },\n        register: function (childId) {\n            presenceChildren.set(childId, false);\n            return function () { return presenceChildren.delete(childId); };\n        },\n    }); }, \n    /**\n     * If the presence of a child affects the layout of the components around it,\n     * we want to make a new context value to ensure they get re-rendered\n     * so they can detect that layout change.\n     */\n    presenceAffectsLayout ? undefined : [isPresent]);\n    React.useMemo(function () {\n        presenceChildren.forEach(function (_, key) { return presenceChildren.set(key, false); });\n    }, [isPresent]);\n    /**\n     * If there's no `motion` components to fire exit animations, we want to remove this\n     * component immediately.\n     */\n    React__namespace.useEffect(function () {\n        !isPresent && !presenceChildren.size && (onExitComplete === null || onExitComplete === void 0 ? void 0 : onExitComplete());\n    }, [isPresent]);\n    return (React__namespace.createElement(PresenceContext.Provider, { value: context }, children));\n};\nfunction newChildrenMap() {\n    return new Map();\n}\n\nvar getChildKey = function (child) { return child.key || \"\"; };\nfunction updateChildLookup(children, allChildren) {\n    children.forEach(function (child) {\n        var key = getChildKey(child);\n        allChildren.set(key, child);\n    });\n}\nfunction onlyElements(children) {\n    var filtered = [];\n    // We use forEach here instead of map as map mutates the component key by preprending `.$`\n    React.Children.forEach(children, function (child) {\n        if (React.isValidElement(child))\n            filtered.push(child);\n    });\n    return filtered;\n}\n/**\n * `AnimatePresence` enables the animation of components that have been removed from the tree.\n *\n * When adding/removing more than a single child, every child **must** be given a unique `key` prop.\n *\n * Any `motion` components that have an `exit` property defined will animate out when removed from\n * the tree.\n *\n * ```jsx\n * import { motion, AnimatePresence } from 'framer-motion'\n *\n * export const Items = ({ items }) => (\n *   <AnimatePresence>\n *     {items.map(item => (\n *       <motion.div\n *         key={item.id}\n *         initial={{ opacity: 0 }}\n *         animate={{ opacity: 1 }}\n *         exit={{ opacity: 0 }}\n *       />\n *     ))}\n *   </AnimatePresence>\n * )\n * ```\n *\n * You can sequence exit animations throughout a tree using variants.\n *\n * If a child contains multiple `motion` components with `exit` props, it will only unmount the child\n * once all `motion` components have finished animating out. Likewise, any components using\n * `usePresence` all need to call `safeToRemove`.\n *\n * @public\n */\nvar AnimatePresence = function (_a) {\n    var children = _a.children, custom = _a.custom, _b = _a.initial, initial = _b === void 0 ? true : _b, onExitComplete = _a.onExitComplete, exitBeforeEnter = _a.exitBeforeEnter, _c = _a.presenceAffectsLayout, presenceAffectsLayout = _c === void 0 ? true : _c;\n    // We want to force a re-render once all exiting animations have finished. We\n    // either use a local forceRender function, or one from a parent context if it exists.\n    var _d = tslib.__read(useForceUpdate(), 1), forceRender = _d[0];\n    var forceRenderLayoutGroup = React.useContext(LayoutGroupContext).forceRender;\n    if (forceRenderLayoutGroup)\n        forceRender = forceRenderLayoutGroup;\n    var isMounted = useIsMounted();\n    // Filter out any children that aren't ReactElements. We can only track ReactElements with a props.key\n    var filteredChildren = onlyElements(children);\n    var childrenToRender = filteredChildren;\n    var exiting = new Set();\n    // Keep a living record of the children we're actually rendering so we\n    // can diff to figure out which are entering and exiting\n    var presentChildren = React.useRef(childrenToRender);\n    // A lookup table to quickly reference components by key\n    var allChildren = React.useRef(new Map()).current;\n    // If this is the initial component render, just deal with logic surrounding whether\n    // we play onMount animations or not.\n    var isInitialRender = React.useRef(true);\n    useIsomorphicLayoutEffect(function () {\n        isInitialRender.current = false;\n        updateChildLookup(filteredChildren, allChildren);\n        presentChildren.current = childrenToRender;\n    });\n    useUnmountEffect(function () {\n        isInitialRender.current = true;\n        allChildren.clear();\n        exiting.clear();\n    });\n    if (isInitialRender.current) {\n        return (React__namespace.createElement(React__namespace.Fragment, null, childrenToRender.map(function (child) { return (React__namespace.createElement(PresenceChild, { key: getChildKey(child), isPresent: true, initial: initial ? undefined : false, presenceAffectsLayout: presenceAffectsLayout }, child)); })));\n    }\n    // If this is a subsequent render, deal with entering and exiting children\n    childrenToRender = tslib.__spreadArray([], tslib.__read(childrenToRender), false);\n    // Diff the keys of the currently-present and target children to update our\n    // exiting list.\n    var presentKeys = presentChildren.current.map(getChildKey);\n    var targetKeys = filteredChildren.map(getChildKey);\n    // Diff the present children with our target children and mark those that are exiting\n    var numPresent = presentKeys.length;\n    for (var i = 0; i < numPresent; i++) {\n        var key = presentKeys[i];\n        if (targetKeys.indexOf(key) === -1) {\n            exiting.add(key);\n        }\n    }\n    // If we currently have exiting children, and we're deferring rendering incoming children\n    // until after all current children have exiting, empty the childrenToRender array\n    if (exitBeforeEnter && exiting.size) {\n        childrenToRender = [];\n    }\n    // Loop through all currently exiting components and clone them to overwrite `animate`\n    // with any `exit` prop they might have defined.\n    exiting.forEach(function (key) {\n        // If this component is actually entering again, early return\n        if (targetKeys.indexOf(key) !== -1)\n            return;\n        var child = allChildren.get(key);\n        if (!child)\n            return;\n        var insertionIndex = presentKeys.indexOf(key);\n        var onExit = function () {\n            allChildren.delete(key);\n            exiting.delete(key);\n            // Remove this child from the present children\n            var removeIndex = presentChildren.current.findIndex(function (presentChild) { return presentChild.key === key; });\n            presentChildren.current.splice(removeIndex, 1);\n            // Defer re-rendering until all exiting children have indeed left\n            if (!exiting.size) {\n                presentChildren.current = filteredChildren;\n                if (isMounted.current === false)\n                    return;\n                forceRender();\n                onExitComplete && onExitComplete();\n            }\n        };\n        childrenToRender.splice(insertionIndex, 0, React__namespace.createElement(PresenceChild, { key: getChildKey(child), isPresent: false, onExitComplete: onExit, custom: custom, presenceAffectsLayout: presenceAffectsLayout }, child));\n    });\n    // Add `MotionContext` even to children that don't need it to ensure we're rendering\n    // the same tree between renders\n    childrenToRender = childrenToRender.map(function (child) {\n        var key = child.key;\n        return exiting.has(key) ? (child) : (React__namespace.createElement(PresenceChild, { key: getChildKey(child), isPresent: true, presenceAffectsLayout: presenceAffectsLayout }, child));\n    });\n    if (env !== \"production\" &&\n        exitBeforeEnter &&\n        childrenToRender.length > 1) {\n        console.warn(\"You're attempting to animate multiple children within AnimatePresence, but its exitBeforeEnter prop is set to true. This will lead to odd visual behaviour.\");\n    }\n    return (React__namespace.createElement(React__namespace.Fragment, null, exiting.size\n        ? childrenToRender\n        : childrenToRender.map(function (child) { return React.cloneElement(child); })));\n};\n\n/**\n * @deprecated\n */\nvar DeprecatedLayoutGroupContext = React.createContext(null);\n\nvar notify = function (node) {\n    return !node.isLayoutDirty && node.willUpdate(false);\n};\nfunction nodeGroup() {\n    var nodes = new Set();\n    var subscriptions = new WeakMap();\n    var dirtyAll = function () { return nodes.forEach(notify); };\n    return {\n        add: function (node) {\n            nodes.add(node);\n            subscriptions.set(node, node.addEventListener(\"willUpdate\", dirtyAll));\n        },\n        remove: function (node) {\n            var _a;\n            nodes.delete(node);\n            (_a = subscriptions.get(node)) === null || _a === void 0 ? void 0 : _a();\n            subscriptions.delete(node);\n            dirtyAll();\n        },\n        dirty: dirtyAll,\n    };\n}\n\nvar shouldInheritGroup = function (inherit) { return inherit === true; };\nvar shouldInheritId = function (inherit) {\n    return shouldInheritGroup(inherit === true) || inherit === \"id\";\n};\nvar LayoutGroup = function (_a) {\n    var _b, _c;\n    var children = _a.children, id = _a.id, inheritId = _a.inheritId, _d = _a.inherit, inherit = _d === void 0 ? true : _d;\n    // Maintain backwards-compatibility with inheritId until 7.0\n    if (inheritId !== undefined)\n        inherit = inheritId;\n    var layoutGroupContext = React.useContext(LayoutGroupContext);\n    var deprecatedLayoutGroupContext = React.useContext(DeprecatedLayoutGroupContext);\n    var _e = tslib.__read(useForceUpdate(), 2), forceRender = _e[0], key = _e[1];\n    var context = React.useRef(null);\n    var upstreamId = (_b = layoutGroupContext.id) !== null && _b !== void 0 ? _b : deprecatedLayoutGroupContext;\n    if (context.current === null) {\n        if (shouldInheritId(inherit) && upstreamId) {\n            id = id ? upstreamId + \"-\" + id : upstreamId;\n        }\n        context.current = {\n            id: id,\n            group: shouldInheritGroup(inherit)\n                ? (_c = layoutGroupContext === null || layoutGroupContext === void 0 ? void 0 : layoutGroupContext.group) !== null && _c !== void 0 ? _c : nodeGroup()\n                : nodeGroup(),\n        };\n    }\n    var memoizedContext = React.useMemo(function () { return (tslib.__assign(tslib.__assign({}, context.current), { forceRender: forceRender })); }, [key]);\n    return (React__namespace.createElement(LayoutGroupContext.Provider, { value: memoizedContext }, children));\n};\n\nvar id = 0;\nvar AnimateSharedLayout = function (_a) {\n    var children = _a.children;\n    React__namespace.useEffect(function () {\n        heyListen.warning(false, \"AnimateSharedLayout is deprecated: https://www.framer.com/docs/guide-upgrade/##shared-layout-animations\");\n    }, []);\n    return (React__namespace.createElement(LayoutGroup, { id: useConstant(function () { return \"asl-\".concat(id++); }) }, children));\n};\n\n/**\n * `MotionConfig` is used to set configuration options for all children `motion` components.\n *\n * ```jsx\n * import { motion, MotionConfig } from \"framer-motion\"\n *\n * export function App() {\n *   return (\n *     <MotionConfig transition={{ type: \"spring\" }}>\n *       <motion.div animate={{ x: 100 }} />\n *     </MotionConfig>\n *   )\n * }\n * ```\n *\n * @public\n */\nfunction MotionConfig(_a) {\n    var children = _a.children, isValidProp = _a.isValidProp, config = tslib.__rest(_a, [\"children\", \"isValidProp\"]);\n    isValidProp && loadExternalIsValidProp(isValidProp);\n    /**\n     * Inherit props from any parent MotionConfig components\n     */\n    config = tslib.__assign(tslib.__assign({}, React.useContext(MotionConfigContext)), config);\n    /**\n     * Don't allow isStatic to change between renders as it affects how many hooks\n     * motion components fire.\n     */\n    config.isStatic = useConstant(function () { return config.isStatic; });\n    /**\n     * Creating a new config context object will re-render every `motion` component\n     * every time it renders. So we only want to create a new one sparingly.\n     */\n    var context = React.useMemo(function () { return config; }, [JSON.stringify(config.transition), config.transformPagePoint, config.reducedMotion]);\n    return (React__namespace.createElement(MotionConfigContext.Provider, { value: context }, children));\n}\n\n/**\n * Used in conjunction with the `m` component to reduce bundle size.\n *\n * `m` is a version of the `motion` component that only loads functionality\n * critical for the initial render.\n *\n * `LazyMotion` can then be used to either synchronously or asynchronously\n * load animation and gesture support.\n *\n * ```jsx\n * // Synchronous loading\n * import { LazyMotion, m, domAnimations } from \"framer-motion\"\n *\n * function App() {\n *   return (\n *     <LazyMotion features={domAnimations}>\n *       <m.div animate={{ scale: 2 }} />\n *     </LazyMotion>\n *   )\n * }\n *\n * // Asynchronous loading\n * import { LazyMotion, m } from \"framer-motion\"\n *\n * function App() {\n *   return (\n *     <LazyMotion features={() => import('./path/to/domAnimations')}>\n *       <m.div animate={{ scale: 2 }} />\n *     </LazyMotion>\n *   )\n * }\n * ```\n *\n * @public\n */\nfunction LazyMotion(_a) {\n    var children = _a.children, features = _a.features, _b = _a.strict, strict = _b === void 0 ? false : _b;\n    var _c = tslib.__read(React.useState(!isLazyBundle(features)), 2), setIsLoaded = _c[1];\n    var loadedRenderer = React.useRef(undefined);\n    /**\n     * If this is a synchronous load, load features immediately\n     */\n    if (!isLazyBundle(features)) {\n        var renderer = features.renderer, loadedFeatures = tslib.__rest(features, [\"renderer\"]);\n        loadedRenderer.current = renderer;\n        loadFeatures(loadedFeatures);\n    }\n    React.useEffect(function () {\n        if (isLazyBundle(features)) {\n            features().then(function (_a) {\n                var renderer = _a.renderer, loadedFeatures = tslib.__rest(_a, [\"renderer\"]);\n                loadFeatures(loadedFeatures);\n                loadedRenderer.current = renderer;\n                setIsLoaded(true);\n            });\n        }\n    }, []);\n    return (React__namespace.createElement(LazyContext.Provider, { value: { renderer: loadedRenderer.current, strict: strict } }, children));\n}\nfunction isLazyBundle(features) {\n    return typeof features === \"function\";\n}\n\nvar ReorderContext = React.createContext(null);\n\nfunction checkReorder(order, value, offset, velocity) {\n    if (!velocity)\n        return order;\n    var index = order.findIndex(function (item) { return item.value === value; });\n    if (index === -1)\n        return order;\n    var nextOffset = velocity > 0 ? 1 : -1;\n    var nextItem = order[index + nextOffset];\n    if (!nextItem)\n        return order;\n    var item = order[index];\n    var nextLayout = nextItem.layout;\n    var nextItemCenter = popmotion.mix(nextLayout.min, nextLayout.max, 0.5);\n    if ((nextOffset === 1 && item.layout.max + offset > nextItemCenter) ||\n        (nextOffset === -1 && item.layout.min + offset < nextItemCenter)) {\n        return moveItem(order, index, index + nextOffset);\n    }\n    return order;\n}\n\nfunction ReorderGroup(_a, externalRef) {\n    var children = _a.children, _b = _a.as, as = _b === void 0 ? \"ul\" : _b, _c = _a.axis, axis = _c === void 0 ? \"y\" : _c, onReorder = _a.onReorder, values = _a.values, props = tslib.__rest(_a, [\"children\", \"as\", \"axis\", \"onReorder\", \"values\"]);\n    var Component = useConstant(function () { return motion(as); });\n    var order = [];\n    var isReordering = React.useRef(false);\n    heyListen.invariant(Boolean(values), \"Reorder.Group must be provided a values prop\");\n    var context = {\n        axis: axis,\n        registerItem: function (value, layout) {\n            /**\n             * Ensure entries can't add themselves more than once\n             */\n            if (layout &&\n                order.findIndex(function (entry) { return value === entry.value; }) === -1) {\n                order.push({ value: value, layout: layout[axis] });\n                order.sort(compareMin);\n            }\n        },\n        updateOrder: function (id, offset, velocity) {\n            if (isReordering.current)\n                return;\n            var newOrder = checkReorder(order, id, offset, velocity);\n            if (order !== newOrder) {\n                isReordering.current = true;\n                onReorder(newOrder\n                    .map(getValue)\n                    .filter(function (value) { return values.indexOf(value) !== -1; }));\n            }\n        },\n    };\n    React.useEffect(function () {\n        isReordering.current = false;\n    });\n    return (React__namespace.createElement(Component, tslib.__assign({}, props, { ref: externalRef }),\n        React__namespace.createElement(ReorderContext.Provider, { value: context }, children)));\n}\nvar Group = React.forwardRef(ReorderGroup);\nfunction getValue(item) {\n    return item.value;\n}\nfunction compareMin(a, b) {\n    return a.layout.min - b.layout.min;\n}\n\n/**\n * Creates a `MotionValue` to track the state and velocity of a value.\n *\n * Usually, these are created automatically. For advanced use-cases, like use with `useTransform`, you can create `MotionValue`s externally and pass them into the animated component via the `style` prop.\n *\n * ```jsx\n * export const MyComponent = () => {\n *   const scale = useMotionValue(1)\n *\n *   return <motion.div style={{ scale }} />\n * }\n * ```\n *\n * @param initial - The initial state.\n *\n * @public\n */\nfunction useMotionValue(initial) {\n    var value = useConstant(function () { return motionValue(initial); });\n    /**\n     * If this motion value is being used in static mode, like on\n     * the Framer canvas, force components to rerender when the motion\n     * value is updated.\n     */\n    var isStatic = React.useContext(MotionConfigContext).isStatic;\n    if (isStatic) {\n        var _a = tslib.__read(React.useState(initial), 2), setLatest_1 = _a[1];\n        React.useEffect(function () { return value.onChange(setLatest_1); }, []);\n    }\n    return value;\n}\n\nvar isCustomValueType = function (v) {\n    return typeof v === \"object\" && v.mix;\n};\nvar getMixer = function (v) { return (isCustomValueType(v) ? v.mix : undefined); };\nfunction transform() {\n    var args = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        args[_i] = arguments[_i];\n    }\n    var useImmediate = !Array.isArray(args[0]);\n    var argOffset = useImmediate ? 0 : -1;\n    var inputValue = args[0 + argOffset];\n    var inputRange = args[1 + argOffset];\n    var outputRange = args[2 + argOffset];\n    var options = args[3 + argOffset];\n    var interpolator = popmotion.interpolate(inputRange, outputRange, tslib.__assign({ mixer: getMixer(outputRange[0]) }, options));\n    return useImmediate ? interpolator(inputValue) : interpolator;\n}\n\nfunction useOnChange(value, callback) {\n    useIsomorphicLayoutEffect(function () {\n        if (isMotionValue(value))\n            return value.onChange(callback);\n    }, [callback]);\n}\nfunction useMultiOnChange(values, handler) {\n    useIsomorphicLayoutEffect(function () {\n        var subscriptions = values.map(function (value) { return value.onChange(handler); });\n        return function () { return subscriptions.forEach(function (unsubscribe) { return unsubscribe(); }); };\n    });\n}\n\nfunction useCombineMotionValues(values, combineValues) {\n    /**\n     * Initialise the returned motion value. This remains the same between renders.\n     */\n    var value = useMotionValue(combineValues());\n    /**\n     * Create a function that will update the template motion value with the latest values.\n     * This is pre-bound so whenever a motion value updates it can schedule its\n     * execution in Framesync. If it's already been scheduled it won't be fired twice\n     * in a single frame.\n     */\n    var updateValue = function () { return value.set(combineValues()); };\n    /**\n     * Synchronously update the motion value with the latest values during the render.\n     * This ensures that within a React render, the styles applied to the DOM are up-to-date.\n     */\n    updateValue();\n    /**\n     * Subscribe to all motion values found within the template. Whenever any of them change,\n     * schedule an update.\n     */\n    useMultiOnChange(values, function () { return sync__default[\"default\"].update(updateValue, false, true); });\n    return value;\n}\n\nfunction useTransform(input, inputRangeOrTransformer, outputRange, options) {\n    var transformer = typeof inputRangeOrTransformer === \"function\"\n        ? inputRangeOrTransformer\n        : transform(inputRangeOrTransformer, outputRange, options);\n    return Array.isArray(input)\n        ? useListTransform(input, transformer)\n        : useListTransform([input], function (_a) {\n            var _b = tslib.__read(_a, 1), latest = _b[0];\n            return transformer(latest);\n        });\n}\nfunction useListTransform(values, transformer) {\n    var latest = useConstant(function () { return []; });\n    return useCombineMotionValues(values, function () {\n        latest.length = 0;\n        var numValues = values.length;\n        for (var i = 0; i < numValues; i++) {\n            latest[i] = values[i].get();\n        }\n        return transformer(latest);\n    });\n}\n\nfunction useDefaultMotionValue(value, defaultValue) {\n    if (defaultValue === void 0) { defaultValue = 0; }\n    return isMotionValue(value) ? value : useMotionValue(defaultValue);\n}\nfunction ReorderItem(_a, externalRef) {\n    var children = _a.children, style = _a.style, value = _a.value, _b = _a.as, as = _b === void 0 ? \"li\" : _b, onDrag = _a.onDrag, _c = _a.layout, layout = _c === void 0 ? true : _c, props = tslib.__rest(_a, [\"children\", \"style\", \"value\", \"as\", \"onDrag\", \"layout\"]);\n    var Component = useConstant(function () { return motion(as); });\n    var context = React.useContext(ReorderContext);\n    var point = {\n        x: useDefaultMotionValue(style === null || style === void 0 ? void 0 : style.x),\n        y: useDefaultMotionValue(style === null || style === void 0 ? void 0 : style.y),\n    };\n    var zIndex = useTransform([point.x, point.y], function (_a) {\n        var _b = tslib.__read(_a, 2), latestX = _b[0], latestY = _b[1];\n        return latestX || latestY ? 1 : \"unset\";\n    });\n    var measuredLayout = React.useRef(null);\n    heyListen.invariant(Boolean(context), \"Reorder.Item must be a child of Reorder.Group\");\n    var _d = context, axis = _d.axis, registerItem = _d.registerItem, updateOrder = _d.updateOrder;\n    React.useEffect(function () {\n        registerItem(value, measuredLayout.current);\n    }, [context]);\n    return (React__namespace.createElement(Component, tslib.__assign({ drag: axis }, props, { dragSnapToOrigin: true, style: tslib.__assign(tslib.__assign({}, style), { x: point.x, y: point.y, zIndex: zIndex }), layout: layout, onDrag: function (event, gesturePoint) {\n            var velocity = gesturePoint.velocity;\n            velocity[axis] &&\n                updateOrder(value, point[axis].get(), velocity[axis]);\n            onDrag === null || onDrag === void 0 ? void 0 : onDrag(event, gesturePoint);\n        }, onLayoutMeasure: function (measured) {\n            measuredLayout.current = measured;\n        }, ref: externalRef }), children));\n}\nvar Item = React.forwardRef(ReorderItem);\n\nvar Reorder = {\n    Group: Group,\n    Item: Item,\n};\n\n/**\n * @public\n */\nvar domAnimation = tslib.__assign(tslib.__assign({ renderer: createDomVisualElement }, animations), gestureAnimations);\n\n/**\n * @public\n */\nvar domMax = tslib.__assign(tslib.__assign(tslib.__assign(tslib.__assign({}, domAnimation), drag), layoutFeatures), { projectionNodeConstructor: HTMLProjectionNode });\n\n/**\n * Combine multiple motion values into a new one using a string template literal.\n *\n * ```jsx\n * import {\n *   motion,\n *   useSpring,\n *   useMotionValue,\n *   useMotionTemplate\n * } from \"framer-motion\"\n *\n * function Component() {\n *   const shadowX = useSpring(0)\n *   const shadowY = useMotionValue(0)\n *   const shadow = useMotionTemplate`drop-shadow(${shadowX}px ${shadowY}px 20px rgba(0,0,0,0.3))`\n *\n *   return <motion.div style={{ filter: shadow }} />\n * }\n * ```\n *\n * @public\n */\nfunction useMotionTemplate(fragments) {\n    var values = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        values[_i - 1] = arguments[_i];\n    }\n    /**\n     * Create a function that will build a string from the latest motion values.\n     */\n    var numFragments = fragments.length;\n    function buildValue() {\n        var output = \"\";\n        for (var i = 0; i < numFragments; i++) {\n            output += fragments[i];\n            var value = values[i];\n            if (value)\n                output += values[i].get();\n        }\n        return output;\n    }\n    return useCombineMotionValues(values, buildValue);\n}\n\n/**\n * Creates a `MotionValue` that, when `set`, will use a spring animation to animate to its new state.\n *\n * It can either work as a stand-alone `MotionValue` by initialising it with a value, or as a subscriber\n * to another `MotionValue`.\n *\n * @remarks\n *\n * ```jsx\n * const x = useSpring(0, { stiffness: 300 })\n * const y = useSpring(x, { damping: 10 })\n * ```\n *\n * @param inputValue - `MotionValue` or number. If provided a `MotionValue`, when the input `MotionValue` changes, the created `MotionValue` will spring towards that value.\n * @param springConfig - Configuration options for the spring.\n * @returns `MotionValue`\n *\n * @public\n */\nfunction useSpring(source, config) {\n    if (config === void 0) { config = {}; }\n    var isStatic = React.useContext(MotionConfigContext).isStatic;\n    var activeSpringAnimation = React.useRef(null);\n    var value = useMotionValue(isMotionValue(source) ? source.get() : source);\n    React.useMemo(function () {\n        return value.attach(function (v, set) {\n            /**\n             * A more hollistic approach to this might be to use isStatic to fix VisualElement animations\n             * at that level, but this will work for now\n             */\n            if (isStatic)\n                return set(v);\n            if (activeSpringAnimation.current) {\n                activeSpringAnimation.current.stop();\n            }\n            activeSpringAnimation.current = popmotion.animate(tslib.__assign(tslib.__assign({ from: value.get(), to: v, velocity: value.getVelocity() }, config), { onUpdate: set }));\n            return value.get();\n        });\n    }, [JSON.stringify(config)]);\n    useOnChange(source, function (v) { return value.set(parseFloat(v)); });\n    return value;\n}\n\n/**\n * Creates a `MotionValue` that updates when the velocity of the provided `MotionValue` changes.\n *\n * ```javascript\n * const x = useMotionValue(0)\n * const xVelocity = useVelocity(x)\n * const xAcceleration = useVelocity(xVelocity)\n * ```\n *\n * @public\n */\nfunction useVelocity(value) {\n    var velocity = useMotionValue(value.getVelocity());\n    React.useEffect(function () {\n        return value.velocityUpdateSubscribers.add(function (newVelocity) {\n            velocity.set(newVelocity);\n        });\n    }, [value]);\n    return velocity;\n}\n\nvar createScrollMotionValues = function () { return ({\n    scrollX: motionValue(0),\n    scrollY: motionValue(0),\n    scrollXProgress: motionValue(0),\n    scrollYProgress: motionValue(0),\n}); };\nfunction useScroll(_a) {\n    if (_a === void 0) { _a = {}; }\n    var container = _a.container, target = _a.target, options = tslib.__rest(_a, [\"container\", \"target\"]);\n    var values = useConstant(createScrollMotionValues);\n    useIsomorphicLayoutEffect(function () {\n        return dom.scroll(function (_a) {\n            var x = _a.x, y = _a.y;\n            values.scrollX.set(x.current);\n            values.scrollXProgress.set(x.progress);\n            values.scrollY.set(y.current);\n            values.scrollYProgress.set(y.progress);\n        }, tslib.__assign(tslib.__assign({}, options), { container: (container === null || container === void 0 ? void 0 : container.current) || undefined, target: (target === null || target === void 0 ? void 0 : target.current) || undefined }));\n    }, []);\n    return values;\n}\n\nfunction useElementScroll(ref) {\n    warnOnce(false, \"useElementScroll is deprecated. Convert to useScroll({ container: ref }).\");\n    return useScroll({ container: ref });\n}\n\nfunction useViewportScroll() {\n    warnOnce(false, \"useViewportScroll is deprecated. Convert to useScroll().\");\n    return useScroll();\n}\n\nvar getCurrentTime = typeof performance !== \"undefined\"\n    ? function () { return performance.now(); }\n    : function () { return Date.now(); };\nfunction useAnimationFrame(callback) {\n    var initialTimestamp = useConstant(getCurrentTime);\n    var isStatic = React.useContext(MotionConfigContext).isStatic;\n    React.useEffect(function () {\n        if (isStatic)\n            return;\n        var provideTimeSinceStart = function (_a) {\n            var timestamp = _a.timestamp;\n            callback(timestamp - initialTimestamp);\n        };\n        sync__default[\"default\"].update(provideTimeSinceStart, true);\n        return function () { return sync.cancelSync.update(provideTimeSinceStart); };\n    }, [callback]);\n}\n\nfunction useTime() {\n    var time = useMotionValue(0);\n    useAnimationFrame(function (t) { return time.set(t); });\n    return time;\n}\n\n/**\n * @public\n */\nfunction animationControls() {\n    /**\n     * Track whether the host component has mounted.\n     */\n    var hasMounted = false;\n    /**\n     * Pending animations that are started before a component is mounted.\n     * TODO: Remove this as animations should only run in effects\n     */\n    var pendingAnimations = [];\n    /**\n     * A collection of linked component animation controls.\n     */\n    var subscribers = new Set();\n    var controls = {\n        subscribe: function (visualElement) {\n            subscribers.add(visualElement);\n            return function () { return void subscribers.delete(visualElement); };\n        },\n        start: function (definition, transitionOverride) {\n            /**\n             * TODO: We only perform this hasMounted check because in Framer we used to\n             * encourage the ability to start an animation within the render phase. This\n             * isn't behaviour concurrent-safe so when we make Framer concurrent-safe\n             * we can ditch this.\n             */\n            if (hasMounted) {\n                var animations_1 = [];\n                subscribers.forEach(function (visualElement) {\n                    animations_1.push(animateVisualElement(visualElement, definition, {\n                        transitionOverride: transitionOverride,\n                    }));\n                });\n                return Promise.all(animations_1);\n            }\n            else {\n                return new Promise(function (resolve) {\n                    pendingAnimations.push({\n                        animation: [definition, transitionOverride],\n                        resolve: resolve,\n                    });\n                });\n            }\n        },\n        set: function (definition) {\n            heyListen.invariant(hasMounted, \"controls.set() should only be called after a component has mounted. Consider calling within a useEffect hook.\");\n            return subscribers.forEach(function (visualElement) {\n                setValues(visualElement, definition);\n            });\n        },\n        stop: function () {\n            subscribers.forEach(function (visualElement) {\n                stopAnimation(visualElement);\n            });\n        },\n        mount: function () {\n            hasMounted = true;\n            pendingAnimations.forEach(function (_a) {\n                var animation = _a.animation, resolve = _a.resolve;\n                controls.start.apply(controls, tslib.__spreadArray([], tslib.__read(animation), false)).then(resolve);\n            });\n            return function () {\n                hasMounted = false;\n                controls.stop();\n            };\n        },\n    };\n    return controls;\n}\n\n/**\n * Creates `AnimationControls`, which can be used to manually start, stop\n * and sequence animations on one or more components.\n *\n * The returned `AnimationControls` should be passed to the `animate` property\n * of the components you want to animate.\n *\n * These components can then be animated with the `start` method.\n *\n * ```jsx\n * import * as React from 'react'\n * import { motion, useAnimation } from 'framer-motion'\n *\n * export function MyComponent(props) {\n *    const controls = useAnimation()\n *\n *    controls.start({\n *        x: 100,\n *        transition: { duration: 0.5 },\n *    })\n *\n *    return <motion.div animate={controls} />\n * }\n * ```\n *\n * @returns Animation controller with `start` and `stop` methods\n *\n * @public\n */\nfunction useAnimationControls() {\n    var controls = useConstant(animationControls);\n    React.useEffect(controls.mount, []);\n    return controls;\n}\nvar useAnimation = useAnimationControls;\n\n/**\n * Cycles through a series of visual properties. Can be used to toggle between or cycle through animations. It works similar to `useState` in React. It is provided an initial array of possible states, and returns an array of two arguments.\n *\n * An index value can be passed to the returned `cycle` function to cycle to a specific index.\n *\n * ```jsx\n * import * as React from \"react\"\n * import { motion, useCycle } from \"framer-motion\"\n *\n * export const MyComponent = () => {\n *   const [x, cycleX] = useCycle(0, 50, 100)\n *\n *   return (\n *     <motion.div\n *       animate={{ x: x }}\n *       onTap={() => cycleX()}\n *      />\n *    )\n * }\n * ```\n *\n * @param items - items to cycle through\n * @returns [currentState, cycleState]\n *\n * @public\n */\nfunction useCycle() {\n    var items = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        items[_i] = arguments[_i];\n    }\n    var index = React.useRef(0);\n    var _a = tslib.__read(React.useState(items[index.current]), 2), item = _a[0], setItem = _a[1];\n    var runCycle = React.useCallback(function (next) {\n        index.current =\n            typeof next !== \"number\"\n                ? popmotion.wrap(0, items.length, index.current + 1)\n                : next;\n        setItem(items[index.current]);\n    }, tslib.__spreadArray([items.length], tslib.__read(items), false));\n    return [item, runCycle];\n}\n\nfunction useInView(ref, _a) {\n    var _b = _a === void 0 ? {} : _a, root = _b.root, margin = _b.margin, amount = _b.amount, _c = _b.once, once = _c === void 0 ? false : _c;\n    var _d = tslib.__read(React.useState(false), 2), isInView = _d[0], setInView = _d[1];\n    React.useEffect(function () {\n        var _a;\n        if (!ref.current || (once && isInView))\n            return;\n        var onEnter = function () {\n            setInView(true);\n            return once ? undefined : function () { return setInView(false); };\n        };\n        var options = {\n            root: (_a = root === null || root === void 0 ? void 0 : root.current) !== null && _a !== void 0 ? _a : undefined,\n            margin: margin,\n            amount: amount === \"some\" ? \"any\" : amount,\n        };\n        return dom.inView(ref.current, onEnter, options);\n    }, [root, ref, margin, once]);\n    return isInView;\n}\n\n/**\n * Can manually trigger a drag gesture on one or more `drag`-enabled `motion` components.\n *\n * ```jsx\n * const dragControls = useDragControls()\n *\n * function startDrag(event) {\n *   dragControls.start(event, { snapToCursor: true })\n * }\n *\n * return (\n *   <>\n *     <div onPointerDown={startDrag} />\n *     <motion.div drag=\"x\" dragControls={dragControls} />\n *   </>\n * )\n * ```\n *\n * @public\n */\nvar DragControls = /** @class */ (function () {\n    function DragControls() {\n        this.componentControls = new Set();\n    }\n    /**\n     * Subscribe a component's internal `VisualElementDragControls` to the user-facing API.\n     *\n     * @internal\n     */\n    DragControls.prototype.subscribe = function (controls) {\n        var _this = this;\n        this.componentControls.add(controls);\n        return function () { return _this.componentControls.delete(controls); };\n    };\n    /**\n     * Start a drag gesture on every `motion` component that has this set of drag controls\n     * passed into it via the `dragControls` prop.\n     *\n     * ```jsx\n     * dragControls.start(e, {\n     *   snapToCursor: true\n     * })\n     * ```\n     *\n     * @param event - PointerEvent\n     * @param options - Options\n     *\n     * @public\n     */\n    DragControls.prototype.start = function (event, options) {\n        this.componentControls.forEach(function (controls) {\n            controls.start(event.nativeEvent || event, options);\n        });\n    };\n    return DragControls;\n}());\nvar createDragControls = function () { return new DragControls(); };\n/**\n * Usually, dragging is initiated by pressing down on a `motion` component with a `drag` prop\n * and moving it. For some use-cases, for instance clicking at an arbitrary point on a video scrubber, we\n * might want to initiate that dragging from a different component than the draggable one.\n *\n * By creating a `dragControls` using the `useDragControls` hook, we can pass this into\n * the draggable component's `dragControls` prop. It exposes a `start` method\n * that can start dragging from pointer events on other components.\n *\n * ```jsx\n * const dragControls = useDragControls()\n *\n * function startDrag(event) {\n *   dragControls.start(event, { snapToCursor: true })\n * }\n *\n * return (\n *   <>\n *     <div onPointerDown={startDrag} />\n *     <motion.div drag=\"x\" dragControls={dragControls} />\n *   </>\n * )\n * ```\n *\n * @public\n */\nfunction useDragControls() {\n    return useConstant(createDragControls);\n}\n\nfunction useInstantLayoutTransition() {\n    return startTransition;\n}\nfunction startTransition(cb) {\n    if (!rootProjectionNode.current)\n        return;\n    rootProjectionNode.current.isUpdating = false;\n    rootProjectionNode.current.blockUpdate();\n    cb === null || cb === void 0 ? void 0 : cb();\n}\n\nfunction useInstantTransition() {\n    var _a = tslib.__read(useForceUpdate(), 2), forceUpdate = _a[0], forcedRenderCount = _a[1];\n    var startInstantLayoutTransition = useInstantLayoutTransition();\n    React.useEffect(function () {\n        /**\n         * Unblock after two animation frames, otherwise this will unblock too soon.\n         */\n        sync__default[\"default\"].postRender(function () {\n            return sync__default[\"default\"].postRender(function () { return (instantAnimationState.current = false); });\n        });\n    }, [forcedRenderCount]);\n    return function (callback) {\n        startInstantLayoutTransition(function () {\n            instantAnimationState.current = true;\n            forceUpdate();\n            callback();\n        });\n    };\n}\n\nfunction useResetProjection() {\n    var reset = React__namespace.useCallback(function () {\n        var root = rootProjectionNode.current;\n        if (!root)\n            return;\n        root.resetTree();\n    }, []);\n    return reset;\n}\n\nvar createObject = function () { return ({}); };\nvar stateVisualElement = visualElement({\n    build: function () { },\n    measureViewportBox: createBox,\n    resetTransform: function () { },\n    restoreTransform: function () { },\n    removeValueFromRenderState: function () { },\n    render: function () { },\n    scrapeMotionValuesFromProps: createObject,\n    readValueFromInstance: function (_state, key, options) {\n        return options.initialState[key] || 0;\n    },\n    makeTargetAnimatable: function (element, _a) {\n        var transition = _a.transition, transitionEnd = _a.transitionEnd, target = tslib.__rest(_a, [\"transition\", \"transitionEnd\"]);\n        var origin = getOrigin(target, transition || {}, element);\n        checkTargetForNewValues(element, target, origin);\n        return tslib.__assign({ transition: transition, transitionEnd: transitionEnd }, target);\n    },\n});\nvar useVisualState = makeUseVisualState({\n    scrapeMotionValuesFromProps: createObject,\n    createRenderState: createObject,\n});\n/**\n * This is not an officially supported API and may be removed\n * on any version.\n */\nfunction useAnimatedState(initialState) {\n    var _a = tslib.__read(React.useState(initialState), 2), animationState = _a[0], setAnimationState = _a[1];\n    var visualState = useVisualState({}, false);\n    var element = useConstant(function () {\n        return stateVisualElement({ props: {}, visualState: visualState }, { initialState: initialState });\n    });\n    React.useEffect(function () {\n        element.mount({});\n        return element.unmount;\n    }, [element]);\n    React.useEffect(function () {\n        element.setProps({\n            onUpdate: function (v) {\n                setAnimationState(tslib.__assign({}, v));\n            },\n        });\n    }, [setAnimationState, element]);\n    var startAnimation = useConstant(function () { return function (animationDefinition) {\n        return animateVisualElement(element, animationDefinition);\n    }; });\n    return [animationState, startAnimation];\n}\n\n// Keep things reasonable and avoid scale: Infinity. In practise we might need\n// to add another value, opacity, that could interpolate scaleX/Y [0,0.01] => [0,1]\n// to simply hide content at unreasonable scales.\nvar maxScale = 100000;\nvar invertScale = function (scale) {\n    return scale > 0.001 ? 1 / scale : maxScale;\n};\nvar hasWarned = false;\n/**\n * Returns a `MotionValue` each for `scaleX` and `scaleY` that update with the inverse\n * of their respective parent scales.\n *\n * This is useful for undoing the distortion of content when scaling a parent component.\n *\n * By default, `useInvertedScale` will automatically fetch `scaleX` and `scaleY` from the nearest parent.\n * By passing other `MotionValue`s in as `useInvertedScale({ scaleX, scaleY })`, it will invert the output\n * of those instead.\n *\n * ```jsx\n * const MyComponent = () => {\n *   const { scaleX, scaleY } = useInvertedScale()\n *   return <motion.div style={{ scaleX, scaleY }} />\n * }\n * ```\n *\n * @deprecated\n */\nfunction useInvertedScale(scale) {\n    var parentScaleX = useMotionValue(1);\n    var parentScaleY = useMotionValue(1);\n    var visualElement = useVisualElementContext();\n    heyListen.invariant(!!(scale || visualElement), \"If no scale values are provided, useInvertedScale must be used within a child of another motion component.\");\n    heyListen.warning(hasWarned, \"useInvertedScale is deprecated and will be removed in 3.0. Use the layout prop instead.\");\n    hasWarned = true;\n    if (scale) {\n        parentScaleX = scale.scaleX || parentScaleX;\n        parentScaleY = scale.scaleY || parentScaleY;\n    }\n    else if (visualElement) {\n        parentScaleX = visualElement.getValue(\"scaleX\", 1);\n        parentScaleY = visualElement.getValue(\"scaleY\", 1);\n    }\n    var scaleX = useTransform(parentScaleX, invertScale);\n    var scaleY = useTransform(parentScaleY, invertScale);\n    return { scaleX: scaleX, scaleY: scaleY };\n}\n\nexports.AnimatePresence = AnimatePresence;\nexports.AnimateSharedLayout = AnimateSharedLayout;\nexports.DeprecatedLayoutGroupContext = DeprecatedLayoutGroupContext;\nexports.DragControls = DragControls;\nexports.FlatTree = FlatTree;\nexports.LayoutGroup = LayoutGroup;\nexports.LayoutGroupContext = LayoutGroupContext;\nexports.LazyMotion = LazyMotion;\nexports.MotionConfig = MotionConfig;\nexports.MotionConfigContext = MotionConfigContext;\nexports.MotionContext = MotionContext;\nexports.MotionValue = MotionValue;\nexports.PresenceContext = PresenceContext;\nexports.Reorder = Reorder;\nexports.SwitchLayoutGroupContext = SwitchLayoutGroupContext;\nexports.addPointerEvent = addPointerEvent;\nexports.addScaleCorrector = addScaleCorrector;\nexports.animate = animate;\nexports.animateVisualElement = animateVisualElement;\nexports.animationControls = animationControls;\nexports.animations = animations;\nexports.calcLength = calcLength;\nexports.checkTargetForNewValues = checkTargetForNewValues;\nexports.createBox = createBox;\nexports.createDomMotionComponent = createDomMotionComponent;\nexports.createMotionComponent = createMotionComponent;\nexports.domAnimation = domAnimation;\nexports.domMax = domMax;\nexports.filterProps = filterProps;\nexports.isBrowser = isBrowser;\nexports.isDragActive = isDragActive;\nexports.isMotionValue = isMotionValue;\nexports.isValidMotionProp = isValidMotionProp;\nexports.m = m;\nexports.makeUseVisualState = makeUseVisualState;\nexports.motion = motion;\nexports.motionValue = motionValue;\nexports.resolveMotionValue = resolveMotionValue;\nexports.transform = transform;\nexports.useAnimation = useAnimation;\nexports.useAnimationControls = useAnimationControls;\nexports.useAnimationFrame = useAnimationFrame;\nexports.useCycle = useCycle;\nexports.useDeprecatedAnimatedState = useAnimatedState;\nexports.useDeprecatedInvertedScale = useInvertedScale;\nexports.useDomEvent = useDomEvent;\nexports.useDragControls = useDragControls;\nexports.useElementScroll = useElementScroll;\nexports.useForceUpdate = useForceUpdate;\nexports.useInView = useInView;\nexports.useInstantLayoutTransition = useInstantLayoutTransition;\nexports.useInstantTransition = useInstantTransition;\nexports.useIsPresent = useIsPresent;\nexports.useIsomorphicLayoutEffect = useIsomorphicLayoutEffect;\nexports.useMotionTemplate = useMotionTemplate;\nexports.useMotionValue = useMotionValue;\nexports.usePresence = usePresence;\nexports.useReducedMotion = useReducedMotion;\nexports.useReducedMotionConfig = useReducedMotionConfig;\nexports.useResetProjection = useResetProjection;\nexports.useScroll = useScroll;\nexports.useSpring = useSpring;\nexports.useTime = useTime;\nexports.useTransform = useTransform;\nexports.useUnmountEffect = useUnmountEffect;\nexports.useVelocity = useVelocity;\nexports.useViewportScroll = useViewportScroll;\nexports.useVisualElementContext = useVisualElementContext;\nexports.visualElement = visualElement;\nexports.wrapHandler = wrapHandler;\n"],"names":["AnimationType","BoundingBoxDimension","Object","defineProperty","exports","value","tslib","__webpack_require__","React","heyListen","styleValueTypes","popmotion","sync","dom","_interopDefaultLegacy","e","React__namespace","_interopNamespace","__esModule","n","create","keys","forEach","k","d","getOwnPropertyDescriptor","get","enumerable","freeze","React__default","sync__default","env","process","createDefinition","propNames","isEnabled","props","some","name","featureDefinitions","measureLayout","animation","exit","drag","focus","hover","tap","pan","inView","loadFeatures","features","key","projectionNodeConstructor","Component","LazyContext","createContext","strict","featureNames","numFeatures","length","MotionConfigContext","transformPagePoint","p","isStatic","reducedMotion","MotionContext","useVisualElementContext","useContext","visualElement","PresenceContext","isBrowser","document","useIsomorphicLayoutEffect","useLayoutEffect","useEffect","prefersReducedMotion","current","hasDetected","useReducedMotion","initPrefersReducedMotion","window","matchMedia","motionMediaQuery_1","setReducedMotionPreferences","matches","addListener","_a","__read","useState","useReducedMotionConfig","reducedMotionPreference","isRefObject","ref","prototype","hasOwnProperty","call","isVariantLabels","v","Array","isArray","isVariantLabel","resolveVariantFromProps","definition","custom","currentValues","currentVelocity","variants","resolveVariant","velocity","getProps","forEachValue","getVelocity","checkIfControllingVariants","animate","start","initial","whileHover","whileDrag","whileTap","whileFocus","checkIfVariantNode","Boolean","variantLabelsAsDependency","prop","join","useConstant","init","useRef","globalProjectionState","hasAnimatedSinceResize","hasEverUpdated","id$1","LayoutGroupContext","SwitchLayoutGroupContext","VisualElementHandler","_super","apply","arguments","__extends","getSnapshotBeforeUpdate","updateProps","componentDidUpdate","setProps","render","children","createMotionComponent","preloadedFeatures","createVisualElement","useRender","useVisualState","forwardRef","externalRef","ProjectionNodeConstructor","_b","layoutId","layout","dragConstraints","layoutScroll","initialPromotionConfig","layoutGroupId","lazyContext","parent","presenceContext","shouldReduceMotion","visualElementRef","id","undefined","__assign","config","context","getCurrentTreeVariants","inherit","useMemo","projectionId","visualState","renderer","presenceId","blockInitialAnimation","syncRender","animationState","animateChanges","notifyUnmount","projection","getLatestValues","setOptions","alwaysMeasureLayout","scheduleRender","animationType","useFeatures","invariant","i","name_1","push","createElement","Provider","useCallback","instance","mount","unmount","createMotionProxy","createConfig","customMotionComponentConfig","Proxy","componentCache","Map","_target","has","set","lowercaseSVGElements","isSVGComponent","includes","indexOf","test","scaleCorrectors","addScaleCorrector","correctors","assign","transformAxes","transformProps","sortTransformProps","a","b","order","operationKey","axesKey","transformPropSet","Set","isTransformProp","transformOriginProps","isForcedMotionValue","isMotionValue","translateAlias","x","y","z","transformPerspective","isCSSVariable$1","startsWith","int","number","transform","Math","round","numberValueTypes","borderWidth","px","borderTopWidth","borderRightWidth","borderBottomWidth","borderLeftWidth","borderRadius","radius","borderTopLeftRadius","borderTopRightRadius","borderBottomRightRadius","borderBottomLeftRadius","width","maxWidth","height","maxHeight","size","top","right","bottom","left","padding","paddingTop","paddingRight","paddingBottom","paddingLeft","margin","marginTop","marginRight","marginBottom","marginLeft","rotate","degrees","rotateX","rotateY","rotateZ","scale","scaleX","scaleY","scaleZ","skew","skewX","skewY","distance","translateX","translateY","translateZ","perspective","opacity","alpha","originX","progressPercentage","originY","originZ","zIndex","fillOpacity","strokeOpacity","numOctaves","buildHTMLStyles","state","latestValues","options","transformTemplate","_c","_d","style","vars","transformKeys","transformOrigin","hasTransform","hasTransformOrigin","transformIsNone","valueType","valueAsType","type","default","buildTransform","transformIsDefault","enableHardwareAcceleration","allowTransformNone","transformString","sort","transformHasZ","numTransformKeys","concat","trim","createHtmlRenderState","copyRawValuesOnly","target","source","validMotionProps","isValidMotionProp","shouldForward","loadExternalIsValidProp","isValidProp","Z","filterProps","isDom","forwardMotionProps","filteredProps","calcOrigin$1","origin","offset","dashKeys","array","camelKeys","buildSVGAttrs","pxOriginX","pxOriginY","spacing","useDashCase","pathLength","pathSpacing","attrX","attrY","pathOffset","__rest","attrs","dimensions","createSvgRenderState","CAMEL_CASE_PATTERN","camelToDash","str","replace","toLowerCase","renderHTML","element","styleProp","getProjectionStyles","setProperty","camelCaseAttributes","renderSVG","renderState","_styleProp","setAttribute","scrapeMotionValuesFromProps$1","newValues","scrapeMotionValuesFromProps","toUpperCase","isAnimationControls","isKeyframesTarget","resolveFinalValueInKeyframes","resolveMotionValue","unwrappedValue","isCustomValue","mix","toValue","makeState","createRenderState","onMount","makeLatestValues","scrapeMotionValues","values","motionValues","isControllingVariants","isVariantNode","initialAnimationIsBlocked","variantToSet","list","resolved","transitionEnd","transition","valueTarget","index","makeUseVisualState","svgMotionConfig","getBBox","getBoundingClientRect","htmlMotionConfig","createDomMotionConfig","baseConfig","visualProps","useVisualProps","rawStyles","htmlProps","transformValues","dragListener","draggable","userSelect","WebkitUserSelect","WebkitTouchCallout","touchAction","elementProps","addDomEvent","eventName","handler","passive","addEventListener","removeEventListener","useDomEvent","isMouseEvent","event","PointerEvent","pointerType","MouseEvent","defaultPagePoint","pageX","pageY","extractEventInfo","pointType","point","isTouchEvent","touches","primaryTouch","changedTouches","wrapHandler","shouldFilterPrimaryPointer","listener","button","eventHandler","mouseEventNames","pointerdown","pointermove","pointerup","pointercancel","pointerover","pointerout","pointerenter","pointerleave","touchEventNames","getPointerEventName","onpointerdown","ontouchstart","onmousedown","addPointerEvent","usePointerEvent","createLock","lock","globalHorizontalLock","globalVerticalLock","getGlobalLock","openHorizontal_1","openVertical_1","isDragActive","openGestureLock","createHoverEvent","isActive","callback","info","setActive","Hover","isNodeOrChild","child","parentElement","useUnmountEffect","warned","warnOnce","condition","message","console","warn","add","observerCallbacks","WeakMap","observers","fireObserverCallback","entry","fireAllObserverCallbacks","entries","thresholdNames","all","makeRenderlessComponent","hook","gestureAnimations","whileInView","onViewportEnter","onViewportLeave","viewport","hasEnteredView","isInView","shouldObserve","once","useObserver","IntersectionObserver","fallback","requestAnimationFrame","InView","root","rootMargin","amount","lookupRoot","rootObservers","rootInteresectionObserver","threshold","getInstance","JSON","stringify","isIntersecting","observe","delete","unobserve","onTap","onTapStart","onTapCancel","hasPressListeners","isPressing","cancelPointerEndListeners","eventOptions","onPointerDown","removePointerEndListener","checkPointerEnd","Tap","onPointerUp","onPointerCancel","pipe","Focus","onHoverStart","onHoverEnd","counter","incrementId","useId","usePresence","isPresent","onExitComplete","register","shallowCompare","next","prev","prevLength","secondsToMilliseconds","seconds","easingLookup","linear","easeIn","easeInOut","easeOut","circIn","circInOut","circOut","backIn","backInOut","backOut","anticipate","bounceIn","bounceInOut","bounceOut","easingDefinitionToFunction","x1","y1","x2","y2","cubicBezier","isAnimatable","complex","underDampedSpring","stiffness","damping","restSpeed","criticallyDampedSpring","to","sqrt","linearTween","ease","duration","keyframes","defaultTransitions","backgroundColor","color","getDefaultTransition","valueKey","transitionFactory","defaultValueTypes","outlineColor","fill","stroke","borderColor","borderTopColor","borderRightColor","borderBottomColor","borderLeftColor","filter","WebkitFilter","getDefaultValueType","getAnimatableNone","defaultValueType","instantAnimationState","legacyRepeatWarning","isZero","parseFloat","getZeroUnit","potentialUnitType","getValueTransition","startAnimation","onComplete","valueTransition","isTargetAnimatable","isOriginAnimatable","delayTimer","controls","from","warning","times","yoyo","flip","loop","onUpdate","inertia","__spreadArray","when","delay","delayChildren","staggerChildren","staggerDirection","repeat","repeatType","repeatDelay","isEasingArray","map","finalTarget","stop","setTimeout","clearTimeout","addUniqueItem","arr","item","removeItem","splice","SubscriptionManager","subscriptions","_this","notify","c","numSubscriptions","getSize","clear","MotionValue","version","timeDelta","lastUpdated","updateSubscribers","velocityUpdateSubscribers","renderSubscribers","canTrackVelocity","updateAndNotify","getFrameData","delta","timestamp","postRender","scheduleVelocityCheck","velocityCheck","hasAnimated","isNaN","onChange","subscription","clearListeners","onRenderRequest","attach","passiveEffect","getPrevious","velocityPerSecond","Promise","resolve","stopAnimation","then","clearAnimation","isAnimating","destroy","motionValue","testValueType","dimensionValueTypes","percent","vw","vh","parse","findDimensionValueType","find","valueTypes","setTarget","makeTargetAnimatable","hasValue","getValue","addValue","setVariants","variantLabels","reversedLabels","reverse","variant","getVariant","variantChildren","checkTargetForNewValues","newValueKeys","numNewValues","targetValue","readValue","isNumericalString","setBaseTarget","getOrigin","getOriginFromTransition","animateVisualElement","notifyAnimationStart","animateVariant","resolvedDefinition","animateTarget","notifyAnimationComplete","transitionOverride","getAnimation","getChildAnimations","forwardDelay","animations","maxStaggerDuration","generateStaggerDuration","sortByTreeOrder","first","last","_e","_f","animationTypeState","getState","shouldBlockAnimation","protectedKeys","needsAnimating","shouldBlock","sortNodePosition","variantPriorityOrder","Animate","Drag","Exit","reversePriorityOrder","numAnimationTypes","createTypeState","prevResolvedValues","createAnimationState","allAnimatedKeys","isInitialRender","buildResolvedTypeValues","acc","changedActiveType","getVariantContext","removedKeys","encounteredKeys","removedVariantIndex","Infinity","_loop_1","typeState","propIsVariant","activeDelta","isInherited","manuallyAnimateOnMount","prevProp","variantDidChange","shouldAnimateType","definitionList","resolvedValues","reduce","allKeys","markToAnimate","fallbackAnimation_1","fallbackTarget","getBaseTarget","shouldAnimate","isAnimated","setAnimateFunction","makeAnimator","subscribe","safeToRemove","PanSession","handlers","startEvent","lastMoveEvent","lastMoveEventInfo","updatePoint","getPanInfo","history","isPanStarted","isDistancePastThreshold","onStart","onMove","handlePointerMove","transformPoint","buttons","handlePointerUp","update","end","onEnd","onSessionEnd","panInfo","initialInfo","onSessionStart","removeListeners","updateHandlers","cancelSync","subtractPoint","lastDevicePoint","timestampedPoint","lastPoint","time","calcLength","axis","max","min","isNear","maxDistance","calcAxisDelta","originPoint","translate","calcBoxDelta","calcRelativeAxis","relative","calcRelativeAxisPosition","calcRelativePosition","calcRelativeAxisConstraints","calcViewportAxisConstraints","layoutAxis","constraintsAxis","resolveAxisElastic","dragElastic","minLabel","maxLabel","resolvePointElastic","label","createAxisDelta","createDelta","createAxis","createBox","eachAxis","convertBoundingBoxToBox","isIdentityScale","hasScale","applyPointDelta","boxScale","applyAxisDelta","applyBoxDelta","box","translateAxis","transformAxis","transforms","scaleKey","originKey","axisOrigin","xKeys$1","yKeys$1","transformBox","measureViewportBox","transformBoxPoints","topLeft","bottomRight","elementDragControls","VisualElementDragControls","openGlobalLock","isDragging","currentDirection","constraints","hasMutatedConstraints","elastic","originEvent","snapToCursor","panSession","dragPropagation","onDragStart","resolveConstraints","isAnimationBlocked","getAxisMotionValue","measuredAxis","actual","length_1","dragDirectionLock","onDirectionLock","onDrag","lockThreshold","direction","abs","updateAxis","getTransformPagePoint","cancel","onDragEnd","_point","shouldDrag","axisValue","layoutBox","prevConstraints","resolveRefConstraints","relativeConstraints","onMeasureDragConstraints","constraintsElement","constraintsBox","rootProjectionNode","viewportBox","scroll","measuredConstraints","userConstraints","dragMomentum","dragTransition","dragSnapToOrigin","onDragTransitionEnd","bounceStiffness","bounceDamping","timeConstant","restDelta","startAxisValueAnimation","dragKey","externalMotionValue","scalePositionWithinConstraints","boxProgress","sourceLength","targetLength","latest","progress","clamp","updateScroll","updateLayout","addListeners","stopPointerListener","measureDragConstraints","stopMeasureLayoutListener","stopResizeListener","hasLayoutChanged","onPan","onPanStart","onPanEnd","onPanSessionStart","hasPanEvents","groupDragControls","dragControls","names","treeType","build","renderInstance","readValueFromInstance","removeValueFromRenderState","managers","propSubscriptions","lifecycles","removeFromVariantTree","isMounted","clearAllListeners","manager","updatePropListeners","on","propListener","args","_i","valueSubscriptions","prevMotionValues","baseTarget","triggerBuild","notifyUpdate","bindToMotionValue","removeOnChange","latestValue","removeOnRenderRequest","initialMotionValues","depth","isVisible","newInstance","addVariantChild","remove","closestVariantNode","getClosestVariantNode","other","getLayoutId","getStaticValue","setStaticValue","setVisibility","visibility","canMutate","removeValue","defaultValue","newProps","updateMotionValuesFromProps","nextValue","prevValue","existingValue","startAtParent","context_1","numVariantProps","variantProps","isCSSVariable","cssVariableRegex","getVariableValue","parseCSSVariable","match","exec","token","getComputedStyle","getPropertyValue","positionalKeys","isPositionalKey","setAndResetVelocity","isNumOrPxType","getPosFromMatrix","matrix","pos","split","getTranslateFromMatrix","pos2","pos3","_bbox","matrix3d","nonTranslationalTransformKeys","positionalValues","convertChangedValueTypes","changedKeys","originBbox","elementComputedStyle","display","targetBbox","checkAndConvertChangedValueTypes","targetPositionalKeys","removedTransformValues","hasAttemptedToRemoveTransformValues","changedValueTypeKeys","toType","fromType","numKeyframes","fromIndex","removedTransforms","scrollY_1","pageYOffset","convertedTarget","scrollTo","parseDomVariant","resolveCSSVariables","Element","hasPositionalKey","htmlConfig","domElement","defaultType","computedStyle","compareDocumentPosition","resetTransform","restoreTransform","mutableState","parsed","htmlVisualElement","svgVisualElement","getAttribute","_element","createDomVisualElement","pixelsToPercent","pixels","correctBorderRadius","correct","node","varToken","MeasureLayoutWithContext","componentDidMount","layoutGroup","switchLayoutGroup","defaultScaleCorrectors","group","didUpdate","prevProps","layoutDependency","willUpdate","promote","relegate","getStack","members","currentAnimation","isLead","componentWillUnmount","promoteContext","scheduleCheckAfterUnmount","deregister","applyTo","boxShadow","treeScale","projectionDelta","original","containsCSSVariables","cssVariables","shadow","template","createTransformer","xScale","yScale","averageScale","output","i_1","cssVariable","layoutFeatures","borders","numBorders","asNumber","isPx","getRadius","radiusName","easeCrossfadeIn","compress","easeCrossfadeOut","easing","copyAxisInto","originAxis","copyBoxInto","originBox","removePointDelta","removeAxisTransforms","sourceAxis","removeAxisDelta","relativeProgress","xKeys","yKeys","removeBoxTransforms","sourceBox","isAxisDeltaZero","isDeltaZero","boxEquals","NodeStack","prevLead","lead","indexOfNode","findIndex","member","preserveFollowOpacity","show","resumeFrom","preserveOpacity","snapshot","animationValues","isShared","isUpdating","isLayoutDirty","crossfade","hide","exitAnimationComplete","resumingFrom","removeLeadSnapshot","buildProjectionTransform","latestTransform","xTranslate","yTranslate","elementScaleX","elementScaleY","compareByDepth","FlatTree","isDirty","createProjectionNode","attachResizeListener","defaultParent","measureScroll","checkIsScrollRoot","ProjectionNode","isTreeAnimating","updateManuallyBlocked","updateBlockedByResize","isSVG","needsReset","shouldResetTransform","eventHandlers","potentialNodes","checkUpdateFailed","clearAllSnapshots","updateProjection","nodes","resolveTargetDelta","calcProjection","hasProjected","animationProgress","sharedNodes","path","registerPotentialNode","notifyListeners","subscriptionManager","hasListeners","SVGElement","tagName","unblockTimeout_1","resizeUnblockUpdate_1","finishAnimation","registerSharedNode","hasRelativeTargetChanged","newLayout","isTreeAnimationBlocked","relativeTarget","layoutTransition","defaultLayoutTransition","_g","onLayoutAnimationStart","onLayoutAnimationComplete","targetChanged","targetLayout","hasOnlyRelativeTargetChanged","setAnimationOrigin","animationOptions","onPlay","preRender","blockUpdate","unblockUpdate","isUpdateBlocked","startUpdate","resetRotation","shouldNotifyListeners","prevTransformTemplateValue","updateSnapshot","clearMeasurements","mountNodeEarly","resetTransformStyle","notifyLayoutUpdate","flushSync","clearSnapshot","removeLeadSnapshots","scheduleUpdateProjection","measured","measure","removeTransform","removeElementScroll","roundBox","prevLayout","layoutCorrected","notifyLayoutMeasure","isScrollRoot","isResetRequested","hasProjection","transformTemplateValue","transformTemplateHasChanged","boxWithoutScroll","scroll_1","rootScroll","applyTransform","transformOnly","withTransforms","boxWithoutTransform","setTargetDelta","targetDelta","relativeParent","getClosestProjectingParent","relativeTargetOrigin","targetWithTransforms","attemptToResolveRelativeTarget","pendingAnimation","getLead","applyTreeDeltas","treePath","isSharedTransition","treeLength","projectionDeltaWithTransform","prevTreeScaleX","prevTreeScaleY","prevProjectionTransform","projectionTransform","notifyAll","snapshotLatestValues","mixedValues","relativeLayout","isSharedLayoutAnimation","isOnlyMember","shouldCrossfadeOpacity","hasOpacityCrossfade","mixTargetDelta","mixAxisDelta","mixAxis","mixValues","follow","opacityExit","borderLabel","followRadius","leadRadius","completeAnimation","applyTransformsToTarget","stack","shouldPreserveFollowOpacity","getPrevLead","hasRotate","resetValues","styles","pointerEvents","emptyStyles","valuesToRender","_h","corrected","num","resetTree","layout_1","measuredLayout","axisSnapshot","layoutDelta","visualDelta","parentSnapshot","parentLayout","relativeSnapshot","onBeforeLayoutMeasure","notifyBeforeLayoutMeasure","searchNode","searchElement","querySelector","roundAxis","DocumentProjectionNode","documentElement","scrollLeft","body","scrollTop","HTMLProjectionNode","documentNode","position","featureBundle","motion","m","useIsMounted","useForceUpdate","forcedRenderCount","setForcedRenderCount","forceRender","PresenceChild","presenceAffectsLayout","presenceChildren","newChildrenMap","childId","e_1","__values","done","e_1_1","error","return","_","getChildKey","DeprecatedLayoutGroupContext","shouldInheritGroup","LayoutGroup","dirtyAll","inheritId","layoutGroupContext","deprecatedLayoutGroupContext","upstreamId","dirty","memoizedContext","isLazyBundle","ReorderContext","Group","as","onReorder","isReordering","registerItem","compareMin","updateOrder","newOrder","checkReorder","nextOffset","nextItem","nextLayout","nextItemCenter","moveItem","toIndex","slice","startIndex","endIndex","useMotionValue","setLatest_1","useImmediate","argOffset","inputValue","inputRange","outputRange","interpolator","interpolate","mixer","isCustomValueType","useCombineMotionValues","combineValues","updateValue","unsubscribe","useTransform","input","inputRangeOrTransformer","transformer","useListTransform","numValues","useDefaultMotionValue","Item","latestX","latestY","gesturePoint","onLayoutMeasure","domAnimation","domMax","createScrollMotionValues","scrollX","scrollY","scrollXProgress","scrollYProgress","useScroll","container","getCurrentTime","performance","now","Date","useAnimationFrame","initialTimestamp","provideTimeSinceStart","animationControls","hasMounted","pendingAnimations","subscribers","animations_1","useAnimationControls","DragControls","componentControls","nativeEvent","createDragControls","startTransition","cb","createObject","stateVisualElement","_state","initialState","invertScale","hasWarned","AnimatePresence","filtered","exitBeforeEnter","forceRenderLayoutGroup","filteredChildren","Children","isValidElement","childrenToRender","exiting","presentChildren","allChildren","updateChildLookup","Fragment","presentKeys","targetKeys","numPresent","insertionIndex","removeIndex","presentChild","cloneElement","AnimateSharedLayout","LazyMotion","setIsLoaded","loadedRenderer","loadedFeatures","MotionConfig","Reorder","createDomMotionComponent","useAnimation","useCycle","items","setItem","wrap","useDeprecatedAnimatedState","setAnimationState","animationDefinition","useDeprecatedInvertedScale","parentScaleX","parentScaleY","useDragControls","useElementScroll","useInView","setInView","useInstantLayoutTransition","useInstantTransition","forceUpdate","startInstantLayoutTransition","useIsPresent","useMotionTemplate","fragments","numFragments","useResetProjection","useSpring","activeSpringAnimation","useTime","t","useVelocity","newVelocity","useViewportScroll"],"sourceRoot":""}