{"version":3,"file":"static/js/8608.36920e58.chunk.js","mappings":"8LACe,SAASA,IActB,OAZEA,EADqB,qBAAZC,SAA2BA,QAAQC,IACrCD,QAAQC,IAAIC,OAEZ,SAAcC,EAAQC,EAAUC,GACrC,IAAIC,ECLK,SAAwBC,EAAQH,GAC7C,MAAQI,OAAOC,UAAUC,eAAeC,KAAKJ,EAAQH,IAEpC,QADfG,GAAS,EAAAK,EAAA,GAAeL,MAG1B,OAAOA,CACT,CDDiB,CAAcJ,EAAQC,GACjC,GAAKE,EAAL,CACA,IAAIO,EAAOL,OAAOM,yBAAyBR,EAAMF,GACjD,OAAIS,EAAKZ,IACAY,EAAKZ,IAAIU,KAAKI,UAAUC,OAAS,EAAIb,EAASE,GAEhDQ,EAAKI,KALK,CAMnB,EAEKlB,EAAKmB,MAAMC,KAAMJ,UAC1B,C,mHEhBMK,EAAO,WACT,SAAAA,EAAYC,IAAMC,EAAAA,EAAAA,GAAA,KAAAF,GACdD,KAAKI,WAAY,EACjBJ,KAAKE,KAAOA,CAChB,CACY,OADXG,EAAAA,EAAAA,GAAAJ,EAAA,EAAAK,IAAA,SAAAR,MACD,WAAW,KAACG,CAAA,CALH,G,sBCAPM,EAAmB,SAACC,GACtB,MAA0B,UAAtBA,EAAMC,YACyB,kBAAjBD,EAAME,QAAuBF,EAAME,QAAU,GAWhC,IAApBF,EAAMG,SAErB,ECbA,SAASC,EAAiBJ,GAA2B,IAApBK,EAASjB,UAAAC,OAAA,QAAAiB,IAAAlB,UAAA,GAAAA,UAAA,GAAG,OACzC,MAAO,CACHmB,MAAO,CACHC,EAAGR,EAAMK,EAAY,KACrBI,EAAGT,EAAMK,EAAY,MAGjC,CACA,IAAMK,EAAiB,SAACC,GACpB,OAAO,SAACX,GAAK,OAAKD,EAAiBC,IAAUW,EAAQX,EAAOI,EAAiBJ,GAAO,CACxF,E,UCNMY,EAAwB,SAACC,GAAO,OAAe,IAAVA,CAAc,ECNzD,SAASC,EAAYtC,EAAQuC,EAAWJ,GAAsC,IAA7BK,EAAO5B,UAAAC,OAAA,QAAAiB,IAAAlB,UAAA,GAAAA,UAAA,GAAG,CAAE6B,SAAS,GAElE,OADAzC,EAAO0C,iBAAiBH,EAAWJ,EAASK,GACrC,kBAAMxC,EAAO2C,oBAAoBJ,EAAWJ,EAAQ,CAC/D,CCAA,SAASS,EAAgB5C,EAAQuC,EAAWJ,EAASK,GACjD,OAAOF,EAAYtC,EAAQuC,EAAWL,EAAeC,GAAUK,EACnE,C,eCLMK,EAAW,SAACC,EAAGC,GAAC,OAAKC,KAAKC,IAAIH,EAAIC,EAAE,E,eCYpCG,EAAU,WACZ,SAAAA,EAAY1B,EAAO2B,GAAuC,IAAAC,EAAA,KAA3BC,GAA2BzC,UAAAC,OAAA,QAAAiB,IAAAlB,UAAA,GAAAA,UAAA,GAAJ,CAAC,GAAxByC,mBA0D3B,IA1D6ClC,EAAAA,EAAAA,GAAA,KAAA+B,GAI7ClC,KAAKsC,WAAa,KAIlBtC,KAAKuC,cAAgB,KAIrBvC,KAAKwC,kBAAoB,KAIzBxC,KAAKmC,SAAW,CAAC,EACjBnC,KAAKyC,YAAc,WACf,GAAML,EAAKG,eAAiBH,EAAKI,kBAAjC,CAEA,IAAME,EAAOC,EAAWP,EAAKI,kBAAmBJ,EAAKQ,SAC/CC,EAAmC,OAApBT,EAAKE,WAIpBQ,EDrClB,SAAoBhB,EAAGC,GAEnB,IAAMgB,EAASlB,EAASC,EAAEd,EAAGe,EAAEf,GACzBgC,EAASnB,EAASC,EAAEb,EAAGc,EAAEd,GAC/B,OAAOe,KAAKiB,KAAKjB,KAAAkB,IAAAH,EAAU,GAACf,KAAAkB,IAAGF,EAAU,GAC7C,CCgC4CG,CAAWT,EAAKU,OAAQ,CAAEpC,EAAG,EAAGC,EAAG,KAAQ,EAC3E,GAAK4B,GAAiBC,EAAtB,CAEA,IAAQ/B,EAAU2B,EAAV3B,MACAsC,EAAcC,EAAAA,EAAAA,UACtBlB,EAAKQ,QAAQW,MAAIC,EAAAA,EAAAA,IAAAA,EAAAA,EAAAA,GAAC,CAAC,EAAIzC,GAAK,IAAEsC,UAAAA,KAC9B,IAAAI,EAA4BrB,EAAKD,SAAzBuB,EAAOD,EAAPC,QAASC,EAAMF,EAANE,OACZd,IACDa,GAAWA,EAAQtB,EAAKG,cAAeG,GACvCN,EAAKE,WAAaF,EAAKG,eAE3BoB,GAAUA,EAAOvB,EAAKG,cAAeG,EAT3B,CARA,CAkBd,EACA1C,KAAK4D,kBAAoB,SAACpD,EAAOkC,GAC7BN,EAAKG,cAAgB/B,EACrB4B,EAAKI,kBAAoBqB,EAAenB,EAAMN,EAAKC,oBAEnDyB,EAAAA,GAAAA,OAAY1B,EAAKK,aAAa,EAClC,EACAzC,KAAK+D,gBAAkB,SAACvD,EAAOkC,GAE3B,GADAN,EAAK4B,MACC5B,EAAKG,eAAiBH,EAAKI,kBAAjC,CAEA,IAAAyB,EAAgC7B,EAAKD,SAA7B+B,EAAKD,EAALC,MAAOC,EAAYF,EAAZE,aACTC,EAAUzB,EAA0B,kBAAfnC,EAAM6D,KAC3BjC,EAAKI,kBACLqB,EAAenB,EAAMN,EAAKC,oBAAqBD,EAAKQ,SACtDR,EAAKE,YAAc4B,GACnBA,EAAM1D,EAAO4D,GAEjBD,GAAgBA,EAAa3D,EAAO4D,EAR1B,CASd,EAEK7D,EAAiBC,GAAtB,CAEAR,KAAKmC,SAAWA,EAChBnC,KAAKqC,mBAAqBA,EAC1B,IACMiC,EAAcT,EADPjD,EAAiBJ,GACWR,KAAKqC,oBACtCtB,EAAUuD,EAAVvD,MACAsC,EAAcC,EAAAA,EAAAA,UACtBtD,KAAK4C,QAAU,EAAAY,EAAAA,EAAAA,IAAAA,EAAAA,EAAAA,GAAA,GAAMzC,GAAK,IAAEsC,UAAAA,KAC5B,IAAQkB,EAAmBpC,EAAnBoC,eACRA,GACIA,EAAe/D,EAAOmC,EAAW2B,EAAatE,KAAK4C,UACvD5C,KAAKwE,iBAAkBC,EAAAA,EAAAA,GAAK7C,EAAgB8C,OAAQ,cAAe1E,KAAK4D,mBAAoBhC,EAAgB8C,OAAQ,YAAa1E,KAAK+D,iBAAkBnC,EAAgB8C,OAAQ,gBAAiB1E,KAAK+D,iBAX5L,CAYd,CAOC,OAPA1D,EAAAA,EAAAA,GAAA6B,EAAA,EAAA5B,IAAA,iBAAAR,MACD,SAAeqC,GACXnC,KAAKmC,SAAWA,CACpB,GAAC,CAAA7B,IAAA,MAAAR,MACD,WACIE,KAAKwE,iBAAmBxE,KAAKwE,kBAC7BG,EAAAA,GAAAA,OAAkB3E,KAAKyC,YAC3B,KAACP,CAAA,CA/EW,GAiFhB,SAAS2B,EAAenB,EAAML,GAC1B,OAAOA,EAAqB,CAAEtB,MAAOsB,EAAmBK,EAAK3B,QAAW2B,CAC5E,CACA,SAASkC,EAAc9C,EAAGC,GACtB,MAAO,CAAEf,EAAGc,EAAEd,EAAIe,EAAEf,EAAGC,EAAGa,EAAEb,EAAIc,EAAEd,EACtC,CACA,SAAS0B,EAAUkC,EAAYjC,GAAS,IAAlB7B,EAAK8D,EAAL9D,MAClB,MAAO,CACHA,MAAAA,EACA+D,MAAOF,EAAc7D,EAAOgE,EAAgBnC,IAC5CQ,OAAQwB,EAAc7D,EAAOiE,EAAiBpC,IAC9CqC,SAAUC,EAAYtC,EAAS,IAEvC,CACA,SAASoC,EAAiBpC,GACtB,OAAOA,EAAQ,EACnB,CACA,SAASmC,EAAgBnC,GACrB,OAAOA,EAAQA,EAAQ/C,OAAS,EACpC,CACA,SAASqF,EAAYtC,EAASuC,GAC1B,GAAIvC,EAAQ/C,OAAS,EACjB,MAAO,CAAEmB,EAAG,EAAGC,EAAG,GAKtB,IAHA,IAAImE,EAAIxC,EAAQ/C,OAAS,EACrBwF,EAAmB,KACjBC,EAAYP,EAAgBnC,GAC3BwC,GAAK,IACRC,EAAmBzC,EAAQwC,KACvBE,EAAUjC,UAAYgC,EAAiBhC,UACvCjC,EAAsB+D,MAG1BC,IAEJ,IAAKC,EACD,MAAO,CAAErE,EAAG,EAAGC,EAAG,GAEtB,IAAMsE,GAAQD,EAAUjC,UAAYgC,EAAiBhC,WAAa,IAClE,GAAa,IAATkC,EACA,MAAO,CAAEvE,EAAG,EAAGC,EAAG,GAEtB,IAAMuE,EAAkB,CACpBxE,GAAIsE,EAAUtE,EAAIqE,EAAiBrE,GAAKuE,EACxCtE,GAAIqE,EAAUrE,EAAIoE,EAAiBpE,GAAKsE,GAQ5C,OANIC,EAAgBxE,IAAMyE,MACtBD,EAAgBxE,EAAI,GAEpBwE,EAAgBvE,IAAMwE,MACtBD,EAAgBvE,EAAI,GAEjBuE,CACX,CClJA,SAASE,EAAWC,GAChB,IAAIC,EAAO,KACX,OAAO,WAIH,OAAa,OAATA,IACAA,EAAOD,EAJM,WACbC,EAAO,IACX,EAMJ,CACJ,CACA,IAAMC,EAAuBH,EAAW,kBAClCI,EAAqBJ,EAAW,gBACtC,SAASK,EAAcC,GACnB,IAAIJ,GAAO,EACX,GAAa,MAATI,EACAJ,EAAOE,SAEN,GAAa,MAATE,EACLJ,EAAOC,QAEN,CACD,IAAMI,EAAiBJ,IACjBK,EAAeJ,IACjBG,GAAkBC,EAClBN,EAAO,WACHK,IACAC,GACJ,GAIID,GACAA,IACAC,GACAA,IAEZ,CACA,OAAON,CACX,CACA,SAASO,IAGL,IAAMC,EAAkBL,GAAc,GACtC,OAAKK,IAELA,KACO,EACX,C,qCChDA,SAASC,EAAWC,GAChB,OAAOA,EAAKC,IAAMD,EAAKE,GAC3B,CACA,SAASC,EAAO3G,GAAuC,IAAhCd,EAAMY,UAAAC,OAAA,QAAAiB,IAAAlB,UAAA,GAAAA,UAAA,GAAG,EAAG8G,EAAW9G,UAAAC,OAAA,QAAAiB,IAAAlB,UAAA,GAAAA,UAAA,GAAG,IAC7C,OAAOoC,KAAKC,IAAInC,EAAQd,IAAW0H,CACvC,CACA,SAASC,EAAc7B,EAAO8B,EAAQ5H,GAAsB,IAAd6H,EAAMjH,UAAAC,OAAA,QAAAiB,IAAAlB,UAAA,GAAAA,UAAA,GAAG,GACnDkF,EAAM+B,OAASA,EACf/B,EAAMgC,aAAcC,EAAAA,EAAAA,GAAIH,EAAOJ,IAAKI,EAAOL,IAAKzB,EAAM+B,QACtD/B,EAAMkC,MAAQX,EAAWrH,GAAUqH,EAAWO,IAC1CH,EAAO3B,EAAMkC,MAAO,EAAG,OAAWC,MAAMnC,EAAMkC,UAC9ClC,EAAMkC,MAAQ,GAClBlC,EAAMoC,WACFH,EAAAA,EAAAA,GAAI/H,EAAOwH,IAAKxH,EAAOuH,IAAKzB,EAAM+B,QAAU/B,EAAMgC,aAClDL,EAAO3B,EAAMoC,YAAcD,MAAMnC,EAAMoC,cACvCpC,EAAMoC,UAAY,EAC1B,CACA,SAASC,EAAarC,EAAO8B,EAAQ5H,EAAQ6H,GACzCF,EAAc7B,EAAM9D,EAAG4F,EAAO5F,EAAGhC,EAAOgC,EAAG6F,EAASA,EAAOO,aAAUtG,GACrE6F,EAAc7B,EAAM7D,EAAG2F,EAAO3F,EAAGjC,EAAOiC,EAAG4F,EAASA,EAAOQ,aAAUvG,EACzE,CACA,SAASwG,EAAiBtI,EAAQuI,EAAUC,GACxCxI,EAAOwH,IAAMgB,EAAOhB,IAAMe,EAASf,IACnCxH,EAAOuH,IAAMvH,EAAOwH,IAAMH,EAAWkB,EACzC,CAKA,SAASE,EAAyBzI,EAAQ0I,EAAQF,GAC9CxI,EAAOwH,IAAMkB,EAAOlB,IAAMgB,EAAOhB,IACjCxH,EAAOuH,IAAMvH,EAAOwH,IAAMH,EAAWqB,EACzC,CACA,SAASC,EAAqB3I,EAAQ0I,EAAQF,GAC1CC,EAAyBzI,EAAOgC,EAAG0G,EAAO1G,EAAGwG,EAAOxG,GACpDyG,EAAyBzI,EAAOiC,EAAGyG,EAAOzG,EAAGuG,EAAOvG,EACxD,C,cCZA,SAAS2G,EAA4BtB,EAAME,EAAKD,GAC5C,MAAO,CACHC,SAAa1F,IAAR0F,EAAoBF,EAAKE,IAAMA,OAAM1F,EAC1CyF,SAAazF,IAARyF,EACCD,EAAKC,IAAMA,GAAOD,EAAKC,IAAMD,EAAKE,UAClC1F,EAEd,CAcA,SAAS+G,EAA4BC,EAAYC,GAC7C,IAAIvB,EAAMuB,EAAgBvB,IAAMsB,EAAWtB,IACvCD,EAAMwB,EAAgBxB,IAAMuB,EAAWvB,IAG3C,GAAIwB,EAAgBxB,IAAMwB,EAAgBvB,IACtCsB,EAAWvB,IAAMuB,EAAWtB,IAAK,KAAAwB,EACpB,CAACzB,EAAKC,GAAlBA,EAAGwB,EAAA,GAAEzB,EAAGyB,EAAA,EACb,CACA,MAAO,CAAExB,IAAAA,EAAKD,IAAAA,EAClB,CAuCA,IAAM0B,EAAiB,IAgBvB,SAASC,EAAmBC,EAAaC,EAAUC,GAC/C,MAAO,CACH7B,IAAK8B,EAAoBH,EAAaC,GACtC7B,IAAK+B,EAAoBH,EAAaE,GAE9C,CACA,SAASC,EAAoBH,EAAaI,GACtC,MAA8B,kBAAhBJ,EACRA,EACAA,EAAYI,IAAU,CAChC,CC1HA,IAMMC,EAAc,WAAH,MAAU,CACvBxH,EAP2B,CAC3BkG,UAAW,EACXF,MAAO,EACPH,OAAQ,EACRC,YAAa,GAIb7F,EAR2B,CAC3BiG,UAAW,EACXF,MAAO,EACPH,OAAQ,EACRC,YAAa,GAKhB,EAEK2B,EAAY,WAAH,MAAU,CACrBzH,EAFsB,CAAEwF,IAAK,EAAGD,IAAK,GAGrCtF,EAHsB,CAAEuF,IAAK,EAAGD,IAAK,GAIxC,ECdD,SAASmC,EAASC,GACd,MAAO,CAACA,EAAS,KAAMA,EAAS,KACpC,CCGA,SAASC,EAAuBC,GAAgC,IAA7BC,EAAGD,EAAHC,IAC/B,MAAO,CACH9H,EAAG,CAAEwF,IAF+BqC,EAAJE,KAEhBxC,IAF2BsC,EAALG,OAGtC/H,EAAG,CAAEuF,IAAKsC,EAAKvC,IAHoCsC,EAANI,QAKrD,C,eCVA,SAASC,GAAgBlC,GACrB,YAAiBlG,IAAVkG,GAAiC,IAAVA,CAClC,CACA,SAASmC,GAAQN,GAA4B,IAAzB7B,EAAK6B,EAAL7B,MAAOoC,EAAMP,EAANO,OAAQC,EAAMR,EAANQ,OAC/B,OAASH,GAAgBlC,KACpBkC,GAAgBE,KAChBF,GAAgBG,EACzB,CACA,SAASC,GAAaC,GAClB,OAAQJ,GAASI,IACbC,GAAeD,IACfA,EAAOE,GACPF,EAAOG,QACPH,EAAOI,SACPJ,EAAOK,OACf,CACA,SAASJ,GAAeD,GACpB,OAAOM,GAAcN,EAAOvI,IAAM6I,GAAcN,EAAOtI,EAC3D,CACA,SAAS4I,GAAc/J,GACnB,OAAOA,GAAmB,OAAVA,CACpB,CCfA,SAASgK,GAAW/I,EAAOiG,EAAOF,GAG9B,OAAOA,EADQE,GADYjG,EAAQ+F,EAGvC,CAIA,SAASiD,GAAgBhJ,EAAOmG,EAAWF,EAAOF,EAAakD,GAI3D,YAHiBlJ,IAAbkJ,IACAjJ,EAAQ+I,GAAW/I,EAAOiJ,EAAUlD,IAEjCgD,GAAW/I,EAAOiG,EAAOF,GAAeI,CACnD,CAIA,SAAS+C,GAAe3D,GAAuD,IAAjDY,EAAStH,UAAAC,OAAA,QAAAiB,IAAAlB,UAAA,GAAAA,UAAA,GAAG,EAAGoH,EAAKpH,UAAAC,OAAA,QAAAiB,IAAAlB,UAAA,GAAAA,UAAA,GAAG,EAAGkH,EAAWlH,UAAAC,OAAA,EAAAD,UAAA,QAAAkB,EAAEkJ,EAAQpK,UAAAC,OAAA,EAAAD,UAAA,QAAAkB,EACzEwF,EAAKE,IAAMuD,GAAgBzD,EAAKE,IAAKU,EAAWF,EAAOF,EAAakD,GACpE1D,EAAKC,IAAMwD,GAAgBzD,EAAKC,IAAKW,EAAWF,EAAOF,EAAakD,EACxE,CAIA,SAASE,GAAcC,EAAGtB,GAAY,IAAR7H,EAAC6H,EAAD7H,EAAGC,EAAC4H,EAAD5H,EAC7BgJ,GAAeE,EAAInJ,EAAGA,EAAEkG,UAAWlG,EAAEgG,MAAOhG,EAAE8F,aAC9CmD,GAAeE,EAAIlJ,EAAGA,EAAEiG,UAAWjG,EAAE+F,MAAO/F,EAAE6F,YAClD,CAuDA,SAASsD,GAAcpD,GACnB,OAAIqD,OAAOC,UAAUtD,IAEdA,EAAQ,iBAAmBA,EAAQ,cAD/BA,EACwD,CACvE,CACA,SAASuD,GAAcjE,EAAMzE,GACzByE,EAAKE,IAAMF,EAAKE,IAAM3E,EACtByE,EAAKC,IAAMD,EAAKC,IAAM1E,CAC1B,CAMA,SAAS2I,GAAclE,EAAMmE,EAAU5F,GAA8B,IAAAmD,GAAA0C,EAAAA,EAAAA,GAAA7F,EAAA,GAA3BvE,EAAG0H,EAAA,GAAE2C,EAAQ3C,EAAA,GAAE4C,EAAS5C,EAAA,GACxD6C,OAAuC/J,IAA1B2J,EAAWG,GAA2BH,EAAWG,GAAa,GAC3E9D,GAAcC,EAAAA,EAAAA,GAAIT,EAAKE,IAAKF,EAAKC,IAAKsE,GAE5CZ,GAAe3D,EAAMmE,EAAWnK,GAAMmK,EAAWE,GAAW7D,EAAa2D,EAAWzD,MACxF,CAIA,IAAM8D,GAAQ,CAAC,IAAK,SAAU,WACxBC,GAAQ,CAAC,IAAK,SAAU,WAI9B,SAASC,GAAab,EAAKc,GACvBT,GAAcL,EAAInJ,EAAGiK,EAAWH,IAChCN,GAAcL,EAAIlJ,EAAGgK,EAAWF,GACpC,CCpHA,SAASG,GAAmBC,EAAUtH,GAClC,OAAO+E,EHeX,SAA4B7H,EAAO8C,GAC/B,IAAKA,EACD,OAAO9C,EACX,IAAMqK,EAAUvH,EAAe,CAAE7C,EAAGD,EAAMgI,KAAM9H,EAAGF,EAAM+H,MACnDuC,EAAcxH,EAAe,CAAE7C,EAAGD,EAAMiI,MAAO/H,EAAGF,EAAMkI,SAC9D,MAAO,CACHH,IAAKsC,EAAQnK,EACb8H,KAAMqC,EAAQpK,EACdiI,OAAQoC,EAAYpK,EACpB+H,MAAOqC,EAAYrK,EAE3B,CG1BmCsK,CAAmBH,EAASI,wBAAyB1H,GACxF,C,gBCLM2H,IACO,E,wBCCPC,GAAe,SAACC,GAAM,OAAK,SAACC,GAAC,OAAKA,GAAK,GAAMD,EAAO,EAAIC,GAAK,GAAK,EAAID,EAAO,GAAK,EAAIC,KAAO,CAAC,GCA9FC,GAAgB,SAACF,GAAM,OAAK,SAACC,GAAC,OAAK,EAAID,EAAO,EAAIC,EAAE,GCCpDE,GAAS,SAACF,GAAC,OAAKA,EAAIA,CAAC,EACrBG,GAAUF,GAAcC,IACxBE,GAAYN,GAAaI,I,uBCe/B,IAAMG,GAAa,SAACC,EAAGC,EAAIC,GAAE,SAAQ,EAAM,EAAMA,EAAK,EAAMD,GAAMD,GAAK,EAAME,EAAK,EAAMD,IAAOD,EAAI,EAAMC,GACrGD,CAAC,EACCG,GAAuB,KACvBC,GAA2B,GAkBjC,SAASC,GAAYC,EAAKC,EAAKC,EAAKC,GAEhC,GAAIH,IAAQC,GAAOC,IAAQC,EACvB,OAAOC,EAAAA,EACX,IAAMC,EAAW,SAACC,GAAE,OArBxB,SAAyB7L,EAAG8L,EAAYC,EAAYR,EAAKE,GACrD,IAAIO,EACAC,EACA7H,EAAI,EACR,IAEI4H,EAAWhB,GADXiB,EAAWH,GAAcC,EAAaD,GAAc,EACpBP,EAAKE,GAAOzL,GAC7B,EACX+L,EAAaE,EAGbH,EAAaG,QAEZjL,KAAKC,IAAI+K,GAAYZ,MACxBhH,EAAIiH,IACV,OAAOY,CACX,CAK6BC,CAAgBL,EAAI,EAAG,EAAGN,EAAKE,EAAI,EAE5D,OAAO,SAACR,GAAC,OAAW,IAANA,GAAiB,IAANA,EAAUA,EAAID,GAAWY,EAASX,GAAIO,EAAKE,EAAI,CAC5E,CC7CA,IAAMS,GAAS,SAACxB,GAAC,OAAK,EAAI3J,KAAKoL,IAAIpL,KAAKqL,KAAK1B,GAAG,EAC1C2B,GAAU1B,GAAcuB,IACxBI,GAAY9B,GAAa6B,ICDzBE,GAAUlB,GAAY,IAAM,KAAM,IAAM,KACxCmB,GAAS7B,GAAc4B,IACvBE,GAAYjC,GAAagC,ICEzBE,GAAe,CACjBC,OAAQjB,EAAAA,EACRd,OAAAA,GACAE,UAAAA,GACAD,QAAAA,GACAqB,OAAAA,GACAI,UAAAA,GACAD,QAAAA,GACAG,OAAAA,GACAC,UAAAA,GACAF,QAAAA,GACAK,WCjBe,SAAClC,GAAC,OAAMA,GAAK,GAAK,EAAI,GAAM8B,GAAO9B,GAAK,IAAO,EAAI3J,KAAKkB,IAAI,GAAI,IAAMyI,EAAI,IAAI,GDmB3FmC,GAA6B,SAACC,GAChC,GAAIC,MAAMC,QAAQF,GAAa,EAE3BG,EAAAA,EAAAA,GAAgC,IAAtBH,EAAWlO,OAAc,2DACnC,IAAAsO,GAAAzD,EAAAA,EAAAA,GAAyBqD,EAAU,GACnC,OAAOzB,GADE6B,EAAA,GAAIA,EAAA,GAAIA,EAAA,GAAIA,EAAA,GAEzB,CACK,MAA0B,kBAAfJ,IAEZG,EAAAA,EAAAA,QAAuCpN,IAA7B6M,GAAaI,GAA2B,wBAAFK,OAA0BL,EAAU,MAC7EJ,GAAaI,IAEjBA,CACX,EACMM,GAAgB,SAACC,GACnB,OAAON,MAAMC,QAAQK,IAA4B,kBAAZA,EAAK,EAC9C,EE5BA,SAASC,GAAS1F,GAA0E,IAA5D2F,EAAc3F,EAAzB0F,UAASE,EAAA5F,EAAkByF,KAAAA,OAAI,IAAAG,EAAG1C,GAAS0C,EAAEC,EAAK7F,EAAL6F,MAAKC,EAAA9F,EAAE+F,SAAAA,OAAQ,IAAAD,EAAG,IAAGA,EACnFH,GAAcK,EAAAA,GAAAA,GAAOL,GAKrB,IAAMM,EAAkBT,GAAcC,GAChCA,EAAKS,IAAIjB,IACTA,GAA2BQ,GAK3BU,EAAQ,CACVC,MAAM,EACNnP,MAAO0O,EAAe,IAKpBU,EC7BV,SAA8B9L,EAAQwL,GAClC,OAAOxL,EAAO2L,KAAI,SAACI,GAAC,OAAKA,EAAIP,CAAQ,GACzC,CD2B0BQ,CAGtBV,GAASA,EAAM7O,SAAW2O,EAAe3O,OACnC6O,GACAW,EAAAA,GAAAA,GAAcb,GAAiBI,GACrC,SAASU,IACL,OAAOC,EAAAA,GAAAA,GAAYL,EAAeV,EAAgB,CAC9CF,KAAMN,MAAMC,QAAQa,GACdA,GAhCKvF,EAiCSiF,EAjCD9C,EAiCiBoD,EAhCrCvF,EAAOwF,KAAI,kBAAMrD,GAAUK,EAAS,IAAEyD,OAAO,EAAGjG,EAAO1J,OAAS,MAD3E,IAAuB0J,EAAQmC,CAmC3B,CACA,IAAI+D,EAAeH,IACnB,MAAO,CACHI,KAAM,SAACzD,GAGH,OAFA+C,EAAMlP,MAAQ2P,EAAaxD,GAC3B+C,EAAMC,KAAOhD,GAAK2C,EACXI,CACX,EACAW,WAAY,WACRnB,EAAeoB,UACfH,EAAeH,GACnB,EAER,CEnDA,IAAMO,GAAU,KACVC,GAAc,IACdC,GAAc,GACdC,GAAa,IACbC,GAAa,EACnB,SAASC,GAAUrH,GAA6D,IACxEsH,EACAC,EAFwEzB,EAAA9F,EAA1D+F,SAAAA,OAAQ,IAAAD,EAAG,IAAGA,EAAA0B,EAAAxH,EAAEyH,OAAAA,OAAM,IAAAD,EAAG,IAAIA,EAAAE,EAAA1H,EAAE5D,SAAAA,OAAQ,IAAAsL,EAAG,EAACA,EAAAC,EAAA3H,EAAE4H,KAAAA,OAAI,IAAAD,EAAG,EAACA,GAGvEE,EAAAA,EAAAA,GAAQ9B,GAA0B,IAAdmB,GAAoB,8CACxC,IAAIY,EAAe,EAAIL,EAIvBK,GAAeC,EAAAA,EAAAA,GAAMZ,GAAYC,GAAYU,GAC7C/B,GAAWgC,EAAAA,EAAAA,GAAMd,GAAaC,GAAanB,EAAW,KAClD+B,EAAe,GAIfR,EAAW,SAACU,GACR,IAAMC,EAAmBD,EAAeF,EAClC7L,EAAQgM,EAAmBlC,EAC3B9M,EAAIgP,EAAmB7L,EACvBlD,EAAIgP,GAAgBF,EAAcF,GAClCK,EAAIhP,KAAKiP,KAAKnM,GACpB,OAAO+K,GAAW/N,EAAIC,EAAKiP,CAC/B,EACAZ,EAAa,SAACS,GACV,IACM/L,EADmB+L,EAAeF,EACP/B,EAC3BsC,EAAIpM,EAAQG,EAAWA,EACvBkM,EAAInP,KAAKkB,IAAIyN,EAAc,GAAK3O,KAAKkB,IAAI2N,EAAc,GAAKjC,EAC5DwC,EAAIpP,KAAKiP,KAAKnM,GACduM,EAAIN,GAAgB/O,KAAKkB,IAAI2N,EAAc,GAAIF,GAErD,QADgBR,EAASU,GAAgBhB,GAAU,GAAK,EAAI,KACzCqB,EAAIC,GAAKC,GAAMC,CACtC,IAMAlB,EAAW,SAACU,GAGR,OAFU7O,KAAKiP,KAAKJ,EAAejC,KACxBiC,EAAe5L,GAAY2J,EAAW,GACzCiB,EACZ,EACAO,EAAa,SAACS,GAGV,OAFU7O,KAAKiP,KAAKJ,EAAejC,IACIA,EAAWA,GAAvC3J,EAAW4L,GAE1B,GAEJ,IACMA,EAmBV,SAAyBV,EAAUC,EAAYkB,GAE3C,IADA,IAAIC,EAASD,EACJlM,EAAI,EAAGA,EAAIoM,GAAgBpM,IAChCmM,GAAkBpB,EAASoB,GAAUnB,EAAWmB,GAEpD,OAAOA,CACX,CAzByBE,CAAgBtB,EAAUC,EAD1B,EAAIxB,GAGzB,GADAA,GAAsB,IAClB3H,MAAM4J,GACN,MAAO,CACHa,UAAW,IACXC,QAAS,GACT/C,SAAAA,GAIJ,IAAM8C,EAAY1P,KAAKkB,IAAI2N,EAAc,GAAKJ,EAC9C,MAAO,CACHiB,UAAAA,EACAC,QAAwB,EAAfhB,EAAmB3O,KAAKiB,KAAKwN,EAAOiB,GAC7C9C,SAAAA,EAGZ,CACA,IAAM4C,GAAiB,GAQvB,SAAST,GAAgBF,EAAcF,GACnC,OAAOE,EAAe7O,KAAKiB,KAAK,EAAI0N,EAAeA,EACvD,C,yDClFMiB,GAAe,CAAC,WAAY,UAC5BC,GAAc,CAAC,YAAa,UAAW,QAC7C,SAASC,GAAatQ,EAASuQ,GAC3B,OAAOA,EAAKC,MAAK,SAAC1R,GAAG,YAAsBQ,IAAjBU,EAAQlB,EAAkB,GACxD,CA4BA,SAAS2R,GAAMpJ,GAAkD,IAA/C0F,EAAS1F,EAAT0F,UAAW2D,EAASrJ,EAATqJ,UAAWC,EAAStJ,EAATsJ,UAAc3Q,GAAO4Q,EAAAA,GAAAA,GAAAvJ,EAAAwJ,IACrDxL,EAAS0H,EAAU,GACnBvP,EAASuP,EAAUA,EAAU1O,OAAS,GAKpCmP,EAAQ,CAAEC,MAAM,EAAOnP,MAAO+G,GACpCyL,EAnCJ,SAA0B9Q,GACtB,IAAI+Q,GAAa/O,EAAAA,EAAAA,GAAA,CACbyB,SAAU,EACVyM,UAAW,IACXC,QAAS,GACTlB,KAAM,EACN+B,wBAAwB,GACrBhR,GAGP,IAAKsQ,GAAatQ,EAASqQ,KACvBC,GAAatQ,EAASoQ,IAAe,CACrC,IAAMa,EAAUvC,GAAW1O,IAC3B+Q,GAAa/O,EAAAA,EAAAA,IAAAA,EAAAA,EAAAA,IAAAA,EAAAA,EAAAA,GAAA,GACN+O,GACAE,GAAO,IACVxN,SAAU,EACVwL,KAAM,KAEI+B,wBAAyB,CAC3C,CACA,OAAOD,CACX,CAasFG,CAAiBlR,GAA3FkQ,EAASY,EAATZ,UAAWC,EAAOW,EAAPX,QAASlB,EAAI6B,EAAJ7B,KAAMxL,EAAQqN,EAARrN,SAAU2J,EAAQ0D,EAAR1D,SAAU4D,EAAsBF,EAAtBE,uBAClDG,EAAgBC,GAChBC,EAAkB5N,GAAaA,EAAW,IAAQ,EAChD0L,EAAegB,GAAW,EAAI3P,KAAKiB,KAAKyO,EAAYjB,IAC1D,SAASqC,IACL,IAAMC,EAAe/T,EAAS6H,EACxBmM,EAAsBhR,KAAKiB,KAAKyO,EAAYjB,GAAQ,IAQpDwC,EAAkBjR,KAAKC,IAAI8Q,GAAgB,EAGjD,GAFAZ,IAAcA,EAAYc,EAAkB,IAAO,GACnDf,IAAcA,EAAYe,EAAkB,KAAQ,IAChDtC,EAAe,EAAG,CAClB,IAAMuC,EAAcnC,GAAgBiC,EAAqBrC,GAEzDgC,EAAgB,SAAC1G,GACb,IAAMkE,EAAWnO,KAAKiP,KAAKN,EAAeqC,EAAsB/G,GAChE,OAAQjN,EACJmR,IACO0C,EACClC,EAAeqC,EAAsBD,GACrCG,EACAlR,KAAKoL,IAAI8F,EAAcjH,GACvB8G,EAAe/Q,KAAKmR,IAAID,EAAcjH,GACtD,CACJ,MACK,GAAqB,IAAjB0E,EAELgC,EAAgB,SAAC1G,GAAC,OAAKjN,EACnBgD,KAAKiP,KAAK+B,EAAsB/G,IAC3B8G,GACIF,EAAkBG,EAAsBD,GACrC9G,EAAE,MAEjB,CAED,IAAMmH,EAAoBJ,EAAsBhR,KAAKiB,KAAK0N,EAAeA,EAAe,GACxFgC,EAAgB,SAAC1G,GACb,IAAMkE,EAAWnO,KAAKiP,KAAKN,EAAeqC,EAAsB/G,GAE1DoH,EAAWrR,KAAKwE,IAAI4M,EAAoBnH,EAAG,KACjD,OAAQjN,EACHmR,IACK0C,EACElC,EAAeqC,EAAsBD,GACrC/Q,KAAKsR,KAAKD,GACVD,EACIL,EACA/Q,KAAKuR,KAAKF,IAClBD,CACZ,CACJ,CACJ,CAEA,OADAN,IACO,CACHpD,KAAM,SAACzD,GACH,IAAMuH,EAAUb,EAAc1G,GAC9B,GAAKuG,EAsBDxD,EAAMC,KAAOhD,GAAK2C,MAtBO,CACzB,IAAIpJ,EAAkBqN,EACtB,GAAU,IAAN5G,EAMA,GAAI0E,EAAe,EAAG,CAClB,IAAM8C,EAAQzR,KAAKuE,IAAI,EAAG0F,EAnFnB,GAoFPzG,GAAkBkO,EAAAA,GAAAA,GAAkBF,EAAUb,EAAcc,GAAQxH,EAAIwH,EAC5E,MAEIjO,EAAkB,EAG1B,IAAMmO,EAA2B3R,KAAKC,IAAIuD,IAAoB2M,EACxDyB,EAA+B5R,KAAKC,IAAIjD,EAASwU,IAAYtB,EACnElD,EAAMC,KACF0E,GAA4BC,CACpC,CAKA,OADA5E,EAAMlP,MAAQkP,EAAMC,KAAOjQ,EAASwU,EAC7BxE,CACX,EACAW,WAAY,WACRkD,GAAmBA,EAAgB,IAAAhO,EAChB,CAAC7F,EAAQ6H,GAA3BA,EAAMhC,EAAA,GAAE7F,EAAM6F,EAAA,GACfiO,GACJ,EAER,CACAb,GAAO4B,mBAAqB,SAAC/R,EAAGC,GAAC,MAAkB,kBAAND,GAA+B,kBAANC,CAAc,EACpF,IAAM6Q,GAAO,SAACkB,GAAE,OAAK,CAAC,E,8JCtIhBC,GAAQ,CACVC,MCPJ,SAAcnL,GAMoF,IAAAoL,EAAApL,EAAlG0F,UAAAA,OAAS,IAAA0F,EAAG,CAAC,GAAEA,EAAA1D,EAAA1H,EAAE5D,SAAAA,OAAQ,IAAAsL,EAAG,EAACA,EAAA2D,EAAArL,EAAEsL,MAAAA,OAAK,IAAAD,EAAG,GAAGA,EAAAE,EAAAvL,EAAEwL,aAAAA,OAAY,IAAAD,EAAG,IAAGA,EAAAE,EAAAzL,EAAEqJ,UAAAA,OAAS,IAAAoC,EAAG,GAAGA,EAAEC,EAAY1L,EAAZ0L,aACvE1N,EAAS0H,EAAU,GAKnBS,EAAQ,CAAEC,MAAM,EAAOnP,MAAO+G,GAChC2N,EAAYL,EAAQlP,EAClBwP,EAAQ5N,EAAS2N,EACjBxV,OAA0B8B,IAAjByT,EAA6BE,EAAQF,EAAaE,GAOjE,OAFIzV,IAAWyV,IACXD,EAAYxV,EAAS6H,GAClB,CACH6I,KAAM,SAACzD,GACH,IAAMnH,GAAS0P,EAAYxS,KAAKiP,KAAKhF,EAAIoI,GAGzC,OAFArF,EAAMC,OAASnK,EAAQoN,GAAapN,GAASoN,GAC7ClD,EAAMlP,MAAQkP,EAAMC,KAAOjQ,EAASA,EAAS8F,EACtCkK,CACX,EACAW,WAAY,WAAQ,EAE5B,EDvBIpB,UAAWA,GACXmG,MAAOnG,GACP0D,OAAAA,IAEJ,SAAS0C,GAAYC,EAAShG,GAC1B,OAAOgG,EAAUhG,GADwBhP,UAAAC,OAAA,QAAAiB,IAAAlB,UAAA,GAAAA,UAAA,GAAG,EAEhD,CASA,IAAMiV,GAAY,SAACC,GACf,IAAMC,EAAgB,SAAHlM,GAAA,IAAM/D,EAAK+D,EAAL/D,MAAK,OAAOgQ,EAAOhQ,EAAM,EAClD,MAAO,CACHkQ,MAAO,kBAAMlR,EAAAA,GAAAA,OAAYiR,GAAe,EAAK,EAC7CE,KAAM,kBAAMtQ,EAAAA,GAAAA,OAAkBoQ,EAAc,EAEpD,EACA,SAASG,GAAYrQ,GAAsO,IAEnPsQ,EAKAC,EAPgBxG,EAAQ/J,EAAR+J,SAAQyG,EAAAxQ,EAAEyQ,OAAAA,OAAM,IAAAD,EAAGR,GAASQ,EAAAE,EAAA1Q,EAAE+P,QAAAA,OAAO,IAAAW,EAAG,EAACA,EAAAC,EAAA3Q,EAAE4Q,OAAQC,OAAS,IAAAF,EAAG,EAACA,EAAAG,EAAA9Q,EAAE+Q,WAAAA,OAAU,IAAAD,EAAG,OAAMA,EAAAE,EAAAhR,EAAEiR,YAAAA,OAAW,IAAAD,EAAG,EAACA,EAAaE,EAAWlR,EAAtB0J,UAASyH,EAAAnR,EAAeoR,SAAAA,OAAQ,IAAAD,GAAOA,EAAEE,EAAMrR,EAANqR,OAAQC,EAAMtR,EAANsR,OAAQC,EAAUvR,EAAVuR,WAAYC,EAAQxR,EAARwR,SAAUC,EAAQzR,EAARyR,SAAQC,EAAA1R,EAAER,KAAAA,OAAI,IAAAkS,EAAG,YAAWA,EAAK/U,GAAO4Q,EAAAA,GAAAA,GAAAvN,EAAAwN,IAC7OmE,EAAiB5B,EAEnB6B,EAAc,EACdC,EAAmB9H,EACnB+H,GAAa,EACbC,GAAoB,EAElBC,EAAW9C,GAAMgC,EAAYlW,OAAS,EAAI,YAAcwE,IAASkK,GACjE1H,EAASkP,EAAY,GACrB/W,EAAS+W,EAAYA,EAAYlW,OAAS,GAC5CmP,EAAQ,CAAEC,MAAM,EAAOnP,MAAO+G,GAK1BgN,EAAuBgD,EAAvBhD,mBACJA,GAAsBA,EAAmBhN,EAAQ7H,KACjDoW,GAAwB7F,EAAAA,GAAAA,GAAY,CAAC,EAAG,KAAM,CAAC1I,EAAQ7H,GAAS,CAC5D4R,OAAO,IAEXmF,EAAc,CAAC,EAAG,MAEtB,IAAMe,EAAYD,GAAQrT,EAAAA,EAAAA,IAAAA,EAAAA,EAAAA,GAAC,CAAC,EACrBhC,GAAO,IACVoN,SAAAA,EACAL,UAAWwH,KAEf,SAASN,IACLgB,IACmB,YAAfb,EAEAhB,EA/CZ,SAAwBA,GAA4D,IAAnDhG,EAAQhP,UAAAC,OAAA,QAAAiB,IAAAlB,UAAA,GAAAA,UAAA,GAAG,EAAGmX,EAAKnX,UAAAC,OAAA,QAAAiB,IAAAlB,UAAA,GAAAA,UAAA,GAAG,EACnD,OADuEA,UAAAC,OAAA,QAAAiB,IAAAlB,UAAA,KAAAA,UAAA,GAGjEgP,GAAYgG,EAAUhG,GAAYmI,EADlCpC,GAAY/F,GAAYgG,EAAShG,EAAUmI,EAErD,CA2CsBC,CAAepC,EAAS8B,EAAkBZ,EADpDc,EAAoBH,EAAc,IAAM,IAIxC7B,EAAUD,GAAYC,EAAS8B,EAAkBZ,GAC9B,WAAfF,GACAkB,EAAUnH,cAElBgH,GAAa,EACbN,GAAYA,GAChB,CAKA,SAASvB,EAAOhQ,GACP8R,IACD9R,GAASA,GACb8P,GAAW9P,EACN6R,IACD3H,EAAQ8H,EAAUpH,KAAK1N,KAAKuE,IAAI,EAAGqO,IAC/BQ,IACApG,EAAMlP,MAAQsV,EAAsBpG,EAAMlP,QAC9C6W,EAAaC,EAAoB5H,EAAMC,KAAO2F,GAAW,GAE7D0B,GAAYA,EAAStH,EAAMlP,OACvB6W,IACoB,IAAhBF,IACAC,OACyB5V,IAArB4V,EAAiCA,EAAmB9B,GAExD6B,EAAcf,EAxE9B,SAA+Bd,EAAShG,EAAUmI,EAAOH,GACrD,OAAOA,EAAoBhC,GAAWhG,EAAWmI,EAAQnC,IAAYmC,CACzE,CAuEgBE,CAAsBrC,EAAS8B,EAAkBZ,EAAac,IAAsBnB,KApB5FN,GAAkBA,EAAeF,OACjCmB,GAAcA,KAyBlB,CAOA,OADAH,IAJIC,GAAUA,KACVf,EAAiBG,EAAOR,IACTE,SAGZ,CACHC,KAAM,WACFkB,GAAUA,IACVhB,GAAkBA,EAAeF,MACrC,EAgBIiC,gBAAYjL,GACZ2I,EAAU4B,EACV1B,EAAO7I,EACX,EAMAkL,OAAQ,SAAClL,GACL2I,EAAU4B,EACV,IAAMY,EAAmBxI,GAAgC,kBAAbA,EACtC5M,KAAKuE,IAAe,GAAXqI,EAAgB,IACzB,GACFyI,EAAgB,EAEpB,IADAvC,EAAO,GACAuC,GAAiBpL,GAAG,CACvB,IAAMqL,EAAYrL,EAAIoL,EACtBvC,EAAO9S,KAAKwE,IAAI8Q,EAAWF,IAC3BC,GAAiBD,CACrB,CACA,OAAOpI,CACX,EAER,C,eEjJA,IAAMuI,GAAsB,SAAH1O,GAAA,IAAAhE,GAAA6F,EAAAA,EAAAA,GAAA7B,EAAA,GAAK/G,EAAC+C,EAAA,GAAE9C,EAAC8C,EAAA,GAAEmM,EAACnM,EAAA,GAAEqM,EAACrM,EAAA,yBAAAuJ,OAAsBtM,EAAC,MAAAsM,OAAKrM,EAAC,MAAAqM,OAAK4C,EAAC,MAAA5C,OAAK8C,EAAC,MAC3EsG,GAAuB,CACzB5J,OAAQ,SACRU,KAAM,OACNzC,OAAQ,UACRC,QAAS,WACTC,UAAW,cACXoB,OAAQoK,GAAoB,CAAC,EAAG,IAAM,IAAM,IAC5CjK,QAASiK,GAAoB,CAAC,IAAM,EAAG,EAAG,MAC1C9J,OAAQ8J,GAAoB,CAAC,IAAM,IAAM,KAAO,MAChD/J,QAAS+J,GAAoB,CAAC,IAAM,KAAM,IAAM,OAEpD,SAASE,GAAwB/L,GAC7B,GAAKA,EAEL,OAAOsC,MAAMC,QAAQvC,GACf6L,GAAoB7L,GACpB8L,GAAqB9L,EAC/B,CCvBA,IAAMgM,GAAe,CACjBC,MAAO,kBAAMtY,OAAOE,eAAeC,KAAKoY,QAAQtY,UAAW,UAAU,GAEnEuY,GAAU,CAAC,EACXC,GAAW,CAAC,EAClBC,GAAA,SAAAzX,GAIIwX,GAASxX,GAAO,WAGZ,YAFqBQ,IAAjB+W,GAAQvX,KACRuX,GAAQvX,GAAOoX,GAAapX,MACzBuX,GAAQvX,EACnB,CACJ,EANA,IAAK,IAAMA,MAAOoX,GAAYK,GAAAzX,I,iCCExB0X,GAAoB,IAAIC,IAAI,CAC9B,UACA,WACA,SACA,cAQJ,SAASC,GAA2BpY,EAAOqY,EAAStP,GAAYA,EAARyN,SAAoC,IAA1BF,EAAUvN,EAAVuN,WAAe5U,GAAO4Q,EAAAA,GAAAA,GAAAvJ,EAAAwJ,IAMpF,KAL+ByF,GAASH,SACpCK,GAAkBI,IAAID,KACrB3W,EAAQsU,aACc,WAAvBtU,EAAQoU,YACY,IAApBpU,EAAQmQ,SAER,OAAO,EACX,IF9B4BjG,EE8BtB6C,EAAiD/M,EAAjD+M,UAAS8J,EAAwC7W,EAAtCoN,SAAAA,OAAQ,IAAAyJ,EAAG,IAAGA,EAAAC,EAAwB9W,EAAtBoT,QAAAA,OAAO,IAAA0D,EAAG,EAACA,EAAEhK,EAAS9M,EAAT8M,KAI9C,GAAqB,WAAjB9M,EAAQ6C,UFlCgBqH,EEkC6BlK,EAAQ8M,OFhC7DN,MAAMC,QAAQvC,IACK,kBAAXA,GAAuB8L,GAAqB9L,IE+BgB,CAKpE,GAAIlK,EAAQiU,SAAWhQ,IACnB,OASJ,IARA,IAAM8S,EAAkBrD,IAAY1R,EAAAA,EAAAA,IAAAA,EAAAA,EAAAA,GAAC,CAAC,EAAIhC,GAAO,IAAEoT,QAAS,KACxD5F,EAAQ,CAAEC,MAAM,EAAOnP,MAAOyO,EAAU,IACtCiK,EAAwB,GAK1BvM,EAAI,GACA+C,EAAMC,MAAQhD,EAAI,KACtB+C,EAAQuJ,EAAgBpB,OAAOlL,GAC/BuM,EAAsBjV,KAAKyL,EAAMlP,OACjCmM,GA/BQ,GAiCZsC,EAAYiK,EACZ5J,EAAW3C,EAlCC,GAmCZqC,EAAO,QACX,CACA,IAAMwI,ECxDV,SAAsB2B,EAASN,EAAW5J,GAAwF,IAAAmK,EAAA7P,EAAAjJ,UAAAC,OAAA,QAAAiB,IAAAlB,UAAA,GAAAA,UAAA,GAAJ,CAAC,EAAC+Y,EAAA9P,EAAzEkO,MAAAA,OAAK,IAAA4B,EAAG,EAACA,EAAE/J,EAAQ/F,EAAR+F,SAAQgK,EAAA/P,EAAE4M,OAAAA,OAAM,IAAAmD,EAAG,EAACA,EAAAC,EAAAhQ,EAAE+M,WAAAA,OAAU,IAAAiD,EAAG,OAAMA,EAAEvK,EAAIzF,EAAJyF,KAAMI,EAAK7F,EAAL6F,MAC/G,OAAO+J,EAAQK,SAAOJ,EAAA,IAAAK,EAAAA,GAAAA,GAAAL,EAAIP,EAAY5J,IAASwK,EAAAA,GAAAA,GAAAL,EAAE,SAAQhK,GAAKgK,GAAI,CAC9D3B,MAAAA,EACAnI,SAAAA,EACAlD,OAAQ+L,GAAwBnJ,GAChC0K,KAAM,OACNC,WAAYxD,EAAS,EACrByD,UAA0B,YAAftD,EAA2B,YAAc,UAE5D,CD+CsBuD,CAAarZ,EAAMsZ,MAAM5F,QAAS2E,EAAW5J,GAAS/K,EAAAA,EAAAA,IAAAA,EAAAA,EAAAA,GAAA,GACjEhC,GAAO,IACVuV,OAAQnC,EACRhG,SAAAA,EASAN,KAAMA,KAkBV,OARAwI,EAAUuC,SAAW,WACjBvZ,EAAMwZ,IEjFd,SAA0B/K,EAAS1F,GAAmC,IAA/B4M,EAAM5M,EAAN4M,OAAMoD,EAAAhQ,EAAE+M,WAI3C,OAAOrH,EAHOkH,GAAyB,eADc,IAAAoD,EAAG,OAAMA,IACbpD,EAAS,IAAM,EAC1D,EACAlH,EAAU1O,OAAS,EAE7B,CF4EkB0Z,CAAiBhL,EAAW/M,IACtCsC,EAAAA,GAAAA,QAAY,kBAAMgT,EAAU0C,QAAQ,IACpCpD,GAAcA,GAClB,EAIO,CACCc,kBACA,OAAOJ,EAAUI,aAAe,CACpC,EACIA,gBAAYjL,GACZ6K,EAAUI,YAAcjL,CAC5B,EACAgJ,KAAM,WASF,IAAQiC,EAAgBJ,EAAhBI,YACR,GAAIA,EAAa,CACb,IAAMqB,EAAkBrD,IAAY1R,EAAAA,EAAAA,IAAAA,EAAAA,EAAAA,GAAC,CAAC,EAC/BhC,GAAO,IACVyU,UAAU,KAEdnW,EAAM2Z,gBAAgBlB,EAAgBpB,OAAOD,EAzFzC,IAyFoEpX,MAAOyY,EAAgBpB,OAAOD,GAAapX,MAzF/G,GA0FR,CACAgE,EAAAA,GAAAA,QAAY,kBAAMgT,EAAU0C,QAAQ,GACxC,EAER,CG9GA,SAASzC,GAAMpO,EAAU+Q,GACrB,IAAM1E,EAAQ2E,YAAYC,MACpBC,EAAe,SAAfA,EAAYhR,GAAsB,IAC9B+L,EADuB/L,EAATxF,UACQ2R,EACxBJ,GAAW8E,IACX/U,EAAAA,GAAAA,KAAgBkV,GAChBlR,EAASiM,EAAU8E,GAE3B,EAEA,OADA5V,EAAAA,GAAAA,KAAU+V,GAAc,GACjB,kBAAMlV,EAAAA,GAAAA,KAAgBkV,EAAa,CAC9C,CCdA,SAASC,GAAsBjR,GAAgD,IAA7C0F,EAAS1F,EAAT0F,UAAWqG,EAAO/L,EAAP+L,QAAS0B,EAAQzN,EAARyN,SAAUF,EAAUvN,EAAVuN,WACtD2D,EAAW,WACbzD,GAAYA,EAAS/H,EAAUA,EAAU1O,OAAS,IAClDuW,GAAcA,GAClB,EACA,OAAOxB,EAAU,CAAEK,KAAM8B,GAAMgD,GAAWnF,IAAamF,GAC3D,C,eCNMC,GAAoB,CACtB3V,KAAM,SACNqN,UAAW,IACXC,QAAS,GACTQ,UAAW,IAQT8H,GAAsB,CACxB5V,KAAM,YACNuK,SAAU,IAMRN,GAAO,CACTjK,KAAM,YACNiK,KAAM,CAAC,IAAM,GAAK,IAAM,GACxBM,SAAU,IAERsL,GAAuB,SAACC,EAAQtR,GAAoB,IAAhB0F,EAAS1F,EAAT0F,UACtC,OAAIA,EAAU1O,OAAS,EACZoa,GAEFG,GAAAA,EAAAA,IAAmBD,GACjBA,EAASE,WAAW,SAxBS,CACxChW,KAAM,SACNqN,UAAW,IACXC,QAAoB,IAsBapD,EAAU,GAtBnB,EAAIvM,KAAKiB,KAAK,KAAO,GAC7CkP,UAAW,IAsBD6H,GAEH1L,EACX,E,WC1BMgM,GAAe,SAACha,EAAKR,GAEvB,MAAY,WAARQ,MAKiB,kBAAVR,IAAsBkO,MAAMC,QAAQnO,OAE1B,kBAAVA,IACPya,GAAAA,EAAAA,KAAaza,IACZA,EAAMua,WAAW,SAK1B,E,YCrBMG,GAAc,IAAIvC,IAAI,CAAC,aAAc,WAAY,WAAY,YACnE,SAASwC,GAAmBC,GACxB,IAAAC,EAAsBD,EAAEE,MAAM,GAAI,GAAGC,MAAM,KAAIC,GAAApQ,EAAAA,EAAAA,GAAAiQ,EAAA,GAAxChV,EAAImV,EAAA,GAAEhb,EAAKgb,EAAA,GAClB,GAAa,gBAATnV,EACA,OAAO+U,EACX,IAAA7R,EAAiB/I,EAAMib,MAAMC,GAAAA,KAAe,GAArCC,GAAuCvQ,EAAAA,EAAAA,GAAA7B,EAAA,GAAjC,GACb,IAAKoS,EACD,OAAOP,EACX,IAAMQ,EAAOpb,EAAMqb,QAAQF,EAAQ,IAC/BG,EAAeZ,GAAYpC,IAAIzS,GAAQ,EAAI,EAG/C,OAFIsV,IAAWnb,IACXsb,GAAgB,KACbzV,EAAO,IAAMyV,EAAeF,EAAO,GAC9C,CACA,IAAMG,GAAgB,oBAChBC,IAAM9X,EAAAA,EAAAA,IAAAA,EAAAA,EAAAA,GAAA,GACL+W,GAAAA,GAAO,IACVgB,kBAAmB,SAACb,GAChB,IAAMc,EAAYd,EAAEK,MAAMM,IAC1B,OAAOG,EAAYA,EAAUzM,IAAI0L,IAAoBgB,KAAK,KAAOf,CACrE,I,wBCnBEgB,IAAiBlY,EAAAA,EAAAA,IAAAA,EAAAA,EAAAA,GAAA,GAChBmY,GAAAA,GAAgB,IAEnBC,MAAAA,GAAAA,EACAC,gBAAiBD,GAAAA,EACjBE,aAAcF,GAAAA,EACd5C,KAAM4C,GAAAA,EACNG,OAAQH,GAAAA,EAERI,YAAaJ,GAAAA,EACbK,eAAgBL,GAAAA,EAChBM,iBAAkBN,GAAAA,EAClBO,kBAAmBP,GAAAA,EACnBQ,gBAAiBR,GAAAA,EACjBN,OAAAA,GACAe,aAAcf,KAKZgB,GAAsB,SAAChc,GAAG,OAAKob,GAAkBpb,EAAI,ECvB3D,SAASib,GAAkBjb,EAAKR,GAC5B,IAAIyc,EAAmBD,GAAoBhc,GAI3C,OAHIic,IAAqBjB,KACrBiB,EAAmBhC,GAAAA,GAEhBgC,EAAiBhB,kBAClBgB,EAAiBhB,kBAAkBzb,QACnCgB,CACV,C,kICFA,SAAS0b,GAAO1c,GACZ,OAAkB,IAAVA,GACc,kBAAVA,GACkB,IAAtB2c,WAAW3c,KACa,IAAxBA,EAAM4c,QAAQ,IAC1B,CACA,SAASC,GAAYC,GACjB,MAAoC,kBAAtBA,EACR,EACArB,GAAkB,GAAIqB,EAChC,CACA,SAASC,GAAmBC,EAAYxc,GACpC,OAAOwc,EAAWxc,IAAQwc,EAAoB,SAAKA,CACvD,CCXA,IAAMC,GAA6B,SAAC5E,EAAWrY,EAAOd,GAA4B,IAApB8d,EAAUld,UAAAC,OAAA,QAAAiB,IAAAlB,UAAA,GAAAA,UAAA,GAAG,CAAC,EACxE,OAAO,SAACwW,GACJ,IAAM4G,EAAkBH,GAAmBC,EAAY3E,IAAc,CAAC,EAMhEpB,EAAQiG,EAAgBjG,OAAS+F,EAAW/F,OAAS,EAK3DkG,EAAsBH,EAAhBlI,QAAAA,OAAO,IAAAqI,EAAG,EAACA,EACjBrI,GAAoBxT,EAAsB2V,GAC1C,IAAMxI,ECvBd,SAAsBzO,EAAOqY,EAAWnZ,EAAQ8d,GAC5C,IAAMI,EAAqB5C,GAAanC,EAAWnZ,GAC/C6H,OAA6B/F,IAApBgc,EAAWK,KAAqBL,EAAWK,KAAOrd,EAAMhB,MAmBrE,MAlBe,SAAX+H,GAAqBqW,GAAwC,kBAAXle,EAKlD6H,EAAS0U,GAAkBpD,EAAWnZ,GAEjCwd,GAAO3V,IAA6B,kBAAX7H,EAC9B6H,EAAS8V,GAAY3d,IAEfgP,MAAMC,QAAQjP,IACpBwd,GAAOxd,IACW,kBAAX6H,IACP7H,EAAS2d,GAAY9V,IAKrBmH,MAAMC,QAAQjP,IAKI,OAAdA,EAAO,KACPA,EAAO,GAAK6H,GAET7H,GAGA,CAAC6H,EAAQ7H,EAExB,CDX0Boe,CAAatd,EAAOqY,EAAWnZ,EAAQge,GAMnDK,EAAiB9O,EAAU,GAC3B+O,EAAiB/O,EAAUA,EAAU1O,OAAS,GAC9C0d,EAAqBjD,GAAanC,EAAWkF,GAC7CH,EAAqB5C,GAAanC,EAAWmF,IACnD5M,EAAAA,EAAAA,GAAQ6M,IAAuBL,EAAoB,6BAAF9O,OAA+B+J,EAAS,WAAA/J,OAAUiP,EAAc,UAAAjP,OAASkP,EAAc,OAAAlP,OAAMiP,EAAc,+DAAAjP,OAA8DiP,EAAc,8BAAAjP,OAA6BkP,EAAc,+BACnR,IAAI9b,GAAOgC,EAAAA,EAAAA,IAAAA,EAAAA,EAAAA,GAAA,CACP+K,UAAAA,EACAtJ,SAAUnF,EAAMoF,eACb8X,GAAe,IAClBpI,QAAAA,EACA0B,SAAU,SAACoE,GACP5a,EAAMwZ,IAAIoB,GACVsC,EAAgB1G,UAAY0G,EAAgB1G,SAASoE,EACzD,EACAtE,WAAY,WACRA,IACA4G,EAAgB5G,YAAc4G,EAAgB5G,YAClD,IAEJ,IAAKmH,IACAL,GACD1R,KACyB,IAAzBwR,EAAgB3Y,KAKhB,OAAOyV,GAAuBtY,GAE7B,GAA6B,YAAzBwb,EAAgB3Y,KAKrB,OE/DZ,SAAgBwE,GAAwL,IAEhM2U,EAFWjP,EAAS1F,EAAT0F,UAASgC,EAAA1H,EAAE5D,SAAAA,OAAQ,IAAAsL,EAAG,EAACA,EAAE/J,EAAGqC,EAAHrC,IAAKD,EAAGsC,EAAHtC,IAAG2N,EAAArL,EAAEsL,MAAAA,OAAK,IAAAD,EAAG,GAAGA,EAAAE,EAAAvL,EAAEwL,aAAAA,OAAY,IAAAD,EAAG,IAAGA,EAAAqJ,EAAA5U,EAAE6U,gBAAAA,OAAe,IAAAD,EAAG,IAAGA,EAAAE,EAAA9U,EAAE+U,cAAAA,OAAa,IAAAD,EAAG,GAAEA,EAAArJ,EAAAzL,EAAEqJ,UAAAA,OAAS,IAAAoC,EAAG,EAACA,EAAEC,EAAY1L,EAAZ0L,aAAce,EAAMzM,EAANyM,OAAQgB,EAAQzN,EAARyN,SAAUF,EAAUvN,EAAVuN,WAAYD,EAAMtN,EAANsN,OACnLtP,EAAS0H,EAAU,GAEzB,SAASsP,EAAcnD,GACnB,YAAgB5Z,IAAR0F,GAAqBkU,EAAIlU,QAAiB1F,IAARyF,GAAqBmU,EAAInU,CACvE,CACA,SAASuX,EAAoBpD,GACzB,YAAY5Z,IAAR0F,EACOD,OACCzF,IAARyF,GAEGvE,KAAKC,IAAIuE,EAAMkU,GAAK1Y,KAAKC,IAAIsE,EAAMmU,GAD/BlU,EAC0CD,CACzD,CACA,SAASwX,EAAevc,GACpBgc,GAAoBA,EAAiBvI,OACrCuI,EAAmBtI,IAAY1R,EAAAA,EAAAA,IAAAA,EAAAA,EAAAA,GAAC,CAC5B+K,UAAW,CAAC,EAAG,GACftJ,SAAU,GACPzD,GAAO,IACV8T,OAAAA,EACAgB,SAAU,SAACoE,GACPpE,GAAYA,EAASoE,GACrBlZ,EAAQ8U,UAAY9U,EAAQ8U,SAASoE,EACzC,EACAtE,WAAAA,EACAD,OAAAA,IAER,CACA,SAAS6H,EAAYxc,GACjBuc,GAAcva,EAAAA,EAAAA,GAAC,CACXa,KAAM,SACNqN,UAAWgM,EACX/L,QAASiM,EACT1L,UAAAA,GACG1Q,GAEX,CACA,GAAIqc,EAAchX,GAEdmX,EAAY,CACR/Y,SAAAA,EACAsJ,UAAW,CAAC1H,EAAQiX,EAAoBjX,UAG3C,CASD,IAAI7H,EAASmV,EAAQlP,EAAW4B,EACJ,qBAAjB0N,IACPvV,EAASuV,EAAavV,IAC1B,IAEIif,EACAzK,EAHE0K,EAAWJ,EAAoB9e,GAC/Bmf,EAAUD,IAAa1X,GAAO,EAAI,EAYxCuX,EAAe,CACX1Z,KAAM,QACNkK,UAAW,CAAC1H,EAAQ,GACpB5B,SAAAA,EACAoP,aAAAA,EACAF,MAAAA,EACAjC,UAAAA,EACAqC,aAAAA,EACA+B,SAAUuH,EAAc7e,GAjBN,SAAC0b,GACnBuD,EAAOzK,EACPA,EAAUkH,EACVzV,GAAWyO,EAAAA,GAAAA,GAAkBgH,EAAIuD,EAAM3a,EAAAA,EAAAA,QACtB,IAAZ6a,GAAiBzD,EAAIwD,IACR,IAAbC,GAAkBzD,EAAIwD,IACvBF,EAAY,CAAEzP,UAAW,CAACmM,EAAGwD,GAAWjZ,SAAAA,GAEhD,OASsDnE,GAE1D,CACA,MAAO,CACHmU,KAAM,kBAAMuI,GAAoBA,EAAiBvI,MAAM,EAE/D,CFpBmBmJ,CAAQ5c,GA0BnB,GDtFR,SAA4BqH,GAAOA,EAAJwV,KAAmBxV,EAAbkO,MAA4BlO,EAAbyV,cAA8BzV,EAAf0V,gBAAiC1V,EAAhB2V,iBAAwB3V,EAAN4M,OAAkB5M,EAAV+M,WAAuB/M,EAAXiN,YAAiBjN,EAAJsU,KAAatU,EAAP+L,QAA0B,IAAdkI,GAAU1K,EAAAA,GAAAA,GAAAvJ,EAAAwJ,IAC/J,QAAShT,OAAO0S,KAAK+K,GAAYjd,MACrC,CCgEa4e,CAAoBzB,KACrBxb,GAAOgC,EAAAA,EAAAA,IAAAA,EAAAA,EAAAA,GAAA,GACAhC,GACA0Y,GAAqB/B,EAAW3W,KAQvCA,EAAQoN,WACRpN,EAAQoN,SAAWxN,EAAsBI,EAAQoN,WAEjDpN,EAAQsU,cACRtU,EAAQsU,YAAc1U,EAAsBI,EAAQsU,cAKpDhW,EAAMsZ,OACNtZ,EAAMsZ,MAAM5F,mBAAmBkL,cAC9B5e,EAAMsZ,MAAMuF,WAAWrI,SAAU,CAClC,IAAMsI,EAAuB1G,GAA2BpY,EAAOqY,EAAW3W,GAC1E,GAAIod,EACA,OAAOA,CACf,CAIA,OAAO1J,GAAa1T,EACxB,CACJ,EGxFMqd,GAAsB,IAAIC,QAK1BC,GAAyB,WAC3B,SAAAA,EAAYC,IAAe7e,EAAAA,EAAAA,GAAA,KAAA4e,GAIvB/e,KAAKif,eAAiB,KACtBjf,KAAKkf,YAAa,EAClBlf,KAAKmf,iBAAmB,KACxBnf,KAAK8G,YAAc,CAAE9F,EAAG,EAAGC,EAAG,GAI9BjB,KAAKof,aAAc,EACnBpf,KAAKqf,uBAAwB,EAI7Brf,KAAKsf,QAAU7W,IACfzI,KAAKgf,cAAgBA,CACzB,CAkYC,OAlYA3e,EAAAA,EAAAA,GAAA0e,EAAA,EAAAze,IAAA,QAAAR,MACD,SAAMyf,GAA4C,IAAAnd,EAAA,KAAFod,GAAE5f,UAAAC,OAAA,QAAAiB,IAAAlB,UAAA,GAAAA,UAAA,GAAJ,CAAC,GAA1B6f,aAAAA,OAAY,IAAAD,GAAQA,EAI7BE,EAAoB1f,KAAKgf,cAAzBU,gBACR,IAAIA,IAAiD,IAA9BA,EAAgBC,UAAvC,CAsFA3f,KAAK4f,WAAa,IAAI1d,EAAWqd,EAAa,CAC1Chb,eArFmB,SAAC/D,GAGpB4B,EAAKyd,gBACDJ,GACArd,EAAKqd,aAAa7e,EAAiBJ,EAAO,QAAQO,MAE1D,EA+EI2C,QA9EY,SAAClD,EAAOkC,GAEpB,IAAAod,EAA+C1d,EAAKuc,WAA5C3Y,EAAI8Z,EAAJ9Z,KAAM+Z,EAAeD,EAAfC,gBAAiBC,EAAWF,EAAXE,YAC/B,IAAIha,GAAS+Z,IACL3d,EAAK6c,gBACL7c,EAAK6c,iBACT7c,EAAK6c,eAAiBlZ,EAAcC,GAE/B5D,EAAK6c,gBALd,CAQA7c,EAAK8c,YAAa,EAClB9c,EAAK+c,iBAAmB,KACxB/c,EAAK6d,qBACD7d,EAAK4c,cAAckB,aACnB9d,EAAK4c,cAAckB,WAAWC,oBAAqB,EACnD/d,EAAK4c,cAAckB,WAAWlhB,YAAS8B,GAK3C4H,GAAS,SAACpC,GACN,IAAIkN,EAAUpR,EAAKge,mBAAmB9Z,GAAMxH,OAAS,EAIrD,GAAIuhB,GAAAA,GAAAA,KAAa7M,GAAU,CACvB,IAAQ0M,EAAe9d,EAAK4c,cAApBkB,WACR,GAAIA,GAAcA,EAAWxY,OAAQ,CACjC,IAAM4Y,EAAeJ,EAAWxY,OAAO6Y,UAAUja,GACjD,GAAIga,EAEA9M,EADenN,EAAWia,IACN7D,WAAWjJ,GAAW,IAElD,CACJ,CACApR,EAAK0E,YAAYR,GAAQkN,CAC7B,IAEAwM,GAAeA,EAAYxf,EAAOkC,GAClC,IAAQ8d,EAAmBpe,EAAK4c,cAAxBwB,eACRA,GAAkBA,EAAeC,UAAU,aAAa,EA/BxD,CAgCJ,EAqCI9c,OApCW,SAACnD,EAAOkC,GAEnB,IAAAge,EAAyEte,EAAKuc,WAAtEoB,EAAeW,EAAfX,gBAAiBY,EAAiBD,EAAjBC,kBAAmBC,EAAeF,EAAfE,gBAAiBC,EAAMH,EAANG,OAE7D,GAAKd,GAAoB3d,EAAK6c,eAA9B,CAEA,IAAQ7b,EAAWV,EAAXU,OAER,GAAIud,GAA+C,OAA1Bve,EAAK+c,iBAM1B,OALA/c,EAAK+c,iBA2UrB,SAA6B/b,GAA4B,IAApB0d,EAAalhB,UAAAC,OAAA,QAAAiB,IAAAlB,UAAA,GAAAA,UAAA,GAAG,GAC7CsZ,EAAY,KACZlX,KAAKC,IAAImB,EAAOnC,GAAK6f,EACrB5H,EAAY,IAEPlX,KAAKC,IAAImB,EAAOpC,GAAK8f,IAC1B5H,EAAY,KAEhB,OAAOA,CACX,CApVwC6H,CAAoB3d,QAEd,OAA1BhB,EAAK+c,kBACLyB,GAAmBA,EAAgBxe,EAAK+c,mBAKhD/c,EAAK4e,WAAW,IAAKte,EAAK3B,MAAOqC,GACjChB,EAAK4e,WAAW,IAAKte,EAAK3B,MAAOqC,GAOjChB,EAAK4c,cAAciC,SAKnBJ,GAAUA,EAAOrgB,EAAOkC,EAzBd,CA0Bd,EAMIyB,aALiB,SAAC3D,EAAOkC,GAAI,OAAKN,EAAK6S,KAAKzU,EAAOkC,EAAK,GAMzD,CAAEL,mBAAoBrC,KAAKgf,cAAckC,yBA1FlC,CA2Fd,GAAC,CAAA5gB,IAAA,OAAAR,MACD,SAAKU,EAAOkC,GACR,IAAMwc,EAAalf,KAAKkf,WAExB,GADAlf,KAAKwZ,SACA0F,EAAL,CAEA,IAAQja,EAAavC,EAAbuC,SACRjF,KAAK+d,eAAe9Y,GACpB,IAAQkc,EAAcnhB,KAAK2e,WAAnBwC,UACRA,GAAaA,EAAU3gB,EAAOkC,EAJpB,CAKd,GAAC,CAAApC,IAAA,SAAAR,MACD,WACIE,KAAKkf,YAAa,EAClB,IAAAkC,EAAuCphB,KAAKgf,cAApCkB,EAAUkB,EAAVlB,WAAYM,EAAcY,EAAdZ,eAChBN,IACAA,EAAWC,oBAAqB,GAEpCngB,KAAK4f,YAAc5f,KAAK4f,WAAW5b,MACnChE,KAAK4f,gBAAa9e,GACUd,KAAK2e,WAAzBoB,iBACgB/f,KAAKif,iBACzBjf,KAAKif,iBACLjf,KAAKif,eAAiB,MAE1BuB,GAAkBA,EAAeC,UAAU,aAAa,EAC5D,GAAC,CAAAngB,IAAA,aAAAR,MACD,SAAWwG,EAAM+a,EAAQje,GACrB,IAAQ4C,EAAShG,KAAK2e,WAAd3Y,KAER,GAAK5C,GAAWke,GAAWhb,EAAMN,EAAMhG,KAAKmf,kBAA5C,CAEA,IAAMoC,EAAYvhB,KAAKogB,mBAAmB9Z,GACtCoJ,EAAO1P,KAAK8G,YAAYR,GAAQlD,EAAOkD,GAEvCtG,KAAKof,aAAepf,KAAKof,YAAY9Y,KACrCoJ,EtCpKZ,SAA0B3O,EAAK8H,EAAgByW,GAAS,IAArB9Y,EAAGqC,EAAHrC,IAAKD,EAAGsC,EAAHtC,IASpC,YARYzF,IAAR0F,GAAqBzF,EAAQyF,EAE7BzF,EAAQue,GAAUvY,EAAAA,EAAAA,GAAIP,EAAKzF,EAAOue,EAAQ9Y,KAAOxE,KAAKuE,IAAIxF,EAAOyF,QAEpD1F,IAARyF,GAAqBxF,EAAQwF,IAElCxF,EAAQue,GAAUvY,EAAAA,EAAAA,GAAIR,EAAKxF,EAAOue,EAAQ/Y,KAAOvE,KAAKwE,IAAIzF,EAAOwF,IAE9DxF,CACX,CsC0JmBygB,CAAiB9R,EAAM1P,KAAKof,YAAY9Y,GAAOtG,KAAKsf,QAAQhZ,KAEvEib,EAAUjI,IAAI5J,EAPJ,CAQd,GAAC,CAAApP,IAAA,qBAAAR,MACD,WAAqB,IAAA2hB,EAAA,KACjBC,EAAyC1hB,KAAK2e,WAAtCgD,EAAeD,EAAfC,gBAAiBxZ,EAAWuZ,EAAXvZ,YACjBT,GAAW1H,KAAKgf,cAAckB,YAAc,CAAC,GAA7CxY,OACFka,EAAkB5hB,KAAKof,YACzBuC,IAAmBE,EAAAA,EAAAA,GAAYF,GAC1B3hB,KAAKof,cACNpf,KAAKof,YAAcpf,KAAK8hB,yBAKxB9hB,KAAKof,eADLuC,IAAmBja,ItCtJnC,SAAiC6Y,EAAS1b,GAAgC,IAA5BiE,EAAGjE,EAAHiE,IAAKC,EAAIlE,EAAJkE,KAAME,EAAMpE,EAANoE,OAAQD,EAAKnE,EAALmE,MAC7D,MAAO,CACHhI,EAAG4G,EAA4B2Y,EAAUvf,EAAG+H,EAAMC,GAClD/H,EAAG2G,EAA4B2Y,EAAUtf,EAAG6H,EAAKG,GAEzD,CsCkJmC8Y,CAAwBra,EAAO6Y,UAAWoB,GAMrE3hB,KAAKsf,QtC/Fb,WAA0D,IAA9BnX,EAAWvI,UAAAC,OAAA,QAAAiB,IAAAlB,UAAA,GAAAA,UAAA,GAAGqI,EAOtC,OANoB,IAAhBE,EACAA,EAAc,GAEO,IAAhBA,IACLA,EAAcF,GAEX,CACHjH,EAAGkH,EAAmBC,EAAa,OAAQ,SAC3ClH,EAAGiH,EAAmBC,EAAa,MAAO,UAElD,CsCoFuB6Z,CAAmB7Z,GAK9ByZ,IAAoB5hB,KAAKof,aACzB1X,GACA1H,KAAKof,cACJpf,KAAKqf,uBACN3W,GAAS,SAACpC,GACFmb,EAAKrB,mBAAmB9Z,KACxBmb,EAAKrC,YAAY9Y,GtCxHrC,SAA+BoB,EAAQ0X,GACnC,IAAM6C,EAAsB,CAAC,EAO7B,YANwBnhB,IAApBse,EAAY5Y,MACZyb,EAAoBzb,IAAM4Y,EAAY5Y,IAAMkB,EAAOlB,UAE/B1F,IAApBse,EAAY7Y,MACZ0b,EAAoB1b,IAAM6Y,EAAY7Y,IAAMmB,EAAOlB,KAEhDyb,CACX,CsC+G6CC,CAAsBxa,EAAO6Y,UAAUja,GAAOmb,EAAKrC,YAAY9Y,IAEhG,GAER,GAAC,CAAAhG,IAAA,wBAAAR,MACD,WACI,IAAAqiB,EAAmEniB,KAAK2e,WAA/CS,EAAW+C,EAA5BR,gBAA8BS,EAAwBD,EAAxBC,yBACtC,IAAKhD,KAAgByC,EAAAA,EAAAA,GAAYzC,GAC7B,OAAO,EACX,IAAMiD,EAAqBjD,EAAY5L,SACvCtF,EAAAA,EAAAA,GAAiC,OAAvBmU,EAA6B,0GACvC,IAAQnC,EAAelgB,KAAKgf,cAApBkB,WAER,IAAKA,IAAeA,EAAWxY,OAC3B,OAAO,EACX,IAAM4a,EhCvNd,SAAwB7J,EAAS8J,EAAoBlgB,GACjD,IAAMmgB,EAActX,GAAmBuN,EAASpW,GACxCogB,EAAWF,EAAXE,OAKR,OAJIA,IACAlY,GAAciY,EAAYxhB,EAAGyhB,EAAOrf,OAAOpC,GAC3CuJ,GAAciY,EAAYvhB,EAAGwhB,EAAOrf,OAAOnC,IAExCuhB,CACX,CgC+M+BE,CAAeL,EAAoBnC,EAAWyC,KAAM3iB,KAAKgf,cAAckC,yBAC1F0B,EtCjKZ,SAAiCrC,EAAW+B,GACxC,MAAO,CACHthB,EAAG6G,EAA4B0Y,EAAUvf,EAAGshB,EAAethB,GAC3DC,EAAG4G,EAA4B0Y,EAAUtf,EAAGqhB,EAAerhB,GAEnE,CsC4JkC4hB,CAAwB3C,EAAWxY,OAAO6Y,UAAW+B,GAK/E,GAAIF,EAA0B,CAC1B,IAAMU,EAAkBV,EnCzNpC,SAAgCvd,GAAW,IAAR7D,EAAC6D,EAAD7D,EAAGC,EAAC4D,EAAD5D,EAClC,MAAO,CAAE6H,IAAK7H,EAAEuF,IAAKwC,MAAOhI,EAAEuF,IAAK0C,OAAQhI,EAAEsF,IAAKwC,KAAM/H,EAAEwF,IAC9D,CmCuN6Duc,CAAwBH,IACzE5iB,KAAKqf,wBAA0ByD,EAC3BA,IACAF,EAAsBha,EAAwBka,GAEtD,CACA,OAAOF,CACX,GAAC,CAAAtiB,IAAA,iBAAAR,MACD,SAAemF,GAAU,IAAA+d,EAAA,KACrBC,EAAoGjjB,KAAK2e,WAAjG3Y,EAAIid,EAAJjd,KAAMkd,EAAYD,EAAZC,aAAc/a,EAAW8a,EAAX9a,YAAagb,EAAcF,EAAdE,eAAgBC,EAAgBH,EAAhBG,iBAAkBC,EAAmBJ,EAAnBI,oBACrEjE,EAAcpf,KAAKof,aAAe,CAAC,EACnCkE,EAAqB5a,GAAS,SAACpC,GACjC,GAAKgb,GAAWhb,EAAMN,EAAMgd,EAAK7D,kBAAjC,CAGA,IAAIrC,EAAcsC,GAAeA,EAAY9Y,IAAU,CAAC,EACpD8c,IACAtG,EAAa,CAAEtW,IAAK,EAAGD,IAAK,IAOhC,IAAMmX,EAAkBvV,EAAc,IAAM,IACtCyV,EAAgBzV,EAAc,GAAK,IACnCiW,GAAO5a,EAAAA,EAAAA,IAAAA,EAAAA,EAAAA,GAAA,CACTa,KAAM,UACNY,SAAUie,EAAeje,EAASqB,GAAQ,EAC1CoX,gBAAAA,EACAE,cAAAA,EACAvJ,aAAc,IACdnC,UAAW,EACXC,UAAW,IACRgR,GACArG,GAKP,OAAOkG,EAAKO,wBAAwBjd,EAAM8X,EA1B1C,CA2BJ,IAEA,OAAOoF,QAAQC,IAAIH,GAAoBI,KAAKL,EAChD,GAAC,CAAA/iB,IAAA,0BAAAR,MACD,SAAwBwG,EAAMwW,GAC1B,IAAMyE,EAAYvhB,KAAKogB,mBAAmB9Z,GAC1C,OAAOib,EAAUvM,MAAM+H,GAA2BzW,EAAMib,EAAW,EAAGzE,GAC1E,GAAC,CAAAxc,IAAA,gBAAAR,MACD,WAAgB,IAAA6jB,EAAA,KACZjb,GAAS,SAACpC,GAAI,OAAKqd,EAAKvD,mBAAmB9Z,GAAM2O,MAAM,GAC3D,GACA,CAAA3U,IAAA,qBAAAR,MAMA,SAAmBwG,GACf,IAAMsd,EAAU,QAAUtd,EAAKud,cACzBC,EAAQ9jB,KAAKgf,cAAcL,WAC3BoF,EAAsBD,EAAMF,GAClC,OAAOG,GAED/jB,KAAKgf,cAAcgF,SAAS1d,GAAOwd,EAAMG,QAAUH,EAAMG,QAAQ3d,QAAQxF,IAAc,EACjG,GAAC,CAAAR,IAAA,eAAAR,MACD,SAAaiB,GAAO,IAAAmjB,EAAA,KAChBxb,GAAS,SAACpC,GAGN,GAAKgb,GAAWhb,EAFC4d,EAAKvF,WAAd3Y,KAEoBke,EAAK/E,kBAAjC,CAEA,IAAQe,EAAegE,EAAKlF,cAApBkB,WACFqB,EAAY2C,EAAK9D,mBAAmB9Z,GAC1C,GAAI4Z,GAAcA,EAAWxY,OAAQ,CACjC,IAAAyc,EAAqBjE,EAAWxY,OAAO6Y,UAAUja,GAAzCE,EAAG2d,EAAH3d,IAAKD,EAAG4d,EAAH5d,IACbgb,EAAUjI,IAAIvY,EAAMuF,IAAQS,EAAAA,EAAAA,GAAIP,EAAKD,EAAK,IAC9C,CANU,CAOd,GACJ,GACA,CAAAjG,IAAA,iCAAAR,MAKA,WAAiC,IAAAskB,EAAA,KAC7B,GAAKpkB,KAAKgf,cAAcxL,QAAxB,CAEA,IAAA6Q,EAAkCrkB,KAAK2e,WAA/B3Y,EAAIqe,EAAJre,KAAM2b,EAAe0C,EAAf1C,gBACNzB,EAAelgB,KAAKgf,cAApBkB,WACR,IAAK2B,EAAAA,EAAAA,GAAYF,IAAqBzB,GAAelgB,KAAKof,YAA1D,CAMApf,KAAK6f,gBAKL,IAAMyE,EAAc,CAAEtjB,EAAG,EAAGC,EAAG,GAC/ByH,GAAS,SAACpC,GACN,IAAMib,EAAY6C,EAAKhE,mBAAmB9Z,GAC1C,GAAIib,EAAW,CACX,IAAMgD,EAAShD,EAAUziB,MACzBwlB,EAAYhe,GtCvQ5B,SAAoBM,EAAQ5H,GACxB,IAAI6H,EAAS,GACP2d,EAAene,EAAWO,GAC1B6d,EAAepe,EAAWrH,GAOhC,OANIylB,EAAeD,EACf3d,GAAS6d,EAAAA,EAAAA,GAAS1lB,EAAOwH,IAAKxH,EAAOuH,IAAMie,EAAc5d,EAAOJ,KAE3Dge,EAAeC,IACpB5d,GAAS6d,EAAAA,EAAAA,GAAS9d,EAAOJ,IAAKI,EAAOL,IAAMke,EAAczlB,EAAOwH,OAE7DoK,EAAAA,EAAAA,GAAM,EAAG,EAAG/J,EACvB,CsC4PoC8d,CAAW,CAAEne,IAAK+d,EAAQhe,IAAKge,GAAUH,EAAKhF,YAAY9Y,GAClF,CACJ,IAIA,IAAQse,EAAsB5kB,KAAKgf,cAAcL,WAAzCiG,kBACR5kB,KAAKgf,cAAcxL,QAAQqR,MAAM5Z,UAAY2Z,EACvCA,EAAkB,CAAC,EAAG,IACtB,OACN1E,EAAWyC,MAAQzC,EAAWyC,KAAKmC,eACnC5E,EAAW6E,eACX/kB,KAAKigB,qBAKLvX,GAAS,SAACpC,GACN,GAAKgb,GAAWhb,EAAMN,EAAM,MAA5B,CAKA,IAAMub,EAAY6C,EAAKhE,mBAAmB9Z,GAC1C0e,EAAqBZ,EAAKhF,YAAY9Y,GAA9BE,EAAGwe,EAAHxe,IAAKD,EAAGye,EAAHze,IACbgb,EAAUjI,KAAIvS,EAAAA,EAAAA,GAAIP,EAAKD,EAAK+d,EAAYhe,IAN9B,CAOd,GAzCU,CAJA,CA8Cd,GAAC,CAAAhG,IAAA,eAAAR,MACD,WAAe,IAAAmlB,EAAA,KACX,GAAKjlB,KAAKgf,cAAcxL,QAAxB,CAEAqL,GAAoBvF,IAAItZ,KAAKgf,cAAehf,MAC5C,IAIMklB,EAAsBtjB,EAJZ5B,KAAKgf,cAAcxL,QAIkB,eAAe,SAAChT,GACjE,IAAA2kB,EAAsCF,EAAKtG,WAAnC3Y,EAAImf,EAAJnf,KAAIof,EAAAD,EAAEE,aACdrf,SAD0B,IAAAof,GAAOA,IACTH,EAAKjQ,MAAMxU,EACvC,IACM8kB,EAAyB,WAC3B,IAAQ3D,EAAoBsD,EAAKtG,WAAzBgD,iBACJE,EAAAA,EAAAA,GAAYF,KACZsD,EAAK7F,YAAc6F,EAAKnD,wBAEhC,EACQ5B,EAAelgB,KAAKgf,cAApBkB,WACFqF,EAA4BrF,EAAWxe,iBAAiB,UAAW4jB,GACrEpF,IAAeA,EAAWxY,SAC1BwY,EAAWyC,MAAQzC,EAAWyC,KAAKmC,eACnC5E,EAAW6E,gBAEfO,IAKA,IAAME,EAAqBlkB,EAAYoD,OAAQ,UAAU,kBAAMugB,EAAKQ,gCAAgC,IAK9FC,EAA2BxF,EAAWxe,iBAAiB,aAAc,SAAAsG,GAAiC,IAA9BlD,EAAKkD,EAALlD,MAAO6gB,EAAgB3d,EAAhB2d,iBAC7EV,EAAK/F,YAAcyG,IACnBjd,GAAS,SAACpC,GACN,IAAMsf,EAAcX,EAAK7E,mBAAmB9Z,GACvCsf,IAELX,EAAKne,YAAYR,IAASxB,EAAMwB,GAAMY,UACtC0e,EAAYtM,IAAIsM,EAAY9mB,MAAQgG,EAAMwB,GAAMY,WACpD,IACA+d,EAAKjG,cAAciC,SAE3B,IACA,OAAO,WACHuE,IACAN,IACAK,IACAG,GAA4BA,GAChC,CAjDU,CAkDd,GAAC,CAAAplB,IAAA,WAAAR,MACD,WACI,IAAMgkB,EAAQ9jB,KAAKgf,cAAcL,WACjCkH,EAA0J/B,EAAlJ9d,KAAAA,OAAI,IAAA6f,GAAQA,EAAAC,EAAsIhC,EAApInD,kBAAAA,OAAiB,IAAAmF,GAAQA,EAAAC,EAA2GjC,EAAzG/D,gBAAAA,OAAe,IAAAgG,GAAQA,EAAAC,EAAkFlC,EAAhFnC,gBAAAA,OAAe,IAAAqE,GAAQA,EAAAC,EAAyDnC,EAAvD3b,YAAAA,OAAW,IAAA8d,EAAGhe,EAAcge,EAAAC,EAA2BpC,EAAzBZ,aAAAA,OAAY,IAAAgD,GAAOA,EACpJ,OAAA1iB,EAAAA,EAAAA,IAAAA,EAAAA,EAAAA,GAAA,GACOsgB,GAAK,IACR9d,KAAAA,EACA2a,kBAAAA,EACAZ,gBAAAA,EACA4B,gBAAAA,EACAxZ,YAAAA,EACA+a,aAAAA,GAER,KAACnE,CAAA,CArZ0B,GAuZ/B,SAASuC,GAAWpI,EAAWlT,EAAMmZ,GACjC,QAAkB,IAATnZ,GAAiBA,IAASkT,KACT,OAArBiG,GAA6BA,IAAqBjG,EAC3D,CC9a4E,IAEtEiN,GAAW,SAAAC,IAAAC,EAAAA,EAAAA,GAAAF,EAAAC,GAAA,IAAAE,GAAAC,EAAAA,EAAAA,GAAAJ,GACb,SAAAA,EAAYjmB,GAAM,IAAAkC,EAIsC,OAJtCjC,EAAAA,EAAAA,GAAA,KAAAgmB,IACd/jB,EAAAkkB,EAAA9mB,KAAA,KAAMU,IACDsmB,oBAAsB7Z,EAAAA,EAC3BvK,EAAKoC,gBAAkBmI,EAAAA,EACvBvK,EAAKqkB,SAAW,IAAI1H,GAA0B7e,GAAMkC,CACxD,CAaC,OAbA/B,EAAAA,EAAAA,GAAA8lB,EAAA,EAAA7lB,IAAA,QAAAR,MACD,WAGI,IAAQ4mB,EAAiB1mB,KAAKE,KAAKye,WAA3B+H,aACJA,IACA1mB,KAAKwmB,oBAAsBE,EAAaC,UAAU3mB,KAAKymB,WAE3DzmB,KAAKwE,gBAAkBxE,KAAKymB,SAASG,gBAAkBja,EAAAA,CAC3D,GAAC,CAAArM,IAAA,UAAAR,MACD,WACIE,KAAKwmB,sBACLxmB,KAAKwE,iBACT,KAAC2hB,CAAA,CAnBY,CAASlmB,GCCpB4mB,GAAU,SAAAT,IAAAC,EAAAA,EAAAA,GAAAQ,EAAAT,GAAA,IAAAE,GAAAC,EAAAA,EAAAA,GAAAM,GACZ,SAAAA,IAAc,IAAAzkB,EAE4B,OAF5BjC,EAAAA,EAAAA,GAAA,KAAA0mB,IACVzkB,EAAAkkB,EAAAvmB,MAAA,KAASH,YACJknB,0BAA4Bna,EAAAA,EAAKvK,CAC1C,CAyBC,OAzBA/B,EAAAA,EAAAA,GAAAwmB,EAAA,EAAAvmB,IAAA,gBAAAR,MACD,SAAcinB,GACV/mB,KAAKgnB,QAAU,IAAI9kB,EAAW6kB,EAAkB/mB,KAAKinB,oBAAqB,CAAE5kB,mBAAoBrC,KAAKE,KAAKghB,yBAC9G,GAAC,CAAA5gB,IAAA,oBAAAR,MACD,WAAoB,IAAA2hB,EAAA,KAChByF,EAA2DlnB,KAAKE,KAAKye,WAA7DwI,EAAiBD,EAAjBC,kBAAmBC,EAAUF,EAAVE,WAAYC,EAAKH,EAALG,MAAOC,EAAQJ,EAARI,SAC9C,MAAO,CACH/iB,eAAgB4iB,EAChBzjB,QAAS0jB,EACTzjB,OAAQ0jB,EACRnjB,MAAO,SAAC1D,EAAOkC,UACJ+e,EAAKuF,QACZM,GAAYA,EAAS9mB,EAAOkC,EAChC,EAER,GAAC,CAAApC,IAAA,QAAAR,MACD,WAAQ,IAAAkjB,EAAA,KACJhjB,KAAK8mB,0BAA4BllB,EAAgB5B,KAAKE,KAAKsT,QAAS,eAAe,SAAChT,GAAK,OAAKwiB,EAAKuE,cAAc/mB,EAAM,GAC3H,GAAC,CAAAF,IAAA,SAAAR,MACD,WACIE,KAAKgnB,SAAWhnB,KAAKgnB,QAAQQ,eAAexnB,KAAKinB,oBACrD,GAAC,CAAA3mB,IAAA,UAAAR,MACD,WACIE,KAAK8mB,4BACL9mB,KAAKgnB,SAAWhnB,KAAKgnB,QAAQhjB,KACjC,KAAC6iB,CAAA,CA7BW,CAAS5mB,G,+DCHzB,SAASwnB,GAAgBC,EAAQphB,GAC7B,OAAIA,EAAKC,MAAQD,EAAKE,IACX,EACHkhB,GAAUphB,EAAKC,IAAMD,EAAKE,KAAQ,GAC9C,CAQA,IAAMmhB,GAAsB,CACxBC,QAAS,SAACrD,EAAQrkB,GACd,IAAKA,EAAKlB,OACN,OAAOulB,EAKX,GAAsB,kBAAXA,EAAqB,CAC5B,IAAIsD,GAAAA,GAAAA,KAAQtD,GAIR,OAAOA,EAHPA,EAAS9H,WAAW8H,EAK5B,CAKA,IAAMvjB,EAAIymB,GAAgBlD,EAAQrkB,EAAKlB,OAAOgC,GACxCC,EAAIwmB,GAAgBlD,EAAQrkB,EAAKlB,OAAOiC,GAC9C,MAAO,GAAPmN,OAAUpN,EAAC,MAAAoN,OAAKnN,EAAC,IACrB,G,wBCzBE6mB,GAAmB,uDAQzB,IAAMC,GAAW,EACjB,SAASC,GAAiBxU,EAASiF,GAAoB,IAAXwP,EAAKroB,UAAAC,OAAA,QAAAiB,IAAAlB,UAAA,GAAAA,UAAA,GAAG,GAChDsO,EAAAA,EAAAA,GAAU+Z,GAASF,GAAU,yDAAF3Z,OAA2DoF,EAAO,yDAC7F,IAAA0U,EAVJ,SAA0B1U,GACtB,IAAMuH,EAAQ+M,GAAiBK,KAAK3U,GACpC,IAAKuH,EACD,MAAO,CAAC,GACZ,IAAAqN,GAAA1d,EAAAA,EAAAA,GAA4BqQ,EAAK,GACjC,MAAO,CADOqN,EAAA,GAAUA,EAAA,GAE5B,CAI8BC,CAAiB7U,GAAQ8U,GAAA5d,EAAAA,EAAAA,GAAAwd,EAAA,GAA5CK,EAAKD,EAAA,GAAEE,EAAQF,EAAA,GAEtB,GAAKC,EAAL,CAGA,IAAME,EAAW/jB,OAAOgkB,iBAAiBjQ,GAASkQ,iBAAiBJ,GACnE,OAAIE,EACOA,EAASG,QAEXC,EAAAA,GAAAA,GAAmBL,GAEjBR,GAAiBQ,EAAU/P,EAASwP,EAAQ,GAG5CO,CAXD,CAad,CCnCA,IAAMM,GAAW,QACXC,GAAmB,CACrBnB,QAAS,SAACrD,EAAM1b,GAAqC,IAAjCmgB,EAASngB,EAATmgB,UAAWC,EAAepgB,EAAfogB,gBACrBC,EAAW3E,EAIX4E,EAAuB5E,EAAO6E,SAAS,QACvCC,EAAe,GACjBF,IACA5E,EAASA,EAAOpJ,QAAQ2M,IAAkB,SAAC/M,GAEvC,OADAsO,EAAa9lB,KAAKwX,GACX+N,EACX,KAEJ,IAAMQ,EAAS/O,GAAAA,EAAAA,MAAcgK,GAE7B,GAAI+E,EAAOzpB,OAAS,EAChB,OAAOqpB,EACX,IAAMK,EAAWhP,GAAAA,EAAAA,kBAA0BgK,GACrCnhB,EAA8B,kBAAdkmB,EAAO,GAAkB,EAAI,EAE7CE,EAASP,EAAgBjoB,EAAEgG,MAAQgiB,EAAUhoB,EAC7CyoB,EAASR,EAAgBhoB,EAAE+F,MAAQgiB,EAAU/nB,EACnDqoB,EAAO,EAAIlmB,IAAWomB,EACtBF,EAAO,EAAIlmB,IAAWqmB,EAOtB,IAAMC,GAAe3iB,EAAAA,EAAAA,GAAIyiB,EAAQC,EAAQ,IAEP,kBAAvBH,EAAO,EAAIlmB,KAClBkmB,EAAO,EAAIlmB,IAAWsmB,GAEQ,kBAAvBJ,EAAO,EAAIlmB,KAClBkmB,EAAO,EAAIlmB,IAAWsmB,GAC1B,IAAIC,EAASJ,EAASD,GACtB,GAAIH,EAAsB,CACtB,IAAI/jB,EAAI,EACRukB,EAASA,EAAOxO,QAAQ2N,IAAU,WAC9B,IAAMc,EAAcP,EAAajkB,GAEjC,OADAA,IACOwkB,CACX,GACJ,CACA,OAAOD,CACX,G,YC3CEE,GAAwB,SAAAC,IAAAzD,EAAAA,EAAAA,GAAAwD,EAAAC,GAAA,IAAAxD,GAAAC,EAAAA,EAAAA,GAAAsD,GAAA,SAAAA,IAAA,OAAA1pB,EAAAA,EAAAA,GAAA,KAAA0pB,GAAAvD,EAAAvmB,MAAA,KAAAH,UAAA,CA8FzB,OA9FyBS,EAAAA,EAAAA,GAAAwpB,EAAA,EAAAvpB,IAAA,oBAAAR,MAM1B,WAAoB,IAAAsC,EAAA,KAChB2nB,EAAoE/pB,KAAK8jB,MAAjE9E,EAAa+K,EAAb/K,cAAegL,EAAWD,EAAXC,YAAaC,EAAiBF,EAAjBE,kBAAmBC,EAAQH,EAARG,SAC/ChK,EAAelB,EAAfkB,YACRiK,EAAAA,GAAAA,GAAkBC,IACdlK,IACI8J,EAAYK,OACZL,EAAYK,MAAMC,IAAIpK,GACtB+J,GAAqBA,EAAkBM,UAAYL,GACnDD,EAAkBM,SAASrK,GAE/BA,EAAWyC,KAAK6H,YAChBtK,EAAWxe,iBAAiB,qBAAqB,WAC7CU,EAAKqoB,cACT,IACAvK,EAAWwK,YAAUlnB,EAAAA,EAAAA,IAAAA,EAAAA,EAAAA,GAAC,CAAC,EAChB0c,EAAW1e,SAAO,IACrBmpB,eAAgB,kBAAMvoB,EAAKqoB,cAAc,MAGjDG,GAAAA,EAAAA,gBAAuC,CAC3C,GAAC,CAAAtqB,IAAA,0BAAAR,MACD,SAAwB+qB,GAAW,IAAApJ,EAAA,KAC/BqJ,EAA6D9qB,KAAK8jB,MAA1DiH,EAAgBD,EAAhBC,iBAAkB/L,EAAa8L,EAAb9L,cAAehZ,EAAI8kB,EAAJ9kB,KAAM2Z,EAASmL,EAATnL,UACzCO,EAAalB,EAAckB,WACjC,OAAKA,GASLA,EAAWP,UAAYA,EACnB3Z,GACA6kB,EAAUE,mBAAqBA,QACVjqB,IAArBiqB,EACA7K,EAAW8K,aAGXhrB,KAAKyqB,eAELI,EAAUlL,YAAcA,IACpBA,EACAO,EAAW+K,UAEL/K,EAAWgL,YAMjBpnB,EAAAA,GAAAA,YAAgB,WACZ,IAAMqnB,EAAQjL,EAAWkL,WACpBD,GAAUA,EAAME,QAAQxrB,QACzB4hB,EAAKgJ,cAEb,KAGD,MAnCI,IAoCf,GAAC,CAAAnqB,IAAA,qBAAAR,MACD,WACI,IAAQogB,EAAelgB,KAAK8jB,MAAM9E,cAA1BkB,WACJA,IACAA,EAAWyC,KAAK6H,aACXtK,EAAW1C,kBAAoB0C,EAAWoL,UAC3CtrB,KAAKyqB,eAGjB,GAAC,CAAAnqB,IAAA,uBAAAR,MACD,WACI,IAAAyrB,EAA2EvrB,KAAK8jB,MAAxE9E,EAAauM,EAAbvM,cAAegL,EAAWuB,EAAXvB,YAAgCwB,EAAcD,EAAjCtB,kBAC5B/J,EAAelB,EAAfkB,WACJA,IACAA,EAAWuL,4BACPzB,GAAeA,EAAYK,OAC3BL,EAAYK,MAAMqB,OAAOxL,GACzBsL,GAAkBA,EAAeG,YACjCH,EAAeG,WAAWzL,GAEtC,GAAC,CAAA5f,IAAA,eAAAR,MACD,WACI,IAAQ2qB,EAAiBzqB,KAAK8jB,MAAtB2G,aACRA,GAAgBA,GACpB,GAAC,CAAAnqB,IAAA,SAAAR,MACD,WACI,OAAO,IACX,KAAC+pB,CAAA,CA9FyB,CAAS+B,GAAAA,WAgGvC,SAASC,GAAc/H,GACnB,IAAAgI,ECjFJ,WACI,IAAMC,GAAUC,EAAAA,GAAAA,YAAWC,GAAAA,GAC3B,GAAgB,OAAZF,EACA,MAAO,EAAC,EAAM,MAClB,IAAQpM,EAAwCoM,EAAxCpM,UAAWgL,EAA6BoB,EAA7BpB,eAAgBJ,EAAawB,EAAbxB,SAG7B2B,GAAKC,EAAAA,GAAAA,SAGX,OAFAC,EAAAA,GAAAA,YAAU,kBAAM7B,EAAS2B,EAAG,GAAE,KAEtBvM,GAAagL,EAAiB,EAAC,EADlB,WAAH,OAASA,GAAkBA,EAAeuB,EAAG,GACD,EAAC,EACnE,CDsEsCG,GAAaC,GAAA5hB,EAAAA,EAAAA,GAAAohB,EAAA,GAAxCnM,EAAS2M,EAAA,GAAE7B,EAAY6B,EAAA,GACxBtC,GAAcgC,EAAAA,GAAAA,YAAWO,GAAAA,GAC/B,OAAQX,GAAAA,cAA6B/B,IAAwBrmB,EAAAA,EAAAA,IAAAA,EAAAA,EAAAA,GAAA,GAAOsgB,GAAK,IAAEkG,YAAaA,EAAaC,mBAAmB+B,EAAAA,GAAAA,YAAWQ,GAAAA,GAA2B7M,UAAWA,EAAW8K,aAAcA,IACtM,CACA,IAAML,GAAyB,CAC3BqC,cAAYjpB,EAAAA,EAAAA,IAAAA,EAAAA,EAAAA,GAAA,GACLmkB,IAAmB,IACtB+E,QAAS,CACL,sBACA,uBACA,yBACA,6BAGRC,oBAAqBhF,GACrBiF,qBAAsBjF,GACtBkF,uBAAwBlF,GACxBmF,wBAAyBnF,GACzBoF,UAAWhE,I,uCEvHTiE,GAAU,CAAC,UAAW,WAAY,aAAc,eAChDC,GAAaD,GAAQntB,OACrBqtB,GAAW,SAACptB,GAAK,MAAsB,kBAAVA,EAAqB2c,WAAW3c,GAASA,CAAK,EAC3EqtB,GAAO,SAACrtB,GAAK,MAAsB,kBAAVA,GAAsB+nB,GAAAA,GAAAA,KAAQ/nB,EAAM,EA0CnE,SAASstB,GAAU7jB,EAAQ8jB,GACvB,YAA8BvsB,IAAvByI,EAAO8jB,GACR9jB,EAAO8jB,GACP9jB,EAAOkjB,YACjB,CAwBA,IAAMa,GAAkBC,GAAS,EAAG,GAAKjgB,IACnCkgB,GAAmBD,GAAS,GAAK,IAAM5gB,EAAAA,GAC7C,SAAS4gB,GAAS/mB,EAAKD,EAAKmF,GACxB,OAAO,SAACC,GAEJ,OAAIA,EAAInF,EACG,EACPmF,EAAIpF,EACG,EACJmF,GAAOgZ,EAAAA,EAAAA,GAASle,EAAKD,EAAKoF,GACrC,CACJ,CCrFA,SAAS8hB,GAAannB,EAAMonB,GACxBpnB,EAAKE,IAAMknB,EAAWlnB,IACtBF,EAAKC,IAAMmnB,EAAWnnB,GAC1B,CAMA,SAASonB,GAAYxjB,EAAKyjB,GACtBH,GAAatjB,EAAInJ,EAAG4sB,EAAU5sB,GAC9BysB,GAAatjB,EAAIlJ,EAAG2sB,EAAU3sB,EAClC,CCVA,SAAS4sB,GAAiB9sB,EAAOmG,EAAWF,EAAOF,EAAakD,GAM5D,OAJAjJ,EAAQ+I,GADR/I,GAASmG,EACiB,EAAIF,EAAOF,QACpBhG,IAAbkJ,IACAjJ,EAAQ+I,GAAW/I,EAAO,EAAIiJ,EAAUlD,IAErC/F,CACX,CAsBA,SAAS+sB,GAAqBxnB,EAAMmE,EAAU5B,EAA8BhC,EAAQknB,GAAY,IAAAlpB,GAAA6F,EAAAA,EAAAA,GAAA7B,EAAA,GAA/CvI,EAAGuE,EAAA,GAAE8F,EAAQ9F,EAAA,GAAE+F,EAAS/F,EAAA,IAlBzE,SAAyByB,GAA8F,IAAxFY,EAAStH,UAAAC,OAAA,QAAAiB,IAAAlB,UAAA,GAAAA,UAAA,GAAG,EAAGoH,EAAKpH,UAAAC,OAAA,QAAAiB,IAAAlB,UAAA,GAAAA,UAAA,GAAG,EAAGiH,EAAMjH,UAAAC,OAAA,QAAAiB,IAAAlB,UAAA,GAAAA,UAAA,GAAG,GAAKoK,EAAQpK,UAAAC,OAAA,EAAAD,UAAA,QAAAkB,EAAE4sB,EAAU9tB,UAAAC,OAAA,QAAAiB,IAAAlB,UAAA,GAAAA,UAAA,GAAG0G,EAAMynB,EAAUnuB,UAAAC,OAAA,QAAAiB,IAAAlB,UAAA,GAAAA,UAAA,GAAG0G,EAM7G,GALI+Z,GAAAA,GAAAA,KAAanZ,KACbA,EAAYuV,WAAWvV,GAEvBA,GADyBH,EAAAA,EAAAA,GAAIgnB,EAAWvnB,IAAKunB,EAAWxnB,IAAKW,EAAY,KAC1C6mB,EAAWvnB,KAErB,kBAAdU,EAAX,CAEA,IAAIJ,GAAcC,EAAAA,EAAAA,GAAI2mB,EAAWlnB,IAAKknB,EAAWnnB,IAAKM,GAClDP,IAASonB,IACT5mB,GAAeI,GACnBZ,EAAKE,IAAMqnB,GAAiBvnB,EAAKE,IAAKU,EAAWF,EAAOF,EAAakD,GACrE1D,EAAKC,IAAMsnB,GAAiBvnB,EAAKC,IAAKW,EAAWF,EAAOF,EAAakD,EAL3D,CAMd,CAMIgkB,CAAgB1nB,EAAMmE,EAAWnK,GAAMmK,EAAWE,GAAWF,EAAWG,GAAYH,EAAWzD,MAAOH,EAAQknB,EAClH,CAIA,IAAMjjB,GAAQ,CAAC,IAAK,SAAU,WACxBC,GAAQ,CAAC,IAAK,SAAU,WAK9B,SAASkjB,GAAoB9jB,EAAKM,EAAYmjB,EAAWM,GACrDJ,GAAqB3jB,EAAInJ,EAAGyJ,EAAYK,GAAO8iB,EAAYA,EAAU5sB,OAAIF,EAAWotB,EAAYA,EAAUltB,OAAIF,GAC9GgtB,GAAqB3jB,EAAIlJ,EAAGwJ,EAAYM,GAAO6iB,EAAYA,EAAU3sB,OAAIH,EAAWotB,EAAYA,EAAUjtB,OAAIH,EAClH,CCjDA,SAASqtB,GAAgBrpB,GACrB,OAA2B,IAApBA,EAAMoC,WAAmC,IAAhBpC,EAAMkC,KAC1C,CACA,SAASonB,GAAYtpB,GACjB,OAAOqpB,GAAgBrpB,EAAM9D,IAAMmtB,GAAgBrpB,EAAM7D,EAC7D,CACA,SAASotB,GAAUvsB,EAAGC,GAClB,OAAQD,EAAEd,EAAEwF,MAAQzE,EAAEf,EAAEwF,KACpB1E,EAAEd,EAAEuF,MAAQxE,EAAEf,EAAEuF,KAChBzE,EAAEb,EAAEuF,MAAQzE,EAAEd,EAAEuF,KAChB1E,EAAEb,EAAEsF,MAAQxE,EAAEd,EAAEsF,GACxB,CACA,SAAS+nB,GAAYnkB,GACjB,OAAO9D,EAAW8D,EAAInJ,GAAKqF,EAAW8D,EAAIlJ,EAC9C,C,gBCdMstB,GAAS,WACX,SAAAA,KAAcpuB,EAAAA,EAAAA,GAAA,KAAAouB,GACVvuB,KAAKqrB,QAAU,EACnB,CAuGC,OAvGAhrB,EAAAA,EAAAA,GAAAkuB,EAAA,EAAAjuB,IAAA,MAAAR,MACD,SAAII,IACAsuB,EAAAA,GAAAA,IAAcxuB,KAAKqrB,QAASnrB,GAC5BA,EAAKuuB,gBACT,GAAC,CAAAnuB,IAAA,SAAAR,MACD,SAAOI,GAKH,IAJAwuB,EAAAA,GAAAA,IAAW1uB,KAAKqrB,QAASnrB,GACrBA,IAASF,KAAK2uB,WACd3uB,KAAK2uB,cAAW7tB,GAEhBZ,IAASF,KAAK4uB,KAAM,CACpB,IAAMD,EAAW3uB,KAAKqrB,QAAQrrB,KAAKqrB,QAAQxrB,OAAS,GAChD8uB,GACA3uB,KAAKirB,QAAQ0D,EAErB,CACJ,GAAC,CAAAruB,IAAA,WAAAR,MACD,SAASI,GACL,IAMIyuB,EANEE,EAAc7uB,KAAKqrB,QAAQyD,WAAU,SAACC,GAAM,OAAK7uB,IAAS6uB,CAAM,IACtE,GAAoB,IAAhBF,EACA,OAAO,EAKX,IAAK,IAAIzpB,EAAIypB,EAAazpB,GAAK,EAAGA,IAAK,CACnC,IAAM2pB,EAAS/uB,KAAKqrB,QAAQjmB,GAC5B,IAAyB,IAArB2pB,EAAOpP,UAAqB,CAC5BgP,EAAWI,EACX,KACJ,CACJ,CACA,QAAIJ,IACA3uB,KAAKirB,QAAQ0D,IACN,EAKf,GAAC,CAAAruB,IAAA,UAAAR,MACD,SAAQI,EAAM8uB,GACV,IAAML,EAAW3uB,KAAK4uB,KAClB1uB,IAASyuB,IAEb3uB,KAAK2uB,SAAWA,EAChB3uB,KAAK4uB,KAAO1uB,EACZA,EAAK+uB,OACDN,IACAA,EAASxjB,UAAYwjB,EAASF,iBAC9BvuB,EAAKuuB,iBACLvuB,EAAKgvB,WAAaP,EACdK,IACA9uB,EAAKgvB,WAAWC,iBAAkB,GAElCR,EAASS,WACTlvB,EAAKkvB,SAAWT,EAASS,SACzBlvB,EAAKkvB,SAASC,aACVV,EAASW,iBAAmBX,EAASU,cAEzCnvB,EAAKyiB,MAAQziB,EAAKyiB,KAAK4M,aACvBrvB,EAAKsvB,eAAgB,IAGP,IADItvB,EAAKsB,QAAnBiuB,WAEJd,EAASe,QAerB,GAAC,CAAApvB,IAAA,wBAAAR,MACD,WACIE,KAAKqrB,QAAQsE,SAAQ,SAACzvB,GAClB,IAAQsB,EAA0BtB,EAA1BsB,QAASouB,EAAiB1vB,EAAjB0vB,aACjBpuB,EAAQmpB,gBAAkBnpB,EAAQmpB,iBAC9BiF,GACAA,EAAapuB,QAAQmpB,gBACjBiF,EAAapuB,QAAQmpB,gBAEjC,GACJ,GAAC,CAAArqB,IAAA,iBAAAR,MACD,WACIE,KAAKqrB,QAAQsE,SAAQ,SAACzvB,GAClBA,EAAKiL,UAAYjL,EAAKuuB,gBAAe,EACzC,GACJ,GACA,CAAAnuB,IAAA,qBAAAR,MAIA,WACQE,KAAK4uB,MAAQ5uB,KAAK4uB,KAAKQ,WACvBpvB,KAAK4uB,KAAKQ,cAAWtuB,EAE7B,KAACytB,CAAA,CA1GU,GCFf,SAASsB,GAAyB/qB,EAAOkkB,EAAW8G,GAChD,IAAI7kB,EAAY,GAOV8kB,EAAajrB,EAAM9D,EAAEkG,UAAY8hB,EAAUhoB,EAC3CgvB,EAAalrB,EAAM7D,EAAEiG,UAAY8hB,EAAU/nB,EAWjD,IAVI8uB,GAAcC,KACd/kB,EAAY,eAAHmD,OAAkB2hB,EAAU,QAAA3hB,OAAO4hB,EAAU,YAMtC,IAAhBhH,EAAUhoB,GAA2B,IAAhBgoB,EAAU/nB,IAC/BgK,GAAa,SAAJmD,OAAa,EAAI4a,EAAUhoB,EAAC,MAAAoN,OAAK,EAAI4a,EAAU/nB,EAAC,OAEzD6uB,EAAiB,CACjB,IAAQpmB,EAA6BomB,EAA7BpmB,OAAQC,EAAqBmmB,EAArBnmB,QAASC,EAAYkmB,EAAZlmB,QACrBF,IACAuB,GAAa,UAAJmD,OAAc1E,EAAM,UAC7BC,IACAsB,GAAa,WAAJmD,OAAezE,EAAO,UAC/BC,IACAqB,GAAa,WAAJmD,OAAexE,EAAO,SACvC,CAKA,IAAMqmB,EAAgBnrB,EAAM9D,EAAEgG,MAAQgiB,EAAUhoB,EAC1CkvB,EAAgBprB,EAAM7D,EAAE+F,MAAQgiB,EAAU/nB,EAIhD,OAHsB,IAAlBgvB,GAAyC,IAAlBC,IACvBjlB,GAAa,SAAJmD,OAAa6hB,EAAa,MAAA7hB,OAAK8hB,EAAa,MAElDjlB,GAAa,MACxB,CCvCA,IAAMklB,GAAiB,SAACruB,EAAGC,GAAC,OAAKD,EAAEmmB,MAAQlmB,EAAEkmB,KAAK,ECG5CmI,GAAQ,WACV,SAAAA,KAAcjwB,EAAAA,EAAAA,GAAA,KAAAiwB,GACVpwB,KAAKqwB,SAAW,GAChBrwB,KAAKswB,SAAU,CACnB,CAaC,OAbAjwB,EAAAA,EAAAA,GAAA+vB,EAAA,EAAA9vB,IAAA,MAAAR,MACD,SAAIywB,IACA/B,EAAAA,GAAAA,IAAcxuB,KAAKqwB,SAAUE,GAC7BvwB,KAAKswB,SAAU,CACnB,GAAC,CAAAhwB,IAAA,SAAAR,MACD,SAAOywB,IACH7B,EAAAA,GAAAA,IAAW1uB,KAAKqwB,SAAUE,GAC1BvwB,KAAKswB,SAAU,CACnB,GAAC,CAAAhwB,IAAA,UAAAR,MACD,SAAQ6I,GACJ3I,KAAKswB,SAAWtwB,KAAKqwB,SAASG,KAAKL,IACnCnwB,KAAKswB,SAAU,EACftwB,KAAKqwB,SAASV,QAAQhnB,EAC1B,KAACynB,CAAA,CAjBS,G,YCoBd,IAAMK,GAAgB,CAAC,GAAI,IAAK,IAAK,KAMjCvE,GAAK,EAKHwE,GAAsB,CACxBrsB,KAAM,kBACNssB,WAAY,EACZC,qBAAsB,EACtBC,uBAAwB,GAE5B,SAASC,GAAoBjoB,GAA6F,IAA1FkoB,EAAoBloB,EAApBkoB,qBAAsBC,EAAanoB,EAAbmoB,cAAeC,EAAapoB,EAAbooB,cAAeC,EAAiBroB,EAAjBqoB,kBAAmBC,EAActoB,EAAdsoB,eACnG,kBACI,SAAAC,EAAYC,GAAsH,IAAAjvB,EAAA,KAA3GitB,EAAYzvB,UAAAC,OAAA,QAAAiB,IAAAlB,UAAA,GAAAA,UAAA,GAAG,CAAC,EAAG4H,EAAM5H,UAAAC,OAAA,QAAAiB,IAAAlB,UAAA,GAAAA,UAAA,GAAqB,OAAlBoxB,QAA4C,IAAlBA,OAA2B,EAASA,KAAe7wB,EAAAA,EAAAA,GAAA,KAAAixB,GAI5HpxB,KAAKksB,GAAKA,KAIVlsB,KAAKsxB,YAAc,EAOnBtxB,KAAKqwB,SAAW,IAAIpY,IAKpBjY,KAAKwB,QAAU,CAAC,EAMhBxB,KAAKuxB,iBAAkB,EACvBvxB,KAAKmgB,oBAAqB,EAO1BngB,KAAKwvB,eAAgB,EAKrBxvB,KAAKwxB,mBAAoB,EAKzBxxB,KAAKyxB,yBAA0B,EAK/BzxB,KAAK0xB,kBAAmB,EAIxB1xB,KAAK2xB,uBAAwB,EAC7B3xB,KAAK4xB,uBAAwB,EAK7B5xB,KAAKuvB,YAAa,EAIlBvvB,KAAK6xB,OAAQ,EAKb7xB,KAAK8xB,YAAa,EAIlB9xB,KAAK+xB,sBAAuB,EAS5B/xB,KAAKgpB,UAAY,CAAEhoB,EAAG,EAAGC,EAAG,GAI5BjB,KAAKgyB,cAAgB,IAAIC,IAEzBjyB,KAAKkyB,eAAiB,IAAID,IAC1BjyB,KAAKmyB,kBAAoB,WACjB/vB,EAAKmtB,aACLntB,EAAKmtB,YAAa,EAClBntB,EAAKgwB,oBAEb,EAMApyB,KAAKqyB,iBAAmB,WAKpB3B,GAAoBC,WAChBD,GAAoBE,qBAChBF,GAAoBG,uBAChB,EACZzuB,EAAKkwB,MAAM3C,QAAQ4C,IACnBnwB,EAAKkwB,MAAM3C,QAAQ6C,IACnBpwB,EAAKkwB,MAAM3C,QAAQ8C,IACnBrwB,EAAKkwB,MAAM3C,QAAQ+C,ICzJnC,SAAgBC,GACRjuB,OAAOkuB,aACPluB,OAAOkuB,YAAYC,OAAOF,EAElC,CDsJgBE,CAAOnC,GACX,EACA1wB,KAAK8yB,cAAe,EACpB9yB,KAAK+yB,WAAY,EACjB/yB,KAAKgzB,kBAAoB,EAKzBhzB,KAAKizB,YAAc,IAAIhB,IACvBjyB,KAAKqxB,UAAYA,EACjBrxB,KAAKqvB,aAAeA,EACpBrvB,KAAK2iB,KAAOnb,EAASA,EAAOmb,MAAQnb,EAASxH,KAC7CA,KAAKkzB,KAAO1rB,EAAS,GAAH4G,QAAAS,EAAAA,GAAAA,GAAOrH,EAAO0rB,MAAI,CAAE1rB,IAAU,GAChDxH,KAAKwH,OAASA,EACdxH,KAAKioB,MAAQzgB,EAASA,EAAOygB,MAAQ,EAAI,EACzCoJ,GAAarxB,KAAK2iB,KAAKwQ,sBAAsB9B,EAAWrxB,MACxD,IAAK,IAAIoF,EAAI,EAAGA,EAAIpF,KAAKkzB,KAAKrzB,OAAQuF,IAClCpF,KAAKkzB,KAAK9tB,GAAG2sB,sBAAuB,EAEpC/xB,KAAK2iB,OAAS3iB,OACdA,KAAKsyB,MAAQ,IAAIlC,GACzB,CA8hCC,OA9hCA/vB,EAAAA,EAAAA,GAAA+wB,EAAA,EAAA9wB,IAAA,mBAAAR,MACD,SAAiB6F,EAAMxE,GAInB,OAHKnB,KAAKgyB,cAAc5Z,IAAIzS,IACxB3F,KAAKgyB,cAAc1Y,IAAI3T,EAAM,IAAIytB,GAAAA,GAE9BpzB,KAAKgyB,cAAclzB,IAAI6G,GAAM2kB,IAAInpB,EAC5C,GAAC,CAAAb,IAAA,kBAAAR,MACD,SAAgB6F,GAC6C,IAAzD,IAAM0tB,EAAsBrzB,KAAKgyB,cAAclzB,IAAI6G,GAAM2tB,EAAA1zB,UAAAC,OADpC0zB,EAAI,IAAAvlB,MAAAslB,EAAA,EAAAA,EAAA,KAAAE,EAAA,EAAAA,EAAAF,EAAAE,IAAJD,EAAIC,EAAA,GAAA5zB,UAAA4zB,GAEzBH,GAAuBA,EAAoBI,OAAM1zB,MAA1BszB,EAA8BE,EACzD,GAAC,CAAAjzB,IAAA,eAAAR,MACD,SAAa6F,GACT,OAAO3F,KAAKgyB,cAAc5Z,IAAIzS,EAClC,GAAC,CAAArF,IAAA,wBAAAR,MACD,SAAsBuxB,EAAWnxB,GAC7BF,KAAKkyB,eAAe5Y,IAAI+X,EAAWnxB,EACvC,GACA,CAAAI,IAAA,QAAAR,MAGA,SAAMqL,GAAiC,IAAAsW,EAAA,KAAvB+N,EAAa5vB,UAAAC,OAAA,QAAAiB,IAAAlB,UAAA,IAAAA,UAAA,GACzB,IAAII,KAAKmL,SAAT,CAEAnL,KAAK6xB,MACD1mB,aAAoBuoB,YAAmC,QAArBvoB,EAASwoB,QAC/C3zB,KAAKmL,SAAWA,EAChB,IAAAyoB,EAA4C5zB,KAAKwB,QAAzC0oB,EAAQ0J,EAAR1J,SAAUxiB,EAAMksB,EAANlsB,OAAQsX,EAAa4U,EAAb5U,cAU1B,GATIA,IAAkBA,EAAcxL,SAChCwL,EAAc6U,MAAM1oB,GAExBnL,KAAK2iB,KAAK2P,MAAMhI,IAAItqB,MACpBA,KAAKwH,QAAUxH,KAAKwH,OAAO6oB,SAAS/F,IAAItqB,MACxCA,KAAKqxB,WAAarxB,KAAK2iB,KAAKuP,eAAe4B,OAAO9zB,KAAKqxB,WACnD7B,IAAkB9nB,GAAUwiB,KAC5BlqB,KAAKwvB,eAAgB,GAErBuB,EAAsB,CACtB,IAAIgD,EACEC,EAAsB,WAAH,OAAUvS,EAAKkB,KAAKiP,uBAAwB,CAAK,EAC1Eb,EAAqB5lB,GAAU,WAC3BsW,EAAKkB,KAAKiP,uBAAwB,EAClCmC,GAAeA,IACfA,EAAchd,GAAMid,EAAqB,KACrCpJ,GAAAA,EAAAA,yBACAA,GAAAA,EAAAA,wBAA+C,EAC/CnJ,EAAK6Q,MAAM3C,QAAQsE,IAE3B,GACJ,CACI/J,GACAlqB,KAAK2iB,KAAKuR,mBAAmBhK,EAAUlqB,OAGd,IAAzBA,KAAKwB,QAAQsX,SACbkG,IACCkL,GAAYxiB,IACb1H,KAAK0B,iBAAiB,aAAa,SAAAmD,GAA+E,IAA5EC,EAAKD,EAALC,MAAO6gB,EAAgB9gB,EAAhB8gB,iBAAkBwO,EAAwBtvB,EAAxBsvB,yBAAkCC,EAASvvB,EAAjB6C,OACrF,GAAI+Z,EAAK4S,yBAGL,OAFA5S,EAAKziB,YAAS8B,OACd2gB,EAAK6S,oBAAiBxzB,GAI1B,IAAMyzB,EAAmB9S,EAAKjgB,QAAQsb,YAClCkC,EAAc9E,wBACdsa,GACJC,EAA+DzV,EAAcL,WAArE+V,EAAsBD,EAAtBC,uBAAwBC,EAAyBF,EAAzBE,0BAK1BC,GAAiBnT,EAAKoT,eACvBxG,GAAU5M,EAAKoT,aAAcT,IAC9BD,EAMEW,GAAgCnP,GAAoBwO,EAC1D,GAAI1S,EAAKjgB,QAAQuzB,YACZtT,EAAKyN,YAAczN,EAAKyN,WAAW/jB,UACpC2pB,GACCnP,IACIiP,IAAkBnT,EAAKjE,kBAAoB,CAC5CiE,EAAKyN,aACLzN,EAAKmO,aAAenO,EAAKyN,WACzBzN,EAAKmO,aAAaA,kBAAe9uB,GAErC2gB,EAAKuT,mBAAmBlwB,EAAOgwB,GAC/B,IAAMG,GAAgBzxB,EAAAA,EAAAA,IAAAA,EAAAA,EAAAA,GAAA,GACfqZ,GAAmB0X,EAAkB,WAAS,IACjDre,OAAQwe,EACRte,WAAYue,KAEZ3V,EAAckW,oBACdzT,EAAKjgB,QAAQuzB,cACbE,EAAiBle,MAAQ,EACzBke,EAAiB5wB,MAAO,GAE5Bod,EAAK1D,eAAekX,EACxB,MAOStP,GAC0B,IAA3BlE,EAAKuR,mBACLiB,GAAgBxS,GAEhBA,EAAK6J,UAAY7J,EAAKjgB,QAAQmpB,gBAC9BlJ,EAAKjgB,QAAQmpB,iBAGrBlJ,EAAKoT,aAAeT,CACxB,GA/FM,CAiGd,GAAC,CAAA9zB,IAAA,UAAAR,MACD,WACIE,KAAKwB,QAAQ0oB,UAAYlqB,KAAKgrB,aAC9BhrB,KAAK2iB,KAAK2P,MAAM5G,OAAO1rB,MACvB,IAAMmrB,EAAQnrB,KAAKorB,WACnBD,GAASA,EAAMO,OAAO1rB,MACtBA,KAAKwH,QAAUxH,KAAKwH,OAAO6oB,SAASyD,OAAO9zB,MAC3CA,KAAKmL,cAAWrK,EAChB6D,EAAAA,GAAAA,UAAqB3E,KAAKqyB,iBAC9B,GACA,CAAA/xB,IAAA,cAAAR,MACA,WACIE,KAAK2xB,uBAAwB,CACjC,GAAC,CAAArxB,IAAA,gBAAAR,MACD,WACIE,KAAK2xB,uBAAwB,CACjC,GAAC,CAAArxB,IAAA,kBAAAR,MACD,WACI,OAAOE,KAAK2xB,uBAAyB3xB,KAAK4xB,qBAC9C,GAAC,CAAAtxB,IAAA,yBAAAR,MACD,WACI,OAAQE,KAAKmgB,oBACRngB,KAAKwH,QAAUxH,KAAKwH,OAAO6sB,2BAC5B,CACR,GACA,CAAA/zB,IAAA,cAAAR,MACA,WACQE,KAAKm1B,oBAETn1B,KAAKuvB,YAAa,EAClBvvB,KAAKsyB,OAAStyB,KAAKsyB,MAAM3C,QAAQyF,IACjCp1B,KAAKsxB,cACT,GAAC,CAAAhxB,IAAA,uBAAAR,MACD,WACI,IAAQkf,EAAkBhf,KAAKwB,QAAvBwd,cACR,OAAOA,GAAiBA,EAAcL,WAAWiG,iBACrD,GAAC,CAAAtkB,IAAA,aAAAR,MACD,WAAyC,IAA9Bu1B,IAAqBz1B,UAAAC,OAAA,QAAAiB,IAAAlB,UAAA,KAAAA,UAAA,GAC5B,GAAII,KAAK2iB,KAAKwS,kBACVn1B,KAAKwB,QAAQmpB,gBAAkB3qB,KAAKwB,QAAQmpB,sBAIhD,IADC3qB,KAAK2iB,KAAK4M,YAAcvvB,KAAK2iB,KAAK2S,eAC/Bt1B,KAAKwvB,cAAT,CAEAxvB,KAAKwvB,eAAgB,EACrB,IAAK,IAAIpqB,EAAI,EAAGA,EAAIpF,KAAKkzB,KAAKrzB,OAAQuF,IAAK,CACvC,IAAMlF,EAAOF,KAAKkzB,KAAK9tB,GACvBlF,EAAK6xB,sBAAuB,EAC5B7xB,EAAK4kB,aAAa,YACd5kB,EAAKsB,QAAQuzB,YACb70B,EAAK8qB,YAAW,EAExB,CACA,IAAAuK,EAA6Bv1B,KAAKwB,QAA1B0oB,EAAQqL,EAARrL,SAAUxiB,EAAM6tB,EAAN7tB,OAClB,QAAiB5G,IAAbopB,GAA2BxiB,EAA/B,CAEA,IAAMkd,EAAoB5kB,KAAKw1B,uBAC/Bx1B,KAAKy1B,2BAA6B7Q,EAC5BA,EAAkB5kB,KAAKqvB,aAAc,SACrCvuB,EACNd,KAAK01B,iBACLL,GAAyBr1B,KAAK21B,gBAAgB,aANpC,CAZA,CAmBd,GACA,CAAAr1B,IAAA,YAAAR,MACA,WAKI,GAJyBE,KAAKm1B,kBAQ1B,OAHAn1B,KAAK41B,gBACL51B,KAAKoyB,yBACLpyB,KAAKsyB,MAAM3C,QAAQkG,IAGlB71B,KAAKuvB,aAEVvvB,KAAKuvB,YAAa,EAOdvvB,KAAKkyB,eAAe4D,OACpB91B,KAAKkyB,eAAevC,QAAQoG,IAC5B/1B,KAAKkyB,eAAe8D,SAKxBh2B,KAAKsyB,MAAM3C,QAAQsG,IAKnBj2B,KAAKsyB,MAAM3C,QAAQ5K,IAKnB/kB,KAAKsyB,MAAM3C,QAAQuG,IACnBl2B,KAAKoyB,oBAEL+D,EAAAA,GAAAA,SACAA,EAAAA,GAAAA,YACAA,EAAAA,GAAAA,SACJ,GAAC,CAAA71B,IAAA,oBAAAR,MACD,WACIE,KAAKsyB,MAAM3C,QAAQyG,IACnBp2B,KAAKizB,YAAYtD,QAAQ0G,GAC7B,GAAC,CAAA/1B,IAAA,2BAAAR,MACD,WACIgE,EAAAA,GAAAA,UAAe9D,KAAKqyB,kBAAkB,GAAO,EACjD,GAAC,CAAA/xB,IAAA,4BAAAR,MACD,WAA4B,IAAAkjB,EAAA,KAMxBlf,EAAAA,GAAAA,YAAgB,WACRkf,EAAKwM,cACLxM,EAAKL,KAAK6H,YAGVxH,EAAKL,KAAKwP,mBAElB,GACJ,GACA,CAAA7xB,IAAA,iBAAAR,MAGA,YACQE,KAAKovB,UAAapvB,KAAKmL,WAE3BnL,KAAKovB,SAAWpvB,KAAKs2B,UACzB,GAAC,CAAAh2B,IAAA,eAAAR,MACD,WACI,GAAKE,KAAKmL,WAGVnL,KAAK8kB,eACC9kB,KAAKwB,QAAQ+0B,qBAAuBv2B,KAAKsrB,UAC1CtrB,KAAKwvB,eADV,CAWA,GAAIxvB,KAAKkvB,aAAelvB,KAAKkvB,WAAW/jB,SACpC,IAAK,IAAI/F,EAAI,EAAGA,EAAIpF,KAAKkzB,KAAKrzB,OAAQuF,IAAK,CAC1BpF,KAAKkzB,KAAK9tB,GAClB0f,cACT,CAEJ,IAAM0R,EAAax2B,KAAK0H,OACxB1H,KAAK0H,OAAS1H,KAAKs2B,SAAQ,GAC3Bt2B,KAAKy2B,gBAAkBhuB,IACvBzI,KAAKwvB,eAAgB,EACrBxvB,KAAKipB,qBAAkBnoB,EACvBd,KAAK21B,gBAAgB,UAAW31B,KAAK0H,OAAO6Y,WAC5C,IAAQvB,EAAkBhf,KAAKwB,QAAvBwd,cACRA,GACIA,EAAcyU,OAAO,gBAAiBzzB,KAAK0H,OAAO6Y,UAAWiW,EAAaA,EAAWjW,eAAYzf,EAtBrG,CAuBJ,GAAC,CAAAR,IAAA,eAAAR,MACD,WAAgC,IAAnB42B,EAAK92B,UAAAC,OAAA,QAAAiB,IAAAlB,UAAA,GAAAA,UAAA,GAAG,UACb+2B,EAAmBC,QAAQ52B,KAAKwB,QAAQq1B,cAAgB72B,KAAKmL,UAC7DnL,KAAKyiB,QACLziB,KAAKyiB,OAAO6O,cAAgBtxB,KAAK2iB,KAAK2O,aACtCtxB,KAAKyiB,OAAOiU,QAAUA,IACtBC,GAAmB,GAEnBA,IACA32B,KAAKyiB,OAAS,CACV6O,YAAatxB,KAAK2iB,KAAK2O,YACvBoF,MAAAA,EACAI,OAAQ5F,EAAkBlxB,KAAKmL,UAC/B/H,OAAQ6tB,EAAcjxB,KAAKmL,WAGvC,GAAC,CAAA7K,IAAA,iBAAAR,MACD,WACI,GAAKqxB,EAAL,CAEA,IAAM4F,EAAmB/2B,KAAKwvB,eAAiBxvB,KAAK+xB,qBAC9CiF,EAAgBh3B,KAAKipB,kBAAoBmF,GAAYpuB,KAAKipB,iBAC1DrE,EAAoB5kB,KAAKw1B,uBACzByB,EAAyBrS,EACzBA,EAAkB5kB,KAAKqvB,aAAc,SACrCvuB,EACAo2B,EAA8BD,IAA2Bj3B,KAAKy1B,2BAChEsB,IACCC,GACG1tB,GAAatJ,KAAKqvB,eAClB6H,KACJ/F,EAAenxB,KAAKmL,SAAU8rB,GAC9Bj3B,KAAK+xB,sBAAuB,EAC5B/xB,KAAKyuB,iBAdC,CAgBd,GAAC,CAAAnuB,IAAA,UAAAR,MACD,WAAgC,IA45BtBqK,EA55BFgtB,IAAev3B,UAAAC,OAAA,QAAAiB,IAAAlB,UAAA,KAAAA,UAAA,GACbw3B,EAAUp3B,KAAK0iB,iBACjBnC,EAAYvgB,KAAKq3B,oBAAoBD,GAUzC,OAJID,IACA5W,EAAYvgB,KAAKm3B,gBAAgB5W,IAo5B7C+W,IADcntB,EAj5BGoW,GAk5BHvf,GACds2B,GAAUntB,EAAIlJ,GAl5BC,CACHqwB,YAAatxB,KAAK2iB,KAAK2O,YACvBiG,YAAaH,EACb7W,UAAAA,EACA8O,aAAc,CAAC,EACfzoB,OAAQ5G,KAAKksB,GAErB,GAAC,CAAA5rB,IAAA,iBAAAR,MACD,WACI,IAAQkf,EAAkBhf,KAAKwB,QAAvBwd,cACR,IAAKA,EACD,OAAOvW,IACX,IAAM0B,EAAM6U,EAAc9T,qBAElBuX,EAAWziB,KAAK2iB,KAAhBF,OAKR,OAJIA,IACAlY,GAAcJ,EAAInJ,EAAGyhB,EAAOrf,OAAOpC,GACnCuJ,GAAcJ,EAAIlJ,EAAGwhB,EAAOrf,OAAOnC,IAEhCkJ,CACX,GAAC,CAAA7J,IAAA,sBAAAR,MACD,SAAoBqK,GAChB,IAAMqtB,EAAmB/uB,IACzBklB,GAAY6J,EAAkBrtB,GAK9B,IAAK,IAAI/E,EAAI,EAAGA,EAAIpF,KAAKkzB,KAAKrzB,OAAQuF,IAAK,CACvC,IAAMlF,EAAOF,KAAKkzB,KAAK9tB,GACfqd,EAAoBviB,EAApBuiB,OAAQjhB,EAAYtB,EAAZsB,QAChB,GAAItB,IAASF,KAAK2iB,MAAQF,GAAUjhB,EAAQq1B,aAAc,CAKtD,GAAIpU,EAAOqU,OAAQ,CACfnJ,GAAY6J,EAAkBrtB,GAC9B,IAAgBstB,EAAez3B,KAAK2iB,KAA5BF,OAKJgV,IACAltB,GAAcitB,EAAiBx2B,GAAIy2B,EAAWr0B,OAAOpC,GACrDuJ,GAAcitB,EAAiBv2B,GAAIw2B,EAAWr0B,OAAOnC,GAE7D,CACAsJ,GAAcitB,EAAiBx2B,EAAGyhB,EAAOrf,OAAOpC,GAChDuJ,GAAcitB,EAAiBv2B,EAAGwhB,EAAOrf,OAAOnC,EACpD,CACJ,CACA,OAAOu2B,CACX,GAAC,CAAAl3B,IAAA,iBAAAR,MACD,SAAeqK,GAA4B,IAAvButB,EAAa93B,UAAAC,OAAA,QAAAiB,IAAAlB,UAAA,IAAAA,UAAA,GACvB+3B,EAAiBlvB,IACvBklB,GAAYgK,EAAgBxtB,GAC5B,IAAK,IAAI/E,EAAI,EAAGA,EAAIpF,KAAKkzB,KAAKrzB,OAAQuF,IAAK,CACvC,IAAMlF,EAAOF,KAAKkzB,KAAK9tB,IAClBsyB,GACDx3B,EAAKsB,QAAQq1B,cACb32B,EAAKuiB,QACLviB,IAASA,EAAKyiB,MACd3X,GAAa2sB,EAAgB,CACzB32B,GAAId,EAAKuiB,OAAOrf,OAAOpC,EACvBC,GAAIf,EAAKuiB,OAAOrf,OAAOnC,IAG1BqI,GAAapJ,EAAKmvB,eAEvBrkB,GAAa2sB,EAAgBz3B,EAAKmvB,aACtC,CAIA,OAHI/lB,GAAatJ,KAAKqvB,eAClBrkB,GAAa2sB,EAAgB33B,KAAKqvB,cAE/BsI,CACX,GAAC,CAAAr3B,IAAA,kBAAAR,MACD,SAAgBqK,GACZ,IAAMytB,EAAsBnvB,IAC5BklB,GAAYiK,EAAqBztB,GACjC,IAAK,IAAI/E,EAAI,EAAGA,EAAIpF,KAAKkzB,KAAKrzB,OAAQuF,IAAK,CACvC,IAAMlF,EAAOF,KAAKkzB,KAAK9tB,GACvB,GAAKlF,EAAKiL,UAEL7B,GAAapJ,EAAKmvB,cAAvB,CAEAlmB,GAASjJ,EAAKmvB,eAAiBnvB,EAAKw1B,iBACpC,IAAMxH,EAAYzlB,IAElBklB,GAAYO,EADIhuB,EAAKwiB,kBAErBuL,GAAoB2J,EAAqB13B,EAAKmvB,aAAcnvB,EAAKkvB,SAAWlvB,EAAKkvB,SAAS7O,eAAYzf,EAAWotB,EALrG,CAMhB,CAIA,OAHI5kB,GAAatJ,KAAKqvB,eAClBpB,GAAoB2J,EAAqB53B,KAAKqvB,cAE3CuI,CACX,GAAC,CAAAt3B,IAAA,iBAAAR,MACD,SAAegF,GACX9E,KAAK63B,YAAc/yB,EACnB9E,KAAK2iB,KAAKmV,2BACV93B,KAAKwxB,mBAAoB,CAC7B,GAAC,CAAAlxB,IAAA,aAAAR,MACD,SAAW0B,GACPxB,KAAKwB,SAAOgC,EAAAA,EAAAA,IAAAA,EAAAA,EAAAA,IAAAA,EAAAA,EAAAA,GAAA,GACLxD,KAAKwB,SACLA,GAAO,IACViuB,eAAiC3uB,IAAtBU,EAAQiuB,WAA0BjuB,EAAQiuB,WAE7D,GAAC,CAAAnvB,IAAA,oBAAAR,MACD,WACIE,KAAKyiB,YAAS3hB,EACdd,KAAK0H,YAAS5G,EACdd,KAAKovB,cAAWtuB,EAChBd,KAAKy1B,gCAA6B30B,EAClCd,KAAK63B,iBAAc/2B,EACnBd,KAAKhB,YAAS8B,EACdd,KAAKwvB,eAAgB,CACzB,GACA,CAAAlvB,IAAA,qBAAAR,MAGA,WACI,IAAIi4B,EAMEnJ,EAAO5uB,KAAKg4B,UAalB,GAZAh4B,KAAKwxB,oBAAsBxxB,KAAKwxB,kBAAoB5C,EAAK4C,mBACzDxxB,KAAK0xB,mBAAqB1xB,KAAK0xB,iBAAmB9C,EAAK8C,kBACvD1xB,KAAKyxB,0BAA4BzxB,KAAKyxB,wBAA0B7C,EAAK6C,6BACpDmF,QAAQ52B,KAAK4vB,eAAiB5vB,OAAS4uB,IAKzB5uB,KAAKyxB,yBAChCzxB,KAAKwxB,oBACmB,QAAtBuG,EAAK/3B,KAAKwH,cAA2B,IAAPuwB,OAAgB,EAASA,EAAGvG,oBAC5DxxB,KAAKi4B,gCACT,CAEA,IAAAC,EAA6Bl4B,KAAKwB,QAA1BkG,EAAMwwB,EAANxwB,OAAQwiB,EAAQgO,EAARhO,SAIhB,GAAKlqB,KAAK0H,SAAYA,GAAUwiB,GAAhC,CAQA,IAAKlqB,KAAK63B,cAAgB73B,KAAKs0B,eAAgB,CAE3C,IAAM6D,EAAiBn4B,KAAKo4B,6BACxBD,GAAkBA,EAAezwB,QACjC1H,KAAKm4B,eAAiBA,EACtBn4B,KAAKs0B,eAAiB7rB,IACtBzI,KAAKq4B,qBAAuB5vB,IAC5Bd,EAAqB3H,KAAKq4B,qBAAsBr4B,KAAK0H,OAAO6Y,UAAW4X,EAAezwB,OAAO6Y,WAC7FoN,GAAY3tB,KAAKs0B,eAAgBt0B,KAAKq4B,uBAGtCr4B,KAAKm4B,eAAiBn4B,KAAKs0B,oBAAiBxzB,CAEpD,CAKA,GAAKd,KAAKs0B,gBAAmBt0B,KAAK63B,YAAlC,CvDnpBZ,IAAyB74B,EAAQuI,EAAUC,EuD2rB/B,GAnCKxH,KAAKhB,SACNgB,KAAKhB,OAASyJ,IACdzI,KAAKs4B,qBAAuB7vB,KAK5BzI,KAAKs0B,gBACLt0B,KAAKq4B,sBACLr4B,KAAKm4B,gBACLn4B,KAAKm4B,eAAen5B,QvDlqBXA,EuDmqBOgB,KAAKhB,OvDnqBJuI,EuDmqBYvH,KAAKs0B,evDnqBP9sB,EuDmqBuBxH,KAAKm4B,eAAen5B,OvDlqBlFsI,EAAiBtI,EAAOgC,EAAGuG,EAASvG,EAAGwG,EAAOxG,GAC9CsG,EAAiBtI,EAAOiC,EAAGsG,EAAStG,EAAGuG,EAAOvG,IuDsqB7BjB,KAAK63B,aACNjB,QAAQ52B,KAAK4vB,cAEb5vB,KAAKhB,OAASgB,KAAKu4B,eAAev4B,KAAK0H,OAAO6Y,WAG9CoN,GAAY3tB,KAAKhB,OAAQgB,KAAK0H,OAAO6Y,WAEzCrW,GAAclK,KAAKhB,OAAQgB,KAAK63B,cAMhClK,GAAY3tB,KAAKhB,OAAQgB,KAAK0H,OAAO6Y,WAKrCvgB,KAAKi4B,+BAAgC,CACrCj4B,KAAKi4B,gCAAiC,EACtC,IAAME,EAAiBn4B,KAAKo4B,6BACxBD,GACAvB,QAAQuB,EAAevI,gBACnBgH,QAAQ52B,KAAK4vB,gBAChBuI,EAAe32B,QAAQq1B,cACxBsB,EAAen5B,QACfgB,KAAKm4B,eAAiBA,EACtBn4B,KAAKs0B,eAAiB7rB,IACtBzI,KAAKq4B,qBAAuB5vB,IAC5Bd,EAAqB3H,KAAKq4B,qBAAsBr4B,KAAKhB,OAAQm5B,EAAen5B,QAC5E2uB,GAAY3tB,KAAKs0B,eAAgBt0B,KAAKq4B,uBAGtCr4B,KAAKm4B,eAAiBn4B,KAAKs0B,oBAAiBxzB,CAEpD,CAIA4vB,GAAoBE,sBA5DV,CA1BA,CANA,CA6Fd,GAAC,CAAAtwB,IAAA,6BAAAR,MACD,WACI,GAAKE,KAAKwH,SACN2B,GAASnJ,KAAKwH,OAAO6nB,gBACrB7lB,GAAexJ,KAAKwH,OAAO6nB,cAG/B,OAAIrvB,KAAKwH,OAAOgxB,eACLx4B,KAAKwH,OAGLxH,KAAKwH,OAAO4wB,4BAE3B,GAAC,CAAA93B,IAAA,eAAAR,MACD,WACI,OAAO82B,SAAS52B,KAAKs0B,gBACjBt0B,KAAK63B,aACL73B,KAAKwB,QAAQuzB,aACb/0B,KAAK0H,OACb,GAAC,CAAApH,IAAA,iBAAAR,MACD,WACI,IAAIi4B,EACEnJ,EAAO5uB,KAAKg4B,UACZS,EAAW7B,QAAQ52B,KAAK4vB,eAAiB5vB,OAAS4uB,EACpD8J,GAAU,EAgBd,IAXI14B,KAAKwxB,oBAA6C,QAAtBuG,EAAK/3B,KAAKwH,cAA2B,IAAPuwB,OAAgB,EAASA,EAAGvG,sBACtFkH,GAAU,GAMVD,IACCz4B,KAAKyxB,yBAA2BzxB,KAAK0xB,oBACtCgH,GAAU,IAEVA,EAAJ,CAEA,IAAAC,EAA6B34B,KAAKwB,QAA1BkG,EAAMixB,EAANjxB,OAAQwiB,EAAQyO,EAARzO,SAWhB,GANAlqB,KAAKuxB,gBAAkBqF,QAAS52B,KAAKwH,QAAUxH,KAAKwH,OAAO+pB,iBACvDvxB,KAAKwd,kBACLxd,KAAK44B,kBACJ54B,KAAKuxB,kBACNvxB,KAAK63B,YAAc73B,KAAKs0B,oBAAiBxzB,GAExCd,KAAK0H,SAAYA,GAAUwiB,GAAhC,CAMAyD,GAAY3tB,KAAKy2B,gBAAiBz2B,KAAK0H,OAAO6Y,WjD/vB1D,SAAyBpW,EAAK6e,EAAW6P,GAAsC,IAA5BC,EAAkBl5B,UAAAC,OAAA,QAAAiB,IAAAlB,UAAA,IAAAA,UAAA,GAC3Dm5B,EAAaF,EAASh5B,OAC5B,GAAKk5B,EAAL,CAIA,IAAI74B,EACA4E,EAFJkkB,EAAUhoB,EAAIgoB,EAAU/nB,EAAI,EAG5B,IAAK,IAAImE,EAAI,EAAGA,EAAI2zB,EAAY3zB,IAAK,CAEjCN,GADA5E,EAAO24B,EAASzzB,IACH6jB,gBAKb,IAAM9d,EAAWjL,EAAKiL,SAClBA,GACAA,EAAS0Z,OACkB,aAA3B1Z,EAAS0Z,MAAMmU,UAGfF,GACA54B,EAAKsB,QAAQq1B,cACb32B,EAAKuiB,QACLviB,IAASA,EAAKyiB,MACd3X,GAAab,EAAK,CACdnJ,GAAId,EAAKuiB,OAAOrf,OAAOpC,EACvBC,GAAIf,EAAKuiB,OAAOrf,OAAOnC,IAG3B6D,IAEAkkB,EAAUhoB,GAAK8D,EAAM9D,EAAEgG,MACvBgiB,EAAU/nB,GAAK6D,EAAM7D,EAAE+F,MAEvBkD,GAAcC,EAAKrF,IAEnBg0B,GAAsBxvB,GAAapJ,EAAKmvB,eACxCrkB,GAAab,EAAKjK,EAAKmvB,cAE/B,CAKArG,EAAUhoB,EAAIoJ,GAAc4e,EAAUhoB,GACtCgoB,EAAU/nB,EAAImJ,GAAc4e,EAAU/nB,EA3C5B,CA4Cd,CiDqtBYg4B,CAAgBj5B,KAAKy2B,gBAAiBz2B,KAAKgpB,UAAWhpB,KAAKkzB,KAAMuF,GACjE,IAAQz5B,EAAW4vB,EAAX5vB,OACR,GAAKA,EAAL,CAEKgB,KAAKipB,kBACNjpB,KAAKipB,gBAAkBzgB,IACvBxI,KAAKk5B,6BAA+B1wB,KAExC,IAAM2wB,EAAiBn5B,KAAKgpB,UAAUhoB,EAChCo4B,EAAiBp5B,KAAKgpB,UAAU/nB,EAChCo4B,EAA0Br5B,KAAKs5B,oBAUrCnyB,EAAanH,KAAKipB,gBAAiBjpB,KAAKy2B,gBAAiBz3B,EAAQgB,KAAKqvB,cACtErvB,KAAKs5B,oBAAsBzJ,GAAyB7vB,KAAKipB,gBAAiBjpB,KAAKgpB,WAC3EhpB,KAAKs5B,sBAAwBD,GAC7Br5B,KAAKgpB,UAAUhoB,IAAMm4B,GACrBn5B,KAAKgpB,UAAU/nB,IAAMm4B,IACrBp5B,KAAK8yB,cAAe,EACpB9yB,KAAKyuB,iBACLzuB,KAAK21B,gBAAgB,mBAAoB32B,IAK7C0xB,GAAoBG,wBA7BV,CAbA,CAbA,CAwDd,GAAC,CAAAvwB,IAAA,OAAAR,MACD,WACIE,KAAK+yB,WAAY,CAErB,GAAC,CAAAzyB,IAAA,OAAAR,MACD,WACIE,KAAK+yB,WAAY,CAErB,GAAC,CAAAzyB,IAAA,iBAAAR,MACD,WAAiC,IAAlBy5B,IAAS35B,UAAAC,OAAA,QAAAiB,IAAAlB,UAAA,KAAAA,UAAA,GAEpB,GADAI,KAAKwB,QAAQitB,gBAAkBzuB,KAAKwB,QAAQitB,iBACxC8K,EAAW,CACX,IAAMpO,EAAQnrB,KAAKorB,WACnBD,GAASA,EAAMsD,gBACnB,CACIzuB,KAAK4vB,eAAiB5vB,KAAK4vB,aAAazkB,WACxCnL,KAAK4vB,kBAAe9uB,EAE5B,GAAC,CAAAR,IAAA,qBAAAR,MACD,SAAmBgF,GAA6C,IAAA6e,EAAA,KAAtCmR,EAA4Bl1B,UAAAC,OAAA,QAAAiB,IAAAlB,UAAA,IAAAA,UAAA,GAC5CwvB,EAAWpvB,KAAKovB,SAChBoK,EAAuBpK,EACvBA,EAASC,aACT,CAAC,EACDoK,GAAWj2B,EAAAA,EAAAA,GAAA,GAAQxD,KAAKqvB,cACxBwI,EAAcrvB,IACfxI,KAAKm4B,gBACLn4B,KAAKm4B,eAAe32B,QAAQuzB,aAC7B/0B,KAAKs0B,eAAiBt0B,KAAKq4B,0BAAuBv3B,GAEtDd,KAAKi4B,gCAAkCnD,EACvC,IAWI4E,EAXEC,EAAiBlxB,IAGjBmxB,GAFiBxK,EAAWA,EAASxoB,YAAS9F,MAC/Bd,KAAK0H,OAAS1H,KAAK0H,OAAOd,YAAS9F,GAElDqqB,EAAQnrB,KAAKorB,WACbyO,GAAgB1O,GAASA,EAAME,QAAQxrB,QAAU,EACjDi6B,EAAyBlD,QAAQgD,IAClCC,IAC0B,IAA3B75B,KAAKwB,QAAQiuB,YACZzvB,KAAKkzB,KAAKlhB,KAAK+nB,KACpB/5B,KAAKgzB,kBAAoB,EAEzBhzB,KAAKg6B,eAAiB,SAACzV,GACnB,IAwfAoF,EAAQxM,EAAM8c,EAAItuB,EAxfZ+Y,EAAWH,EAAS,IAC1B2V,GAAarC,EAAY72B,EAAG8D,EAAM9D,EAAG0jB,GACrCwV,GAAarC,EAAY52B,EAAG6D,EAAM7D,EAAGyjB,GACrCf,EAAKwW,eAAetC,GAChBlU,EAAK2Q,gBACL3Q,EAAK0U,sBACL1U,EAAKjc,QACLic,EAAKwU,gBACLxU,EAAKwU,eAAezwB,SACpBC,EAAqBgyB,EAAgBhW,EAAKjc,OAAO6Y,UAAWoD,EAAKwU,eAAezwB,OAAO6Y,WA+e3FoJ,EA9eWhG,EAAK2Q,eA8eRnX,EA9ewBwG,EAAK0U,qBA8evB4B,EA9e6CN,EA8ezChuB,EA9eyD+Y,EA+evF0V,GAAQzQ,EAAO3oB,EAAGmc,EAAKnc,EAAGi5B,EAAGj5B,EAAG2K,GAChCyuB,GAAQzQ,EAAO1oB,EAAGkc,EAAKlc,EAAGg5B,EAAGh5B,EAAG0K,GA3eZ+tB,GACArL,GAAU1K,EAAK2Q,eAAgBoF,KAC/B/V,EAAK6N,mBAAoB,GAExBkI,IACDA,EAAqBjxB,KACzBklB,GAAY+L,EAAoB/V,EAAK2Q,iBAErCsF,IACAjW,EAAK2L,gBAAkBmK,ERv4B3C,SAAmBz6B,EAAQq7B,EAAQzL,EAAMlK,EAAUoV,EAAwBD,GACnEC,GACA96B,EAAOs7B,SAAUvzB,EAAAA,EAAAA,GAAI,OAEJjG,IAAjB8tB,EAAK0L,QAAwB1L,EAAK0L,QAAU,EAAGhN,GAAgB5I,IAC/D1lB,EAAOu7B,aAAcxzB,EAAAA,EAAAA,QAAuBjG,IAAnBu5B,EAAOC,QAAwBD,EAAOC,QAAU,EAAG,EAAG9M,GAAiB9I,KAE3FmV,IACL76B,EAAOs7B,SAAUvzB,EAAAA,EAAAA,QAAuBjG,IAAnBu5B,EAAOC,QAAwBD,EAAOC,QAAU,OAAoBx5B,IAAjB8tB,EAAK0L,QAAwB1L,EAAK0L,QAAU,EAAG5V,IAK3H,IAAK,IAAItf,EAAI,EAAGA,EAAI6nB,GAAY7nB,IAAK,CACjC,IAAMo1B,EAAc,SAAHpsB,OAAY4e,GAAQ5nB,GAAE,UACnCq1B,EAAerN,GAAUiN,EAAQG,GACjCE,EAAatN,GAAUwB,EAAM4L,QACZ15B,IAAjB25B,QAA6C35B,IAAf45B,IAElCD,IAAiBA,EAAe,GAChCC,IAAeA,EAAa,GACI,IAAjBD,GACI,IAAfC,GACAvN,GAAKsN,KAAkBtN,GAAKuN,IAE5B17B,EAAOw7B,GAAex4B,KAAKuE,KAAIQ,EAAAA,EAAAA,GAAImmB,GAASuN,GAAevN,GAASwN,GAAahW,GAAW,IACxFrE,GAAAA,GAAAA,KAAaqa,IAAera,GAAAA,GAAAA,KAAaoa,MACzCz7B,EAAOw7B,IAAgB,MAI3Bx7B,EAAOw7B,GAAeE,EAE9B,EAIIL,EAAO3wB,QAAUklB,EAAKllB,UACtB1K,EAAO0K,QAAS3C,EAAAA,EAAAA,GAAIszB,EAAO3wB,QAAU,EAAGklB,EAAKllB,QAAU,EAAGgb,GAElE,CQg2BoBiW,CAAUlB,EAAaD,EAAsB7V,EAAK0L,aAAc3K,EAAUoV,EAAwBD,IAEtGlW,EAAKhB,KAAKmV,2BACVnU,EAAK8K,iBACL9K,EAAKqP,kBAAoBtO,CAC7B,EACA1kB,KAAKg6B,eAAeh6B,KAAKwB,QAAQuzB,WAAa,IAAO,EACzD,GAAC,CAAAz0B,IAAA,iBAAAR,MACD,SAAe0B,GAAS,IAAA0iB,EAAA,KACpBlkB,KAAK21B,gBAAgB,kBACrB31B,KAAKwd,kBAAoBxd,KAAKwd,iBAAiBvI,OAC3CjV,KAAK4vB,cAAgB5vB,KAAK4vB,aAAapS,kBACvCxd,KAAK4vB,aAAapS,iBAAiBvI,OAEnCjV,KAAK44B,mBACLj0B,EAAAA,GAAAA,OAAkB3E,KAAK44B,kBACvB54B,KAAK44B,sBAAmB93B,GAO5Bd,KAAK44B,iBAAmB90B,EAAAA,GAAAA,QAAY,WAChC8mB,GAAAA,EAAAA,wBAA+C,EAC/C1G,EAAK1G,iBE54BrB,SAAiBL,EAAM8c,GAAqB,IAAjBnd,EAAUld,UAAAC,OAAA,QAAAiB,IAAAlB,UAAA,GAAAA,UAAA,GAAG,CAAC,EAC/BE,GAAQ86B,EAAAA,GAAAA,GAAczd,GAAQA,GAAOyI,EAAAA,GAAAA,GAAYzI,GAEvD,OADArd,EAAMkV,MAAM+H,GAA2B,GAAIjd,EAAOm6B,EAAInd,IAC/C,CACH7H,KAAM,kBAAMnV,EAAMmV,MAAM,EACxB4lB,YAAa,kBAAM/6B,EAAM+6B,aAAa,EAE9C,CFq4BwC/hB,CAAQ,EA/4BxB,KA+4B0CtV,EAAAA,EAAAA,IAAAA,EAAAA,EAAAA,GAAA,GAC3ChC,GAAO,IACV8U,SAAU,SAACiO,GACPL,EAAK8V,eAAezV,GACpB/iB,EAAQ8U,UAAY9U,EAAQ8U,SAASiO,EACzC,EACAnO,WAAY,WACR5U,EAAQ4U,YAAc5U,EAAQ4U,aAC9B8N,EAAK4W,mBACT,KAEA5W,EAAK0L,eACL1L,EAAK0L,aAAapS,iBAAmB0G,EAAK1G,kBAE9C0G,EAAK0U,sBAAmB93B,CAC5B,GACJ,GAAC,CAAAR,IAAA,oBAAAR,MACD,WACQE,KAAK4vB,eACL5vB,KAAK4vB,aAAapS,sBAAmB1c,EACrCd,KAAK4vB,aAAaT,qBAAkBruB,GAExC,IAAMqqB,EAAQnrB,KAAKorB,WACnBD,GAASA,EAAM4P,wBACf/6B,KAAK4vB,aACD5vB,KAAKwd,iBACDxd,KAAKsvB,qBACDxuB,EACZd,KAAK21B,gBAAgB,oBACzB,GAAC,CAAAr1B,IAAA,kBAAAR,MACD,WACQE,KAAKwd,mBACLxd,KAAKg6B,gBAAkBh6B,KAAKg6B,eA/6BpB,KAg7BRh6B,KAAKwd,iBAAiBvI,QAE1BjV,KAAK86B,mBACT,GAAC,CAAAx6B,IAAA,0BAAAR,MACD,WACI,IAAM8uB,EAAO5uB,KAAKg4B,UACZM,EAAuD1J,EAAvD0J,qBAAsBt5B,EAAiC4vB,EAAjC5vB,OAAQ0I,EAAyBknB,EAAzBlnB,OAAQ2nB,EAAiBT,EAAjBS,aAC5C,GAAKiJ,GAAyBt5B,GAAW0I,EAAzC,CAOA,GAAI1H,OAAS4uB,GACT5uB,KAAK0H,QACLA,GACAszB,GAA0Bh7B,KAAKwB,QAAQy5B,cAAej7B,KAAK0H,OAAO6Y,UAAW7Y,EAAO6Y,WAAY,CAChGvhB,EAASgB,KAAKhB,QAAUyJ,IACxB,IAAMyyB,EAAU70B,EAAWrG,KAAK0H,OAAO6Y,UAAUvf,GACjDhC,EAAOgC,EAAEwF,IAAMooB,EAAK5vB,OAAOgC,EAAEwF,IAC7BxH,EAAOgC,EAAEuF,IAAMvH,EAAOgC,EAAEwF,IAAM00B,EAC9B,IAAMC,EAAU90B,EAAWrG,KAAK0H,OAAO6Y,UAAUtf,GACjDjC,EAAOiC,EAAEuF,IAAMooB,EAAK5vB,OAAOiC,EAAEuF,IAC7BxH,EAAOiC,EAAEsF,IAAMvH,EAAOiC,EAAEuF,IAAM20B,CAClC,CACAxN,GAAY2K,EAAsBt5B,GAMlCgM,GAAastB,EAAsBjJ,GAOnCloB,EAAanH,KAAKk5B,6BAA8Bl5B,KAAKy2B,gBAAiB6B,EAAsBjJ,EA/BlF,CAgCd,GAAC,CAAA/uB,IAAA,qBAAAR,MACD,SAAmBoqB,EAAUhqB,GACpBF,KAAKizB,YAAY7a,IAAI8R,IACtBlqB,KAAKizB,YAAY3Z,IAAI4Q,EAAU,IAAIqE,IAEzBvuB,KAAKizB,YAAYn0B,IAAIorB,GAC7BI,IAAIpqB,GACV,IAAMk7B,EAASl7B,EAAKsB,QAAQ65B,uBAC5Bn7B,EAAK+qB,QAAQ,CACTnO,WAAYse,EAASA,EAAOte,gBAAahc,EACzCkuB,sBAAuBoM,GAAUA,EAAOE,4BAClCF,EAAOE,4BAA4Bp7B,QACnCY,GAEd,GAAC,CAAAR,IAAA,SAAAR,MACD,WACI,IAAMqrB,EAAQnrB,KAAKorB,WACnB,OAAOD,GAAQA,EAAMyD,OAAS5uB,IAClC,GAAC,CAAAM,IAAA,UAAAR,MACD,WACI,IAAIi4B,EAEJ,OADqB/3B,KAAKwB,QAAlB0oB,WACsC,QAA1B6N,EAAK/3B,KAAKorB,kBAA+B,IAAP2M,OAAgB,EAASA,EAAGnJ,OAAgB5uB,IACtG,GAAC,CAAAM,IAAA,cAAAR,MACD,WACI,IAAIi4B,EAEJ,OADqB/3B,KAAKwB,QAAlB0oB,SACqC,QAA1B6N,EAAK/3B,KAAKorB,kBAA+B,IAAP2M,OAAgB,EAASA,EAAGpJ,cAAW7tB,CAChG,GAAC,CAAAR,IAAA,WAAAR,MACD,WACI,IAAQoqB,EAAalqB,KAAKwB,QAAlB0oB,SACR,GAAIA,EACA,OAAOlqB,KAAK2iB,KAAKsQ,YAAYn0B,IAAIorB,EACzC,GAAC,CAAA5pB,IAAA,UAAAR,MACD,WAAiE,IAAAkI,EAAApI,UAAAC,OAAA,QAAAiB,IAAAlB,UAAA,GAAAA,UAAA,GAAJ,CAAC,EAApDkyB,EAAU9pB,EAAV8pB,WAAYhV,EAAU9U,EAAV8U,WAAYkS,EAAqBhnB,EAArBgnB,sBACxB7D,EAAQnrB,KAAKorB,WACfD,GACAA,EAAMF,QAAQjrB,KAAMgvB,GACpB8C,IACA9xB,KAAKipB,qBAAkBnoB,EACvBd,KAAK8xB,YAAa,GAElBhV,GACA9c,KAAK0qB,WAAW,CAAE5N,WAAAA,GAC1B,GAAC,CAAAxc,IAAA,WAAAR,MACD,WACI,IAAMqrB,EAAQnrB,KAAKorB,WACnB,QAAID,GACOA,EAAMD,SAASlrB,KAK9B,GAAC,CAAAM,IAAA,gBAAAR,MACD,WACI,IAAQkf,EAAkBhf,KAAKwB,QAAvBwd,cACR,GAAKA,EAAL,CAGA,IAAIuc,GAAY,EAKRlM,EAAiBrQ,EAAjBqQ,aAQR,IAPIA,EAAa3lB,QACb2lB,EAAa1lB,SACb0lB,EAAazlB,SACbylB,EAAamM,WACbD,GAAY,GAGXA,EAAL,CAIA,IAFA,IAAME,EAAc,CAAC,EAEZr2B,EAAI,EAAGA,EAAIqrB,GAAc5wB,OAAQuF,IAAK,CAC3C,IAAM9E,EAAM,SAAWmwB,GAAcrrB,GAEjCiqB,EAAa/uB,KACbm7B,EAAYn7B,GAAO+uB,EAAa/uB,GAChC0e,EAAc0c,eAAep7B,EAAK,GAE1C,CAKA,IAAK,IAAMA,KAFX0e,EAAciC,SAEIwa,EACdzc,EAAc0c,eAAep7B,EAAKm7B,EAAYn7B,IAIlD0e,EAAcyP,gBApBJ,CAhBA,CAqCd,GAAC,CAAAnuB,IAAA,sBAAAR,MACD,WAAoC,IAC5Bi4B,EAAI4D,EADQC,EAASh8B,UAAAC,OAAA,QAAAiB,IAAAlB,UAAA,GAAAA,UAAA,GAAG,CAAC,EAGvBi8B,EAAS,CAAC,EAChB,IAAK77B,KAAKmL,UAAYnL,KAAK6xB,MACvB,OAAOgK,EACX,IAAK77B,KAAK+yB,UACN,MAAO,CAAE+I,WAAY,UAGrBD,EAAOC,WAAa,GAExB,IAAMlX,EAAoB5kB,KAAKw1B,uBAC/B,GAAIx1B,KAAK8xB,WAQL,OAPA9xB,KAAK8xB,YAAa,EAClB+J,EAAOvB,QAAU,GACjBuB,EAAOE,eACHC,EAAAA,GAAAA,GAAmBJ,EAAUG,gBAAkB,GACnDF,EAAO5wB,UAAY2Z,EACbA,EAAkB5kB,KAAKqvB,aAAc,IACrC,OACCwM,EAEX,IAAMjN,EAAO5uB,KAAKg4B,UAClB,IAAKh4B,KAAKipB,kBAAoBjpB,KAAK0H,SAAWknB,EAAK5vB,OAAQ,CACvD,IAAMi9B,EAAc,CAAC,EAerB,OAdIj8B,KAAKwB,QAAQ0oB,WACb+R,EAAY3B,aACsBx5B,IAA9Bd,KAAKqvB,aAAaiL,QACZt6B,KAAKqvB,aAAaiL,QAClB,EACV2B,EAAYF,eACRC,EAAAA,GAAAA,GAAmBJ,EAAUG,gBAAkB,IAEnD/7B,KAAK8yB,eAAiBxpB,GAAatJ,KAAKqvB,gBACxC4M,EAAYhxB,UAAY2Z,EAClBA,EAAkB,CAAC,EAAG,IACtB,OACN5kB,KAAK8yB,cAAe,GAEjBmJ,CACX,CACA,IAAMC,EAAiBtN,EAAKU,iBAAmBV,EAAKS,aACpDrvB,KAAKm8B,0BACLN,EAAO5wB,UAAY4kB,GAAyB7vB,KAAKk5B,6BAA8Bl5B,KAAKgpB,UAAWkT,GAC3FtX,IACAiX,EAAO5wB,UAAY2Z,EAAkBsX,EAAgBL,EAAO5wB,YAEhE,IAAAmxB,EAAiBp8B,KAAKipB,gBAAdjoB,EAACo7B,EAADp7B,EAAGC,EAACm7B,EAADn7B,EA+BX,IAAK,IAAMX,KA9BXu7B,EAAOQ,gBAAkB,GAAHjuB,OAAiB,IAAXpN,EAAE6F,OAAY,MAAAuH,OAAgB,IAAXnN,EAAE4F,OAAY,OACzD+nB,EAAKU,gBAKLuM,EAAOvB,QACH1L,IAAS5uB,KACiG,QAAnG27B,EAAuC,QAAjC5D,EAAKmE,EAAe5B,eAA4B,IAAPvC,EAAgBA,EAAK/3B,KAAKqvB,aAAaiL,eAA4B,IAAPqB,EAAgBA,EAAK,EACjI37B,KAAKmvB,gBACDnvB,KAAKqvB,aAAaiL,QAClB4B,EAAe3B,YAO7BsB,EAAOvB,QACH1L,IAAS5uB,UACwBc,IAA3Bo7B,EAAe5B,QACX4B,EAAe5B,QACf,QAC2Bx5B,IAA/Bo7B,EAAe3B,YACX2B,EAAe3B,YACf,EAKA+B,GAAAA,EACd,QAA4Bx7B,IAAxBo7B,EAAe57B,GAAnB,CAEA,IAAAi8B,EAA6BD,GAAAA,EAAgBh8B,GAArCsnB,EAAO2U,EAAP3U,QAAS8E,EAAO6P,EAAP7P,QAOX8P,EAAiC,SAArBX,EAAO5wB,UACnBixB,EAAe57B,GACfsnB,EAAQsU,EAAe57B,GAAMsuB,GACnC,GAAIlC,EAEA,IADA,IAAM+P,EAAM/P,EAAQ7sB,OACXuF,EAAI,EAAGA,EAAIq3B,EAAKr3B,IACrBy2B,EAAOnP,EAAQtnB,IAAMo3B,OAIzBX,EAAOv7B,GAAOk8B,CAlBN,CAgChB,OANIx8B,KAAKwB,QAAQ0oB,WACb2R,EAAOE,cACHnN,IAAS5uB,MACHg8B,EAAAA,GAAAA,GAAmBJ,EAAUG,gBAAkB,GAC/C,QAEPF,CACX,GAAC,CAAAv7B,IAAA,gBAAAR,MACD,WACIE,KAAKkvB,WAAalvB,KAAKovB,cAAWtuB,CACtC,GACA,CAAAR,IAAA,YAAAR,MACA,WACIE,KAAK2iB,KAAK2P,MAAM3C,SAAQ,SAACzvB,GAAW,IAAI63B,EAAI,OAAwC,QAAhCA,EAAK73B,EAAKsd,wBAAqC,IAAPua,OAAgB,EAASA,EAAG9iB,MAAQ,IAChIjV,KAAK2iB,KAAK2P,MAAM3C,QAAQkG,IACxB71B,KAAK2iB,KAAKsQ,YAAY+C,OAC1B,KAAC5E,CAAA,CArqCL,EAuqCJ,CACA,SAASrM,GAAa7kB,GAClBA,EAAK6kB,cACT,CACA,SAASmR,GAAmBh2B,GACxB,IAAI63B,EACE3I,GAAuC,QAA1B2I,EAAK73B,EAAKgvB,kBAA+B,IAAP6I,OAAgB,EAASA,EAAG3I,WAAalvB,EAAKkvB,SACnG,GAAIlvB,EAAKorB,UACLprB,EAAKwH,QACL0nB,GACAlvB,EAAKw8B,aAAa,aAAc,CAChC,IAAAC,EAA2Dz8B,EAAKwH,OAA7CA,EAAMi1B,EAAjBpc,UAAgCqc,EAAcD,EAA3BpF,YACnB0D,EAAkB/6B,EAAKsB,QAAvBy5B,cACFxC,EAAWrJ,EAASxoB,SAAW1G,EAAKwH,OAAOd,OAG3B,SAAlBq0B,EACAvyB,GAAS,SAACpC,GACN,IAAMu2B,EAAepE,EACfrJ,EAASmI,YAAYjxB,GACrB8oB,EAAS7O,UAAUja,GACnBzG,EAASwG,EAAWw2B,GAC1BA,EAAar2B,IAAMkB,EAAOpB,GAAME,IAChCq2B,EAAat2B,IAAMs2B,EAAar2B,IAAM3G,CAC1C,IAEKm7B,GAA0BC,EAAe7L,EAAS7O,UAAW7Y,IAClEgB,GAAS,SAACpC,GACN,IAAMu2B,EAAepE,EACfrJ,EAASmI,YAAYjxB,GACrB8oB,EAAS7O,UAAUja,GACnBzG,EAASwG,EAAWqB,EAAOpB,IACjCu2B,EAAat2B,IAAMs2B,EAAar2B,IAAM3G,CAC1C,IAEJ,IAAMi9B,EAAct0B,IACpBrB,EAAa21B,EAAap1B,EAAQ0nB,EAAS7O,WAC3C,IAAMwc,EAAcv0B,IAChBiwB,EACAtxB,EAAa41B,EAAa78B,EAAKq4B,eAAeqE,GAAgB,GAAOxN,EAASmI,aAG9EpwB,EAAa41B,EAAar1B,EAAQ0nB,EAAS7O,WAE/C,IAAMoF,GAAoByI,GAAY0O,GAClC3I,GAA2B,EAC/B,IAAKj0B,EAAKgvB,WAAY,CAClB,IAAMiJ,EAAiBj4B,EAAKk4B,6BAK5B,GAAID,IAAmBA,EAAejJ,WAAY,CAC9C,IAAkB8N,EAAyC7E,EAAnD/I,SAAkC6N,EAAiB9E,EAAzBzwB,OAClC,GAAIs1B,GAAkBC,EAAc,CAChC,IAAMC,EAAmBz0B,IACzBd,EAAqBu1B,EAAkB9N,EAAS7O,UAAWyc,EAAezc,WAC1E,IAAMoZ,EAAiBlxB,IACvBd,EAAqBgyB,EAAgBjyB,EAAQu1B,EAAa1c,WACrD8N,GAAU6O,EAAkBvD,KAC7BxF,GAA2B,GAE3BgE,EAAe32B,QAAQuzB,aACvB70B,EAAKo0B,eAAiBqF,EACtBz5B,EAAKm4B,qBAAuB6E,EAC5Bh9B,EAAKi4B,eAAiBA,EAE9B,CACJ,CACJ,CACAj4B,EAAKy1B,gBAAgB,YAAa,CAC9BjuB,OAAAA,EACA0nB,SAAAA,EACAtqB,MAAOi4B,EACPD,YAAAA,EACAnX,iBAAAA,EACAwO,yBAAAA,GAER,MACK,GAAIj0B,EAAKorB,SAAU,CACpB,IAAQX,EAAmBzqB,EAAKsB,QAAxBmpB,eACRA,GAAkBA,GACtB,CAMAzqB,EAAKsB,QAAQsb,gBAAahc,CAC9B,CACA,SAASyxB,GAAoBryB,GAIzBwwB,GAAoBC,aACfzwB,EAAKsH,SAQLtH,EAAKs4B,iBACNt4B,EAAKsxB,kBAAoBtxB,EAAKsH,OAAOgqB,mBAOzCtxB,EAAKuxB,0BAA4BvxB,EAAKuxB,wBAA0BmF,QAAQ12B,EAAKsxB,mBACzEtxB,EAAKsH,OAAOgqB,mBACZtxB,EAAKsH,OAAOiqB,0BAChBvxB,EAAKwxB,mBAAqBxxB,EAAKwxB,iBAAmBxxB,EAAKsH,OAAOkqB,kBAClE,CACA,SAASgB,GAAgBxyB,GACrBA,EAAKsxB,kBACDtxB,EAAKuxB,wBACDvxB,EAAKwxB,kBACD,CAChB,CACA,SAAS0E,GAAcl2B,GACnBA,EAAKk2B,eACT,CACA,SAASP,GAAkB31B,GACvBA,EAAK21B,mBACT,CACA,SAASI,GAAoB/1B,GACzB,IAAQ8e,EAAkB9e,EAAKsB,QAAvBwd,cACJA,GAAiBA,EAAcL,WAAWwe,uBAC1Cne,EAAcyU,OAAO,uBAEzBvzB,EAAKixB,gBACT,CACA,SAAS8C,GAAgB/zB,GACrBA,EAAK+zB,kBACL/zB,EAAK23B,YAAc33B,EAAKo0B,eAAiBp0B,EAAKlB,YAAS8B,CAC3D,CACA,SAAS0xB,GAAmBtyB,GACxBA,EAAKsyB,oBACT,CACA,SAASC,GAAevyB,GACpBA,EAAKuyB,gBACT,CACA,SAAS2C,GAAcl1B,GACnBA,EAAKk1B,eACT,CACA,SAASiB,GAAoBlL,GACzBA,EAAMiS,oBACV,CACA,SAASlD,GAAavQ,EAAQ7kB,EAAO6G,GACjCge,EAAOziB,WAAYH,EAAAA,EAAAA,GAAIjC,EAAMoC,UAAW,EAAGyE,GAC3Cge,EAAO3iB,OAAQD,EAAAA,EAAAA,GAAIjC,EAAMkC,MAAO,EAAG2E,GACnCge,EAAO9iB,OAAS/B,EAAM+B,OACtB8iB,EAAO7iB,YAAchC,EAAMgC,WAC/B,CACA,SAASszB,GAAQzQ,EAAQxM,EAAM8c,EAAItuB,GAC/Bge,EAAOnjB,KAAMO,EAAAA,EAAAA,GAAIoW,EAAK3W,IAAKyzB,EAAGzzB,IAAKmF,GACnCge,EAAOpjB,KAAMQ,EAAAA,EAAAA,GAAIoW,EAAK5W,IAAK0zB,EAAG1zB,IAAKoF,EACvC,CAKA,SAASouB,GAAoB75B,GACzB,OAAQA,EAAKovB,sBAAwDxuB,IAArCZ,EAAKovB,gBAAgBiL,WACzD,CACA,IAAM/F,GAA0B,CAC5B5lB,SAAU,IACVN,KAAM,CAAC,GAAK,EAAG,GAAK,IAExB,SAASynB,GAAe71B,EAAMmxB,GAM1B,IADA,IAAIgM,EAAan9B,EAAKyiB,KACbvd,EAAIlF,EAAKgzB,KAAKrzB,OAAS,EAAGuF,GAAK,EAAGA,IACvC,GAAIwxB,QAAQ12B,EAAKgzB,KAAK9tB,GAAG+F,UAAW,CAChCkyB,EAAan9B,EAAKgzB,KAAK9tB,GACvB,KACJ,CAEJ,IACMqT,GADgB4kB,GAAcA,IAAen9B,EAAKyiB,KAAO0a,EAAWlyB,SAAWmyB,UACvDC,cAAc,wBAADnvB,OAAyBijB,EAAS,OACzE5Y,GACAvY,EAAK2zB,MAAMpb,GAAS,EAC5B,CACA,SAAS6e,GAAUhxB,GACfA,EAAKE,IAAMxE,KAAKw7B,MAAMl3B,EAAKE,KAC3BF,EAAKC,IAAMvE,KAAKw7B,MAAMl3B,EAAKC,IAC/B,CAKA,SAASy0B,GAA0BC,EAAe7L,EAAU1nB,GACxD,MAA0B,aAAlBuzB,GACe,oBAAlBA,IACIx0B,EAAO6nB,GAAYc,GAAWd,GAAY5mB,GAAS,GAChE,CGt5CA,IAAM+1B,GAAyB3M,GAAqB,CAChDC,qBAAsB,SAAC2M,EAAKjK,GAAM,OAAKnyB,EAAYo8B,EAAK,SAAUjK,EAAO,EACzExC,cAAe,iBAAO,CAClBjwB,EAAGs8B,SAASK,gBAAgBC,YAAcN,SAASO,KAAKD,WACxD38B,EAAGq8B,SAASK,gBAAgBG,WAAaR,SAASO,KAAKC,UAC1D,EACD5M,kBAAmB,kBAAM,CAAI,ICN3B3O,GAAqB,CACvB/O,aAAS1S,GAEPi9B,GAAqBjN,GAAqB,CAC5CG,cAAe,SAAC9lB,GAAQ,MAAM,CAC1BnK,EAAGmK,EAASyyB,WACZ38B,EAAGkK,EAAS2yB,UACf,EACD9M,cAAe,WACX,IAAKzO,GAAmB/O,QAAS,CAC7B,IAAMwqB,EAAe,IAAIP,GAAuB,EAAG,CAAC,GACpDO,EAAanK,MAAMnvB,QACnBs5B,EAAatT,WAAW,CAAEmM,cAAc,IACxCtU,GAAmB/O,QAAUwqB,CACjC,CACA,OAAOzb,GAAmB/O,OAC9B,EACA2d,eAAgB,SAAChmB,EAAUrL,GACvBqL,EAAS0Z,MAAM5Z,eAAsBnK,IAAVhB,EAAsBA,EAAQ,MAC7D,EACAoxB,kBAAmB,SAAC/lB,GAAQ,OAAKyrB,QAAuD,UAA/ClyB,OAAOgkB,iBAAiBvd,GAAU8yB,SAAqB,IClB9Fj4B,GAAO,CACTk4B,IAAK,CACDj+B,QAAS4mB,IAEb7gB,KAAM,CACF/F,QAASkmB,GACTiL,eAAgB2M,GAChBlS,cAAAA,KCTFnkB,GAAS,CACXA,OAAQ,CACJ0pB,eAAgB2M,GAChBlS,cAAAA,K,wBCNR,SAASsS,GAAezuB,EAAMuO,GAC1B,IAAKjQ,MAAMC,QAAQgQ,GACf,OAAO,EACX,IAAMmgB,EAAangB,EAAKpe,OACxB,GAAIu+B,IAAe1uB,EAAK7P,OACpB,OAAO,EACX,IAAK,IAAIuF,EAAI,EAAGA,EAAIg5B,EAAYh5B,IAC5B,GAAI6Y,EAAK7Y,KAAOsK,EAAKtK,GACjB,OAAO,EAEf,OAAO,CACX,CCRA,ICAMi5B,GAAoB,SAAC3jB,GAAC,MAAK,aAAa4jB,KAAK5jB,EAAE,E,uBCA/C6jB,GAAgB,SAAC7jB,GAAC,OAAK,SAACrW,GAAI,OAAKA,EAAKi6B,KAAK5jB,EAAE,GCK7C8jB,GAAsB,CAACvjB,GAAAA,GAAQ4M,GAAAA,GAAIxH,GAAAA,GAASoe,GAAAA,GAASC,GAAAA,GAAIC,GAAAA,GCLlD,CACTL,KAAM,SAAC5jB,GAAC,MAAW,SAANA,CAAY,EACzBkkB,MAAO,SAAClkB,GAAC,OAAKA,CAAC,IDObmkB,GAAyB,SAACnkB,GAAC,OAAK8jB,GAAoBM,KAAKP,GAAc7jB,GAAG,EEJ1EqkB,GAAa,GAAH3wB,QAAAS,EAAAA,GAAAA,GAAO2vB,IAAmB,CAAE5iB,GAAAA,EAAOrB,GAAAA,IAI7CykB,GAAgB,SAACtkB,GAAC,OAAKqkB,GAAWD,KAAKP,GAAc7jB,GAAG,E,WCM9D,SAASukB,GAAejgB,EAAejR,EAAYmxB,GAC/C,IAAMpb,EAAQ9E,EAAcL,WAC5B,OAAOwgB,EAAAA,GAAAA,GAAwBrb,EAAO/V,OAAuBjN,IAAXo+B,EAAuBA,EAASpb,EAAMob,OAf5F,SAAoBlgB,GAChB,IAAMxL,EAAU,CAAC,EAEjB,OADAwL,EAAczV,OAAOomB,SAAQ,SAAC7vB,EAAOQ,GAAG,OAAMkT,EAAQlT,GAAOR,EAAMhB,KAAK,IACjE0U,CACX,CAWoG4rB,CAAWpgB,GAP/G,SAAqBA,GACjB,IAAM/Z,EAAW,CAAC,EAElB,OADA+Z,EAAczV,OAAOomB,SAAQ,SAAC7vB,EAAOQ,GAAG,OAAM2E,EAAS3E,GAAOR,EAAMoF,aAAa,IAC1ED,CACX,CAG+HC,CAAY8Z,GAC3I,C,sCCRA,SAASqgB,GAAergB,EAAe1e,EAAKR,GACpCkf,EAAcsgB,SAASh/B,GACvB0e,EAAcgF,SAAS1jB,GAAKgZ,IAAIxZ,GAGhCkf,EAAcugB,SAASj/B,GAAKslB,EAAAA,GAAAA,GAAY9lB,GAEhD,CACA,SAAS0/B,GAAUxgB,EAAejR,GAC9B,IAAM0a,EAAWwW,GAAejgB,EAAejR,GAC/ClF,EAAyD4f,EAAWzJ,EAAcygB,qBAAqBhX,GAAU,GAAS,CAAC,EAACiX,EAAA72B,EAAtH82B,cAAAA,OAAa,IAAAD,EAAG,CAAC,EAACA,EAAsB1gC,GAAtB6J,EAAEiU,YAA0B1K,EAAAA,GAAAA,GAAAvJ,EAAAwJ,KAEpD,IAAK,IAAM/R,KADXtB,GAAMwE,EAAAA,EAAAA,IAAAA,EAAAA,EAAAA,GAAA,GAAQxE,GAAW2gC,GACC,CAEtBN,GAAergB,EAAe1e,GADhBs/B,EAAAA,GAAAA,GAA6B5gC,EAAOsB,IAEtD,CACJ,CAuEA,SAASu/B,GAAwBv/B,EAAKwc,GAClC,GAAKA,EAGL,OADwBA,EAAWxc,IAAQwc,EAAoB,SAAKA,GAC7CK,IAC3B,CCvGA,SAAS2iB,GAAwBhgC,GAC7B,OAAO82B,SAAQgE,EAAAA,GAAAA,GAAc96B,IAAUA,EAAMwqB,IACjD,C,gBCDMyV,GAA+B,SAAUC,EAAAA,GAAAA,GADjB,kB,kCCwB9B,SAASC,GAAejhB,EAAekhB,GAAuB,IAAd1+B,EAAO5B,UAAAC,OAAA,QAAAiB,IAAAlB,UAAA,GAAAA,UAAA,GAAG,CAAC,EACjD6oB,EAAWwW,GAAejgB,EAAekhB,EAAS1+B,EAAQ09B,QACgBiB,GAAd1X,GAAY,CAAC,GAAzE3L,WAAAA,OAAU,IAAAqjB,EAAGnhB,EAAc9E,wBAA0B,CAAC,EAACimB,EACzD3+B,EAAQ4+B,qBACRtjB,EAAatb,EAAQ4+B,oBAMzB,IAAMC,EAAe5X,EACf,kBAAM6X,GAActhB,EAAeyJ,EAAUjnB,EAAQ,EACrD,kBAAMgiB,QAAQ+c,SAAS,EAKvBC,EAAqBxhB,EAAcyhB,iBAAmBzhB,EAAcyhB,gBAAgB3K,KACpF,WAAsB,IAArB4K,EAAY9gC,UAAAC,OAAA,QAAAiB,IAAAlB,UAAA,GAAAA,UAAA,GAAG,EACd+gC,EAAkE7jB,EAAU8jB,EAAAD,EAApEriB,cAAAA,OAAa,IAAAsiB,EAAG,EAACA,EAAEriB,EAAeoiB,EAAfpiB,gBAAiBC,EAAgBmiB,EAAhBniB,iBAC5C,OA+DZ,SAAyBQ,EAAekhB,GAAgF,IAAvE5hB,EAAa1e,UAAAC,OAAA,QAAAiB,IAAAlB,UAAA,GAAAA,UAAA,GAAG,EAAG2e,EAAe3e,UAAAC,OAAA,QAAAiB,IAAAlB,UAAA,GAAAA,UAAA,GAAG,EAAG4e,EAAgB5e,UAAAC,OAAA,QAAAiB,IAAAlB,UAAA,GAAAA,UAAA,GAAG,EAAG4B,EAAO5B,UAAAC,OAAA,EAAAD,UAAA,QAAAkB,EAC5G+/B,EAAa,GACbC,GAAsB9hB,EAAcyhB,gBAAgB3K,KAAO,GAAKvX,EAChEwiB,EAA+C,IAArBviB,EAC1B,WAAM,OAAJ5e,UAAAC,OAAA,QAAAiB,IAAAlB,UAAA,GAAAA,UAAA,GAAG,GAAU2e,CAAe,EAC9B,WAAM,OAAKuiB,GAATlhC,UAAAC,OAAA,QAAAiB,IAAAlB,UAAA,GAAAA,UAAA,GAAG,GAA+B2e,CAAe,EAUzD,OATAvQ,MAAMmP,KAAK6B,EAAcyhB,iBACpBjQ,KAAKwQ,IACLrR,SAAQ,SAACY,EAAOnrB,GACjBmrB,EAAMkD,OAAO,iBAAkByM,GAC/BW,EAAWt9B,KAAK08B,GAAe1P,EAAO2P,GAAO18B,EAAAA,EAAAA,IAAAA,EAAAA,EAAAA,GAAA,GACtChC,GAAO,IACVuV,MAAOuH,EAAgByiB,EAAwB37B,MAChDse,MAAK,kBAAM6M,EAAMkD,OAAO,oBAAqByM,EAAQ,IAC5D,IACO1c,QAAQC,IAAIod,EACvB,CA/EmBI,CAAgBjiB,EAAekhB,EAAS5hB,EAAgBoiB,EAAcniB,EAAiBC,EAAkBhd,EACpH,EACE,kBAAMgiB,QAAQ+c,SAAS,EAKrBliB,EAASvB,EAATuB,KACR,GAAIA,EAAM,CACN,IAAAxZ,EAA+B,mBAATwZ,EAChB,CAACgiB,EAAcG,GACf,CAACA,EAAoBH,GAAar4B,GAAA0C,EAAAA,EAAAA,GAAA7F,EAAA,GAFjCq8B,EAAKl5B,EAAA,GAAEm5B,EAAIn5B,EAAA,GAGlB,OAAOk5B,IAAQxd,KAAKyd,EACxB,CAEI,OAAO3d,QAAQC,IAAI,CAAC4c,IAAgBG,EAAmBh/B,EAAQuV,QAEvE,CAIA,SAASupB,GAActhB,EAAejR,GAA0D,IAAAqzB,EAAAxhC,UAAAC,OAAA,QAAAiB,IAAAlB,UAAA,GAAAA,UAAA,GAAJ,CAAC,EAACyhC,EAAAD,EAA1CrqB,MAAAA,OAAK,IAAAsqB,EAAG,EAACA,EAAEjB,EAAkBgB,EAAlBhB,mBAAoB/7B,EAAI+8B,EAAJ/8B,KAC/Ei9B,EAAsFtiB,EAAcygB,qBAAqB1xB,GAAWwzB,EAAAD,EAA9HxkB,WAAAA,OAAU,IAAAykB,EAAGviB,EAAc9E,uBAAsBqnB,EAAE5B,EAAa2B,EAAb3B,cAAkB3gC,GAAMoT,EAAAA,GAAAA,GAAAkvB,EAAAjvB,IAC3EmvB,EAAaxiB,EAAcgF,SAAS,cACtCoc,IACAtjB,EAAasjB,GACjB,IAAMS,EAAa,GACbY,EAAqBp9B,GACvB2a,EAAcwB,gBACdxB,EAAcwB,eAAekhB,WAAWr9B,GAAM0T,EAAA,SAAAzX,GAE9C,IAAMR,EAAQkf,EAAcgF,SAAS1jB,GAC/BqhC,EAAc3iC,EAAOsB,GAC3B,IAAKR,QACegB,IAAhB6gC,GACCF,GAyDb,SAA6BG,EAAoCthC,GAAK,IAAtCuhC,EAAaD,EAAbC,cAAeC,EAAcF,EAAdE,eACrCC,EAAcF,EAActiC,eAAee,KAAgC,IAAxBwhC,EAAexhC,GAExE,OADAwhC,EAAexhC,IAAO,EACfyhC,CACX,CA5DgBC,CAAqBP,EAAoBnhC,GAAO,iBAGxD,IAAM0c,GAAexZ,EAAAA,EAAAA,GAAA,CAAKuT,MAAAA,EAAOnC,QAAS,GAAMkI,GAKhD,GAAIpY,OAAOu9B,0BAA4BniC,EAAMoiC,YAAa,CACtD,IAAMC,EAAWnjB,EAAcL,WAAWohB,IACtCoC,IACAnlB,EAAgBpI,QAAUlQ,OAAOu9B,wBAAwBE,EAAU7hC,EAAKR,EAAOgE,EAAAA,IAEvF,CACA,IAAIgT,EAAYhX,EAAMkV,MAAM+H,GAA2Bzc,EAAKR,EAAO6hC,EAAa3iB,EAAckW,oBAAsB9a,GAAAA,EAAAA,IAAmB9Z,GACjI,CAAE+D,MAAM,GACR2Y,IACF8iB,GAAwB0B,KACxBA,EAAWlX,IAAIhqB,GACfwW,EAAYA,EAAU4M,MAAK,kBAAM8d,EAAW9V,OAAOprB,EAAI,KAE3DugC,EAAWt9B,KAAKuT,EACpB,EA5BA,IAAK,IAAMxW,KAAOtB,EAAM+Y,EAAAzX,GA6BxB,OAAOkjB,QAAQC,IAAIod,GAAYnd,MAAK,WAChCic,GAAiBH,GAAUxgB,EAAe2gB,EAC9C,GACJ,CAqBA,SAASqB,GAAgBl/B,EAAGC,GACxB,OAAOD,EAAEsgC,iBAAiBrgC,EAC9B,C,8DC3HMsgC,IAAuBxzB,EAAAA,GAAAA,GAAIyzB,GAAAA,GAAsB1yB,UACjD2yB,GAAoBD,GAAAA,EAAAA,OAC1B,SAASE,GAAYxjB,GACjB,OAAO,SAAC6hB,GAAU,OAAKrd,QAAQC,IAAIod,EAAW9xB,KAAI,SAAAlG,GAAA,IAAGiO,EAASjO,EAATiO,UAAWtV,EAAOqH,EAAPrH,QAAO,ODH3E,SAA8Bwd,EAAejR,GAA0B,IAE/D+I,EAFiDtV,EAAO5B,UAAAC,OAAA,QAAAiB,IAAAlB,UAAA,GAAAA,UAAA,GAAG,CAAC,EAGhE,GAFAof,EAAcyU,OAAO,iBAAkB1lB,GAEnCC,MAAMC,QAAQF,GAAa,CAC3B,IAAM8yB,EAAa9yB,EAAWgB,KAAI,SAACmxB,GAAO,OAAKD,GAAejhB,EAAekhB,EAAS1+B,EAAQ,IAC9FsV,EAAY0M,QAAQC,IAAIod,EAC5B,MACK,GAA0B,kBAAf9yB,EACZ+I,EAAYmpB,GAAejhB,EAAejR,EAAYvM,OAErD,CACD,IAAMihC,EAA2C,oBAAf10B,EAC5BkxB,GAAejgB,EAAejR,EAAYvM,EAAQ09B,QAClDnxB,EACN+I,EAAYwpB,GAActhB,EAAeyjB,EAAoBjhC,EACjE,CACA,OAAOsV,EAAU4M,MAAK,kBAAM1E,EAAcyU,OAAO,oBAAqB1lB,EAAW,GACrF,CCdkF20B,CAAqB1jB,EAAelI,EAAWtV,EAAQ,IAAE,CAC3I,CACA,SAASmhC,GAAqB3jB,GAC1B,IAAIlG,EAAU0pB,GAAYxjB,GACpBhQ,EAoSC,CACH8J,QAAS8pB,IAAgB,GACzBC,YAAaD,KACbE,WAAYF,KACZG,SAAUH,KACVI,UAAWJ,KACXK,WAAYL,KACZM,KAAMN,MA1SNO,GAAkB,EAKhBC,EAA0B,SAACC,EAAKt1B,GAClC,IAAM0a,EAAWwW,GAAejgB,EAAejR,GAC/C,GAAI0a,EAAU,CACuCA,EAAzC3L,WAAR,IAAoB6iB,EAA6BlX,EAA7BkX,cAAkB3gC,GAAMoT,EAAAA,GAAAA,GAAKqW,EAAQpW,IACzDgxB,GAAG7/B,EAAAA,EAAAA,IAAAA,EAAAA,EAAAA,IAAAA,EAAAA,EAAAA,GAAA,GAAQ6/B,GAAQrkC,GAAW2gC,EAClC,CACA,OAAO0D,CACX,EAkBA,SAASC,EAAe9hC,EAAS+hC,GA8B7B,IA7BA,IAAMzf,EAAQ9E,EAAcL,WACtBoN,EAAU/M,EAAcwkB,mBAAkB,IAAS,CAAC,EAKpD3C,EAAa,GAKb4C,EAAc,IAAIxrB,IAMpByrB,EAAkB,CAAC,EAKnBC,EAAsBl+B,IAC1BsS,EAAA,WAOI,IAAM1T,EAAOg+B,GAAqBj9B,GAC5Bw+B,EAAY50B,EAAM3K,GAClBw/B,OAAuB/iC,IAAhBgjB,EAAMzf,GAAsByf,EAAMzf,GAAQ0nB,EAAQ1nB,GACzDy/B,GAAgBC,EAAAA,GAAAA,GAAeF,GAK/BG,EAAc3/B,IAASk/B,EAAoBK,EAAUK,SAAW,MAClD,IAAhBD,IACAL,EAAsBv+B,GAO1B,IAAI8+B,EAAcL,IAAS9X,EAAQ1nB,IAASw/B,IAAS/f,EAAMzf,IAASy/B,EAepE,GAXII,GACAf,GACAnkB,EAAcmlB,yBACdD,GAAc,GAMlBN,EAAU/B,eAAar+B,EAAAA,EAAAA,GAAA,GAAQkgC,IAI7BE,EAAUK,UAA4B,OAAhBD,IAElBH,IAASD,EAAUQ,WAErBC,EAAAA,GAAAA,GAAoBR,IACJ,mBAATA,EAAoB,iBAQ/B,IAAMS,EAqKlB,SAAgCrmB,EAAMvO,GAClC,GAAoB,kBAATA,EACP,OAAOA,IAASuO,EAEf,GAAIjQ,MAAMC,QAAQyB,GACnB,OAAQyuB,GAAezuB,EAAMuO,GAEjC,OAAO,CACX,CA7KqCsmB,CAAuBX,EAAUQ,SAAUP,GAChEW,EAAoBF,GAEnBjgC,IAASk/B,GACNK,EAAUK,WACTC,GACDJ,GAEH1+B,EAAIu+B,GAAuBG,EAK1BW,EAAiBz2B,MAAMC,QAAQ41B,GAAQA,EAAO,CAACA,GAKjDa,EAAiBD,EAAeE,OAAOvB,EAAyB,CAAC,IACjD,IAAhBY,IACAU,EAAiB,CAAC,GAUtB,IAAAE,EAAoChB,EAA5BiB,mBAAAA,OAAkB,IAAAD,EAAG,CAAC,EAACA,EACzBE,GAAOthC,EAAAA,EAAAA,IAAAA,EAAAA,EAAAA,GAAA,GACNqhC,GACAH,GAEDK,EAAgB,SAACzkC,GACnBkkC,GAAoB,EACpBf,EAAY3P,OAAOxzB,GACnBsjC,EAAU9B,eAAexhC,IAAO,CACpC,EACA,IAAK,IAAMA,KAAOwkC,EAAS,CACvB,IAAMp1B,EAAOg1B,EAAepkC,GACtB2d,EAAO4mB,EAAmBvkC,GAE5BojC,EAAgBnkC,eAAee,KAK/BoP,IAASuO,GAKL+mB,EAAAA,GAAAA,GAAkBt1B,KAASs1B,EAAAA,GAAAA,GAAkB/mB,IACxCkgB,GAAezuB,EAAMuO,IAASqmB,EAC/BS,EAAczkC,GAOdsjC,EAAU/B,cAAcvhC,IAAO,OAGrBQ,IAAT4O,EAELq1B,EAAczkC,GAIdmjC,EAAYnZ,IAAIhqB,QAGNQ,IAAT4O,GAAsB+zB,EAAYrrB,IAAI9X,GAK3CykC,EAAczkC,GAOdsjC,EAAU/B,cAAcvhC,IAAO,EAEvC,CAKAsjC,EAAUQ,SAAWP,EACrBD,EAAUiB,mBAAqBH,EAI3Bd,EAAUK,WACVP,GAAelgC,EAAAA,EAAAA,IAAAA,EAAAA,EAAAA,GAAA,GAAQkgC,GAAoBgB,IAE3CvB,GAAmBnkB,EAAcimB,wBACjCT,GAAoB,GAOpBA,IAAsBN,GACtBrD,EAAWt9B,KAAIxD,MAAf8gC,GAAUhyB,EAAAA,GAAAA,GAAS41B,EAAe11B,KAAI,SAAC+H,GAAS,MAAM,CAClDA,UAAWA,EACXtV,SAAOgC,EAAAA,EAAAA,GAAA,CAAIa,KAAAA,GAAS7C,GACvB,KAET,EApKS4D,EAAI,EAAGA,EAAIm9B,GAAmBn9B,IAAG2S,IA0K1C,GAAI0rB,EAAY3N,KAAM,CAClB,IAAMoP,EAAoB,CAAC,EAC3BzB,EAAY9T,SAAQ,SAACrvB,GACjB,IAAM6kC,EAAiBnmB,EAAcomB,cAAc9kC,QAC5BQ,IAAnBqkC,IACAD,EAAkB5kC,GAAO6kC,EAEjC,IACAtE,EAAWt9B,KAAK,CAAEuT,UAAWouB,GACjC,CACA,IAAIG,EAAgBzO,QAAQiK,EAAWhhC,QAOvC,OANIsjC,IACkB,IAAlBrf,EAAMG,UACLjF,EAAcmlB,yBACfkB,GAAgB,GAEpBlC,GAAkB,EACXkC,EAAgBvsB,EAAQ+nB,GAAcrd,QAAQ+c,SACzD,CAkBA,MAAO,CACH+C,eAAAA,EACA7iB,UAhBJ,SAAmBpc,EAAM4/B,EAAUziC,GAC/B,IAAIu2B,EAEJ,GAAI/oB,EAAM3K,GAAM4/B,WAAaA,EACzB,OAAOzgB,QAAQ+c,UAEsB,QAAxCxI,EAAK/Y,EAAcyhB,uBAAoC,IAAP1I,GAAyBA,EAAGpI,SAAQ,SAACY,GAAY,IAAIwH,EAAI,OAAuC,QAA/BA,EAAKxH,EAAM/P,sBAAmC,IAAPuX,OAAgB,EAASA,EAAGtX,UAAUpc,EAAM4/B,EAAW,IAChNj1B,EAAM3K,GAAM4/B,SAAWA,EACvB,IAAMpD,EAAayC,EAAe9hC,EAAS6C,GAC3C,IAAK,IAAM/D,KAAO0O,EACdA,EAAM1O,GAAKuhC,cAAgB,CAAC,EAEhC,OAAOhB,CACX,EAIIyE,mBA5PJ,SAA4BC,GACxBzsB,EAAUysB,EAAavmB,EAC3B,EA2PI0iB,SAAU,kBAAM1yB,CAAK,EAE7B,CAUA,SAAS4zB,KACL,MAAO,CACHqB,SAFyBrkC,UAAAC,OAAA,QAAAiB,IAAAlB,UAAA,IAAAA,UAAA,GAGzBiiC,cAAe,CAAC,EAChBC,eAAgB,CAAC,EACjB+C,mBAAoB,CAAC,EAE7B,CC/SyC,IAEnCW,GAAgB,SAAApf,IAAAC,EAAAA,EAAAA,GAAAmf,EAAApf,GAAA,IAAAE,GAAAC,EAAAA,EAAAA,GAAAif,GAMlB,SAAAA,EAAYtlC,GAAM,IAAAkC,EAE4D,OAF5DjC,EAAAA,EAAAA,GAAA,KAAAqlC,GACdpjC,EAAAkkB,EAAA9mB,KAAA,KAAMU,GACNA,EAAKsgB,iBAAmBtgB,EAAKsgB,eAAiBmiB,GAAqBziC,IAAOkC,CAC9E,CAqBa,OArBZ/B,EAAAA,EAAAA,GAAAmlC,EAAA,EAAAllC,IAAA,sCAAAR,MACD,WACI,IAAQgZ,EAAY9Y,KAAKE,KAAKye,WAAtB7F,QACR9Y,KAAKylC,WACDpB,EAAAA,GAAAA,GAAoBvrB,KACpB9Y,KAAKylC,QAAU3sB,EAAQ6N,UAAU3mB,KAAKE,MAE9C,GACA,CAAAI,IAAA,QAAAR,MAGA,WACIE,KAAK0lC,qCACT,GAAC,CAAAplC,IAAA,SAAAR,MACD,WACwBE,KAAKE,KAAKye,WAAtB7F,WACyB9Y,KAAKE,KAAK2qB,WAAa,CAAC,GAAjD/R,SAEJ9Y,KAAK0lC,qCAEb,GAAC,CAAAplC,IAAA,UAAAR,MACD,WAAY,KAAC0lC,CAAA,CA9BK,CAASvlC,GCF3BisB,GAAK,EACHyZ,GAAoB,SAAAvf,IAAAC,EAAAA,EAAAA,GAAAsf,EAAAvf,GAAA,IAAAE,GAAAC,EAAAA,EAAAA,GAAAof,GACtB,SAAAA,IAAc,IAAAvjC,EAEK,OAFLjC,EAAAA,EAAAA,GAAA,KAAAwlC,IACVvjC,EAAAkkB,EAAAvmB,MAAA,KAASH,YACJssB,GAAKA,KAAK9pB,CACnB,CAoBa,OApBZ/B,EAAAA,EAAAA,GAAAslC,EAAA,EAAArlC,IAAA,SAAAR,MACD,WAAS,IAAA2hB,EAAA,KACL,GAAKzhB,KAAKE,KAAKwf,gBAAf,CAEA,IAAAkmB,EAA8C5lC,KAAKE,KAAKwf,gBAAhDC,EAASimB,EAATjmB,UAAWgL,EAAcib,EAAdjb,eAAgBuU,EAAM0G,EAAN1G,OAChB2G,GAAkB7lC,KAAKE,KAAK4lC,qBAAuB,CAAC,GAA/DnmB,UACR,GAAK3f,KAAKE,KAAKsgB,gBAAkBb,IAAckmB,EAA/C,CAGA,IAAME,EAAgB/lC,KAAKE,KAAKsgB,eAAeC,UAAU,QAASd,EAAW,CAAEuf,OAAmB,OAAXA,QAA8B,IAAXA,EAAoBA,EAASl/B,KAAKE,KAAKye,WAAWugB,SACxJvU,IAAmBhL,GACnBomB,EAAcriB,MAAK,kBAAMiH,EAAelJ,EAAKyK,GAAG,GAHpD,CALU,CAUd,GAAC,CAAA5rB,IAAA,QAAAR,MACD,WACI,IAAQyqB,GAAavqB,KAAKE,KAAKwf,iBAAmB,CAAC,GAA3C6K,SACJA,IACAvqB,KAAKylC,QAAUlb,EAASvqB,KAAKksB,IAErC,GAAC,CAAA5rB,IAAA,UAAAR,MACD,WAAY,KAAC6lC,CAAA,CAxBS,CAAS1lC,GCA7B4gC,GAAa,CACf/pB,UAAW,CACP7W,QAASulC,IAEbtC,KAAM,CACFjjC,QAAS0lC,KCHjB,SAASK,GAAc9lC,EAAM+jC,GACzB,IAAM1iC,EAAY,WAAa0iC,EAAW,QAAU,SAC9CgC,EAAe,WAAahC,EAAW,QAAU,OAYvD,OAAOriC,EAAgB1B,EAAKsT,QAASjS,GAXjB,SAACf,EAAOkC,GACxB,GAAmB,UAAflC,EAAM6D,OAAoB8B,IAA9B,CAEA,IAAM2d,EAAQ5jB,EAAKye,WACfze,EAAKsgB,gBAAkBsD,EAAMgf,YAC7B5iC,EAAKsgB,eAAeC,UAAU,aAAcwjB,GAE5CngB,EAAMmiB,IACNniB,EAAMmiB,GAAczlC,EAAOkC,EANrB,CAQd,GAC6D,CACzDjB,SAAUvB,EAAKye,WAAWsnB,IAElC,CAAC,IACKC,GAAY,SAAA9f,IAAAC,EAAAA,EAAAA,GAAA6f,EAAA9f,GAAA,IAAAE,GAAAC,EAAAA,EAAAA,GAAA2f,GAAA,SAAAA,IAAA,OAAA/lC,EAAAA,EAAAA,GAAA,KAAA+lC,GAAA5f,EAAAvmB,MAAA,KAAAH,UAAA,CAID,OAJCS,EAAAA,EAAAA,GAAA6lC,EAAA,EAAA5lC,IAAA,QAAAR,MACd,WACIE,KAAKylC,SAAUhhC,EAAAA,EAAAA,GAAKuhC,GAAchmC,KAAKE,MAAM,GAAO8lC,GAAchmC,KAAKE,MAAM,GACjF,GAAC,CAAAI,IAAA,UAAAR,MACD,WAAY,KAAComC,CAAA,CAJC,CAASjmC,GCnBrBkmC,GAAY,SAAA/f,IAAAC,EAAAA,EAAAA,GAAA8f,EAAA/f,GAAA,IAAAE,GAAAC,EAAAA,EAAAA,GAAA4f,GACd,SAAAA,IAAc,IAAA/jC,EAEY,OAFZjC,EAAAA,EAAAA,GAAA,KAAAgmC,IACV/jC,EAAAkkB,EAAAvmB,MAAA,KAASH,YACJqkC,UAAW,EAAM7hC,CAC1B,CA6Ba,OA7BZ/B,EAAAA,EAAAA,GAAA8lC,EAAA,EAAA7lC,IAAA,UAAAR,MACD,WACI,IAAIsmC,GAAiB,EAOrB,IACIA,EAAiBpmC,KAAKE,KAAKsT,QAAQ6yB,QAAQ,iBAC/C,CACA,MAAOl1B,GACHi1B,GAAiB,CACrB,CACKA,GAAmBpmC,KAAKE,KAAKsgB,iBAElCxgB,KAAKE,KAAKsgB,eAAeC,UAAU,cAAc,GACjDzgB,KAAKikC,UAAW,EACpB,GAAC,CAAA3jC,IAAA,SAAAR,MACD,WACSE,KAAKikC,UAAajkC,KAAKE,KAAKsgB,iBAEjCxgB,KAAKE,KAAKsgB,eAAeC,UAAU,cAAc,GACjDzgB,KAAKikC,UAAW,EACpB,GAAC,CAAA3jC,IAAA,QAAAR,MACD,WAAQ,IAAA2hB,EAAA,KACJzhB,KAAKylC,SAAUhhC,EAAAA,EAAAA,GAAKnD,EAAYtB,KAAKE,KAAKsT,QAAS,SAAS,kBAAMiO,EAAK6kB,SAAS,IAAGhlC,EAAYtB,KAAKE,KAAKsT,QAAS,QAAQ,kBAAMiO,EAAK8kB,QAAQ,IACjJ,GAAC,CAAAjmC,IAAA,UAAAR,MACD,WAAY,KAACqmC,CAAA,CAjCC,CAASlmC,GCGrBumC,GAAgB,SAAhBA,EAAiBh/B,EAAQ+oB,GAC3B,QAAKA,IAGI/oB,IAAW+oB,GAITiW,EAAch/B,EAAQ+oB,EAAMkW,eAE3C,ECRA,SAASC,GAA0B/gC,EAAMxE,GACrC,GAAKA,EAAL,CAEA,IAAMwlC,EAAwB,IAAIC,aAAa,UAAYjhC,GAC3DxE,EAAQwlC,EAAuB/lC,EAAiB+lC,GAFtC,CAGd,CAAC,IACKE,GAAY,SAAAzgB,IAAAC,EAAAA,EAAAA,GAAAwgB,EAAAzgB,GAAA,IAAAE,GAAAC,EAAAA,EAAAA,GAAAsgB,GACd,SAAAA,IAAc,IAAAzkC,EAkDR,OAlDQjC,EAAAA,EAAAA,GAAA,KAAA0mC,IACVzkC,EAAAkkB,EAAAvmB,MAAA,KAASH,YACJknC,qBAAuBn6B,EAAAA,EAC5BvK,EAAK2kC,mBAAqBp6B,EAAAA,EAC1BvK,EAAK4kC,0BAA4Br6B,EAAAA,EACjCvK,EAAK6kC,kBAAoB,SAAC3kC,EAAY4kC,GAElC,GADA9kC,EAAK2kC,sBACD3kC,EAAK+kC,WAAT,CAEA,IAAMrjB,EAAQ1hB,EAAKlC,KAAKye,WAalByoB,EAA0BxlC,EAAgB8C,OAAQ,aAZhC,SAAC2iC,EAAUC,GAC/B,GAAKllC,EAAKmlC,gBAAV,CAEA,IAAArgB,EAA+B9kB,EAAKlC,KAAKye,WAAjC6oB,EAAKtgB,EAALsgB,MAAOC,EAAWvgB,EAAXugB,YAKdjB,GAAcpkC,EAAKlC,KAAKsT,QAAS6zB,EAASroC,QAErCwoC,GAASA,EAAMH,EAAUC,GADzBG,GAAeA,EAAYJ,EAAUC,EAPjC,CASd,GACsF,CAAE7lC,UAAWqiB,EAAM0jB,OAAS1jB,EAAmB,eAC/H4jB,EAA8B9lC,EAAgB8C,OAAQ,iBAAiB,SAACijC,EAAaC,GAAU,OAAKxlC,EAAKylC,YAAYF,EAAaC,EAAW,GAAE,CAAEnmC,UAAWqiB,EAAM2jB,aAAe3jB,EAAuB,mBAC9M1hB,EAAK2kC,oBAAqBtiC,EAAAA,EAAAA,GAAK2iC,EAAyBM,GACxDtlC,EAAK0lC,WAAWxlC,EAAY4kC,EAjBlB,CAkBd,EACA9kC,EAAK2lC,qBAAuB,WACxB,IAcMC,EAAwB1mC,EAAYc,EAAKlC,KAAKsT,QAAS,WAdvC,SAACy0B,GACnB,GAAyB,UAArBA,EAAa3nC,MAAmB8B,EAAK+kC,WAAzC,CAOA/kC,EAAK2kC,qBACL3kC,EAAK2kC,mBAAqBzlC,EAAYc,EAAKlC,KAAKsT,QAAS,SANrC,SAAC00B,GACM,UAAnBA,EAAW5nC,KAAoB8B,EAAKmlC,iBAExCb,GAA0B,KAAMtkC,EAAKlC,KAAKye,WAAW6oB,MACzD,IAGAd,GAA0B,QAAQ,SAAClmC,EAAOkC,GACtCN,EAAK0lC,WAAWtnC,EAAOkC,EAC3B,GAVU,CAWd,IAOMylC,EAAqB7mC,EAAYc,EAAKlC,KAAKsT,QAAS,QALvC,WACVpR,EAAK+kC,YAEVT,GAA0B,UAAU,SAACiB,EAAaC,GAAU,OAAKxlC,EAAKylC,YAAYF,EAAaC,EAAW,GAC9G,IAEAxlC,EAAK4kC,2BAA4BviC,EAAAA,EAAAA,GAAKujC,EAAuBG,EACjE,EAAE/lC,CACN,CAqCC,OArCA/B,EAAAA,EAAAA,GAAAwmC,EAAA,EAAAvmC,IAAA,aAAAR,MACD,SAAWU,EAAOkC,GACd1C,KAAKmnC,YAAa,EAClB,IAAAiB,EAAiCpoC,KAAKE,KAAKye,WAAnC0pB,EAAUD,EAAVC,WAAoBD,EAARrF,UAIJ/iC,KAAKE,KAAKsgB,gBACtBxgB,KAAKE,KAAKsgB,eAAeC,UAAU,YAAY,GAEnD4nB,GAAcA,EAAW7nC,EAAOkC,EACpC,GAAC,CAAApC,IAAA,gBAAAR,MACD,WAOI,OANAE,KAAK+mC,qBACL/mC,KAAKmnC,YAAa,EACJnnC,KAAKE,KAAKye,WACdokB,UAAY/iC,KAAKE,KAAKsgB,gBAC5BxgB,KAAKE,KAAKsgB,eAAeC,UAAU,YAAY,IAE3Cta,GACZ,GAAC,CAAA7F,IAAA,cAAAR,MACD,SAAYU,EAAOkC,GACf,GAAK1C,KAAKunC,gBAAV,CAEA,IAAQE,EAAgBznC,KAAKE,KAAKye,WAA1B8oB,YACRA,GAAeA,EAAYjnC,EAAOkC,EAFxB,CAGd,GAAC,CAAApC,IAAA,QAAAR,MACD,WACI,IAAMgkB,EAAQ9jB,KAAKE,KAAKye,WAClB2pB,EAAwB1mC,EAAgB5B,KAAKE,KAAKsT,QAAS,cAAexT,KAAKinC,kBAAmB,CAAExlC,UAAWqiB,EAAMukB,YAAcvkB,EAAsB,kBACzJykB,EAAsBjnC,EAAYtB,KAAKE,KAAKsT,QAAS,QAASxT,KAAK+nC,sBACzE/nC,KAAK8mC,sBAAuBriC,EAAAA,EAAAA,GAAK6jC,EAAuBC,EAC5D,GAAC,CAAAjoC,IAAA,UAAAR,MACD,WACIE,KAAK8mC,uBACL9mC,KAAK+mC,qBACL/mC,KAAKgnC,2BACT,KAACH,CAAA,CAzFa,CAAS5mC,G,YCVrBuoC,GAAoB,IAAI1pB,QAMxB2pB,GAAY,IAAI3pB,QAChB4pB,GAAuB,SAACC,GAC1B,IAAMhgC,EAAW6/B,GAAkB1pC,IAAI6pC,EAAM3pC,QAC7C2J,GAAYA,EAASggC,EACzB,EACMC,GAA2B,SAACC,GAC9BA,EAAQlZ,QAAQ+Y,GACpB,EAoBA,SAASI,GAAoBrwB,EAASjX,EAASmH,GAC3C,IAAMogC,EApBV,SAAiClgC,GAAuB,IAApB8Z,EAAI9Z,EAAJ8Z,KAASnhB,GAAO4Q,EAAAA,GAAAA,GAAAvJ,EAAAwJ,IAC1C22B,EAAarmB,GAAQ2a,SAItBmL,GAAUrwB,IAAI4wB,IACfP,GAAUnvB,IAAI0vB,EAAY,CAAC,GAE/B,IAAMC,EAAgBR,GAAU3pC,IAAIkqC,GAC9B1oC,EAAM4oC,KAAKC,UAAU3nC,GAQ3B,OAHKynC,EAAc3oC,KACf2oC,EAAc3oC,GAAO,IAAI8oC,qBAAqBR,IAAwBplC,EAAAA,EAAAA,GAAA,CAAImf,KAAAA,GAASnhB,KAEhFynC,EAAc3oC,EACzB,CAEsC+oC,CAAyB7nC,GAG3D,OAFAgnC,GAAkBlvB,IAAIb,EAAS9P,GAC/BogC,EAA0BO,QAAQ7wB,GAC3B,WACH+vB,GAAkB1U,OAAOrb,GACzBswB,EAA0BQ,UAAU9wB,EACxC,CACJ,CC3CA,IAAM+wB,GAAiB,CACnBx3B,KAAM,EACNyR,IAAK,GAEHgmB,GAAa,SAAArjB,IAAAC,EAAAA,EAAAA,GAAAojB,EAAArjB,GAAA,IAAAE,GAAAC,EAAAA,EAAAA,GAAAkjB,GACf,SAAAA,IAAc,IAAArnC,EAGY,OAHZjC,EAAAA,EAAAA,GAAA,KAAAspC,IACVrnC,EAAAkkB,EAAAvmB,MAAA,KAASH,YACJ8pC,gBAAiB,EACtBtnC,EAAKunC,UAAW,EAAMvnC,CAC1B,CA4Ea,OA3Eb/B,EAAAA,EAAAA,GAAAopC,EAAA,EAAAnpC,IAAA,mBAAAR,MAGA,WAAmB,IAAA2hB,EAAA,KAMfmoB,uBAAsB,WAClBnoB,EAAKioB,gBAAiB,EACtB,IAAQG,EAAoBpoB,EAAKvhB,KAAKye,WAA9BkrB,gBACRA,GAAmBA,EAAgB,MAC/BpoB,EAAKvhB,KAAKsgB,gBACViB,EAAKvhB,KAAKsgB,eAAeC,UAAU,eAAe,EAE1D,GACJ,GAAC,CAAAngB,IAAA,gBAAAR,MACD,WAAgB,IAAAkjB,EAAA,KACZhjB,KAAKylC,UACL,IAA8CqE,EAApB9pC,KAAKE,KAAKye,WAA5BorB,SAAAA,OAAQ,IAAAD,EAAG,CAAC,EAACA,EACbnnB,EAAsEonB,EAAtEpnB,KAAcqnB,EAAwDD,EAAhEE,OAAMC,EAA0DH,EAA5CI,OAAAA,OAAM,IAAAD,EAAG,OAAMA,EAAEE,EAA2BL,EAA3BK,KAAIC,EAAuBN,EAArBvhB,SAAAA,OAAQ,IAAA6hB,GAAOA,EACxE,GAAoC,qBAAzBjB,qBAAX,CAKA,IAAM5nC,EAAU,CACZmhB,KAAMA,EAAOA,EAAKnP,aAAU1S,EAC5BkpC,WAAAA,EACAM,UAA6B,kBAAXH,EAAsBA,EAASX,GAAeW,IA+BpE,OAAOrB,GAAoB9oC,KAAKE,KAAKsT,QAAShS,GA7BjB,SAACmnC,GAC1B,IAAQ4B,EAAmB5B,EAAnB4B,eAIR,GAAIvnB,EAAK2mB,WAAaY,IAEtBvnB,EAAK2mB,SAAWY,GAKZH,GAASG,IAAkBvnB,EAAK0mB,gBAApC,CAGSa,IACLvnB,EAAK0mB,gBAAiB,GAEtB1mB,EAAK9iB,KAAKsgB,gBACVwC,EAAK9iB,KAAKsgB,eAAeC,UAAU,cAAe8pB,GAMtD,IAAAC,EAA6CxnB,EAAK9iB,KAAKye,WAA/CkrB,EAAeW,EAAfX,gBAAiBY,EAAeD,EAAfC,gBACnB9hC,EAAW4hC,EAAiBV,EAAkBY,EACpD9hC,GAAYA,EAASggC,EAVrB,CAWJ,GAlCA,CAHQngB,GACAxoB,KAAK0qC,kBAsCjB,GAAC,CAAApqC,IAAA,QAAAR,MACD,WACIE,KAAK2qC,eACT,GAAC,CAAArqC,IAAA,SAAAR,MACD,WACI,GAAoC,qBAAzBspC,qBAAX,CAEA,IAAAwB,EAA6B5qC,KAAKE,KAA1B4jB,EAAK8mB,EAAL9mB,MAAO+G,EAAS+f,EAAT/f,UACTggB,EAAoB,CAAC,SAAU,SAAU,QAAQ74B,KAO/D,SAAiCnJ,GAA0D,IAAAiiC,EAAAjiC,EAAvDkhC,SAAAA,OAAQ,IAAAe,EAAG,CAAC,EAACA,EAAAjmC,EAAAjF,UAAAC,OAAA,QAAAiB,IAAAlB,UAAA,GAAAA,UAAA,GAAsC,CAAC,EAACmrC,EAAAlmC,EAAlCklC,SAAUiB,OAAY,IAAAD,EAAG,CAAC,EAACA,EAC9E,OAAO,SAACplC,GAAI,OAAKokC,EAASpkC,KAAUqlC,EAAarlC,EAAK,CAC1D,CAToEslC,CAAyBnnB,EAAO+G,IACxFggB,GACA7qC,KAAK2qC,eAJC,CAMd,GAAC,CAAArqC,IAAA,UAAAR,MACD,WAAY,KAAC2pC,CAAA,CAjFE,CAASxpC,GCF5B,IAAMirC,GAAoB,CACtBC,OAAQ,CACJlrC,QAASwpC,IAEb2B,IAAK,CACDnrC,QAAS4mC,IAEbwE,MAAO,CACHprC,QAASkmC,IAEbmF,MAAO,CACHrrC,QAASimC,K,gDCRXqF,GAAiB,IAAItzB,IAAI,CAC3B,QACA,SACA,MACA,OACA,QACA,SACA,IACA,MAEEuzB,GAAkB,SAAClrC,GAAG,OAAKirC,GAAenzB,IAAI9X,EAAI,EAIlDmrC,GAAgB,SAAC/wB,GAAC,OAAKA,IAAMO,GAAAA,IAAUP,IAAMmN,GAAAA,EAAE,EAC/C6jB,GAAmB,SAACC,EAAQC,GAAG,OAAKnvB,WAAWkvB,EAAO9wB,MAAM,MAAM+wB,GAAK,EACvEC,GAAyB,SAACC,EAAMC,GAAI,OAAK,SAACC,EAAKnjC,GAAoB,IAAhBoC,EAASpC,EAAToC,UACrD,GAAkB,SAAdA,IAAyBA,EACzB,OAAO,EACX,IAAMghC,EAAWhhC,EAAU8P,MAAM,sBACjC,GAAIkxB,EACA,OAAOP,GAAiBO,EAAS,GAAIF,GAGrC,IAAMJ,EAAS1gC,EAAU8P,MAAM,oBAC/B,OAAI4wB,EACOD,GAAiBC,EAAO,GAAIG,GAG5B,CAGnB,CAAC,EACKI,GAAgB,IAAIj0B,IAAI,CAAC,IAAK,IAAK,MACnCk0B,GAAgCC,GAAAA,EAAAA,QAA0B,SAAC9rC,GAAG,OAAM4rC,GAAc9zB,IAAI9X,EAAI,IAehG,IAAM+rC,GAAmB,CAErBC,MAAO,SAAAznC,EAAAmD,GAAA,IAAGhH,EAAC6D,EAAD7D,EAACurC,EAAAvkC,EAAMwkC,YAAAA,OAAW,IAAAD,EAAG,IAAGA,EAAAE,EAAAzkC,EAAE0kC,aAAAA,OAAY,IAAAD,EAAG,IAAGA,EAAA,OAAOzrC,EAAEuF,IAAMvF,EAAEwF,IAAMiW,WAAW+vB,GAAe/vB,WAAWiwB,EAAa,EAC/HC,OAAQ,SAAAvL,EAAAQ,GAAA,IAAG3gC,EAACmgC,EAADngC,EAAC2rC,EAAAhL,EAAMiL,WAAAA,OAAU,IAAAD,EAAG,IAAGA,EAAAE,EAAAlL,EAAEmL,cAAAA,OAAa,IAAAD,EAAG,IAAGA,EAAA,OAAO7rC,EAAEsF,IAAMtF,EAAEuF,IAAMiW,WAAWowB,GAAcpwB,WAAWswB,EAAc,EAChIjkC,IAAK,SAACkjC,EAAKgB,GAAA,IAAIlkC,EAAGkkC,EAAHlkC,IAAG,OAAO2T,WAAW3T,EAAI,EACxCC,KAAM,SAACijC,EAAKiB,GAAA,IAAIlkC,EAAIkkC,EAAJlkC,KAAI,OAAO0T,WAAW1T,EAAK,EAC3CE,OAAQ,SAAAikC,EAAAC,GAAA,IAAGlsC,EAACisC,EAADjsC,EAAO6H,EAAGqkC,EAAHrkC,IAAG,OAAO2T,WAAW3T,IAAQ7H,EAAEsF,IAAMtF,EAAEuF,IAAI,EAC7DwC,MAAO,SAAAokC,EAAAC,GAAA,IAAGrsC,EAACosC,EAADpsC,EAAO+H,EAAIskC,EAAJtkC,KAAI,OAAO0T,WAAW1T,IAAS/H,EAAEuF,IAAMvF,EAAEwF,IAAI,EAE9DxF,EAAG6qC,GAAuB,EAAG,IAC7B5qC,EAAG4qC,GAAuB,EAAG,KA+B3ByB,GAAmC,SAACtuB,EAAehgB,GAA4C,IAApC6H,EAAMjH,UAAAC,OAAA,QAAAiB,IAAAlB,UAAA,GAAAA,UAAA,GAAG,CAAC,EAAG+/B,EAAa//B,UAAAC,OAAA,QAAAiB,IAAAlB,UAAA,GAAAA,UAAA,GAAG,CAAC,EAC3FZ,GAAMwE,EAAAA,EAAAA,GAAA,GAAQxE,GACd2gC,GAAan8B,EAAAA,EAAAA,GAAA,GAAQm8B,GACrB,IAAM4N,EAAuBluC,OAAO0S,KAAK/S,GAAQsc,OAAOkwB,IAGpDgC,EAAyB,GACzBC,GAAsC,EACpCC,EAAuB,GA4E7B,GA3EAH,EAAqB5d,SAAQ,SAACrvB,GAC1B,IAAMR,EAAQkf,EAAcgF,SAAS1jB,GACrC,GAAK0e,EAAcsgB,SAASh/B,GAA5B,CAEA,IAGIqtC,EAHAxwB,EAAOtW,EAAOvG,GACdstC,EAAW/O,GAAuB1hB,GAChC8c,EAAKj7B,EAAOsB,GAMlB,IAAI0kC,EAAAA,GAAAA,GAAkB/K,GAAK,CACvB,IAAM4T,EAAe5T,EAAGp6B,OAClBiuC,EAAsB,OAAV7T,EAAG,GAAc,EAAI,EACvC9c,EAAO8c,EAAG6T,GACVF,EAAW/O,GAAuB1hB,GAClC,IAAK,IAAI/X,EAAI0oC,EAAW1oC,EAAIyoC,EAAczoC,IACjCuoC,GAMDz/B,EAAAA,EAAAA,GAAU2wB,GAAuB5E,EAAG70B,MAAQuoC,EAAQ,2CALpDA,EAAS9O,GAAuB5E,EAAG70B,KACnC8I,EAAAA,EAAAA,GAAUy/B,IAAWC,GAChBnC,GAAcmC,IAAanC,GAAckC,GAAU,gEAMpE,MAEIA,EAAS9O,GAAuB5E,GAEpC,GAAI2T,IAAaD,EAGb,GAAIlC,GAAcmC,IAAanC,GAAckC,GAAS,CAClD,IAAMn6B,EAAU1T,EAAMhB,MACC,kBAAZ0U,GACP1T,EAAMwZ,IAAImD,WAAWjJ,IAEP,kBAAPymB,EACPj7B,EAAOsB,GAAOmc,WAAWwd,GAEpBjsB,MAAMC,QAAQgsB,IAAO0T,IAAW9lB,GAAAA,KACrC7oB,EAAOsB,GAAO25B,EAAGlrB,IAAI0N,YAE7B,MACuB,OAAbmxB,QAAkC,IAAbA,OAAsB,EAASA,EAAS3iC,aACvD,OAAX0iC,QAA8B,IAAXA,OAAoB,EAASA,EAAO1iC,aAC9C,IAATkS,GAAqB,IAAP8c,GAGF,IAAT9c,EACArd,EAAMwZ,IAAIq0B,EAAO1iC,UAAUkS,IAG3Bne,EAAOsB,GAAOstC,EAAS3iC,UAAUgvB,IAMhCwT,IACDD,EA9HpB,SAAyCxuB,GACrC,IAAM+uB,EAAoB,GAW1B,OAVA5B,GAA8Bxc,SAAQ,SAACrvB,GACnC,IAAMR,EAAQkf,EAAcgF,SAAS1jB,QACvBQ,IAAVhB,IACAiuC,EAAkBxqC,KAAK,CAACjD,EAAKR,EAAMhB,QACnCgB,EAAMwZ,IAAIhZ,EAAI+Z,WAAW,SAAW,EAAI,GAEhD,IAEI0zB,EAAkBluC,QAClBmf,EAAciC,SACX8sB,CACX,CAkHwBC,CAAgChvB,GACpCyuB,GAAsC,GAE1CC,EAAqBnqC,KAAKjD,GAC1Bq/B,EAAcr/B,QACaQ,IAAvB6+B,EAAcr/B,GACRq/B,EAAcr/B,GACdtB,EAAOsB,GACjBR,EAAMmuC,KAAKhU,GApET,CAuEd,IACIyT,EAAqB7tC,OAAQ,CAC7B,IAAMquC,EAAUR,EAAqBhxB,QAAQ,WAAa,EACpDhY,OAAOypC,YACP,KACAC,EArHmB,SAACpvC,EAAQggB,EAAeqvB,GACrD,IAAMC,EAAatvB,EAAc9T,qBAC3BuN,EAAUuG,EAAcxL,QACxB+6B,EAAuB7lB,iBAAiBjQ,GACtCugB,EAAYuV,EAAZvV,QACFnyB,EAAS,CAAC,EAGA,SAAZmyB,GACAha,EAAc0c,eAAe,UAAW18B,EAAOg6B,SAAW,SAK9DqV,EAAY1e,SAAQ,SAACrvB,GACjBuG,EAAOvG,GAAO+rC,GAAiB/rC,GAAKguC,EAAYC,EACpD,IAEAvvB,EAAciC,SACd,IAAMutB,EAAaxvB,EAAc9T,qBAQjC,OAPAmjC,EAAY1e,SAAQ,SAACrvB,GAGjB,IAAMR,EAAQkf,EAAcgF,SAAS1jB,GACrCR,GAASA,EAAMmuC,KAAKpnC,EAAOvG,IAC3BtB,EAAOsB,GAAO+rC,GAAiB/rC,GAAKkuC,EAAYD,EACpD,IACOvvC,CACX,CAyFgCyvC,CAAyBzvC,EAAQggB,EAAe0uB,GAaxE,OAXIF,EAAuB3tC,QACvB2tC,EAAuB7d,SAAQ,SAAA+e,GAAkB,IAAAC,GAAAjkC,EAAAA,EAAAA,GAAAgkC,EAAA,GAAhBpuC,EAAGquC,EAAA,GAAE7uC,EAAK6uC,EAAA,GACvC3vB,EAAcgF,SAAS1jB,GAAKgZ,IAAIxZ,EACpC,IAGJkf,EAAciC,SAEV2tB,GAAAA,GAAyB,OAAZV,GACbxpC,OAAOmqC,SAAS,CAAE/lC,IAAKolC,IAEpB,CAAElvC,OAAQovC,EAAiBzO,cAAAA,EACtC,CAEI,MAAO,CAAE3gC,OAAAA,EAAQ2gC,cAAAA,EAEzB,EAQA,SAASmP,GAAe9vB,EAAehgB,EAAQ6H,EAAQ84B,GACnD,OAlMqB,SAAC3gC,GACtB,OAAOK,OAAO0S,KAAK/S,GAAQgT,KAAKw5B,GACpC,CAgMWuD,CAAiB/vC,GAClBsuC,GAAiCtuB,EAAehgB,EAAQ6H,EAAQ84B,GAChE,CAAE3gC,OAAAA,EAAQ2gC,cAAAA,EACpB,CCjNA,IAAMqP,GAAkB,SAAChwB,EAAehgB,EAAQ6H,EAAQ84B,GACpD,IAAMlX,E3CqCV,SAA6BzJ,EAAanW,EAAiB82B,GAAe,IAAzB3gC,EAAMK,OAAA4vC,OAAA,KAAAC,EAAAA,GAAAA,GAAArmC,GAAAA,IAC7C4P,EAAUuG,EAAcxL,QAC9B,KAAMiF,aAAmBb,SACrB,MAAO,CAAE5Y,OAAAA,EAAQ2gC,cAAAA,GAiBrB,IAAK,IAAMr/B,KAdPq/B,IACAA,GAAan8B,EAAAA,EAAAA,GAAA,GAAQm8B,IAGzB3gB,EAAczV,OAAOomB,SAAQ,SAAC7vB,GAC1B,IAAM0T,EAAU1T,EAAMhB,MACtB,IAAK+pB,EAAAA,GAAAA,GAAmBrV,GAAxB,CAEA,IAAMiV,EAAWT,GAAiBxU,EAASiF,GACvCgQ,GACA3oB,EAAMwZ,IAAImP,EAHJ,CAId,IAGkBzpB,EAAQ,CACtB,IAAMwU,EAAUxU,EAAOsB,GACvB,IAAKuoB,EAAAA,GAAAA,GAAmBrV,GAAxB,CAEA,IAAMiV,EAAWT,GAAiBxU,EAASiF,GACtCgQ,IAGLzpB,EAAOsB,GAAOmoB,EAIVkX,QAAwC7+B,IAAvB6+B,EAAcr/B,KAC/Bq/B,EAAcr/B,GAAOkT,GAVb,CAYhB,CACA,MAAO,CAAExU,OAAAA,EAAQ2gC,cAAAA,EACrB,C2C1EqBwP,CAAoBnwB,EAAehgB,EAAQ2gC,GAG5D,OAAOmP,GAAe9vB,EAFtBhgB,EAASypB,EAASzpB,OAE2B6H,EAD7C84B,EAAgBlX,EAASkX,cAE7B,ECXMyP,GAAuB,CAAE57B,QAAS,MAClC67B,GAA2B,CAAE77B,SAAS,G,iECiBtC87B,GAAejwC,OAAO0S,KAAKw9B,GAAAA,GAC3BC,GAAcF,GAAazvC,OAC3B4vC,GAAoB,CACtB,iBACA,oBACA,SACA,sBACA,gBACA,uBACA,2BAEEC,GAAkBC,GAAAA,EAAAA,OAKlBC,GAAa,WACf,SAAAA,EAAA/mC,GAAiG,IAAAzG,EAAA,KAAnFoF,EAAMqB,EAANrB,OAAQsc,EAAKjb,EAALib,MAAOpE,EAAe7W,EAAf6W,gBAAiBmwB,EAAmBhnC,EAAnBgnC,oBAAqBC,EAAWjnC,EAAXinC,YAAgBtuC,EAAO5B,UAAAC,OAAA,QAAAiB,IAAAlB,UAAA,GAAAA,UAAA,GAAG,CAAC,GAACO,EAAAA,EAAAA,GAAA,KAAAyvC,GAK3F5vC,KAAKwT,QAAU,KAIfxT,KAAKqwB,SAAW,IAAIpY,IAIpBjY,KAAK+vC,eAAgB,EACrB/vC,KAAKgwC,uBAAwB,EAQ7BhwC,KAAKk1B,mBAAqB,KAM1Bl1B,KAAKuJ,OAAS,IAAI0oB,IAIlBjyB,KAAKiwC,SAAW,CAAC,EAKjBjwC,KAAKkwC,mBAAqB,IAAIje,IAM9BjyB,KAAKmwC,iBAAmB,CAAC,EAIzBnwC,KAAKowC,OAAS,CAAC,EAMfpwC,KAAKqwC,uBAAyB,CAAC,EAC/BrwC,KAAKswC,aAAe,kBAAMluC,EAAKqxB,OAAO,SAAUrxB,EAAKitB,aAAa,EAClErvB,KAAKihB,OAAS,WACL7e,EAAKoR,UAEVpR,EAAKmuC,eACLnuC,EAAKouC,eAAepuC,EAAKoR,QAASpR,EAAKquC,YAAaruC,EAAK0hB,MAAMe,MAAOziB,EAAK8d,YAC/E,EACAlgB,KAAKyuB,eAAiB,kBAAM3qB,EAAAA,GAAAA,OAAY1B,EAAK6e,QAAQ,GAAO,EAAK,EACjE,IAAQoO,EAA8BygB,EAA9BzgB,aAAcohB,EAAgBX,EAAhBW,YACtBzwC,KAAKqvB,aAAeA,EACpBrvB,KAAK0wC,YAAUltC,EAAAA,EAAAA,GAAA,GAAQ6rB,GACvBrvB,KAAK2wC,cAAgB7sB,EAAMG,SAAOzgB,EAAAA,EAAAA,GAAA,GAAQ6rB,GAAiB,CAAC,EAC5DrvB,KAAKywC,YAAcA,EACnBzwC,KAAKwH,OAASA,EACdxH,KAAK8jB,MAAQA,EACb9jB,KAAK0f,gBAAkBA,EACvB1f,KAAKioB,MAAQzgB,EAASA,EAAOygB,MAAQ,EAAI,EACzCjoB,KAAK6vC,oBAAsBA,EAC3B7vC,KAAKwB,QAAUA,EACfxB,KAAKgwC,uBAAwBA,EAAAA,GAAAA,GAAsBlsB,GACnD9jB,KAAK+vC,eAAgBA,EAAAA,GAAAA,GAAcjsB,GAC/B9jB,KAAK+vC,gBACL/vC,KAAKygC,gBAAkB,IAAIxoB,KAE/BjY,KAAKmkC,uBAAyBvN,QAAQpvB,GAAUA,EAAOgM,SAWvD,IAAAo9B,EAA+C5wC,KAAK6wC,4BAA4B/sB,EAAO,CAAC,GAAhF0d,EAAUoP,EAAVpP,WAAesP,GAAmB1+B,EAAAA,GAAAA,GAAAw+B,EAAAv+B,IAC1C,IAAK,IAAM/R,KAAOwwC,EAAqB,CACnC,IAAMhxC,EAAQgxC,EAAoBxwC,QACRQ,IAAtBuuB,EAAa/uB,KAAsBs6B,EAAAA,GAAAA,GAAc96B,KACjDA,EAAMwZ,IAAI+V,EAAa/uB,IAAM,GACzBw/B,GAAwB0B,IACxBA,EAAWlX,IAAIhqB,GAG3B,CACJ,CA4WC,OA3WDD,EAAAA,EAAAA,GAAAuvC,EAAA,EAAAtvC,IAAA,8BAAAR,MAOA,SAA4BixC,EAAQC,GAChC,MAAO,CAAC,CACZ,GAAC,CAAA1wC,IAAA,QAAAR,MACD,SAAMqL,GAAU,IAAAsW,EAAA,KACZzhB,KAAKwT,QAAUrI,EACXnL,KAAKkgB,YACLlgB,KAAKkgB,WAAW2T,MAAM1oB,GAEtBnL,KAAKwH,QAAUxH,KAAK+vC,gBAAkB/vC,KAAKgwC,wBAC3ChwC,KAAKixC,sBAAwBjxC,KAAKwH,OAAO0pC,gBAAgBlxC,OAE7DA,KAAKuJ,OAAOomB,SAAQ,SAAC7vB,EAAOQ,GAAG,OAAKmhB,EAAK0vB,kBAAkB7wC,EAAKR,EAAM,IACjEuvC,GAAyB77B,SCxJtC,WAEI,GADA67B,GAAyB77B,SAAU,EAC9Bo7B,GAAAA,EAEL,GAAIlqC,OAAO0sC,WAAY,CACnB,IAAMC,EAAmB3sC,OAAO0sC,WAAW,4BACrCE,EAA8B,WAAH,OAAUlC,GAAqB57B,QAAU69B,EAAiBhL,OAAO,EAClGgL,EAAiBE,YAAYD,GAC7BA,GACJ,MAEIlC,GAAqB57B,SAAU,CAEvC,CD4IYg+B,GAEJxxC,KAAKk1B,mBAC4B,UAA7Bl1B,KAAK6vC,sBAE8B,WAA7B7vC,KAAK6vC,qBAEDT,GAAqB57B,SAI/BxT,KAAKwH,QACLxH,KAAKwH,OAAO6oB,SAAS/F,IAAItqB,MAC7BA,KAAK8U,OAAO9U,KAAK8jB,MAAO9jB,KAAK0f,gBACjC,GAAC,CAAApf,IAAA,UAAAR,MACD,WAOI,IAAK,IAAMQ,KANXN,KAAKkgB,YAAclgB,KAAKkgB,WAAWulB,UACnC9gC,EAAAA,GAAAA,OAAkB3E,KAAKswC,cACvB3rC,EAAAA,GAAAA,OAAkB3E,KAAKihB,QACvBjhB,KAAKkwC,mBAAmBvgB,SAAQ,SAACjE,GAAM,OAAKA,GAAQ,IACpD1rB,KAAKixC,uBAAyBjxC,KAAKixC,wBACnCjxC,KAAKwH,QAAUxH,KAAKwH,OAAO6oB,SAASyD,OAAO9zB,MACzBA,KAAKowC,OACnBpwC,KAAKowC,OAAO9vC,GAAK01B,QAErB,IAAK,IAAM11B,KAAON,KAAKiwC,SACnBjwC,KAAKiwC,SAAS3vC,GAAKmlC,UAEvBzlC,KAAKwT,QAAU,IACnB,GAAC,CAAAlT,IAAA,oBAAAR,MACD,SAAkBQ,EAAKR,GAAO,IAAAkjB,EAAA,KACpByuB,EAAmBr3B,GAAAA,EAAAA,IAAmB9Z,GACtCoxC,EAAiB5xC,EAAM6xC,GAAG,UAAU,SAACC,GACvC5uB,EAAKqM,aAAa/uB,GAAOsxC,EACzB5uB,EAAKc,MAAMxN,UACPxS,EAAAA,GAAAA,OAAYkf,EAAKstB,cAAc,GAAO,GACtCmB,GAAoBzuB,EAAK9C,aACzB8C,EAAK9C,WAAWwR,kBAAmB,EAE3C,IACMmgB,EAAwB/xC,EAAM6xC,GAAG,gBAAiB3xC,KAAKyuB,gBAC7DzuB,KAAKkwC,mBAAmB52B,IAAIhZ,GAAK,WAC7BoxC,IACAG,GACJ,GACJ,GAAC,CAAAvxC,IAAA,mBAAAR,MACD,SAAiBgyC,GAIb,OAAK9xC,KAAKwT,SACLxT,KAAK+xC,0BACN/xC,KAAKqE,OAASytC,EAAMztC,KAGjBrE,KAAK+xC,yBAAyB/xC,KAAKwT,QAASs+B,EAAMt+B,SAF9C,CAGf,GAAC,CAAAlT,IAAA,eAAAR,MACD,SAAA+E,EAA6CmtC,EAAUC,EAAmBC,EAAcC,GAepF,IAf8G,IAC1GC,EACAvmB,EAF0GlI,EAAA,KAAtF0uB,GAALxtC,EAARwrB,UAA0Bje,EAAAA,GAAAA,GAAAvN,EAAAytC,KAe5BltC,EAAI,EAAGA,EAAIoqC,GAAapqC,IAAK,CAClC,IAAMO,EAAO2pC,GAAalqC,GAC1BmtC,EAA2GhD,GAAAA,EAAmB5pC,GAAtH6sC,EAASD,EAATC,UAAoBC,EAAkBF,EAA3BtyC,QAA6BmxB,EAAcmhB,EAAdnhB,eAA+BshB,EAAsBH,EAArC1mB,cAC5DuF,IACAghB,EAA4BhhB,GAC5BohB,EAAUH,MACLryC,KAAKiwC,SAAStqC,IAAS8sC,IACxBzyC,KAAKiwC,SAAStqC,GAAQ,IAAI8sC,EAAmBzyC,OAE7C0yC,IACA7mB,EAAgB6mB,GAG5B,CACA,IAAK1yC,KAAKkgB,YAAckyB,EAA2B,CAC/CpyC,KAAKkgB,WAAa,IAAIkyB,EAA0BF,EAAclyC,KAAKqvB,aAAcrvB,KAAKwH,QAAUxH,KAAKwH,OAAO0Y,YAC5G,IAAQgK,EAAuEmoB,EAAvEnoB,SAAUxiB,EAA6D2qC,EAA7D3qC,OAAQ1B,EAAqDqsC,EAArDrsC,KAAM2b,EAA+C0wB,EAA/C1wB,gBAAiBkV,EAA8Bwb,EAA9Bxb,aAAc9B,EAAgBsd,EAAhBtd,WAC/D/0B,KAAKkgB,WAAWwK,WAAW,CACvBR,SAAAA,EACAxiB,OAAAA,EACA6uB,oBAAqBK,QAAQ5wB,IACxB2b,IAAmBE,EAAAA,EAAAA,GAAYF,GACpC3C,cAAehf,KACfyuB,eAAgB,kBAAM9K,EAAK8K,gBAAgB,EAQ3CwM,cAAiC,kBAAXvzB,EAAsBA,EAAS,OACrD2zB,uBAAwB8W,EACxBtb,aAAAA,EACA9B,WAAAA,GAER,CACA,OAAOlJ,CACX,GAAC,CAAAvrB,IAAA,iBAAAR,MACD,WACI,IAAK,IAAMQ,KAAON,KAAKiwC,SAAU,CAC7B,IAAM0C,EAAU3yC,KAAKiwC,SAAS3vC,GAC1BqyC,EAAQvyC,UACRuyC,EAAQ79B,OAAO9U,KAAK8jB,MAAO9jB,KAAK6qB,YAGhC8nB,EAAQ9e,QACR8e,EAAQvyC,WAAY,EAE5B,CACJ,GAAC,CAAAE,IAAA,eAAAR,MACD,WACIE,KAAK4yC,MAAM5yC,KAAKywC,YAAazwC,KAAKqvB,aAAcrvB,KAAKwB,QAASxB,KAAK8jB,MACvE,GACA,CAAAxjB,IAAA,qBAAAR,MAKA,WACI,OAAOE,KAAKwT,QACNxT,KAAK6yC,2BAA2B7yC,KAAKwT,QAASxT,KAAK8jB,OACnDrb,GACV,GAAC,CAAAnI,IAAA,iBAAAR,MACD,SAAeQ,GACX,OAAON,KAAKqvB,aAAa/uB,EAC7B,GAAC,CAAAA,IAAA,iBAAAR,MACD,SAAeQ,EAAKR,GAChBE,KAAKqvB,aAAa/uB,GAAOR,CAC7B,GACA,CAAAQ,IAAA,uBAAAR,MAOA,SAAqBd,GAA0B,IAAlB8zC,IAASlzC,UAAAC,OAAA,QAAAiB,IAAAlB,UAAA,KAAAA,UAAA,GAClC,OAAOI,KAAK+yC,iCAAiC/zC,EAAQgB,KAAK8jB,MAAOgvB,EACrE,GACA,CAAAxyC,IAAA,SAAAR,MAIA,SAAOgkB,EAAOpE,IACNoE,EAAMc,mBAAqB5kB,KAAK8jB,MAAMc,oBACtC5kB,KAAKyuB,iBAETzuB,KAAK6qB,UAAY7qB,KAAK8jB,MACtB9jB,KAAK8jB,MAAQA,EACb9jB,KAAK8lC,oBAAsB9lC,KAAK0f,gBAChC1f,KAAK0f,gBAAkBA,EAIvB,IAAK,IAAIta,EAAI,EAAGA,EAAIqqC,GAAkB5vC,OAAQuF,IAAK,CAC/C,IAAM9E,EAAMmvC,GAAkBrqC,GAC1BpF,KAAKqwC,uBAAuB/vC,KAC5BN,KAAKqwC,uBAAuB/vC,YACrBN,KAAKqwC,uBAAuB/vC,IAEvC,IAAM0yC,EAAWlvB,EAAM,KAAOxjB,GAC1B0yC,IACAhzC,KAAKqwC,uBAAuB/vC,GAAON,KAAK2xC,GAAGrxC,EAAK0yC,GAExD,CACAhzC,KAAKmwC,iBEzUb,SAAqC13B,EAAS/I,EAAMuO,GAChD,IAAQujB,EAAe9xB,EAAf8xB,WACR,IAAK,IAAMlhC,KAAOoP,EAAM,CACpB,IAAMujC,EAAYvjC,EAAKpP,GACjB4yC,EAAYj1B,EAAK3d,GACvB,IAAIs6B,EAAAA,GAAAA,GAAcqY,GAKdx6B,EAAQ8mB,SAASj/B,EAAK2yC,GAClBnT,GAAwB0B,IACxBA,EAAWlX,IAAIhqB,QAUlB,IAAIs6B,EAAAA,GAAAA,GAAcsY,GAKnBz6B,EAAQ8mB,SAASj/B,GAAKslB,EAAAA,GAAAA,GAAYqtB,EAAW,CAAE75B,MAAOX,KAClDqnB,GAAwB0B,IACxBA,EAAW9V,OAAOprB,QAGrB,GAAI4yC,IAAcD,EAMnB,GAAIx6B,EAAQ6mB,SAASh/B,GAAM,CACvB,IAAM6yC,EAAgB16B,EAAQuL,SAAS1jB,IAEtC6yC,EAAcjR,aAAeiR,EAAc75B,IAAI25B,EACpD,KACK,CACD,IAAMrB,EAAcn5B,EAAQ26B,eAAe9yC,GAC3CmY,EAAQ8mB,SAASj/B,GAAKslB,EAAAA,GAAAA,QAA4B9kB,IAAhB8wC,EAA4BA,EAAcqB,EAAW,CAAE75B,MAAOX,IACpG,CAER,CAEA,IAAK,IAAMnY,KAAO2d,OACInd,IAAd4O,EAAKpP,IACLmY,EAAQ46B,YAAY/yC,GAE5B,OAAOoP,CACX,CFkRgC4jC,CAA4BtzC,KAAMA,KAAK6wC,4BAA4B/sB,EAAO9jB,KAAK6qB,WAAY7qB,KAAKmwC,kBACpHnwC,KAAKuzC,wBACLvzC,KAAKuzC,wBAEb,GAAC,CAAAjzC,IAAA,WAAAR,MACD,WACI,OAAOE,KAAK8jB,KAChB,GACA,CAAAxjB,IAAA,aAAAR,MAGA,SAAW6F,GACP,OAAO3F,KAAK8jB,MAAM0vB,SAAWxzC,KAAK8jB,MAAM0vB,SAAS7tC,QAAQ7E,CAC7D,GACA,CAAAR,IAAA,uBAAAR,MAGA,WACI,OAAOE,KAAK8jB,MAAMhH,UACtB,GAAC,CAAAxc,IAAA,wBAAAR,MACD,WACI,OAAOE,KAAK8jB,MAAMzhB,kBACtB,GAAC,CAAA/B,IAAA,wBAAAR,MACD,WACI,OAAOE,KAAK+vC,cACN/vC,KACAA,KAAKwH,OACDxH,KAAKwH,OAAOisC,6BACZ3yC,CACd,GAAC,CAAAR,IAAA,oBAAAR,MACD,WACI,GAD2BF,UAAAC,OAAA,QAAAiB,IAAAlB,UAAA,IAAAA,UAAA,GAEvB,OAAOI,KAAKwH,OAASxH,KAAKwH,OAAOg8B,yBAAsB1iC,EAE3D,IAAKd,KAAKgwC,sBAAuB,CAC7B,IAAMjkB,EAAU/rB,KAAKwH,QACfxH,KAAKwH,OAAOg8B,qBACZ,CAAC,EAIP,YAH2B1iC,IAAvBd,KAAK8jB,MAAMG,UACX8H,EAAQ9H,QAAUjkB,KAAK8jB,MAAMG,SAE1B8H,CACX,CAEA,IADA,IAAMA,EAAU,CAAC,EACR3mB,EAAI,EAAGA,EAAIsqC,GAAiBtqC,IAAK,CACtC,IAAMO,EAAOgqC,GAAAA,EAAavqC,GACpBy+B,EAAO7jC,KAAK8jB,MAAMne,KACpBo+B,EAAAA,GAAAA,GAAeF,KAAkB,IAATA,KACxB9X,EAAQpmB,GAAQk+B,EAExB,CACA,OAAO9X,CACX,GACA,CAAAzrB,IAAA,kBAAAR,MAGA,SAAgBywB,GACZ,IAAMmjB,EAAqB1zC,KAAKyzC,wBAChC,GAAIC,EAGA,OAFAA,EAAmBjT,iBACfiT,EAAmBjT,gBAAgBnW,IAAIiG,GACpC,kBAAMmjB,EAAmBjT,gBAAgB3M,OAAOvD,EAAM,CAErE,GACA,CAAAjwB,IAAA,WAAAR,MAGA,SAASQ,EAAKR,GAENA,IAAUE,KAAKuJ,OAAOzK,IAAIwB,KAC1BN,KAAKqzC,YAAY/yC,GACjBN,KAAKmxC,kBAAkB7wC,EAAKR,IAEhCE,KAAKuJ,OAAO+P,IAAIhZ,EAAKR,GACrBE,KAAKqvB,aAAa/uB,GAAOR,EAAMhB,KACnC,GACA,CAAAwB,IAAA,cAAAR,MAGA,SAAYQ,GACRN,KAAKuJ,OAAOuqB,OAAOxzB,GACnB,IAAMqzC,EAAc3zC,KAAKkwC,mBAAmBpxC,IAAIwB,GAC5CqzC,IACAA,IACA3zC,KAAKkwC,mBAAmBpc,OAAOxzB,WAE5BN,KAAKqvB,aAAa/uB,GACzBN,KAAK4zC,2BAA2BtzC,EAAKN,KAAKywC,YAC9C,GACA,CAAAnwC,IAAA,WAAAR,MAGA,SAASQ,GACL,OAAON,KAAKuJ,OAAO6O,IAAI9X,EAC3B,GAAC,CAAAA,IAAA,WAAAR,MACD,SAASQ,EAAK8a,GACV,GAAIpb,KAAK8jB,MAAMva,QAAUvJ,KAAK8jB,MAAMva,OAAOjJ,GACvC,OAAON,KAAK8jB,MAAMva,OAAOjJ,GAE7B,IAAIR,EAAQE,KAAKuJ,OAAOzK,IAAIwB,GAK5B,YAJcQ,IAAVhB,QAAwCgB,IAAjBsa,IACvBtb,GAAQ8lB,EAAAA,GAAAA,GAAYxK,EAAc,CAAEhC,MAAOpZ,OAC3CA,KAAKu/B,SAASj/B,EAAKR,IAEhBA,CACX,GACA,CAAAQ,IAAA,YAAAR,MAKA,SAAUQ,GACN,YAAkCQ,IAA3Bd,KAAKqvB,aAAa/uB,IAAuBN,KAAKwT,QAE/CxT,KAAK6zC,sBAAsB7zC,KAAKwT,QAASlT,EAAKN,KAAKwB,SADnDxB,KAAKqvB,aAAa/uB,EAE5B,GACA,CAAAA,IAAA,gBAAAR,MAIA,SAAcQ,EAAKR,GACfE,KAAK0wC,WAAWpwC,GAAOR,CAC3B,GACA,CAAAQ,IAAA,gBAAAR,MAIA,SAAcQ,GACV,IAAIy3B,EACI9T,EAAYjkB,KAAK8jB,MAAjBG,QACF6vB,EAAsC,kBAAZ7vB,GAA2C,kBAAZA,EACD,QAAvD8T,GAAKoH,EAAAA,GAAAA,GAAwBn/B,KAAK8jB,MAAOG,UAA6B,IAAP8T,OAAgB,EAASA,EAAGz3B,QAC5FQ,EAIN,GAAImjB,QAAgCnjB,IAArBgzC,EACX,OAAOA,EAMX,IAAM90C,EAASgB,KAAK+zC,uBAAuB/zC,KAAK8jB,MAAOxjB,GACvD,YAAeQ,IAAX9B,IAAyB47B,EAAAA,GAAAA,GAAc57B,QAMR8B,IAA5Bd,KAAK2wC,cAAcrwC,SACDQ,IAArBgzC,OACEhzC,EACAd,KAAK0wC,WAAWpwC,GARXtB,CASf,GAAC,CAAAsB,IAAA,KAAAR,MACD,SAAGyB,EAAWoH,GAIV,OAHK3I,KAAKowC,OAAO7uC,KACbvB,KAAKowC,OAAO7uC,GAAa,IAAI6xB,GAAAA,GAE1BpzB,KAAKowC,OAAO7uC,GAAW+oB,IAAI3hB,EACtC,GAAC,CAAArI,IAAA,SAAAR,MACD,SAAOyB,GACH,GAAIvB,KAAKowC,OAAO7uC,GAAY,SAAAyyC,EAAA1gB,EAAA1zB,UAAAC,OADX0zB,EAAI,IAAAvlB,MAAAslB,EAAA,EAAAA,EAAA,KAAA2gB,EAAA,EAAAA,EAAA3gB,EAAA2gB,IAAJ1gB,EAAI0gB,EAAA,GAAAr0C,UAAAq0C,IAEjBD,EAAAh0C,KAAKowC,OAAO7uC,IAAWkyB,OAAM1zB,MAAAi0C,EAAIzgB,EACrC,CACJ,KAACqc,CAAA,CAhdc,G,kCG/BbsE,GAAgB,SAAAC,IAAA9tB,EAAAA,EAAAA,GAAA6tB,EAAAC,GAAA,IAAA7tB,GAAAC,EAAAA,EAAAA,GAAA2tB,GAAA,SAAAA,IAAA,OAAA/zC,EAAAA,EAAAA,GAAA,KAAA+zC,GAAA5tB,EAAAvmB,MAAA,KAAAH,UAAA,CAwCjB,OAxCiBS,EAAAA,EAAAA,GAAA6zC,EAAA,EAAA5zC,IAAA,2BAAAR,MAClB,SAAyBgC,EAAGC,GAMxB,OAAsC,EAA/BD,EAAEsyC,wBAAwBryC,GAAS,GAAK,CACnD,GAAC,CAAAzB,IAAA,yBAAAR,MACD,SAAuBgkB,EAAOxjB,GAC1B,OAAOwjB,EAAMe,MAAQf,EAAMe,MAAMvkB,QAAOQ,CAC5C,GAAC,CAAAR,IAAA,6BAAAR,MACD,SAA2BQ,EAAGuI,GAAmB,IAAfwrC,EAAIxrC,EAAJwrC,KAAMxvB,EAAKhc,EAALgc,aAC7BwvB,EAAK/zC,UACLukB,EAAMvkB,EACjB,GAAC,CAAAA,IAAA,mCAAAR,MACD,SAAA+E,EAAAmD,EAAgG5H,GAAW,IAAxE0c,EAAUjY,EAAViY,WAAY6iB,EAAa96B,EAAb86B,cAAkB3gC,GAAMoT,EAAAA,GAAAA,GAAAvN,EAAAwN,IAAMiiC,EAAetsC,EAAfssC,gBACrEztC,ErBqFZ,SAAmB7H,EAAQ8d,EAAYkC,GACnC,IAAMnY,EAAS,CAAC,EAChB,IAAK,IAAMvG,KAAOtB,EAAQ,CACtB,IAAMu1C,EAAmB1U,GAAwBv/B,EAAKwc,GACtD,QAAyBhc,IAArByzC,EACA1tC,EAAOvG,GAAOi0C,MAEb,CACD,IAAMz0C,EAAQkf,EAAcgF,SAAS1jB,GACjCR,IACA+G,EAAOvG,GAAOR,EAAMhB,MAE5B,CACJ,CACA,OAAO+H,CACX,CqBpGqB2tC,CAAUx1C,EAAQ8d,GAAc,CAAC,EAAG9c,MAYjD,GARIs0C,IACI3U,IACAA,EAAgB2U,EAAgB3U,IAChC3gC,IACAA,EAASs1C,EAAgBt1C,IACzB6H,IACAA,EAASytC,EAAgBztC,KAE7BzG,EAAW,ErBoBvB,SAAiC4e,EAAehgB,EAAQ6H,GACpD,IAAIkxB,EAAI4D,EACF8Y,EAAep1C,OAAO0S,KAAK/S,GAAQsc,QAAO,SAAChb,GAAG,OAAM0e,EAAcsgB,SAASh/B,EAAI,IAC/Eo0C,EAAeD,EAAa50C,OAClC,GAAK60C,EAEL,IAAK,IAAItvC,EAAI,EAAGA,EAAIsvC,EAActvC,IAAK,CACnC,IAAM9E,EAAMm0C,EAAarvC,GACnBuvC,EAAc31C,EAAOsB,GACvBR,EAAQ,KAKRkO,MAAMC,QAAQ0mC,KACd70C,EAAQ60C,EAAY,IAOV,OAAV70C,IACAA,EAAoG,QAA3F67B,EAA4B,QAAtB5D,EAAKlxB,EAAOvG,UAAyB,IAAPy3B,EAAgBA,EAAK/Y,EAAc41B,UAAUt0C,UAAyB,IAAPq7B,EAAgBA,EAAK38B,EAAOsB,SAM9HQ,IAAVhB,GAAiC,OAAVA,IAEN,kBAAVA,IPjFc,iBAAiBw+B,KOkFnBx+B,IAAUu+B,GAAkBv+B,IAE/CA,EAAQ2c,WAAW3c,IAEbk/B,GAAcl/B,IAAUya,GAAAA,EAAAA,KAAao6B,KAC3C70C,EAAQyb,GAAkBjb,EAAKq0C,IAEnC31B,EAAcugB,SAASj/B,GAAKslB,EAAAA,GAAAA,GAAY9lB,EAAO,CAAEsZ,MAAO4F,UACpCle,IAAhB+F,EAAOvG,KACPuG,EAAOvG,GAAOR,GAEJ,OAAVA,GACAkf,EAAc61B,cAAcv0C,EAAKR,GACzC,CACJ,CqBjEYg1C,CAAwB90C,KAAMhB,EAAQ6H,GACtC,IAAMkuC,EAAS/F,GAAgBhvC,KAAMhB,EAAQ6H,EAAQ84B,GACrDA,EAAgBoV,EAAOpV,cACvB3gC,EAAS+1C,EAAO/1C,MACpB,CACA,OAAAwE,EAAAA,EAAAA,GAAA,CACIsZ,WAAAA,EACA6iB,cAAAA,GACG3gC,EAEX,KAACk1C,CAAA,CAxCiB,CAAStE,ICQ9B,IACKoF,GAAiB,SAAAC,IAAA5uB,EAAAA,EAAAA,GAAA2uB,EAAAC,GAAA,IAAA3uB,GAAAC,EAAAA,EAAAA,GAAAyuB,GAAA,SAAAA,IAAA,OAAA70C,EAAAA,EAAAA,GAAA,KAAA60C,GAAA1uB,EAAAvmB,MAAA,KAAAH,UAAA,CAsClB,OAtCkBS,EAAAA,EAAAA,GAAA20C,EAAA,EAAA10C,IAAA,wBAAAR,MACnB,SAAsBqL,EAAU7K,GAC5B,GAAI8Z,GAAAA,EAAAA,IAAmB9Z,GAAM,CACzB,IAAM40C,EAAc54B,GAAoBhc,GACxC,OAAO40C,GAAcA,EAAYC,SAAe,CACpD,CAEI,IAVc18B,EAUR28B,GAVQ38B,EAUyBtN,EATxCzG,OAAOgkB,iBAAiBjQ,IAUjB3Y,IAASu1C,EAAAA,GAAAA,GAAkB/0C,GAC3B80C,EAAczsB,iBAAiBroB,GAC/B80C,EAAc90C,KAAS,EAC7B,MAAwB,kBAAVR,EAAqBA,EAAM8oB,OAAS9oB,CAE1D,GAAC,CAAAQ,IAAA,6BAAAR,MACD,SAA2BqL,EAAQtC,GAC/B,OAAOqC,GAAmBC,EAD2BtC,EAAlBxG,mBAEvC,GAAC,CAAA/B,IAAA,QAAAR,MACD,SAAM2wC,EAAaphB,EAAc7tB,EAASsiB,IACtCwxB,EAAAA,GAAAA,GAAgB7E,EAAaphB,EAAc7tB,EAASsiB,EAAMc,kBAC9D,GAAC,CAAAtkB,IAAA,8BAAAR,MACD,SAA4BgkB,EAAO+G,GAC/B,OAAOgmB,EAAAA,GAAAA,GAA4B/sB,EAAO+G,EAC9C,GAAC,CAAAvqB,IAAA,yBAAAR,MACD,WAAyB,IAAAsC,EAAA,KACjBpC,KAAKu1C,oBACLv1C,KAAKu1C,2BACEv1C,KAAKu1C,mBAEhB,IAAQllB,EAAarwB,KAAK8jB,MAAlBuM,UACJuK,EAAAA,GAAAA,GAAcvK,KACdrwB,KAAKu1C,kBAAoBllB,EAASshB,GAAG,UAAU,SAACptB,GACxCniB,EAAKoR,UACLpR,EAAKoR,QAAQgiC,YAAc,GAAHpnC,OAAMmW,GACtC,IAER,GAAC,CAAAjkB,IAAA,iBAAAR,MACD,SAAeqL,EAAUslC,EAAa7U,EAAW1b,IAC7Cu1B,EAAAA,GAAAA,GAAWtqC,EAAUslC,EAAa7U,EAAW1b,EACjD,KAAC80B,CAAA,CAtCkB,CAASd,I,mFCF1BwB,GAAgB,SAAAT,IAAA5uB,EAAAA,EAAAA,GAAAqvB,EAAAT,GAAA,IAAA3uB,GAAAC,EAAAA,EAAAA,GAAAmvB,GAClB,SAAAA,IAAc,IAAAtzC,EAEY,OAFZjC,EAAAA,EAAAA,GAAA,KAAAu1C,IACVtzC,EAAAkkB,EAAAvmB,MAAA,KAASH,YACJ+1C,UAAW,EAAMvzC,CAC1B,CA2BC,OA3BA/B,EAAAA,EAAAA,GAAAq1C,EAAA,EAAAp1C,IAAA,yBAAAR,MACD,SAAuBgkB,EAAOxjB,GAC1B,OAAOwjB,EAAMxjB,EACjB,GAAC,CAAAA,IAAA,wBAAAR,MACD,SAAsBqL,EAAU7K,GAC5B,GAAI8Z,GAAAA,EAAAA,IAAmB9Z,GAAM,CACzB,IAAM40C,EAAc54B,GAAoBhc,GACxC,OAAO40C,GAAcA,EAAYC,SAAe,CACpD,CAEA,OADA70C,EAAOs1C,GAAAA,EAAAA,IAAwBt1C,GAA0BA,GAAnB0/B,EAAAA,GAAAA,GAAY1/B,GAC3C6K,EAAS0qC,aAAav1C,EACjC,GAAC,CAAAA,IAAA,6BAAAR,MACD,WACI,OAAO2I,GACX,GAAC,CAAAnI,IAAA,8BAAAR,MACD,SAA4BgkB,EAAO+G,GAC/B,OAAOgmB,EAAAA,GAAAA,GAA4B/sB,EAAO+G,EAC9C,GAAC,CAAAvqB,IAAA,QAAAR,MACD,SAAM2wC,EAAaphB,EAAc7tB,EAASsiB,IACtCgyB,EAAAA,GAAAA,GAAcrF,EAAaphB,EAAc7tB,EAASxB,KAAK21C,SAAU7xB,EAAMc,kBAC3E,GAAC,CAAAtkB,IAAA,iBAAAR,MACD,SAAeqL,EAAUslC,EAAa7U,EAAW1b,IAC7C61B,EAAAA,GAAAA,GAAU5qC,EAAUslC,EAAa7U,EAAW1b,EAChD,GAAC,CAAA5f,IAAA,QAAAR,MACD,SAAMqL,GACFnL,KAAK21C,UAAWA,EAAAA,GAAAA,GAASxqC,EAASwoB,UAClC/0B,EAAAA,GAAAA,IAAAo3C,EAAAA,GAAAA,GAAAN,EAAAp2C,WAAA,cAAAE,KAAA,KAAY2L,EAChB,KAACuqC,CAAA,CA/BiB,CAASxB,I,YCJzB+B,IAAYzyC,EAAAA,EAAAA,IAAAA,EAAAA,EAAAA,GAAA,CACd0yC,SCJ2B,SAACC,EAAW30C,GACvC,OAAO40C,EAAAA,GAAAA,GAAeD,GAChB,IAAIT,GAAiBl0C,EAAS,CAAE60C,4BAA4B,IAC5D,IAAIrB,GAAkBxzC,EAAS,CAAE60C,4BAA4B,GACvE,GDCOxV,IACAqK,IEHDoL,IAAM9yC,EAAAA,EAAAA,IAAAA,EAAAA,EAAAA,IAAAA,EAAAA,EAAAA,GAAA,GACLyyC,IACAjwC,IACA0B,G","sources":["../node_modules/@babel/runtime/helpers/esm/get.js","../node_modules/@babel/runtime/helpers/esm/superPropBase.js","../node_modules/framer-motion/dist/es/motion/features/Feature.mjs","../node_modules/framer-motion/dist/es/events/utils/is-primary-pointer.mjs","../node_modules/framer-motion/dist/es/events/event-info.mjs","../node_modules/framer-motion/dist/es/utils/time-conversion.mjs","../node_modules/framer-motion/dist/es/events/add-dom-event.mjs","../node_modules/framer-motion/dist/es/events/add-pointer-event.mjs","../node_modules/framer-motion/dist/es/utils/distance.mjs","../node_modules/framer-motion/dist/es/gestures/pan/PanSession.mjs","../node_modules/framer-motion/dist/es/gestures/drag/utils/lock.mjs","../node_modules/framer-motion/dist/es/projection/geometry/delta-calc.mjs","../node_modules/framer-motion/dist/es/gestures/drag/utils/constraints.mjs","../node_modules/framer-motion/dist/es/projection/geometry/models.mjs","../node_modules/framer-motion/dist/es/projection/utils/each-axis.mjs","../node_modules/framer-motion/dist/es/projection/geometry/conversion.mjs","../node_modules/framer-motion/dist/es/projection/utils/has-transform.mjs","../node_modules/framer-motion/dist/es/projection/geometry/delta-apply.mjs","../node_modules/framer-motion/dist/es/projection/utils/measure.mjs","../node_modules/framer-motion/dist/es/utils/use-instant-transition-state.mjs","../node_modules/framer-motion/dist/es/easing/modifiers/mirror.mjs","../node_modules/framer-motion/dist/es/easing/modifiers/reverse.mjs","../node_modules/framer-motion/dist/es/easing/ease.mjs","../node_modules/framer-motion/dist/es/easing/cubic-bezier.mjs","../node_modules/framer-motion/dist/es/easing/circ.mjs","../node_modules/framer-motion/dist/es/easing/back.mjs","../node_modules/framer-motion/dist/es/animation/utils/easing.mjs","../node_modules/framer-motion/dist/es/easing/anticipate.mjs","../node_modules/framer-motion/dist/es/animation/legacy-popmotion/keyframes.mjs","../node_modules/framer-motion/dist/es/utils/offsets/time.mjs","../node_modules/framer-motion/dist/es/animation/legacy-popmotion/find-spring.mjs","../node_modules/framer-motion/dist/es/animation/legacy-popmotion/spring.mjs","../node_modules/framer-motion/dist/es/animation/legacy-popmotion/index.mjs","../node_modules/framer-motion/dist/es/animation/legacy-popmotion/decay.mjs","../node_modules/framer-motion/dist/es/animation/waapi/easing.mjs","../node_modules/framer-motion/dist/es/animation/waapi/supports.mjs","../node_modules/framer-motion/dist/es/animation/waapi/create-accelerated-animation.mjs","../node_modules/framer-motion/dist/es/animation/waapi/index.mjs","../node_modules/framer-motion/dist/es/animation/waapi/utils/get-final-keyframe.mjs","../node_modules/framer-motion/dist/es/utils/delay.mjs","../node_modules/framer-motion/dist/es/animation/create-instant-animation.mjs","../node_modules/framer-motion/dist/es/animation/utils/default-transitions.mjs","../node_modules/framer-motion/dist/es/animation/utils/is-animatable.mjs","../node_modules/framer-motion/dist/es/value/types/complex/filter.mjs","../node_modules/framer-motion/dist/es/render/dom/value-types/defaults.mjs","../node_modules/framer-motion/dist/es/render/dom/value-types/animatable-none.mjs","../node_modules/framer-motion/dist/es/animation/utils/transitions.mjs","../node_modules/framer-motion/dist/es/animation/index.mjs","../node_modules/framer-motion/dist/es/animation/utils/keyframes.mjs","../node_modules/framer-motion/dist/es/animation/legacy-popmotion/inertia.mjs","../node_modules/framer-motion/dist/es/gestures/drag/VisualElementDragControls.mjs","../node_modules/framer-motion/dist/es/gestures/drag/index.mjs","../node_modules/framer-motion/dist/es/gestures/pan/index.mjs","../node_modules/framer-motion/dist/es/projection/styles/scale-border-radius.mjs","../node_modules/framer-motion/dist/es/render/dom/utils/css-variables-conversion.mjs","../node_modules/framer-motion/dist/es/projection/styles/scale-box-shadow.mjs","../node_modules/framer-motion/dist/es/motion/features/layout/MeasureLayout.mjs","../node_modules/framer-motion/dist/es/components/AnimatePresence/use-presence.mjs","../node_modules/framer-motion/dist/es/projection/animation/mix-values.mjs","../node_modules/framer-motion/dist/es/projection/geometry/copy.mjs","../node_modules/framer-motion/dist/es/projection/geometry/delta-remove.mjs","../node_modules/framer-motion/dist/es/projection/geometry/utils.mjs","../node_modules/framer-motion/dist/es/projection/shared/stack.mjs","../node_modules/framer-motion/dist/es/projection/styles/transform.mjs","../node_modules/framer-motion/dist/es/render/utils/compare-by-depth.mjs","../node_modules/framer-motion/dist/es/render/utils/flat-tree.mjs","../node_modules/framer-motion/dist/es/projection/node/create-projection-node.mjs","../node_modules/framer-motion/dist/es/debug/record.mjs","../node_modules/framer-motion/dist/es/animation/animate.mjs","../node_modules/framer-motion/dist/es/projection/node/DocumentProjectionNode.mjs","../node_modules/framer-motion/dist/es/projection/node/HTMLProjectionNode.mjs","../node_modules/framer-motion/dist/es/motion/features/drag.mjs","../node_modules/framer-motion/dist/es/motion/features/layout.mjs","../node_modules/framer-motion/dist/es/utils/shallow-compare.mjs","../node_modules/framer-motion/dist/es/utils/is-numerical-string.mjs","../node_modules/framer-motion/dist/es/utils/is-zero-value-string.mjs","../node_modules/framer-motion/dist/es/render/dom/value-types/test.mjs","../node_modules/framer-motion/dist/es/render/dom/value-types/dimensions.mjs","../node_modules/framer-motion/dist/es/render/dom/value-types/type-auto.mjs","../node_modules/framer-motion/dist/es/render/dom/value-types/find.mjs","../node_modules/framer-motion/dist/es/render/utils/resolve-dynamic-variants.mjs","../node_modules/framer-motion/dist/es/render/utils/setters.mjs","../node_modules/framer-motion/dist/es/value/use-will-change/is.mjs","../node_modules/framer-motion/dist/es/animation/optimized-appear/data-id.mjs","../node_modules/framer-motion/dist/es/render/utils/animation.mjs","../node_modules/framer-motion/dist/es/render/utils/animation-state.mjs","../node_modules/framer-motion/dist/es/motion/features/animation/index.mjs","../node_modules/framer-motion/dist/es/motion/features/animation/exit.mjs","../node_modules/framer-motion/dist/es/motion/features/animations.mjs","../node_modules/framer-motion/dist/es/gestures/hover.mjs","../node_modules/framer-motion/dist/es/gestures/focus.mjs","../node_modules/framer-motion/dist/es/gestures/utils/is-node-or-child.mjs","../node_modules/framer-motion/dist/es/gestures/press.mjs","../node_modules/framer-motion/dist/es/motion/features/viewport/observers.mjs","../node_modules/framer-motion/dist/es/motion/features/viewport/index.mjs","../node_modules/framer-motion/dist/es/motion/features/gestures.mjs","../node_modules/framer-motion/dist/es/render/dom/utils/unit-conversion.mjs","../node_modules/framer-motion/dist/es/render/dom/utils/parse-dom-variant.mjs","../node_modules/framer-motion/dist/es/utils/reduced-motion/state.mjs","../node_modules/framer-motion/dist/es/render/VisualElement.mjs","../node_modules/framer-motion/dist/es/utils/reduced-motion/index.mjs","../node_modules/framer-motion/dist/es/render/utils/motion-values.mjs","../node_modules/framer-motion/dist/es/render/dom/DOMVisualElement.mjs","../node_modules/framer-motion/dist/es/render/html/HTMLVisualElement.mjs","../node_modules/framer-motion/dist/es/render/svg/SVGVisualElement.mjs","../node_modules/framer-motion/dist/es/render/dom/features-animation.mjs","../node_modules/framer-motion/dist/es/render/dom/create-visual-element.mjs","../node_modules/framer-motion/dist/es/render/dom/features-max.mjs"],"sourcesContent":["import superPropBase from \"./superPropBase.js\";\nexport default function _get() {\n  if (typeof Reflect !== \"undefined\" && Reflect.get) {\n    _get = Reflect.get.bind();\n  } else {\n    _get = function _get(target, property, receiver) {\n      var base = superPropBase(target, property);\n      if (!base) return;\n      var desc = Object.getOwnPropertyDescriptor(base, property);\n      if (desc.get) {\n        return desc.get.call(arguments.length < 3 ? target : receiver);\n      }\n      return desc.value;\n    };\n  }\n  return _get.apply(this, arguments);\n}","import getPrototypeOf from \"./getPrototypeOf.js\";\nexport default function _superPropBase(object, property) {\n  while (!Object.prototype.hasOwnProperty.call(object, property)) {\n    object = getPrototypeOf(object);\n    if (object === null) break;\n  }\n  return object;\n}","class Feature {\n    constructor(node) {\n        this.isMounted = false;\n        this.node = node;\n    }\n    update() { }\n}\n\nexport { Feature };\n","const isPrimaryPointer = (event) => {\n    if (event.pointerType === \"mouse\") {\n        return typeof event.button !== \"number\" || event.button <= 0;\n    }\n    else {\n        /**\n         * isPrimary is true for all mice buttons, whereas every touch point\n         * is regarded as its own input. So subsequent concurrent touch points\n         * will be false.\n         *\n         * Specifically match against false here as incomplete versions of\n         * PointerEvents in very old browser might have it set as undefined.\n         */\n        return event.isPrimary !== false;\n    }\n};\n\nexport { isPrimaryPointer };\n","import { isPrimaryPointer } from './utils/is-primary-pointer.mjs';\n\nfunction extractEventInfo(event, pointType = \"page\") {\n    return {\n        point: {\n            x: event[pointType + \"X\"],\n            y: event[pointType + \"Y\"],\n        },\n    };\n}\nconst addPointerInfo = (handler) => {\n    return (event) => isPrimaryPointer(event) && handler(event, extractEventInfo(event));\n};\n\nexport { addPointerInfo, extractEventInfo };\n","/**\n * Converts seconds to milliseconds\n *\n * @param seconds - Time in seconds.\n * @return milliseconds - Converted time in milliseconds.\n */\nconst secondsToMilliseconds = (seconds) => seconds * 1000;\n\nexport { secondsToMilliseconds };\n","function addDomEvent(target, eventName, handler, options = { passive: true }) {\n    target.addEventListener(eventName, handler, options);\n    return () => target.removeEventListener(eventName, handler);\n}\n\nexport { addDomEvent };\n","import { addDomEvent } from './add-dom-event.mjs';\nimport { addPointerInfo } from './event-info.mjs';\n\nfunction addPointerEvent(target, eventName, handler, options) {\n    return addDomEvent(target, eventName, addPointerInfo(handler), options);\n}\n\nexport { addPointerEvent };\n","const distance = (a, b) => Math.abs(a - b);\nfunction distance2D(a, b) {\n    // Multi-dimensional\n    const xDelta = distance(a.x, b.x);\n    const yDelta = distance(a.y, b.y);\n    return Math.sqrt(xDelta ** 2 + yDelta ** 2);\n}\n\nexport { distance, distance2D };\n","import { extractEventInfo } from '../../events/event-info.mjs';\nimport { sync, cancelSync } from '../../frameloop/index.mjs';\nimport { secondsToMilliseconds } from '../../utils/time-conversion.mjs';\nimport { addPointerEvent } from '../../events/add-pointer-event.mjs';\nimport { pipe } from '../../utils/pipe.mjs';\nimport { distance2D } from '../../utils/distance.mjs';\nimport { frameData } from '../../frameloop/data.mjs';\nimport { isPrimaryPointer } from '../../events/utils/is-primary-pointer.mjs';\n\n/**\n * @internal\n */\nclass PanSession {\n    constructor(event, handlers, { 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 = () => {\n            if (!(this.lastMoveEvent && this.lastMoveEventInfo))\n                return;\n            const info = getPanInfo(this.lastMoveEventInfo, this.history);\n            const 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            const isDistancePastThreshold = distance2D(info.offset, { x: 0, y: 0 }) >= 3;\n            if (!isPanStarted && !isDistancePastThreshold)\n                return;\n            const { point } = info;\n            const { timestamp } = frameData;\n            this.history.push({ ...point, timestamp });\n            const { onStart, onMove } = this.handlers;\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 = (event, info) => {\n            this.lastMoveEvent = event;\n            this.lastMoveEventInfo = transformPoint(info, this.transformPagePoint);\n            // Throttle mouse move event to once per frame\n            sync.update(this.updatePoint, true);\n        };\n        this.handlePointerUp = (event, info) => {\n            this.end();\n            if (!(this.lastMoveEvent && this.lastMoveEventInfo))\n                return;\n            const { onEnd, onSessionEnd } = this.handlers;\n            const panInfo = getPanInfo(event.type === \"pointercancel\"\n                ? this.lastMoveEventInfo\n                : 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 (!isPrimaryPointer(event))\n            return;\n        this.handlers = handlers;\n        this.transformPagePoint = transformPagePoint;\n        const info = extractEventInfo(event);\n        const initialInfo = transformPoint(info, this.transformPagePoint);\n        const { point } = initialInfo;\n        const { timestamp } = frameData;\n        this.history = [{ ...point, timestamp }];\n        const { onSessionStart } = handlers;\n        onSessionStart &&\n            onSessionStart(event, getPanInfo(initialInfo, this.history));\n        this.removeListeners = pipe(addPointerEvent(window, \"pointermove\", this.handlePointerMove), addPointerEvent(window, \"pointerup\", this.handlePointerUp), addPointerEvent(window, \"pointercancel\", this.handlePointerUp));\n    }\n    updateHandlers(handlers) {\n        this.handlers = handlers;\n    }\n    end() {\n        this.removeListeners && this.removeListeners();\n        cancelSync.update(this.updatePoint);\n    }\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({ point }, history) {\n    return {\n        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    let i = history.length - 1;\n    let timestampedPoint = null;\n    const 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    const time = (lastPoint.timestamp - timestampedPoint.timestamp) / 1000;\n    if (time === 0) {\n        return { x: 0, y: 0 };\n    }\n    const 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\nexport { PanSession };\n","function createLock(name) {\n    let lock = null;\n    return () => {\n        const openLock = () => {\n            lock = null;\n        };\n        if (lock === null) {\n            lock = name;\n            return openLock;\n        }\n        return false;\n    };\n}\nconst globalHorizontalLock = createLock(\"dragHorizontal\");\nconst globalVerticalLock = createLock(\"dragVertical\");\nfunction getGlobalLock(drag) {\n    let lock = false;\n    if (drag === \"y\") {\n        lock = globalVerticalLock();\n    }\n    else if (drag === \"x\") {\n        lock = globalHorizontalLock();\n    }\n    else {\n        const openHorizontal = globalHorizontalLock();\n        const openVertical = globalVerticalLock();\n        if (openHorizontal && openVertical) {\n            lock = () => {\n                openHorizontal();\n                openVertical();\n            };\n        }\n        else {\n            // Release the locks because we don't use them\n            if (openHorizontal)\n                openHorizontal();\n            if (openVertical)\n                openVertical();\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    const openGestureLock = getGlobalLock(true);\n    if (!openGestureLock)\n        return true;\n    openGestureLock();\n    return false;\n}\n\nexport { createLock, getGlobalLock, isDragActive };\n","import { mix } from '../../utils/mix.mjs';\n\nfunction calcLength(axis) {\n    return axis.max - axis.min;\n}\nfunction isNear(value, target = 0, maxDistance = 0.01) {\n    return Math.abs(value - target) <= maxDistance;\n}\nfunction calcAxisDelta(delta, source, target, origin = 0.5) {\n    delta.origin = origin;\n    delta.originPoint = 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        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 ? origin.originX : undefined);\n    calcAxisDelta(delta.y, source.y, target.y, origin ? origin.originY : undefined);\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\nexport { calcAxisDelta, calcBoxDelta, calcLength, calcRelativeAxis, calcRelativeAxisPosition, calcRelativeBox, calcRelativePosition, isNear };\n","import { progress } from '../../../utils/progress.mjs';\nimport { calcLength } from '../../../projection/geometry/delta-calc.mjs';\nimport { clamp } from '../../../utils/clamp.mjs';\nimport { mix } from '../../../utils/mix.mjs';\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, { min, max }, elastic) {\n    if (min !== undefined && point < min) {\n        // If we have a min point defined, and this is outside of that, constrain\n        point = elastic ? 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 ? 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, { top, left, bottom, 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    let min = constraintsAxis.min - layoutAxis.min;\n    let 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        [min, max] = [max, min];\n    }\n    return { min, 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    let origin = 0.5;\n    const sourceLength = calcLength(source);\n    const targetLength = calcLength(target);\n    if (targetLength > sourceLength) {\n        origin = progress(target.min, target.max - sourceLength, source.min);\n    }\n    else if (sourceLength > targetLength) {\n        origin = progress(source.min, source.max - targetLength, target.min);\n    }\n    return clamp(0, 1, origin);\n}\n/**\n * Rebase the calculated viewport constraints relative to the layout.min point.\n */\nfunction rebaseAxisConstraints(layout, constraints) {\n    const 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}\nconst defaultElastic = 0.35;\n/**\n * Accepts a dragElastic prop and returns resolved elastic values for each axis.\n */\nfunction resolveDragElastic(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    return typeof dragElastic === \"number\"\n        ? dragElastic\n        : dragElastic[label] || 0;\n}\n\nexport { applyConstraints, calcOrigin, calcRelativeAxisConstraints, calcRelativeConstraints, calcViewportAxisConstraints, calcViewportConstraints, defaultElastic, rebaseAxisConstraints, resolveAxisElastic, resolveDragElastic, resolvePointElastic };\n","const createAxisDelta = () => ({\n    translate: 0,\n    scale: 1,\n    origin: 0,\n    originPoint: 0,\n});\nconst createDelta = () => ({\n    x: createAxisDelta(),\n    y: createAxisDelta(),\n});\nconst createAxis = () => ({ min: 0, max: 0 });\nconst createBox = () => ({\n    x: createAxis(),\n    y: createAxis(),\n});\n\nexport { createAxis, createAxisDelta, createBox, createDelta };\n","function eachAxis(callback) {\n    return [callback(\"x\"), callback(\"y\")];\n}\n\nexport { eachAxis };\n","/**\n * Bounding boxes tend to be defined as top, left, right, bottom. For various operations\n * it's easier to consider each axis individually. This function returns a bounding box\n * as a map of single-axis min/max values.\n */\nfunction convertBoundingBoxToBox({ top, left, right, bottom, }) {\n    return {\n        x: { min: left, max: right },\n        y: { min: top, max: bottom },\n    };\n}\nfunction convertBoxToBoundingBox({ x, y }) {\n    return { top: y.min, right: x.max, bottom: y.max, left: x.min };\n}\n/**\n * Applies a TransformPoint function to a bounding box. TransformPoint is usually a function\n * provided by Framer to allow measured points to be corrected for device scaling. This is used\n * when measuring DOM elements and DOM event points.\n */\nfunction transformBoxPoints(point, transformPoint) {\n    if (!transformPoint)\n        return point;\n    const topLeft = transformPoint({ x: point.left, y: point.top });\n    const bottomRight = transformPoint({ x: point.right, y: point.bottom });\n    return {\n        top: topLeft.y,\n        left: topLeft.x,\n        bottom: bottomRight.y,\n        right: bottomRight.x,\n    };\n}\n\nexport { convertBoundingBoxToBox, convertBoxToBoundingBox, transformBoxPoints };\n","function isIdentityScale(scale) {\n    return scale === undefined || scale === 1;\n}\nfunction hasScale({ scale, scaleX, scaleY }) {\n    return (!isIdentityScale(scale) ||\n        !isIdentityScale(scaleX) ||\n        !isIdentityScale(scaleY));\n}\nfunction hasTransform(values) {\n    return (hasScale(values) ||\n        has2DTranslate(values) ||\n        values.z ||\n        values.rotate ||\n        values.rotateX ||\n        values.rotateY);\n}\nfunction has2DTranslate(values) {\n    return is2DTranslate(values.x) || is2DTranslate(values.y);\n}\nfunction is2DTranslate(value) {\n    return value && value !== \"0%\";\n}\n\nexport { has2DTranslate, hasScale, hasTransform };\n","import { mix } from '../../utils/mix.mjs';\nimport { hasTransform } from '../utils/has-transform.mjs';\n\n/**\n * Scales a point based on a factor and an originPoint\n */\nfunction scalePoint(point, scale, originPoint) {\n    const distanceFromOrigin = point - originPoint;\n    const scaled = scale * distanceFromOrigin;\n    return originPoint + scaled;\n}\n/**\n * Applies a translate/scale delta to a point\n */\nfunction applyPointDelta(point, translate, scale, originPoint, boxScale) {\n    if (boxScale !== undefined) {\n        point = scalePoint(point, boxScale, originPoint);\n    }\n    return scalePoint(point, scale, originPoint) + translate;\n}\n/**\n * Applies a translate/scale delta to an axis\n */\nfunction applyAxisDelta(axis, translate = 0, scale = 1, originPoint, boxScale) {\n    axis.min = applyPointDelta(axis.min, translate, scale, originPoint, boxScale);\n    axis.max = applyPointDelta(axis.max, translate, scale, originPoint, boxScale);\n}\n/**\n * Applies a translate/scale delta to a box\n */\nfunction applyBoxDelta(box, { x, y }) {\n    applyAxisDelta(box.x, x.translate, x.scale, x.originPoint);\n    applyAxisDelta(box.y, y.translate, y.scale, y.originPoint);\n}\n/**\n * Apply a tree of deltas to a box. We do this to calculate the effect of all the transforms\n * in a tree upon our box before then calculating how to project it into our desired viewport-relative box\n *\n * This is the final nested loop within updateLayoutDelta for future refactoring\n */\nfunction applyTreeDeltas(box, treeScale, treePath, isSharedTransition = false) {\n    const treeLength = treePath.length;\n    if (!treeLength)\n        return;\n    // Reset the treeScale\n    treeScale.x = treeScale.y = 1;\n    let node;\n    let delta;\n    for (let i = 0; i < treeLength; i++) {\n        node = treePath[i];\n        delta = node.projectionDelta;\n        /**\n         * TODO: Prefer to remove this, but currently we have motion components with\n         * display: contents in Framer.\n         */\n        const instance = node.instance;\n        if (instance &&\n            instance.style &&\n            instance.style.display === \"contents\") {\n            continue;\n        }\n        if (isSharedTransition &&\n            node.options.layoutScroll &&\n            node.scroll &&\n            node !== node.root) {\n            transformBox(box, {\n                x: -node.scroll.offset.x,\n                y: -node.scroll.offset.y,\n            });\n        }\n        if (delta) {\n            // Incoporate each ancestor's scale into a culmulative treeScale for this component\n            treeScale.x *= delta.x.scale;\n            treeScale.y *= delta.y.scale;\n            // Apply each ancestor's calculated delta into this component's recorded layout box\n            applyBoxDelta(box, delta);\n        }\n        if (isSharedTransition && hasTransform(node.latestValues)) {\n            transformBox(box, node.latestValues);\n        }\n    }\n    /**\n     * Snap tree scale back to 1 if it's within a non-perceivable threshold.\n     * This will help reduce useless scales getting rendered.\n     */\n    treeScale.x = snapToDefault(treeScale.x);\n    treeScale.y = snapToDefault(treeScale.y);\n}\nfunction snapToDefault(scale) {\n    if (Number.isInteger(scale))\n        return scale;\n    return scale > 1.0000000000001 || scale < 0.999999999999 ? scale : 1;\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, [key, scaleKey, originKey]) {\n    const axisOrigin = transforms[originKey] !== undefined ? transforms[originKey] : 0.5;\n    const originPoint = 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 */\nconst xKeys = [\"x\", \"scaleX\", \"originX\"];\nconst yKeys = [\"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);\n    transformAxis(box.y, transform, yKeys);\n}\n\nexport { applyAxisDelta, applyBoxDelta, applyPointDelta, applyTreeDeltas, scalePoint, transformAxis, transformBox, translateAxis };\n","import { convertBoundingBoxToBox, transformBoxPoints } from '../geometry/conversion.mjs';\nimport { translateAxis } from '../geometry/delta-apply.mjs';\n\nfunction measureViewportBox(instance, transformPoint) {\n    return convertBoundingBoxToBox(transformBoxPoints(instance.getBoundingClientRect(), transformPoint));\n}\nfunction measurePageBox(element, rootProjectionNode, transformPagePoint) {\n    const viewportBox = measureViewportBox(element, transformPagePoint);\n    const { scroll } = rootProjectionNode;\n    if (scroll) {\n        translateAxis(viewportBox.x, scroll.offset.x);\n        translateAxis(viewportBox.y, scroll.offset.y);\n    }\n    return viewportBox;\n}\n\nexport { measurePageBox, measureViewportBox };\n","const instantAnimationState = {\n    current: false,\n};\n\nexport { instantAnimationState };\n","// Accepts an easing function and returns a new one that outputs mirrored values for\n// the second half of the animation. Turns easeIn into easeInOut.\nconst mirrorEasing = (easing) => (p) => p <= 0.5 ? easing(2 * p) / 2 : (2 - easing(2 * (1 - p))) / 2;\n\nexport { mirrorEasing };\n","// Accepts an easing function and returns a new one that outputs reversed values.\n// Turns easeIn into easeOut.\nconst reverseEasing = (easing) => (p) => 1 - easing(1 - p);\n\nexport { reverseEasing };\n","import { mirrorEasing } from './modifiers/mirror.mjs';\nimport { reverseEasing } from './modifiers/reverse.mjs';\n\nconst easeIn = (p) => p * p;\nconst easeOut = reverseEasing(easeIn);\nconst easeInOut = mirrorEasing(easeIn);\n\nexport { easeIn, easeInOut, easeOut };\n","import { noop } from '../utils/noop.mjs';\n\n/*\n  Bezier function generator\n  This has been modified from Gaëtan Renaudeau's BezierEasing\n  https://github.com/gre/bezier-easing/blob/master/src/index.js\n  https://github.com/gre/bezier-easing/blob/master/LICENSE\n  \n  I've removed the newtonRaphsonIterate algo because in benchmarking it\n  wasn't noticiably faster than binarySubdivision, indeed removing it\n  usually improved times, depending on the curve.\n  I also removed the lookup table, as for the added bundle size and loop we're\n  only cutting ~4 or so subdivision iterations. I bumped the max iterations up\n  to 12 to compensate and this still tended to be faster for no perceivable\n  loss in accuracy.\n  Usage\n    const easeOut = cubicBezier(.17,.67,.83,.67);\n    const x = easeOut(0.5); // returns 0.627...\n*/\n// Returns x(t) given t, x1, and x2, or y(t) given t, y1, and y2.\nconst calcBezier = (t, a1, a2) => (((1.0 - 3.0 * a2 + 3.0 * a1) * t + (3.0 * a2 - 6.0 * a1)) * t + 3.0 * a1) *\n    t;\nconst subdivisionPrecision = 0.0000001;\nconst subdivisionMaxIterations = 12;\nfunction binarySubdivide(x, lowerBound, upperBound, mX1, mX2) {\n    let currentX;\n    let currentT;\n    let i = 0;\n    do {\n        currentT = lowerBound + (upperBound - lowerBound) / 2.0;\n        currentX = calcBezier(currentT, mX1, mX2) - x;\n        if (currentX > 0.0) {\n            upperBound = currentT;\n        }\n        else {\n            lowerBound = currentT;\n        }\n    } while (Math.abs(currentX) > subdivisionPrecision &&\n        ++i < subdivisionMaxIterations);\n    return currentT;\n}\nfunction cubicBezier(mX1, mY1, mX2, mY2) {\n    // If this is a linear gradient, return linear easing\n    if (mX1 === mY1 && mX2 === mY2)\n        return noop;\n    const getTForX = (aX) => binarySubdivide(aX, 0, 1, mX1, mX2);\n    // If animation is at start/end, return t without easing\n    return (t) => t === 0 || t === 1 ? t : calcBezier(getTForX(t), mY1, mY2);\n}\n\nexport { cubicBezier };\n","import { mirrorEasing } from './modifiers/mirror.mjs';\nimport { reverseEasing } from './modifiers/reverse.mjs';\n\nconst circIn = (p) => 1 - Math.sin(Math.acos(p));\nconst circOut = reverseEasing(circIn);\nconst circInOut = mirrorEasing(circOut);\n\nexport { circIn, circInOut, circOut };\n","import { cubicBezier } from './cubic-bezier.mjs';\nimport { mirrorEasing } from './modifiers/mirror.mjs';\nimport { reverseEasing } from './modifiers/reverse.mjs';\n\nconst backOut = cubicBezier(0.33, 1.53, 0.69, 0.99);\nconst backIn = reverseEasing(backOut);\nconst backInOut = mirrorEasing(backIn);\n\nexport { backIn, backInOut, backOut };\n","import { invariant } from '../../utils/errors.mjs';\nimport { cubicBezier } from '../../easing/cubic-bezier.mjs';\nimport { noop } from '../../utils/noop.mjs';\nimport { easeIn, easeInOut, easeOut } from '../../easing/ease.mjs';\nimport { circIn, circInOut, circOut } from '../../easing/circ.mjs';\nimport { backIn, backInOut, backOut } from '../../easing/back.mjs';\nimport { anticipate } from '../../easing/anticipate.mjs';\n\nconst easingLookup = {\n    linear: noop,\n    easeIn,\n    easeInOut,\n    easeOut,\n    circIn,\n    circInOut,\n    circOut,\n    backIn,\n    backInOut,\n    backOut,\n    anticipate,\n};\nconst easingDefinitionToFunction = (definition) => {\n    if (Array.isArray(definition)) {\n        // If cubic bezier definition, create bezier curve\n        invariant(definition.length === 4, `Cubic bezier arrays must contain four numerical values.`);\n        const [x1, y1, x2, y2] = definition;\n        return cubicBezier(x1, y1, x2, y2);\n    }\n    else if (typeof definition === \"string\") {\n        // Else lookup from table\n        invariant(easingLookup[definition] !== undefined, `Invalid easing type '${definition}'`);\n        return easingLookup[definition];\n    }\n    return definition;\n};\nconst isEasingArray = (ease) => {\n    return Array.isArray(ease) && typeof ease[0] !== \"number\";\n};\n\nexport { easingDefinitionToFunction, isEasingArray };\n","import { backIn } from './back.mjs';\n\nconst anticipate = (p) => (p *= 2) < 1 ? 0.5 * backIn(p) : 0.5 * (2 - Math.pow(2, -10 * (p - 1)));\n\nexport { anticipate };\n","import { easeInOut } from '../../easing/ease.mjs';\nimport { interpolate } from '../../utils/interpolate.mjs';\nimport { defaultOffset } from '../../utils/offsets/default.mjs';\nimport { convertOffsetToTimes } from '../../utils/offsets/time.mjs';\nimport { isEasingArray, easingDefinitionToFunction } from '../utils/easing.mjs';\n\nfunction defaultEasing(values, easing) {\n    return values.map(() => easing || easeInOut).splice(0, values.length - 1);\n}\nfunction keyframes({ keyframes: keyframeValues, ease = easeInOut, times, duration = 300, }) {\n    keyframeValues = [...keyframeValues];\n    /**\n     * Easing functions can be externally defined as strings. Here we convert them\n     * into actual functions.\n     */\n    const easingFunctions = isEasingArray(ease)\n        ? ease.map(easingDefinitionToFunction)\n        : easingDefinitionToFunction(ease);\n    /**\n     * This is the Iterator-spec return value. We ensure it's mutable rather than using a generator\n     * to reduce GC during animation.\n     */\n    const state = {\n        done: false,\n        value: keyframeValues[0],\n    };\n    /**\n     * Create a times array based on the provided 0-1 offsets\n     */\n    const absoluteTimes = convertOffsetToTimes(\n    // Only use the provided offsets if they're the correct length\n    // TODO Maybe we should warn here if there's a length mismatch\n    times && times.length === keyframeValues.length\n        ? times\n        : defaultOffset(keyframeValues), duration);\n    function createInterpolator() {\n        return interpolate(absoluteTimes, keyframeValues, {\n            ease: Array.isArray(easingFunctions)\n                ? easingFunctions\n                : defaultEasing(keyframeValues, easingFunctions),\n        });\n    }\n    let interpolator = createInterpolator();\n    return {\n        next: (t) => {\n            state.value = interpolator(t);\n            state.done = t >= duration;\n            return state;\n        },\n        flipTarget: () => {\n            keyframeValues.reverse();\n            interpolator = createInterpolator();\n        },\n    };\n}\n\nexport { defaultEasing, keyframes };\n","function convertOffsetToTimes(offset, duration) {\n    return offset.map((o) => o * duration);\n}\n\nexport { convertOffsetToTimes };\n","import { warning } from '../../utils/errors.mjs';\nimport { clamp } from '../../utils/clamp.mjs';\n\nconst safeMin = 0.001;\nconst minDuration = 0.01;\nconst maxDuration = 10.0;\nconst minDamping = 0.05;\nconst maxDamping = 1;\nfunction findSpring({ duration = 800, bounce = 0.25, velocity = 0, mass = 1, }) {\n    let envelope;\n    let derivative;\n    warning(duration <= maxDuration * 1000, \"Spring duration must be 10 seconds or less\");\n    let dampingRatio = 1 - bounce;\n    /**\n     * Restrict dampingRatio and duration to within acceptable ranges.\n     */\n    dampingRatio = clamp(minDamping, maxDamping, dampingRatio);\n    duration = clamp(minDuration, maxDuration, duration / 1000);\n    if (dampingRatio < 1) {\n        /**\n         * Underdamped spring\n         */\n        envelope = (undampedFreq) => {\n            const exponentialDecay = undampedFreq * dampingRatio;\n            const delta = exponentialDecay * duration;\n            const a = exponentialDecay - velocity;\n            const b = calcAngularFreq(undampedFreq, dampingRatio);\n            const c = Math.exp(-delta);\n            return safeMin - (a / b) * c;\n        };\n        derivative = (undampedFreq) => {\n            const exponentialDecay = undampedFreq * dampingRatio;\n            const delta = exponentialDecay * duration;\n            const d = delta * velocity + velocity;\n            const e = Math.pow(dampingRatio, 2) * Math.pow(undampedFreq, 2) * duration;\n            const f = Math.exp(-delta);\n            const g = calcAngularFreq(Math.pow(undampedFreq, 2), dampingRatio);\n            const factor = -envelope(undampedFreq) + safeMin > 0 ? -1 : 1;\n            return (factor * ((d - e) * f)) / g;\n        };\n    }\n    else {\n        /**\n         * Critically-damped spring\n         */\n        envelope = (undampedFreq) => {\n            const a = Math.exp(-undampedFreq * duration);\n            const b = (undampedFreq - velocity) * duration + 1;\n            return -safeMin + a * b;\n        };\n        derivative = (undampedFreq) => {\n            const a = Math.exp(-undampedFreq * duration);\n            const b = (velocity - undampedFreq) * (duration * duration);\n            return a * b;\n        };\n    }\n    const initialGuess = 5 / duration;\n    const undampedFreq = approximateRoot(envelope, derivative, initialGuess);\n    duration = duration * 1000;\n    if (isNaN(undampedFreq)) {\n        return {\n            stiffness: 100,\n            damping: 10,\n            duration,\n        };\n    }\n    else {\n        const stiffness = Math.pow(undampedFreq, 2) * mass;\n        return {\n            stiffness,\n            damping: dampingRatio * 2 * Math.sqrt(mass * stiffness),\n            duration,\n        };\n    }\n}\nconst rootIterations = 12;\nfunction approximateRoot(envelope, derivative, initialGuess) {\n    let result = initialGuess;\n    for (let i = 1; i < rootIterations; i++) {\n        result = result - envelope(result) / derivative(result);\n    }\n    return result;\n}\nfunction calcAngularFreq(undampedFreq, dampingRatio) {\n    return undampedFreq * Math.sqrt(1 - dampingRatio * dampingRatio);\n}\n\nexport { calcAngularFreq, findSpring, maxDamping, maxDuration, minDamping, minDuration };\n","import { findSpring, calcAngularFreq } from './find-spring.mjs';\nimport { velocityPerSecond } from '../../utils/velocity-per-second.mjs';\n\nconst durationKeys = [\"duration\", \"bounce\"];\nconst physicsKeys = [\"stiffness\", \"damping\", \"mass\"];\nfunction isSpringType(options, keys) {\n    return keys.some((key) => options[key] !== undefined);\n}\nfunction getSpringOptions(options) {\n    let springOptions = {\n        velocity: 0.0,\n        stiffness: 100,\n        damping: 10,\n        mass: 1.0,\n        isResolvedFromDuration: false,\n        ...options,\n    };\n    // stiffness/damping/mass overrides duration/bounce\n    if (!isSpringType(options, physicsKeys) &&\n        isSpringType(options, durationKeys)) {\n        const derived = findSpring(options);\n        springOptions = {\n            ...springOptions,\n            ...derived,\n            velocity: 0.0,\n            mass: 1.0,\n        };\n        springOptions.isResolvedFromDuration = true;\n    }\n    return springOptions;\n}\nconst velocitySampleDuration = 5;\n/**\n * This is based on the spring implementation of Wobble https://github.com/skevy/wobble\n */\nfunction spring({ keyframes, restDelta, restSpeed, ...options }) {\n    let origin = keyframes[0];\n    let target = keyframes[keyframes.length - 1];\n    /**\n     * This is the Iterator-spec return value. We ensure it's mutable rather than using a generator\n     * to reduce GC during animation.\n     */\n    const state = { done: false, value: origin };\n    const { stiffness, damping, mass, velocity, duration, isResolvedFromDuration, } = getSpringOptions(options);\n    let resolveSpring = zero;\n    let initialVelocity = velocity ? -(velocity / 1000) : 0.0;\n    const dampingRatio = damping / (2 * Math.sqrt(stiffness * mass));\n    function createSpring() {\n        const initialDelta = target - origin;\n        const undampedAngularFreq = Math.sqrt(stiffness / mass) / 1000;\n        /**\n         * If we're working on a granular scale, use smaller defaults for determining\n         * when the spring is finished.\n         *\n         * These defaults have been selected emprically based on what strikes a good\n         * ratio between feeling good and finishing as soon as changes are imperceptible.\n         */\n        const isGranularScale = Math.abs(initialDelta) < 5;\n        restSpeed || (restSpeed = isGranularScale ? 0.01 : 2);\n        restDelta || (restDelta = isGranularScale ? 0.005 : 0.5);\n        if (dampingRatio < 1) {\n            const angularFreq = calcAngularFreq(undampedAngularFreq, dampingRatio);\n            // Underdamped spring\n            resolveSpring = (t) => {\n                const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n                return (target -\n                    envelope *\n                        (((initialVelocity +\n                            dampingRatio * undampedAngularFreq * initialDelta) /\n                            angularFreq) *\n                            Math.sin(angularFreq * t) +\n                            initialDelta * Math.cos(angularFreq * t)));\n            };\n        }\n        else if (dampingRatio === 1) {\n            // Critically damped spring\n            resolveSpring = (t) => target -\n                Math.exp(-undampedAngularFreq * t) *\n                    (initialDelta +\n                        (initialVelocity + undampedAngularFreq * initialDelta) *\n                            t);\n        }\n        else {\n            // Overdamped spring\n            const dampedAngularFreq = undampedAngularFreq * Math.sqrt(dampingRatio * dampingRatio - 1);\n            resolveSpring = (t) => {\n                const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n                // When performing sinh or cosh values can hit Infinity so we cap them here\n                const freqForT = Math.min(dampedAngularFreq * t, 300);\n                return (target -\n                    (envelope *\n                        ((initialVelocity +\n                            dampingRatio * undampedAngularFreq * initialDelta) *\n                            Math.sinh(freqForT) +\n                            dampedAngularFreq *\n                                initialDelta *\n                                Math.cosh(freqForT))) /\n                        dampedAngularFreq);\n            };\n        }\n    }\n    createSpring();\n    return {\n        next: (t) => {\n            const current = resolveSpring(t);\n            if (!isResolvedFromDuration) {\n                let currentVelocity = initialVelocity;\n                if (t !== 0) {\n                    /**\n                     * We only need to calculate velocity for under-damped springs\n                     * as over- and critically-damped springs can't overshoot, so\n                     * checking only for displacement is enough.\n                     */\n                    if (dampingRatio < 1) {\n                        const prevT = Math.max(0, t - velocitySampleDuration);\n                        currentVelocity = velocityPerSecond(current - resolveSpring(prevT), t - prevT);\n                    }\n                    else {\n                        currentVelocity = 0;\n                    }\n                }\n                const isBelowVelocityThreshold = Math.abs(currentVelocity) <= restSpeed;\n                const isBelowDisplacementThreshold = Math.abs(target - current) <= restDelta;\n                state.done =\n                    isBelowVelocityThreshold && isBelowDisplacementThreshold;\n            }\n            else {\n                state.done = t >= duration;\n            }\n            state.value = state.done ? target : current;\n            return state;\n        },\n        flipTarget: () => {\n            initialVelocity = -initialVelocity;\n            [origin, target] = [target, origin];\n            createSpring();\n        },\n    };\n}\nspring.needsInterpolation = (a, b) => typeof a === \"string\" || typeof b === \"string\";\nconst zero = (_t) => 0;\n\nexport { spring };\n","import { keyframes } from './keyframes.mjs';\nimport { spring } from './spring.mjs';\nimport { decay } from './decay.mjs';\nimport { sync, cancelSync } from '../../frameloop/index.mjs';\nimport { interpolate } from '../../utils/interpolate.mjs';\n\nconst types = {\n    decay,\n    keyframes: keyframes,\n    tween: keyframes,\n    spring,\n};\nfunction loopElapsed(elapsed, duration, delay = 0) {\n    return elapsed - duration - delay;\n}\nfunction reverseElapsed(elapsed, duration = 0, delay = 0, isForwardPlayback = true) {\n    return isForwardPlayback\n        ? loopElapsed(duration + -elapsed, duration, delay)\n        : duration - (elapsed - duration) + delay;\n}\nfunction hasRepeatDelayElapsed(elapsed, duration, delay, isForwardPlayback) {\n    return isForwardPlayback ? elapsed >= duration + delay : elapsed <= -delay;\n}\nconst framesync = (update) => {\n    const passTimestamp = ({ delta }) => update(delta);\n    return {\n        start: () => sync.update(passTimestamp, true),\n        stop: () => cancelSync.update(passTimestamp),\n    };\n};\nfunction animateValue({ duration, driver = framesync, elapsed = 0, repeat: repeatMax = 0, repeatType = \"loop\", repeatDelay = 0, keyframes: keyframes$1, autoplay = true, onPlay, onStop, onComplete, onRepeat, onUpdate, type = \"keyframes\", ...options }) {\n    const initialElapsed = elapsed;\n    let driverControls;\n    let repeatCount = 0;\n    let computedDuration = duration;\n    let isComplete = false;\n    let isForwardPlayback = true;\n    let interpolateFromNumber;\n    const animator = types[keyframes$1.length > 2 ? \"keyframes\" : type] || keyframes;\n    const origin = keyframes$1[0];\n    const target = keyframes$1[keyframes$1.length - 1];\n    let state = { done: false, value: origin };\n    /**\n     * If this value needs interpolation (ie is non-numerical), set up an interpolator.\n     * TODO: Keyframes animation also performs this step. This could be removed so it only happens here.\n     */\n    const { needsInterpolation } = animator;\n    if (needsInterpolation && needsInterpolation(origin, target)) {\n        interpolateFromNumber = interpolate([0, 100], [origin, target], {\n            clamp: false,\n        });\n        keyframes$1 = [0, 100];\n    }\n    const animation = animator({\n        ...options,\n        duration,\n        keyframes: keyframes$1,\n    });\n    function repeat() {\n        repeatCount++;\n        if (repeatType === \"reverse\") {\n            isForwardPlayback = repeatCount % 2 === 0;\n            elapsed = reverseElapsed(elapsed, computedDuration, repeatDelay, isForwardPlayback);\n        }\n        else {\n            elapsed = loopElapsed(elapsed, computedDuration, repeatDelay);\n            if (repeatType === \"mirror\")\n                animation.flipTarget();\n        }\n        isComplete = false;\n        onRepeat && onRepeat();\n    }\n    function complete() {\n        driverControls && driverControls.stop();\n        onComplete && onComplete();\n    }\n    function update(delta) {\n        if (!isForwardPlayback)\n            delta = -delta;\n        elapsed += delta;\n        if (!isComplete) {\n            state = animation.next(Math.max(0, elapsed));\n            if (interpolateFromNumber)\n                state.value = interpolateFromNumber(state.value);\n            isComplete = isForwardPlayback ? state.done : elapsed <= 0;\n        }\n        onUpdate && onUpdate(state.value);\n        if (isComplete) {\n            if (repeatCount === 0) {\n                computedDuration =\n                    computedDuration !== undefined ? computedDuration : elapsed;\n            }\n            if (repeatCount < repeatMax) {\n                hasRepeatDelayElapsed(elapsed, computedDuration, repeatDelay, isForwardPlayback) && repeat();\n            }\n            else {\n                complete();\n            }\n        }\n    }\n    function play() {\n        onPlay && onPlay();\n        driverControls = driver(update);\n        driverControls.start();\n    }\n    autoplay && play();\n    return {\n        stop: () => {\n            onStop && onStop();\n            driverControls && driverControls.stop();\n        },\n        /**\n         * Set the current time of the animation. This is purposefully\n         * mirroring the WAAPI animation API to make them interchanagable.\n         * Going forward this file should be ported more towards\n         * https://github.com/motiondivision/motionone/blob/main/packages/animation/src/Animation.ts\n         * Which behaviourally adheres to WAAPI as far as possible.\n         *\n         * WARNING: This is not safe to use for most animations. We currently\n         * only use it for handoff from WAAPI within Framer.\n         *\n         * This animation function consumes time every frame rather than being sampled for time.\n         * So the sample() method performs some headless frames to ensure\n         * repeats are handled correctly. Ideally in the future we will replace\n         * that method with this, once repeat calculations are pure.\n         */\n        set currentTime(t) {\n            elapsed = initialElapsed;\n            update(t);\n        },\n        /**\n         * animate() can't yet be sampled for time, instead it\n         * consumes time. So to sample it we have to run a low\n         * temporal-resolution version.\n         */\n        sample: (t) => {\n            elapsed = initialElapsed;\n            const sampleResolution = duration && typeof duration === \"number\"\n                ? Math.max(duration * 0.5, 50)\n                : 50;\n            let sampleElapsed = 0;\n            update(0);\n            while (sampleElapsed <= t) {\n                const remaining = t - sampleElapsed;\n                update(Math.min(remaining, sampleResolution));\n                sampleElapsed += sampleResolution;\n            }\n            return state;\n        },\n    };\n}\n\nexport { animateValue, hasRepeatDelayElapsed, loopElapsed, reverseElapsed };\n","function decay({ \n/**\n * The decay animation dynamically calculates an end of the animation\n * based on the initial keyframe, so we only need to define a single keyframe\n * as default.\n */\nkeyframes = [0], velocity = 0, power = 0.8, timeConstant = 350, restDelta = 0.5, modifyTarget, }) {\n    const origin = keyframes[0];\n    /**\n     * This is the Iterator-spec return value. We ensure it's mutable rather than using a generator\n     * to reduce GC during animation.\n     */\n    const state = { done: false, value: origin };\n    let amplitude = power * velocity;\n    const ideal = origin + amplitude;\n    const target = modifyTarget === undefined ? ideal : modifyTarget(ideal);\n    /**\n     * If the target has changed we need to re-calculate the amplitude, otherwise\n     * the animation will start from the wrong position.\n     */\n    if (target !== ideal)\n        amplitude = target - origin;\n    return {\n        next: (t) => {\n            const delta = -amplitude * Math.exp(-t / timeConstant);\n            state.done = !(delta > restDelta || delta < -restDelta);\n            state.value = state.done ? target : target + delta;\n            return state;\n        },\n        flipTarget: () => { },\n    };\n}\n\nexport { decay };\n","function isWaapiSupportedEasing(easing) {\n    return (!easing || // Default easing\n        Array.isArray(easing) || // Bezier curve\n        (typeof easing === \"string\" && supportedWaapiEasing[easing]));\n}\nconst cubicBezierAsString = ([a, b, c, d]) => `cubic-bezier(${a}, ${b}, ${c}, ${d})`;\nconst supportedWaapiEasing = {\n    linear: \"linear\",\n    ease: \"ease\",\n    easeIn: \"ease-in\",\n    easeOut: \"ease-out\",\n    easeInOut: \"ease-in-out\",\n    circIn: cubicBezierAsString([0, 0.65, 0.55, 1]),\n    circOut: cubicBezierAsString([0.55, 0, 1, 0.45]),\n    backIn: cubicBezierAsString([0.31, 0.01, 0.66, -0.59]),\n    backOut: cubicBezierAsString([0.33, 1.53, 0.69, 0.99]),\n};\nfunction mapEasingToNativeEasing(easing) {\n    if (!easing)\n        return undefined;\n    return Array.isArray(easing)\n        ? cubicBezierAsString(easing)\n        : supportedWaapiEasing[easing];\n}\n\nexport { cubicBezierAsString, isWaapiSupportedEasing, mapEasingToNativeEasing, supportedWaapiEasing };\n","const featureTests = {\n    waapi: () => Object.hasOwnProperty.call(Element.prototype, \"animate\"),\n};\nconst results = {};\nconst supports = {};\n/**\n * Generate features tests that cache their results.\n */\nfor (const key in featureTests) {\n    supports[key] = () => {\n        if (results[key] === undefined)\n            results[key] = featureTests[key]();\n        return results[key];\n    };\n}\n\nexport { supports };\n","import { sync } from '../../frameloop/index.mjs';\nimport { animateValue } from '../legacy-popmotion/index.mjs';\nimport { animateStyle } from './index.mjs';\nimport { isWaapiSupportedEasing } from './easing.mjs';\nimport { supports } from './supports.mjs';\nimport { getFinalKeyframe } from './utils/get-final-keyframe.mjs';\n\n/**\n * A list of values that can be hardware-accelerated.\n */\nconst acceleratedValues = new Set([\n    \"opacity\",\n    \"clipPath\",\n    \"filter\",\n    \"transform\",\n]);\n/**\n * 10ms is chosen here as it strikes a balance between smooth\n * results (more than one keyframe per frame at 60fps) and\n * keyframe quantity.\n */\nconst sampleDelta = 10; //ms\nfunction createAcceleratedAnimation(value, valueName, { onUpdate, onComplete, ...options }) {\n    const canAccelerateAnimation = supports.waapi() &&\n        acceleratedValues.has(valueName) &&\n        !options.repeatDelay &&\n        options.repeatType !== \"mirror\" &&\n        options.damping !== 0;\n    if (!canAccelerateAnimation)\n        return false;\n    let { keyframes, duration = 300, elapsed = 0, ease } = options;\n    /**\n     * If this animation needs pre-generated keyframes then generate.\n     */\n    if (options.type === \"spring\" || !isWaapiSupportedEasing(options.ease)) {\n        /**\n         * If we need to pre-generate keyframes and repeat is infinite then\n         * early return as this will lock the thread.\n         */\n        if (options.repeat === Infinity)\n            return;\n        const sampleAnimation = animateValue({ ...options, elapsed: 0 });\n        let state = { done: false, value: keyframes[0] };\n        const pregeneratedKeyframes = [];\n        /**\n         * Bail after 20 seconds of pre-generated keyframes as it's likely\n         * we're heading for an infinite loop.\n         */\n        let t = 0;\n        while (!state.done && t < 20000) {\n            state = sampleAnimation.sample(t);\n            pregeneratedKeyframes.push(state.value);\n            t += sampleDelta;\n        }\n        keyframes = pregeneratedKeyframes;\n        duration = t - sampleDelta;\n        ease = \"linear\";\n    }\n    const animation = animateStyle(value.owner.current, valueName, keyframes, {\n        ...options,\n        delay: -elapsed,\n        duration,\n        /**\n         * This function is currently not called if ease is provided\n         * as a function so the cast is safe.\n         *\n         * However it would be possible for a future refinement to port\n         * in easing pregeneration from Motion One for browsers that\n         * support the upcoming `linear()` easing function.\n         */\n        ease: ease,\n    });\n    /**\n     * Prefer the `onfinish` prop as it's more widely supported than\n     * the `finished` promise.\n     *\n     * Here, we synchronously set the provided MotionValue to the end\n     * keyframe. If we didn't, when the WAAPI animation is finished it would\n     * be removed from the element which would then revert to its old styles.\n     */\n    animation.onfinish = () => {\n        value.set(getFinalKeyframe(keyframes, options));\n        sync.update(() => animation.cancel());\n        onComplete && onComplete();\n    };\n    /**\n     * Animation interrupt callback.\n     */\n    return {\n        get currentTime() {\n            return animation.currentTime || 0;\n        },\n        set currentTime(t) {\n            animation.currentTime = t;\n        },\n        stop: () => {\n            /**\n             * WAAPI doesn't natively have any interruption capabilities.\n             *\n             * Rather than read commited styles back out of the DOM, we can\n             * create a renderless JS animation and sample it twice to calculate\n             * its current value, \"previous\" value, and therefore allow\n             * Motion to calculate velocity for any subsequent animation.\n             */\n            const { currentTime } = animation;\n            if (currentTime) {\n                const sampleAnimation = animateValue({\n                    ...options,\n                    autoplay: false,\n                });\n                value.setWithVelocity(sampleAnimation.sample(currentTime - sampleDelta).value, sampleAnimation.sample(currentTime).value, sampleDelta);\n            }\n            sync.update(() => animation.cancel());\n        },\n    };\n}\n\nexport { createAcceleratedAnimation };\n","import { mapEasingToNativeEasing } from './easing.mjs';\n\nfunction animateStyle(element, valueName, keyframes, { delay = 0, duration, repeat = 0, repeatType = \"loop\", ease, times, } = {}) {\n    return element.animate({ [valueName]: keyframes, offset: times }, {\n        delay,\n        duration,\n        easing: mapEasingToNativeEasing(ease),\n        fill: \"both\",\n        iterations: repeat + 1,\n        direction: repeatType === \"reverse\" ? \"alternate\" : \"normal\",\n    });\n}\n\nexport { animateStyle };\n","function getFinalKeyframe(keyframes, { repeat, repeatType = \"loop\" }) {\n    const index = repeat && repeatType !== \"loop\" && repeat % 2 === 1\n        ? 0\n        : keyframes.length - 1;\n    return keyframes[index];\n}\n\nexport { getFinalKeyframe };\n","import { sync, cancelSync } from '../frameloop/index.mjs';\n\n/**\n * Timeout defined in ms\n */\nfunction delay(callback, timeout) {\n    const start = performance.now();\n    const checkElapsed = ({ timestamp }) => {\n        const elapsed = timestamp - start;\n        if (elapsed >= timeout) {\n            cancelSync.read(checkElapsed);\n            callback(elapsed - timeout);\n        }\n    };\n    sync.read(checkElapsed, true);\n    return () => cancelSync.read(checkElapsed);\n}\n\nexport { delay };\n","import { delay } from '../utils/delay.mjs';\n\nfunction createInstantAnimation({ keyframes, elapsed, onUpdate, onComplete, }) {\n    const setValue = () => {\n        onUpdate && onUpdate(keyframes[keyframes.length - 1]);\n        onComplete && onComplete();\n    };\n    return elapsed ? { stop: delay(setValue, -elapsed) } : setValue();\n}\n\nexport { createInstantAnimation };\n","import { transformProps } from '../../render/html/utils/transform.mjs';\n\nconst underDampedSpring = {\n    type: \"spring\",\n    stiffness: 500,\n    damping: 25,\n    restSpeed: 10,\n};\nconst criticallyDampedSpring = (target) => ({\n    type: \"spring\",\n    stiffness: 550,\n    damping: target === 0 ? 2 * Math.sqrt(550) : 30,\n    restSpeed: 10,\n});\nconst keyframesTransition = {\n    type: \"keyframes\",\n    duration: 0.8,\n};\n/**\n * Default easing curve is a slightly shallower version of\n * the default browser easing curve.\n */\nconst ease = {\n    type: \"keyframes\",\n    ease: [0.25, 0.1, 0.35, 1],\n    duration: 0.3,\n};\nconst getDefaultTransition = (valueKey, { keyframes }) => {\n    if (keyframes.length > 2) {\n        return keyframesTransition;\n    }\n    else if (transformProps.has(valueKey)) {\n        return valueKey.startsWith(\"scale\")\n            ? criticallyDampedSpring(keyframes[1])\n            : underDampedSpring;\n    }\n    return ease;\n};\n\nexport { getDefaultTransition };\n","import { complex } from '../../value/types/complex/index.mjs';\n\n/**\n * Check if a value is animatable. Examples:\n *\n * ✅: 100, \"100px\", \"#fff\"\n * ❌: \"block\", \"url(2.jpg)\"\n * @param value\n *\n * @internal\n */\nconst isAnimatable = (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        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\nexport { isAnimatable };\n","import { complex } from './index.mjs';\nimport { floatRegex } from '../utils.mjs';\n\n/**\n * Properties that should default to 1 or 100%\n */\nconst maxDefaults = new Set([\"brightness\", \"contrast\", \"saturate\", \"opacity\"]);\nfunction applyDefaultFilter(v) {\n    const [name, value] = v.slice(0, -1).split(\"(\");\n    if (name === \"drop-shadow\")\n        return v;\n    const [number] = value.match(floatRegex) || [];\n    if (!number)\n        return v;\n    const unit = value.replace(number, \"\");\n    let defaultValue = maxDefaults.has(name) ? 1 : 0;\n    if (number !== value)\n        defaultValue *= 100;\n    return name + \"(\" + defaultValue + unit + \")\";\n}\nconst functionRegex = /([a-z-]*)\\(.*?\\)/g;\nconst filter = {\n    ...complex,\n    getAnimatableNone: (v) => {\n        const functions = v.match(functionRegex);\n        return functions ? functions.map(applyDefaultFilter).join(\" \") : v;\n    },\n};\n\nexport { filter };\n","import { color } from '../../../value/types/color/index.mjs';\nimport { filter } from '../../../value/types/complex/filter.mjs';\nimport { numberValueTypes } from './number.mjs';\n\n/**\n * A map of default value types for common values\n */\nconst defaultValueTypes = {\n    ...numberValueTypes,\n    // Color props\n    color,\n    backgroundColor: color,\n    outlineColor: color,\n    fill: color,\n    stroke: color,\n    // Border props\n    borderColor: color,\n    borderTopColor: color,\n    borderRightColor: color,\n    borderBottomColor: color,\n    borderLeftColor: color,\n    filter,\n    WebkitFilter: filter,\n};\n/**\n * Gets the default ValueType for the provided value key\n */\nconst getDefaultValueType = (key) => defaultValueTypes[key];\n\nexport { defaultValueTypes, getDefaultValueType };\n","import { complex } from '../../../value/types/complex/index.mjs';\nimport { filter } from '../../../value/types/complex/filter.mjs';\nimport { getDefaultValueType } from './defaults.mjs';\n\nfunction getAnimatableNone(key, value) {\n    let defaultValueType = getDefaultValueType(key);\n    if (defaultValueType !== filter)\n        defaultValueType = complex;\n    // If value is not recognised as animatable, ie \"none\", create an animatable version origin based on the target\n    return defaultValueType.getAnimatableNone\n        ? defaultValueType.getAnimatableNone(value)\n        : undefined;\n}\n\nexport { getAnimatableNone };\n","import { getAnimatableNone } from '../../render/dom/value-types/animatable-none.mjs';\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({ when, delay: _delay, delayChildren, staggerChildren, staggerDirection, repeat, repeatType, repeatDelay, from, elapsed, ...transition }) {\n    return !!Object.keys(transition).length;\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\nexport { getValueTransition, getZeroUnit, isTransitionDefined, isZero };\n","import { warning } from '../utils/errors.mjs';\nimport { secondsToMilliseconds } from '../utils/time-conversion.mjs';\nimport { instantAnimationState } from '../utils/use-instant-transition-state.mjs';\nimport { createAcceleratedAnimation } from './waapi/create-accelerated-animation.mjs';\nimport { createInstantAnimation } from './create-instant-animation.mjs';\nimport { animateValue } from './legacy-popmotion/index.mjs';\nimport { inertia } from './legacy-popmotion/inertia.mjs';\nimport { getDefaultTransition } from './utils/default-transitions.mjs';\nimport { isAnimatable } from './utils/is-animatable.mjs';\nimport { getKeyframes } from './utils/keyframes.mjs';\nimport { getValueTransition, isTransitionDefined } from './utils/transitions.mjs';\n\nconst createMotionValueAnimation = (valueName, value, target, transition = {}) => {\n    return (onComplete) => {\n        const valueTransition = getValueTransition(transition, valueName) || {};\n        /**\n         * Most transition values are currently completely overwritten by value-specific\n         * transitions. In the future it'd be nicer to blend these transitions. But for now\n         * delay actually does inherit from the root transition if not value-specific.\n         */\n        const delay = valueTransition.delay || transition.delay || 0;\n        /**\n         * Elapsed isn't a public transition option but can be passed through from\n         * optimized appear effects in milliseconds.\n         */\n        let { elapsed = 0 } = transition;\n        elapsed = elapsed - secondsToMilliseconds(delay);\n        const keyframes = getKeyframes(value, valueName, target, valueTransition);\n        /**\n         * Check if we're able to animate between the start and end keyframes,\n         * and throw a warning if we're attempting to animate between one that's\n         * animatable and another that isn't.\n         */\n        const originKeyframe = keyframes[0];\n        const targetKeyframe = keyframes[keyframes.length - 1];\n        const isOriginAnimatable = isAnimatable(valueName, originKeyframe);\n        const isTargetAnimatable = isAnimatable(valueName, targetKeyframe);\n        warning(isOriginAnimatable === isTargetAnimatable, `You are trying to animate ${valueName} from \"${originKeyframe}\" to \"${targetKeyframe}\". ${originKeyframe} is not an animatable value - to enable this animation set ${originKeyframe} to a value animatable to ${targetKeyframe} via the \\`style\\` property.`);\n        let options = {\n            keyframes,\n            velocity: value.getVelocity(),\n            ...valueTransition,\n            elapsed,\n            onUpdate: (v) => {\n                value.set(v);\n                valueTransition.onUpdate && valueTransition.onUpdate(v);\n            },\n            onComplete: () => {\n                onComplete();\n                valueTransition.onComplete && valueTransition.onComplete();\n            },\n        };\n        if (!isOriginAnimatable ||\n            !isTargetAnimatable ||\n            instantAnimationState.current ||\n            valueTransition.type === false) {\n            /**\n             * If we can't animate this value, or the global instant animation flag is set,\n             * or this is simply defined as an instant transition, return an instant transition.\n             */\n            return createInstantAnimation(options);\n        }\n        else if (valueTransition.type === \"inertia\") {\n            /**\n             * If this is an inertia animation, we currently don't support pre-generating\n             * keyframes for this as such it must always run on the main thread.\n             */\n            return inertia(options);\n        }\n        /**\n         * If there's no transition defined for this value, we can generate\n         * unqiue transition settings for this value.\n         */\n        if (!isTransitionDefined(valueTransition)) {\n            options = {\n                ...options,\n                ...getDefaultTransition(valueName, options),\n            };\n        }\n        /**\n         * Both WAAPI and our internal animation functions use durations\n         * as defined by milliseconds, while our external API defines them\n         * as seconds.\n         */\n        if (options.duration) {\n            options.duration = secondsToMilliseconds(options.duration);\n        }\n        if (options.repeatDelay) {\n            options.repeatDelay = secondsToMilliseconds(options.repeatDelay);\n        }\n        /**\n         * Animate via WAAPI if possible.\n         */\n        if (value.owner &&\n            value.owner.current instanceof HTMLElement &&\n            !value.owner.getProps().onUpdate) {\n            const acceleratedAnimation = createAcceleratedAnimation(value, valueName, options);\n            if (acceleratedAnimation)\n                return acceleratedAnimation;\n        }\n        /**\n         * If we didn't create an accelerated animation, create a JS animation\n         */\n        return animateValue(options);\n    };\n};\n\nexport { createMotionValueAnimation };\n","import { getAnimatableNone } from '../../render/dom/value-types/animatable-none.mjs';\nimport { isAnimatable } from './is-animatable.mjs';\nimport { isZero, getZeroUnit } from './transitions.mjs';\n\nfunction getKeyframes(value, valueName, target, transition) {\n    const isTargetAnimatable = isAnimatable(valueName, target);\n    let origin = transition.from !== undefined ? transition.from : value.get();\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(valueName, 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    /**\n     * If the target has been defined as a series of keyframes\n     */\n    if (Array.isArray(target)) {\n        /**\n         * Ensure an initial wildcard keyframe is hydrated by the origin.\n         * TODO: Support extra wildcard keyframes i.e [1, null, 0]\n         */\n        if (target[0] === null) {\n            target[0] = origin;\n        }\n        return target;\n    }\n    else {\n        return [origin, target];\n    }\n}\n\nexport { getKeyframes };\n","import { animateValue } from './index.mjs';\nimport { velocityPerSecond } from '../../utils/velocity-per-second.mjs';\nimport { frameData } from '../../frameloop/data.mjs';\n\nfunction inertia({ keyframes, velocity = 0, min, max, power = 0.8, timeConstant = 750, bounceStiffness = 500, bounceDamping = 10, restDelta = 1, modifyTarget, driver, onUpdate, onComplete, onStop, }) {\n    const origin = keyframes[0];\n    let currentAnimation;\n    function isOutOfBounds(v) {\n        return (min !== undefined && v < min) || (max !== undefined && v > max);\n    }\n    function findNearestBoundary(v) {\n        if (min === undefined)\n            return max;\n        if (max === undefined)\n            return min;\n        return Math.abs(min - v) < Math.abs(max - v) ? min : max;\n    }\n    function startAnimation(options) {\n        currentAnimation && currentAnimation.stop();\n        currentAnimation = animateValue({\n            keyframes: [0, 1],\n            velocity: 0,\n            ...options,\n            driver,\n            onUpdate: (v) => {\n                onUpdate && onUpdate(v);\n                options.onUpdate && options.onUpdate(v);\n            },\n            onComplete,\n            onStop,\n        });\n    }\n    function startSpring(options) {\n        startAnimation({\n            type: \"spring\",\n            stiffness: bounceStiffness,\n            damping: bounceDamping,\n            restDelta,\n            ...options,\n        });\n    }\n    if (isOutOfBounds(origin)) {\n        // Start the animation with spring if outside the defined boundaries\n        startSpring({\n            velocity,\n            keyframes: [origin, findNearestBoundary(origin)],\n        });\n    }\n    else {\n        /**\n         * Or if the value is out of bounds, simulate the inertia movement\n         * with the decay animation.\n         *\n         * Pre-calculate the target so we can detect if it's out-of-bounds.\n         * If it is, we want to check per frame when to switch to a spring\n         * animation\n         */\n        let target = power * velocity + origin;\n        if (typeof modifyTarget !== \"undefined\")\n            target = modifyTarget(target);\n        const boundary = findNearestBoundary(target);\n        const heading = boundary === min ? -1 : 1;\n        let prev;\n        let current;\n        const checkBoundary = (v) => {\n            prev = current;\n            current = v;\n            velocity = velocityPerSecond(v - prev, frameData.delta);\n            if ((heading === 1 && v > boundary) ||\n                (heading === -1 && v < boundary)) {\n                startSpring({ keyframes: [v, boundary], velocity });\n            }\n        };\n        startAnimation({\n            type: \"decay\",\n            keyframes: [origin, 0],\n            velocity,\n            timeConstant,\n            power,\n            restDelta,\n            modifyTarget,\n            onUpdate: isOutOfBounds(target) ? checkBoundary : undefined,\n        });\n    }\n    return {\n        stop: () => currentAnimation && currentAnimation.stop(),\n    };\n}\n\nexport { inertia };\n","import { invariant } from '../../utils/errors.mjs';\nimport { PanSession } from '../pan/PanSession.mjs';\nimport { getGlobalLock } from './utils/lock.mjs';\nimport { isRefObject } from '../../utils/is-ref-object.mjs';\nimport { addPointerEvent } from '../../events/add-pointer-event.mjs';\nimport { applyConstraints, calcRelativeConstraints, resolveDragElastic, calcViewportConstraints, defaultElastic, rebaseAxisConstraints, calcOrigin } from './utils/constraints.mjs';\nimport { createBox } from '../../projection/geometry/models.mjs';\nimport { eachAxis } from '../../projection/utils/each-axis.mjs';\nimport { measurePageBox } from '../../projection/utils/measure.mjs';\nimport { extractEventInfo } from '../../events/event-info.mjs';\nimport { convertBoxToBoundingBox, convertBoundingBoxToBox } from '../../projection/geometry/conversion.mjs';\nimport { addDomEvent } from '../../events/add-dom-event.mjs';\nimport { calcLength } from '../../projection/geometry/delta-calc.mjs';\nimport { mix } from '../../utils/mix.mjs';\nimport { percent } from '../../value/types/numbers/units.mjs';\nimport { createMotionValueAnimation } from '../../animation/index.mjs';\n\nconst elementDragControls = new WeakMap();\n/**\n *\n */\n// let latestPointerEvent: PointerEvent\nclass VisualElementDragControls {\n    constructor(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    start(originEvent, { snapToCursor = false } = {}) {\n        /**\n         * Don't start dragging if this component is exiting\n         */\n        const { presenceContext } = this.visualElement;\n        if (presenceContext && presenceContext.isPresent === false)\n            return;\n        const onSessionStart = (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        const onStart = (event, info) => {\n            // Attempt to grab the global drag gesture lock - maybe make this part of PanSession\n            const { drag, dragPropagation, onDragStart } = this.getProps();\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((axis) => {\n                let current = this.getAxisMotionValue(axis).get() || 0;\n                /**\n                 * If the MotionValue is a percentage value convert to px\n                 */\n                if (percent.test(current)) {\n                    const { projection } = this.visualElement;\n                    if (projection && projection.layout) {\n                        const measuredAxis = projection.layout.layoutBox[axis];\n                        if (measuredAxis) {\n                            const length = calcLength(measuredAxis);\n                            current = length * (parseFloat(current) / 100);\n                        }\n                    }\n                }\n                this.originPoint[axis] = current;\n            });\n            // Fire onDragStart event\n            onDragStart && onDragStart(event, info);\n            const { animationState } = this.visualElement;\n            animationState && animationState.setActive(\"whileDrag\", true);\n        };\n        const onMove = (event, info) => {\n            // latestPointerEvent = event\n            const { dragPropagation, dragDirectionLock, onDirectionLock, onDrag, } = this.getProps();\n            // If we didn't successfully receive the gesture lock, early return.\n            if (!dragPropagation && !this.openGlobalLock)\n                return;\n            const { offset } = info;\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 && 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.render();\n            /**\n             * This must fire after the render call as it might trigger a state\n             * change which itself might trigger a layout update.\n             */\n            onDrag && onDrag(event, info);\n        };\n        const onSessionEnd = (event, info) => this.stop(event, info);\n        this.panSession = new PanSession(originEvent, {\n            onSessionStart,\n            onStart,\n            onMove,\n            onSessionEnd,\n        }, { transformPagePoint: this.visualElement.getTransformPagePoint() });\n    }\n    stop(event, info) {\n        const isDragging = this.isDragging;\n        this.cancel();\n        if (!isDragging)\n            return;\n        const { velocity } = info;\n        this.startAnimation(velocity);\n        const { onDragEnd } = this.getProps();\n        onDragEnd && onDragEnd(event, info);\n    }\n    cancel() {\n        this.isDragging = false;\n        const { projection, animationState } = this.visualElement;\n        if (projection) {\n            projection.isAnimationBlocked = false;\n        }\n        this.panSession && this.panSession.end();\n        this.panSession = undefined;\n        const { dragPropagation } = this.getProps();\n        if (!dragPropagation && this.openGlobalLock) {\n            this.openGlobalLock();\n            this.openGlobalLock = null;\n        }\n        animationState && animationState.setActive(\"whileDrag\", false);\n    }\n    updateAxis(axis, _point, offset) {\n        const { drag } = this.getProps();\n        // If we're not dragging this axis, do an early return.\n        if (!offset || !shouldDrag(axis, drag, this.currentDirection))\n            return;\n        const axisValue = this.getAxisMotionValue(axis);\n        let 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    resolveConstraints() {\n        const { dragConstraints, dragElastic } = this.getProps();\n        const { layout } = this.visualElement.projection || {};\n        const 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.layoutBox, 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((axis) => {\n                if (this.getAxisMotionValue(axis)) {\n                    this.constraints[axis] = rebaseAxisConstraints(layout.layoutBox[axis], this.constraints[axis]);\n                }\n            });\n        }\n    }\n    resolveRefConstraints() {\n        const { dragConstraints: constraints, onMeasureDragConstraints } = this.getProps();\n        if (!constraints || !isRefObject(constraints))\n            return false;\n        const constraintsElement = constraints.current;\n        invariant(constraintsElement !== null, \"If `dragConstraints` is set as a React ref, that ref must be passed to another component's `ref` prop.\");\n        const { projection } = this.visualElement;\n        // TODO\n        if (!projection || !projection.layout)\n            return false;\n        const constraintsBox = measurePageBox(constraintsElement, projection.root, this.visualElement.getTransformPagePoint());\n        let measuredConstraints = calcViewportConstraints(projection.layout.layoutBox, 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            const userConstraints = onMeasureDragConstraints(convertBoxToBoundingBox(measuredConstraints));\n            this.hasMutatedConstraints = !!userConstraints;\n            if (userConstraints) {\n                measuredConstraints = convertBoundingBoxToBox(userConstraints);\n            }\n        }\n        return measuredConstraints;\n    }\n    startAnimation(velocity) {\n        const { drag, dragMomentum, dragElastic, dragTransition, dragSnapToOrigin, onDragTransitionEnd, } = this.getProps();\n        const constraints = this.constraints || {};\n        const momentumAnimations = eachAxis((axis) => {\n            if (!shouldDrag(axis, drag, this.currentDirection)) {\n                return;\n            }\n            let transition = (constraints && constraints[axis]) || {};\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            const bounceStiffness = dragElastic ? 200 : 1000000;\n            const bounceDamping = dragElastic ? 40 : 10000000;\n            const inertia = {\n                type: \"inertia\",\n                velocity: dragMomentum ? velocity[axis] : 0,\n                bounceStiffness,\n                bounceDamping,\n                timeConstant: 750,\n                restDelta: 1,\n                restSpeed: 10,\n                ...dragTransition,\n                ...transition,\n            };\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    startAxisValueAnimation(axis, transition) {\n        const axisValue = this.getAxisMotionValue(axis);\n        return axisValue.start(createMotionValueAnimation(axis, axisValue, 0, transition));\n    }\n    stopAnimation() {\n        eachAxis((axis) => 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    getAxisMotionValue(axis) {\n        const dragKey = \"_drag\" + axis.toUpperCase();\n        const props = this.visualElement.getProps();\n        const externalMotionValue = props[dragKey];\n        return externalMotionValue\n            ? externalMotionValue\n            : this.visualElement.getValue(axis, (props.initial ? props.initial[axis] : undefined) || 0);\n    }\n    snapToCursor(point) {\n        eachAxis((axis) => {\n            const { drag } = this.getProps();\n            // If we're not dragging this axis, do an early return.\n            if (!shouldDrag(axis, drag, this.currentDirection))\n                return;\n            const { projection } = this.visualElement;\n            const axisValue = this.getAxisMotionValue(axis);\n            if (projection && projection.layout) {\n                const { min, max } = projection.layout.layoutBox[axis];\n                axisValue.set(point[axis] - 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    scalePositionWithinConstraints() {\n        if (!this.visualElement.current)\n            return;\n        const { drag, dragConstraints } = this.getProps();\n        const { projection } = this.visualElement;\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        const boxProgress = { x: 0, y: 0 };\n        eachAxis((axis) => {\n            const axisValue = this.getAxisMotionValue(axis);\n            if (axisValue) {\n                const 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        const { transformTemplate } = this.visualElement.getProps();\n        this.visualElement.current.style.transform = transformTemplate\n            ? transformTemplate({}, \"\")\n            : \"none\";\n        projection.root && projection.root.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((axis) => {\n            if (!shouldDrag(axis, drag, null))\n                return;\n            /**\n             * Calculate a new transform based on the previous box progress\n             */\n            const axisValue = this.getAxisMotionValue(axis);\n            const { min, max } = this.constraints[axis];\n            axisValue.set(mix(min, max, boxProgress[axis]));\n        });\n    }\n    addListeners() {\n        if (!this.visualElement.current)\n            return;\n        elementDragControls.set(this.visualElement, this);\n        const element = this.visualElement.current;\n        /**\n         * Attach a pointerdown event listener on this DOM element to initiate drag tracking.\n         */\n        const stopPointerListener = addPointerEvent(element, \"pointerdown\", (event) => {\n            const { drag, dragListener = true } = this.getProps();\n            drag && dragListener && this.start(event);\n        });\n        const measureDragConstraints = () => {\n            const { dragConstraints } = this.getProps();\n            if (isRefObject(dragConstraints)) {\n                this.constraints = this.resolveRefConstraints();\n            }\n        };\n        const { projection } = this.visualElement;\n        const stopMeasureLayoutListener = projection.addEventListener(\"measure\", measureDragConstraints);\n        if (projection && !projection.layout) {\n            projection.root && projection.root.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        const stopResizeListener = addDomEvent(window, \"resize\", () => this.scalePositionWithinConstraints());\n        /**\n         * If the element's layout changes, calculate the delta and apply that to\n         * the drag gesture's origin point.\n         */\n        const stopLayoutUpdateListener = projection.addEventListener(\"didUpdate\", (({ delta, hasLayoutChanged }) => {\n            if (this.isDragging && hasLayoutChanged) {\n                eachAxis((axis) => {\n                    const 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.render();\n            }\n        }));\n        return () => {\n            stopResizeListener();\n            stopPointerListener();\n            stopMeasureLayoutListener();\n            stopLayoutUpdateListener && stopLayoutUpdateListener();\n        };\n    }\n    getProps() {\n        const props = this.visualElement.getProps();\n        const { drag = false, dragDirectionLock = false, dragPropagation = false, dragConstraints = false, dragElastic = defaultElastic, dragMomentum = true, } = props;\n        return {\n            ...props,\n            drag,\n            dragDirectionLock,\n            dragPropagation,\n            dragConstraints,\n            dragElastic,\n            dragMomentum,\n        };\n    }\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 = 10) {\n    let 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\nexport { VisualElementDragControls, elementDragControls };\n","import { Feature } from '../../motion/features/Feature.mjs';\nimport { noop } from '../../utils/noop.mjs';\nimport { VisualElementDragControls } from './VisualElementDragControls.mjs';\n\nclass DragGesture extends Feature {\n    constructor(node) {\n        super(node);\n        this.removeGroupControls = noop;\n        this.removeListeners = noop;\n        this.controls = new VisualElementDragControls(node);\n    }\n    mount() {\n        // If we've been provided a DragControls for manual control over the drag gesture,\n        // subscribe this component to it on mount.\n        const { dragControls } = this.node.getProps();\n        if (dragControls) {\n            this.removeGroupControls = dragControls.subscribe(this.controls);\n        }\n        this.removeListeners = this.controls.addListeners() || noop;\n    }\n    unmount() {\n        this.removeGroupControls();\n        this.removeListeners();\n    }\n}\n\nexport { DragGesture };\n","import { PanSession } from './PanSession.mjs';\nimport { addPointerEvent } from '../../events/add-pointer-event.mjs';\nimport { Feature } from '../../motion/features/Feature.mjs';\nimport { noop } from '../../utils/noop.mjs';\n\nclass PanGesture extends Feature {\n    constructor() {\n        super(...arguments);\n        this.removePointerDownListener = noop;\n    }\n    onPointerDown(pointerDownEvent) {\n        this.session = new PanSession(pointerDownEvent, this.createPanHandlers(), { transformPagePoint: this.node.getTransformPagePoint() });\n    }\n    createPanHandlers() {\n        const { onPanSessionStart, onPanStart, onPan, onPanEnd } = this.node.getProps();\n        return {\n            onSessionStart: onPanSessionStart,\n            onStart: onPanStart,\n            onMove: onPan,\n            onEnd: (event, info) => {\n                delete this.session;\n                onPanEnd && onPanEnd(event, info);\n            },\n        };\n    }\n    mount() {\n        this.removePointerDownListener = addPointerEvent(this.node.current, \"pointerdown\", (event) => this.onPointerDown(event));\n    }\n    update() {\n        this.session && this.session.updateHandlers(this.createPanHandlers());\n    }\n    unmount() {\n        this.removePointerDownListener();\n        this.session && this.session.end();\n    }\n}\n\nexport { PanGesture };\n","import { px } from '../../value/types/numbers/units.mjs';\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 */\nconst correctBorderRadius = {\n    correct: (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 (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        const x = pixelsToPercent(latest, node.target.x);\n        const y = pixelsToPercent(latest, node.target.y);\n        return `${x}% ${y}%`;\n    },\n};\n\nexport { correctBorderRadius, pixelsToPercent };\n","import { invariant } from '../../../utils/errors.mjs';\nimport { isCSSVariableToken } from './is-css-variable.mjs';\n\n/**\n * Parse Framer's special CSS variable format into a CSS token and a fallback.\n *\n * ```\n * `var(--foo, #fff)` => [`--foo`, '#fff']\n * ```\n *\n * @param current\n */\nconst cssVariableRegex = /var\\((--[a-zA-Z0-9-_]+),? ?([a-zA-Z0-9 ()%#.,-]+)?\\)/;\nfunction parseCSSVariable(current) {\n    const match = cssVariableRegex.exec(current);\n    if (!match)\n        return [,];\n    const [, token, fallback] = match;\n    return [token, fallback];\n}\nconst maxDepth = 4;\nfunction getVariableValue(current, element, depth = 1) {\n    invariant(depth <= maxDepth, `Max CSS variable fallback depth detected in property \"${current}\". This may indicate a circular fallback dependency.`);\n    const [token, fallback] = parseCSSVariable(current);\n    // No CSS variable detected\n    if (!token)\n        return;\n    // Attempt to read this CSS variable off the element\n    const resolved = window.getComputedStyle(element).getPropertyValue(token);\n    if (resolved) {\n        return resolved.trim();\n    }\n    else if (isCSSVariableToken(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, { ...target }, transitionEnd) {\n    const element = visualElement.current;\n    if (!(element instanceof Element))\n        return { target, 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 = { ...transitionEnd };\n    }\n    // Go through existing `MotionValue`s and ensure any existing CSS variables are resolved\n    visualElement.values.forEach((value) => {\n        const current = value.get();\n        if (!isCSSVariableToken(current))\n            return;\n        const 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 (const key in target) {\n        const current = target[key];\n        if (!isCSSVariableToken(current))\n            continue;\n        const 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 && transitionEnd[key] === undefined) {\n            transitionEnd[key] = current;\n        }\n    }\n    return { target, transitionEnd };\n}\n\nexport { cssVariableRegex, parseCSSVariable, resolveCSSVariables };\n","import { cssVariableRegex } from '../../render/dom/utils/css-variables-conversion.mjs';\nimport { mix } from '../../utils/mix.mjs';\nimport { complex } from '../../value/types/complex/index.mjs';\n\nconst varToken = \"_$css\";\nconst correctBoxShadow = {\n    correct: (latest, { treeScale, projectionDelta }) => {\n        const original = latest;\n        /**\n         * We need to first strip and store CSS variables from the string.\n         */\n        const containsCSSVariables = latest.includes(\"var(\");\n        const cssVariables = [];\n        if (containsCSSVariables) {\n            latest = latest.replace(cssVariableRegex, (match) => {\n                cssVariables.push(match);\n                return varToken;\n            });\n        }\n        const shadow = complex.parse(latest);\n        // TODO: Doesn't support multiple shadows\n        if (shadow.length > 5)\n            return original;\n        const template = complex.createTransformer(latest);\n        const offset = typeof shadow[0] !== \"number\" ? 1 : 0;\n        // Calculate the overall context scale\n        const xScale = projectionDelta.x.scale * treeScale.x;\n        const 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        const averageScale = 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        let output = template(shadow);\n        if (containsCSSVariables) {\n            let i = 0;\n            output = output.replace(varToken, () => {\n                const cssVariable = cssVariables[i];\n                i++;\n                return cssVariable;\n            });\n        }\n        return output;\n    },\n};\n\nexport { correctBoxShadow };\n","import { sync } from '../../../frameloop/index.mjs';\nimport React__default, { useContext } from 'react';\nimport { usePresence } from '../../../components/AnimatePresence/use-presence.mjs';\nimport { LayoutGroupContext } from '../../../context/LayoutGroupContext.mjs';\nimport { SwitchLayoutGroupContext } from '../../../context/SwitchLayoutGroupContext.mjs';\nimport { globalProjectionState } from '../../../projection/node/state.mjs';\nimport { correctBorderRadius } from '../../../projection/styles/scale-border-radius.mjs';\nimport { correctBoxShadow } from '../../../projection/styles/scale-box-shadow.mjs';\nimport { addScaleCorrector } from '../../../projection/styles/scale-correction.mjs';\n\nclass MeasureLayoutWithContext extends React__default.Component {\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    componentDidMount() {\n        const { visualElement, layoutGroup, switchLayoutGroup, layoutId } = this.props;\n        const { projection } = visualElement;\n        addScaleCorrector(defaultScaleCorrectors);\n        if (projection) {\n            if (layoutGroup.group)\n                layoutGroup.group.add(projection);\n            if (switchLayoutGroup && switchLayoutGroup.register && layoutId) {\n                switchLayoutGroup.register(projection);\n            }\n            projection.root.didUpdate();\n            projection.addEventListener(\"animationComplete\", () => {\n                this.safeToRemove();\n            });\n            projection.setOptions({\n                ...projection.options,\n                onExitComplete: () => this.safeToRemove(),\n            });\n        }\n        globalProjectionState.hasEverUpdated = true;\n    }\n    getSnapshotBeforeUpdate(prevProps) {\n        const { layoutDependency, visualElement, drag, isPresent } = this.props;\n        const 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.postRender(() => {\n                    const stack = projection.getStack();\n                    if (!stack || !stack.members.length) {\n                        this.safeToRemove();\n                    }\n                });\n            }\n        }\n        return null;\n    }\n    componentDidUpdate() {\n        const { projection } = this.props.visualElement;\n        if (projection) {\n            projection.root.didUpdate();\n            if (!projection.currentAnimation && projection.isLead()) {\n                this.safeToRemove();\n            }\n        }\n    }\n    componentWillUnmount() {\n        const { visualElement, layoutGroup, switchLayoutGroup: promoteContext, } = this.props;\n        const { projection } = visualElement;\n        if (projection) {\n            projection.scheduleCheckAfterUnmount();\n            if (layoutGroup && layoutGroup.group)\n                layoutGroup.group.remove(projection);\n            if (promoteContext && promoteContext.deregister)\n                promoteContext.deregister(projection);\n        }\n    }\n    safeToRemove() {\n        const { safeToRemove } = this.props;\n        safeToRemove && safeToRemove();\n    }\n    render() {\n        return null;\n    }\n}\nfunction MeasureLayout(props) {\n    const [isPresent, safeToRemove] = usePresence();\n    const layoutGroup = useContext(LayoutGroupContext);\n    return (React__default.createElement(MeasureLayoutWithContext, { ...props, layoutGroup: layoutGroup, switchLayoutGroup: useContext(SwitchLayoutGroupContext), isPresent: isPresent, safeToRemove: safeToRemove }));\n}\nconst defaultScaleCorrectors = {\n    borderRadius: {\n        ...correctBorderRadius,\n        applyTo: [\n            \"borderTopLeftRadius\",\n            \"borderTopRightRadius\",\n            \"borderBottomLeftRadius\",\n            \"borderBottomRightRadius\",\n        ],\n    },\n    borderTopLeftRadius: correctBorderRadius,\n    borderTopRightRadius: correctBorderRadius,\n    borderBottomLeftRadius: correctBorderRadius,\n    borderBottomRightRadius: correctBorderRadius,\n    boxShadow: correctBoxShadow,\n};\n\nexport { MeasureLayout };\n","import { useContext, useId, useEffect } from 'react';\nimport { PresenceContext } from '../../context/PresenceContext.mjs';\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    const context = useContext(PresenceContext);\n    if (context === null)\n        return [true, null];\n    const { isPresent, onExitComplete, register } = context;\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    const id = useId();\n    useEffect(() => register(id), []);\n    const safeToRemove = () => onExitComplete && 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(useContext(PresenceContext));\n}\nfunction isPresent(context) {\n    return context === null ? true : context.isPresent;\n}\n\nexport { isPresent, useIsPresent, usePresence };\n","import { circOut } from '../../easing/circ.mjs';\nimport { progress } from '../../utils/progress.mjs';\nimport { mix } from '../../utils/mix.mjs';\nimport { noop } from '../../utils/noop.mjs';\nimport { percent, px } from '../../value/types/numbers/units.mjs';\n\nconst borders = [\"TopLeft\", \"TopRight\", \"BottomLeft\", \"BottomRight\"];\nconst numBorders = borders.length;\nconst asNumber = (value) => typeof value === \"string\" ? parseFloat(value) : value;\nconst isPx = (value) => typeof value === \"number\" || px.test(value);\nfunction mixValues(target, follow, lead, progress, shouldCrossfadeOpacity, isOnlyMember) {\n    if (shouldCrossfadeOpacity) {\n        target.opacity = mix(0, \n        // TODO Reinstate this if only child\n        lead.opacity !== undefined ? lead.opacity : 1, easeCrossfadeIn(progress));\n        target.opacityExit = mix(follow.opacity !== undefined ? follow.opacity : 1, 0, easeCrossfadeOut(progress));\n    }\n    else if (isOnlyMember) {\n        target.opacity = mix(follow.opacity !== undefined ? follow.opacity : 1, lead.opacity !== undefined ? lead.opacity : 1, progress);\n    }\n    /**\n     * Mix border radius\n     */\n    for (let i = 0; i < numBorders; i++) {\n        const borderLabel = `border${borders[i]}Radius`;\n        let followRadius = getRadius(follow, borderLabel);\n        let leadRadius = getRadius(lead, borderLabel);\n        if (followRadius === undefined && leadRadius === undefined)\n            continue;\n        followRadius || (followRadius = 0);\n        leadRadius || (leadRadius = 0);\n        const canMix = followRadius === 0 ||\n            leadRadius === 0 ||\n            isPx(followRadius) === isPx(leadRadius);\n        if (canMix) {\n            target[borderLabel] = Math.max(mix(asNumber(followRadius), asNumber(leadRadius), progress), 0);\n            if (percent.test(leadRadius) || 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 = mix(follow.rotate || 0, lead.rotate || 0, progress);\n    }\n}\nfunction getRadius(values, radiusName) {\n    return values[radiusName] !== undefined\n        ? values[radiusName]\n        : 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// }\nconst easeCrossfadeIn = compress(0, 0.5, circOut);\nconst easeCrossfadeOut = compress(0.5, 0.95, noop);\nfunction compress(min, max, easing) {\n    return (p) => {\n        // Could replace ifs with clamp\n        if (p < min)\n            return 0;\n        if (p > max)\n            return 1;\n        return easing(progress(min, max, p));\n    };\n}\n\nexport { mixValues };\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\nexport { copyAxisInto, copyBoxInto };\n","import { mix } from '../../utils/mix.mjs';\nimport { percent } from '../../value/types/numbers/units.mjs';\nimport { scalePoint } from './delta-apply.mjs';\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 = 0, scale = 1, origin = 0.5, boxScale, originAxis = axis, sourceAxis = axis) {\n    if (percent.test(translate)) {\n        translate = parseFloat(translate);\n        const relativeProgress = mix(sourceAxis.min, sourceAxis.max, translate / 100);\n        translate = relativeProgress - sourceAxis.min;\n    }\n    if (typeof translate !== \"number\")\n        return;\n    let originPoint = 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, [key, scaleKey, originKey], origin, sourceAxis) {\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 */\nconst xKeys = [\"x\", \"scaleX\", \"originX\"];\nconst 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 ? originBox.x : undefined, sourceBox ? sourceBox.x : undefined);\n    removeAxisTransforms(box.y, transforms, yKeys, originBox ? originBox.y : undefined, sourceBox ? sourceBox.y : undefined);\n}\n\nexport { removeAxisDelta, removeAxisTransforms, removeBoxTransforms, removePointDelta };\n","import { calcLength } from './delta-calc.mjs';\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}\nfunction aspectRatio(box) {\n    return calcLength(box.x) / calcLength(box.y);\n}\n\nexport { aspectRatio, boxEquals, isDeltaZero };\n","import { addUniqueItem, removeItem } from '../../utils/array.mjs';\n\nclass NodeStack {\n    constructor() {\n        this.members = [];\n    }\n    add(node) {\n        addUniqueItem(this.members, node);\n        node.scheduleRender();\n    }\n    remove(node) {\n        removeItem(this.members, node);\n        if (node === this.prevLead) {\n            this.prevLead = undefined;\n        }\n        if (node === this.lead) {\n            const prevLead = this.members[this.members.length - 1];\n            if (prevLead) {\n                this.promote(prevLead);\n            }\n        }\n    }\n    relegate(node) {\n        const indexOfNode = this.members.findIndex((member) => node === member);\n        if (indexOfNode === 0)\n            return false;\n        /**\n         * Find the next projection node that is present\n         */\n        let prevLead;\n        for (let i = indexOfNode; i >= 0; i--) {\n            const 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    promote(node, preserveFollowOpacity) {\n        const 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            }\n            if (node.root && node.root.isUpdating) {\n                node.isLayoutDirty = true;\n            }\n            const { crossfade } = node.options;\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    exitAnimationComplete() {\n        this.members.forEach((node) => {\n            const { options, resumingFrom } = node;\n            options.onExitComplete && options.onExitComplete();\n            if (resumingFrom) {\n                resumingFrom.options.onExitComplete &&\n                    resumingFrom.options.onExitComplete();\n            }\n        });\n    }\n    scheduleRender() {\n        this.members.forEach((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    removeLeadSnapshot() {\n        if (this.lead && this.lead.snapshot) {\n            this.lead.snapshot = undefined;\n        }\n    }\n}\n\nexport { NodeStack };\n","function buildProjectionTransform(delta, treeScale, latestTransform) {\n    let transform = \"\";\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    const xTranslate = delta.x.translate / treeScale.x;\n    const yTranslate = delta.y.translate / treeScale.y;\n    if (xTranslate || yTranslate) {\n        transform = `translate3d(${xTranslate}px, ${yTranslate}px, 0) `;\n    }\n    /**\n     * Apply scale correction for the tree transform.\n     * This will apply scale to the screen-orientated axes.\n     */\n    if (treeScale.x !== 1 || treeScale.y !== 1) {\n        transform += `scale(${1 / treeScale.x}, ${1 / treeScale.y}) `;\n    }\n    if (latestTransform) {\n        const { rotate, rotateX, rotateY } = latestTransform;\n        if (rotate)\n            transform += `rotate(${rotate}deg) `;\n        if (rotateX)\n            transform += `rotateX(${rotateX}deg) `;\n        if (rotateY)\n            transform += `rotateY(${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    const elementScaleX = delta.x.scale * treeScale.x;\n    const elementScaleY = delta.y.scale * treeScale.y;\n    if (elementScaleX !== 1 || elementScaleY !== 1) {\n        transform += `scale(${elementScaleX}, ${elementScaleY})`;\n    }\n    return transform || \"none\";\n}\n\nexport { buildProjectionTransform };\n","const compareByDepth = (a, b) => a.depth - b.depth;\n\nexport { compareByDepth };\n","import { addUniqueItem, removeItem } from '../../utils/array.mjs';\nimport { compareByDepth } from './compare-by-depth.mjs';\n\nclass FlatTree {\n    constructor() {\n        this.children = [];\n        this.isDirty = false;\n    }\n    add(child) {\n        addUniqueItem(this.children, child);\n        this.isDirty = true;\n    }\n    remove(child) {\n        removeItem(this.children, child);\n        this.isDirty = true;\n    }\n    forEach(callback) {\n        this.isDirty && this.children.sort(compareByDepth);\n        this.isDirty = false;\n        this.children.forEach(callback);\n    }\n}\n\nexport { FlatTree };\n","import { cancelSync, flushSync, sync } from '../../frameloop/index.mjs';\nimport { animate } from '../../animation/animate.mjs';\nimport { SubscriptionManager } from '../../utils/subscription-manager.mjs';\nimport { mixValues } from '../animation/mix-values.mjs';\nimport { copyBoxInto } from '../geometry/copy.mjs';\nimport { translateAxis, transformBox, applyBoxDelta, applyTreeDeltas } from '../geometry/delta-apply.mjs';\nimport { calcRelativePosition, calcRelativeBox, calcBoxDelta, calcLength, isNear } from '../geometry/delta-calc.mjs';\nimport { removeBoxTransforms } from '../geometry/delta-remove.mjs';\nimport { createBox, createDelta } from '../geometry/models.mjs';\nimport { getValueTransition } from '../../animation/utils/transitions.mjs';\nimport { boxEquals, isDeltaZero, aspectRatio } from '../geometry/utils.mjs';\nimport { NodeStack } from '../shared/stack.mjs';\nimport { scaleCorrectors } from '../styles/scale-correction.mjs';\nimport { buildProjectionTransform } from '../styles/transform.mjs';\nimport { eachAxis } from '../utils/each-axis.mjs';\nimport { hasTransform, hasScale, has2DTranslate } from '../utils/has-transform.mjs';\nimport { FlatTree } from '../../render/utils/flat-tree.mjs';\nimport { resolveMotionValue } from '../../value/utils/resolve-motion-value.mjs';\nimport { globalProjectionState } from './state.mjs';\nimport { delay } from '../../utils/delay.mjs';\nimport { mix } from '../../utils/mix.mjs';\nimport { record } from '../../debug/record.mjs';\n\nconst transformAxes = [\"\", \"X\", \"Y\", \"Z\"];\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 */\nconst animationTarget = 1000;\nlet id = 0;\n/**\n * Use a mutable data object for debug data so as to not create a new\n * object every frame.\n */\nconst projectionFrameData = {\n    type: \"projectionFrame\",\n    totalNodes: 0,\n    resolvedTargetDeltas: 0,\n    recalculatedProjection: 0,\n};\nfunction createProjectionNode({ attachResizeListener, defaultParent, measureScroll, checkIsScrollRoot, resetTransform, }) {\n    return class ProjectionNode {\n        constructor(elementId, latestValues = {}, parent = defaultParent === null || defaultParent === void 0 ? void 0 : defaultParent()) {\n            /**\n             * A unique ID generated for every projection node.\n             */\n            this.id = id++;\n            /**\n             * An id that represents a unique session instigated by startUpdate.\n             */\n            this.animationId = 0;\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             * Flag to true if we think the projection calculations for this node needs\n             * recalculating as a result of an updated transform or layout animation.\n             */\n            this.isProjectionDirty = false;\n            /**\n             * Flag to true if the layout *or* transform has changed. This then gets propagated\n             * throughout the projection tree, forcing any element below to recalculate on the next frame.\n             */\n            this.isSharedProjectionDirty = false;\n            /**\n             * Flag transform dirty. This gets propagated throughout the whole tree but is only\n             * respected by shared nodes.\n             */\n            this.isTransformDirty = 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 layoutly\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 = () => {\n                if (this.isUpdating) {\n                    this.isUpdating = false;\n                    this.clearAllSnapshots();\n                }\n            };\n            /**\n             * This is a multi-step process as shared nodes might be of different depths. Nodes\n             * are sorted by depth order, so we need to resolve the entire tree before moving to\n             * the next step.\n             */\n            this.updateProjection = () => {\n                /**\n                 * Reset debug counts. Manually resetting rather than creating a new\n                 * object each frame.\n                 */\n                projectionFrameData.totalNodes =\n                    projectionFrameData.resolvedTargetDeltas =\n                        projectionFrameData.recalculatedProjection =\n                            0;\n                this.nodes.forEach(propagateDirtyNodes);\n                this.nodes.forEach(resolveTargetDelta);\n                this.nodes.forEach(calcProjection);\n                this.nodes.forEach(cleanDirtyNodes);\n                record(projectionFrameData);\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.elementId = elementId;\n            this.latestValues = latestValues;\n            this.root = parent ? parent.root || parent : this;\n            this.path = parent ? [...parent.path, parent] : [];\n            this.parent = parent;\n            this.depth = parent ? parent.depth + 1 : 0;\n            elementId && this.root.registerPotentialNode(elementId, this);\n            for (let 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        addEventListener(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        notifyListeners(name, ...args) {\n            const subscriptionManager = this.eventHandlers.get(name);\n            subscriptionManager && subscriptionManager.notify(...args);\n        }\n        hasListeners(name) {\n            return this.eventHandlers.has(name);\n        }\n        registerPotentialNode(elementId, node) {\n            this.potentialNodes.set(elementId, node);\n        }\n        /**\n         * Lifecycles\n         */\n        mount(instance, isLayoutDirty = false) {\n            if (this.instance)\n                return;\n            this.isSVG =\n                instance instanceof SVGElement && instance.tagName !== \"svg\";\n            this.instance = instance;\n            const { layoutId, layout, visualElement } = this.options;\n            if (visualElement && !visualElement.current) {\n                visualElement.mount(instance);\n            }\n            this.root.nodes.add(this);\n            this.parent && this.parent.children.add(this);\n            this.elementId && this.root.potentialNodes.delete(this.elementId);\n            if (isLayoutDirty && (layout || layoutId)) {\n                this.isLayoutDirty = true;\n            }\n            if (attachResizeListener) {\n                let cancelDelay;\n                const resizeUnblockUpdate = () => (this.root.updateBlockedByResize = false);\n                attachResizeListener(instance, () => {\n                    this.root.updateBlockedByResize = true;\n                    cancelDelay && cancelDelay();\n                    cancelDelay = delay(resizeUnblockUpdate, 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\", ({ delta, hasLayoutChanged, hasRelativeTargetChanged, layout: newLayout, }) => {\n                    if (this.isTreeAnimationBlocked()) {\n                        this.target = undefined;\n                        this.relativeTarget = undefined;\n                        return;\n                    }\n                    // TODO: Check here if an animation exists\n                    const layoutTransition = this.options.transition ||\n                        visualElement.getDefaultTransition() ||\n                        defaultLayoutTransition;\n                    const { onLayoutAnimationStart, onLayoutAnimationComplete, } = visualElement.getProps();\n                    /**\n                     * The target layout of the element might stay the same,\n                     * but its position relative to its parent has changed.\n                     */\n                    const 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                    const hasOnlyRelativeTargetChanged = !hasLayoutChanged && hasRelativeTargetChanged;\n                    if (this.options.layoutRoot ||\n                        (this.resumeFrom && this.resumeFrom.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                        const animationOptions = {\n                            ...getValueTransition(layoutTransition, \"layout\"),\n                            onPlay: onLayoutAnimationStart,\n                            onComplete: onLayoutAnimationComplete,\n                        };\n                        if (visualElement.shouldReduceMotion ||\n                            this.options.layoutRoot) {\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                            finishAnimation(this);\n                        }\n                        if (this.isLead() && this.options.onExitComplete) {\n                            this.options.onExitComplete();\n                        }\n                    }\n                    this.targetLayout = newLayout;\n                });\n            }\n        }\n        unmount() {\n            this.options.layoutId && this.willUpdate();\n            this.root.nodes.remove(this);\n            const stack = this.getStack();\n            stack && stack.remove(this);\n            this.parent && this.parent.children.delete(this);\n            this.instance = undefined;\n            cancelSync.preRender(this.updateProjection);\n        }\n        // only on the root\n        blockUpdate() {\n            this.updateManuallyBlocked = true;\n        }\n        unblockUpdate() {\n            this.updateManuallyBlocked = false;\n        }\n        isUpdateBlocked() {\n            return this.updateManuallyBlocked || this.updateBlockedByResize;\n        }\n        isTreeAnimationBlocked() {\n            return (this.isAnimationBlocked ||\n                (this.parent && this.parent.isTreeAnimationBlocked()) ||\n                false);\n        }\n        // Note: currently only running on root node\n        startUpdate() {\n            if (this.isUpdateBlocked())\n                return;\n            this.isUpdating = true;\n            this.nodes && this.nodes.forEach(resetRotation);\n            this.animationId++;\n        }\n        getTransformTemplate() {\n            const { visualElement } = this.options;\n            return visualElement && visualElement.getProps().transformTemplate;\n        }\n        willUpdate(shouldNotifyListeners = true) {\n            if (this.root.isUpdateBlocked()) {\n                this.options.onExitComplete && this.options.onExitComplete();\n                return;\n            }\n            !this.root.isUpdating && this.root.startUpdate();\n            if (this.isLayoutDirty)\n                return;\n            this.isLayoutDirty = true;\n            for (let i = 0; i < this.path.length; i++) {\n                const node = this.path[i];\n                node.shouldResetTransform = true;\n                node.updateScroll(\"snapshot\");\n                if (node.options.layoutRoot) {\n                    node.willUpdate(false);\n                }\n            }\n            const { layoutId, layout } = this.options;\n            if (layoutId === undefined && !layout)\n                return;\n            const transformTemplate = this.getTransformTemplate();\n            this.prevTransformTemplateValue = transformTemplate\n                ? transformTemplate(this.latestValues, \"\")\n                : undefined;\n            this.updateSnapshot();\n            shouldNotifyListeners && this.notifyListeners(\"willUpdate\");\n        }\n        // Note: Currently only running on root node\n        didUpdate() {\n            const 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            flushSync.update();\n            flushSync.preRender();\n            flushSync.render();\n        }\n        clearAllSnapshots() {\n            this.nodes.forEach(clearSnapshot);\n            this.sharedNodes.forEach(removeLeadSnapshots);\n        }\n        scheduleUpdateProjection() {\n            sync.preRender(this.updateProjection, false, true);\n        }\n        scheduleCheckAfterUnmount() {\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.postRender(() => {\n                if (this.isLayoutDirty) {\n                    this.root.didUpdate();\n                }\n                else {\n                    this.root.checkUpdateFailed();\n                }\n            });\n        }\n        /**\n         * Update measurements\n         */\n        updateSnapshot() {\n            if (this.snapshot || !this.instance)\n                return;\n            this.snapshot = this.measure();\n        }\n        updateLayout() {\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 (let i = 0; i < this.path.length; i++) {\n                    const node = this.path[i];\n                    node.updateScroll();\n                }\n            }\n            const prevLayout = this.layout;\n            this.layout = this.measure(false);\n            this.layoutCorrected = createBox();\n            this.isLayoutDirty = false;\n            this.projectionDelta = undefined;\n            this.notifyListeners(\"measure\", this.layout.layoutBox);\n            const { visualElement } = this.options;\n            visualElement &&\n                visualElement.notify(\"LayoutMeasure\", this.layout.layoutBox, prevLayout ? prevLayout.layoutBox : undefined);\n        }\n        updateScroll(phase = \"measure\") {\n            let needsMeasurement = Boolean(this.options.layoutScroll && this.instance);\n            if (this.scroll &&\n                this.scroll.animationId === this.root.animationId &&\n                this.scroll.phase === phase) {\n                needsMeasurement = false;\n            }\n            if (needsMeasurement) {\n                this.scroll = {\n                    animationId: this.root.animationId,\n                    phase,\n                    isRoot: checkIsScrollRoot(this.instance),\n                    offset: measureScroll(this.instance),\n                };\n            }\n        }\n        resetTransform() {\n            if (!resetTransform)\n                return;\n            const isResetRequested = this.isLayoutDirty || this.shouldResetTransform;\n            const hasProjection = this.projectionDelta && !isDeltaZero(this.projectionDelta);\n            const transformTemplate = this.getTransformTemplate();\n            const transformTemplateValue = transformTemplate\n                ? transformTemplate(this.latestValues, \"\")\n                : undefined;\n            const 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        measure(removeTransform = true) {\n            const pageBox = this.measurePageBox();\n            let layoutBox = this.removeElementScroll(pageBox);\n            /**\n             * Measurements taken during the pre-render stage\n             * still have transforms applied so we remove them\n             * via calculation.\n             */\n            if (removeTransform) {\n                layoutBox = this.removeTransform(layoutBox);\n            }\n            roundBox(layoutBox);\n            return {\n                animationId: this.root.animationId,\n                measuredBox: pageBox,\n                layoutBox,\n                latestValues: {},\n                source: this.id,\n            };\n        }\n        measurePageBox() {\n            const { visualElement } = this.options;\n            if (!visualElement)\n                return createBox();\n            const box = visualElement.measureViewportBox();\n            // Remove viewport scroll to give page-relative coordinates\n            const { scroll } = this.root;\n            if (scroll) {\n                translateAxis(box.x, scroll.offset.x);\n                translateAxis(box.y, scroll.offset.y);\n            }\n            return box;\n        }\n        removeElementScroll(box) {\n            const 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 (let i = 0; i < this.path.length; i++) {\n                const node = this.path[i];\n                const { scroll, options } = node;\n                if (node !== this.root && scroll && 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 (scroll.isRoot) {\n                        copyBoxInto(boxWithoutScroll, box);\n                        const { scroll: rootScroll } = this.root;\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.offset.x);\n                            translateAxis(boxWithoutScroll.y, -rootScroll.offset.y);\n                        }\n                    }\n                    translateAxis(boxWithoutScroll.x, scroll.offset.x);\n                    translateAxis(boxWithoutScroll.y, scroll.offset.y);\n                }\n            }\n            return boxWithoutScroll;\n        }\n        applyTransform(box, transformOnly = false) {\n            const withTransforms = createBox();\n            copyBoxInto(withTransforms, box);\n            for (let i = 0; i < this.path.length; i++) {\n                const 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.offset.x,\n                        y: -node.scroll.offset.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        removeTransform(box) {\n            const boxWithoutTransform = createBox();\n            copyBoxInto(boxWithoutTransform, box);\n            for (let i = 0; i < this.path.length; i++) {\n                const node = this.path[i];\n                if (!node.instance)\n                    continue;\n                if (!hasTransform(node.latestValues))\n                    continue;\n                hasScale(node.latestValues) && node.updateSnapshot();\n                const sourceBox = createBox();\n                const nodeBox = node.measurePageBox();\n                copyBoxInto(sourceBox, nodeBox);\n                removeBoxTransforms(boxWithoutTransform, node.latestValues, node.snapshot ? node.snapshot.layoutBox : undefined, sourceBox);\n            }\n            if (hasTransform(this.latestValues)) {\n                removeBoxTransforms(boxWithoutTransform, this.latestValues);\n            }\n            return boxWithoutTransform;\n        }\n        setTargetDelta(delta) {\n            this.targetDelta = delta;\n            this.root.scheduleUpdateProjection();\n            this.isProjectionDirty = true;\n        }\n        setOptions(options) {\n            this.options = {\n                ...this.options,\n                ...options,\n                crossfade: options.crossfade !== undefined ? options.crossfade : true,\n            };\n        }\n        clearMeasurements() {\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        resolveTargetDelta() {\n            var _a;\n            /**\n             * Once the dirty status of nodes has been spread through the tree, we also\n             * need to check if we have a shared node of a different depth that has itself\n             * been dirtied.\n             */\n            const lead = this.getLead();\n            this.isProjectionDirty || (this.isProjectionDirty = lead.isProjectionDirty);\n            this.isTransformDirty || (this.isTransformDirty = lead.isTransformDirty);\n            this.isSharedProjectionDirty || (this.isSharedProjectionDirty = lead.isSharedProjectionDirty);\n            const isShared = Boolean(this.resumingFrom) || this !== lead;\n            /**\n             * We don't use transform for this step of processing so we don't\n             * need to check whether any nodes have changed transform.\n             */\n            const canSkip = !((isShared && this.isSharedProjectionDirty) ||\n                this.isProjectionDirty ||\n                ((_a = this.parent) === null || _a === void 0 ? void 0 : _a.isProjectionDirty) ||\n                this.attemptToResolveRelativeTarget);\n            if (canSkip)\n                return;\n            const { layout, layoutId } = this.options;\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                const relativeParent = this.getClosestProjectingParent();\n                if (relativeParent && relativeParent.layout) {\n                    this.relativeParent = relativeParent;\n                    this.relativeTarget = createBox();\n                    this.relativeTargetOrigin = createBox();\n                    calcRelativePosition(this.relativeTargetOrigin, this.layout.layoutBox, relativeParent.layout.layoutBox);\n                    copyBoxInto(this.relativeTarget, this.relativeTargetOrigin);\n                }\n                else {\n                    this.relativeParent = this.relativeTarget = undefined;\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                this.relativeParent &&\n                this.relativeParent.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.layoutBox);\n                }\n                else {\n                    copyBoxInto(this.target, this.layout.layoutBox);\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.layoutBox);\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                const relativeParent = this.getClosestProjectingParent();\n                if (relativeParent &&\n                    Boolean(relativeParent.resumingFrom) ===\n                        Boolean(this.resumingFrom) &&\n                    !relativeParent.options.layoutScroll &&\n                    relativeParent.target) {\n                    this.relativeParent = relativeParent;\n                    this.relativeTarget = createBox();\n                    this.relativeTargetOrigin = createBox();\n                    calcRelativePosition(this.relativeTargetOrigin, this.target, relativeParent.target);\n                    copyBoxInto(this.relativeTarget, this.relativeTargetOrigin);\n                }\n                else {\n                    this.relativeParent = this.relativeTarget = undefined;\n                }\n            }\n            /**\n             * Increase debug counter for resolved target deltas\n             */\n            projectionFrameData.resolvedTargetDeltas++;\n        }\n        getClosestProjectingParent() {\n            if (!this.parent ||\n                hasScale(this.parent.latestValues) ||\n                has2DTranslate(this.parent.latestValues)) {\n                return undefined;\n            }\n            if (this.parent.isProjecting()) {\n                return this.parent;\n            }\n            else {\n                return this.parent.getClosestProjectingParent();\n            }\n        }\n        isProjecting() {\n            return Boolean((this.relativeTarget ||\n                this.targetDelta ||\n                this.options.layoutRoot) &&\n                this.layout);\n        }\n        calcProjection() {\n            var _a;\n            const lead = this.getLead();\n            const isShared = Boolean(this.resumingFrom) || this !== lead;\n            let canSkip = true;\n            /**\n             * If this is a normal layout animation and neither this node nor its nearest projecting\n             * is dirty then we can't skip.\n             */\n            if (this.isProjectionDirty || ((_a = this.parent) === null || _a === void 0 ? void 0 : _a.isProjectionDirty)) {\n                canSkip = false;\n            }\n            /**\n             * If this is a shared layout animation and this node's shared projection is dirty then\n             * we can't skip.\n             */\n            if (isShared &&\n                (this.isSharedProjectionDirty || this.isTransformDirty)) {\n                canSkip = false;\n            }\n            if (canSkip)\n                return;\n            const { layout, layoutId } = this.options;\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((this.parent && this.parent.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            /**\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.layoutBox);\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, isShared);\n            const { target } = lead;\n            if (!target)\n                return;\n            if (!this.projectionDelta) {\n                this.projectionDelta = createDelta();\n                this.projectionDeltaWithTransform = createDelta();\n            }\n            const prevTreeScaleX = this.treeScale.x;\n            const prevTreeScaleY = this.treeScale.y;\n            const 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             * Increase debug counter for recalculated projections\n             */\n            projectionFrameData.recalculatedProjection++;\n        }\n        hide() {\n            this.isVisible = false;\n            // TODO: Schedule render\n        }\n        show() {\n            this.isVisible = true;\n            // TODO: Schedule render\n        }\n        scheduleRender(notifyAll = true) {\n            this.options.scheduleRender && this.options.scheduleRender();\n            if (notifyAll) {\n                const stack = this.getStack();\n                stack && stack.scheduleRender();\n            }\n            if (this.resumingFrom && !this.resumingFrom.instance) {\n                this.resumingFrom = undefined;\n            }\n        }\n        setAnimationOrigin(delta, hasOnlyRelativeTargetChanged = false) {\n            const snapshot = this.snapshot;\n            const snapshotLatestValues = snapshot\n                ? snapshot.latestValues\n                : {};\n            const mixedValues = { ...this.latestValues };\n            const targetDelta = createDelta();\n            if (!this.relativeParent ||\n                !this.relativeParent.options.layoutRoot) {\n                this.relativeTarget = this.relativeTargetOrigin = undefined;\n            }\n            this.attemptToResolveRelativeTarget = !hasOnlyRelativeTargetChanged;\n            const relativeLayout = createBox();\n            const snapshotSource = snapshot ? snapshot.source : undefined;\n            const layoutSource = this.layout ? this.layout.source : undefined;\n            const isSharedLayoutAnimation = snapshotSource !== layoutSource;\n            const stack = this.getStack();\n            const isOnlyMember = !stack || stack.members.length <= 1;\n            const shouldCrossfadeOpacity = Boolean(isSharedLayoutAnimation &&\n                !isOnlyMember &&\n                this.options.crossfade === true &&\n                !this.path.some(hasOpacityCrossfade));\n            this.animationProgress = 0;\n            let prevRelativeTarget;\n            this.mixTargetDelta = (latest) => {\n                const 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                    this.relativeParent &&\n                    this.relativeParent.layout) {\n                    calcRelativePosition(relativeLayout, this.layout.layoutBox, this.relativeParent.layout.layoutBox);\n                    mixBox(this.relativeTarget, this.relativeTargetOrigin, relativeLayout, progress);\n                    /**\n                     * If this is an unchanged relative target we can consider the\n                     * projection not dirty.\n                     */\n                    if (prevRelativeTarget &&\n                        boxEquals(this.relativeTarget, prevRelativeTarget)) {\n                        this.isProjectionDirty = false;\n                    }\n                    if (!prevRelativeTarget)\n                        prevRelativeTarget = createBox();\n                    copyBoxInto(prevRelativeTarget, this.relativeTarget);\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(this.options.layoutRoot ? 1000 : 0);\n        }\n        startAnimation(options) {\n            this.notifyListeners(\"animationStart\");\n            this.currentAnimation && this.currentAnimation.stop();\n            if (this.resumingFrom && this.resumingFrom.currentAnimation) {\n                this.resumingFrom.currentAnimation.stop();\n            }\n            if (this.pendingAnimation) {\n                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.update(() => {\n                globalProjectionState.hasAnimatedSinceResize = true;\n                this.currentAnimation = animate(0, animationTarget, {\n                    ...options,\n                    onUpdate: (latest) => {\n                        this.mixTargetDelta(latest);\n                        options.onUpdate && options.onUpdate(latest);\n                    },\n                    onComplete: () => {\n                        options.onComplete && options.onComplete();\n                        this.completeAnimation();\n                    },\n                });\n                if (this.resumingFrom) {\n                    this.resumingFrom.currentAnimation = this.currentAnimation;\n                }\n                this.pendingAnimation = undefined;\n            });\n        }\n        completeAnimation() {\n            if (this.resumingFrom) {\n                this.resumingFrom.currentAnimation = undefined;\n                this.resumingFrom.preserveOpacity = undefined;\n            }\n            const stack = this.getStack();\n            stack && stack.exitAnimationComplete();\n            this.resumingFrom =\n                this.currentAnimation =\n                    this.animationValues =\n                        undefined;\n            this.notifyListeners(\"animationComplete\");\n        }\n        finishAnimation() {\n            if (this.currentAnimation) {\n                this.mixTargetDelta && this.mixTargetDelta(animationTarget);\n                this.currentAnimation.stop();\n            }\n            this.completeAnimation();\n        }\n        applyTransformsToTarget() {\n            const lead = this.getLead();\n            let { targetWithTransforms, target, layout, latestValues } = lead;\n            if (!targetWithTransforms || !target || !layout)\n                return;\n            /**\n             * If we're only animating position, and this element isn't the lead element,\n             * then instead of projecting into the lead box we instead want to calculate\n             * a new target that aligns the two boxes but maintains the layout shape.\n             */\n            if (this !== lead &&\n                this.layout &&\n                layout &&\n                shouldAnimatePositionOnly(this.options.animationType, this.layout.layoutBox, layout.layoutBox)) {\n                target = this.target || createBox();\n                const xLength = calcLength(this.layout.layoutBox.x);\n                target.x.min = lead.target.x.min;\n                target.x.max = target.x.min + xLength;\n                const yLength = calcLength(this.layout.layoutBox.y);\n                target.y.min = lead.target.y.min;\n                target.y.max = target.y.min + yLength;\n            }\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 layout layout\n             * into the desired bounding box.\n             */\n            calcBoxDelta(this.projectionDeltaWithTransform, this.layoutCorrected, targetWithTransforms, latestValues);\n        }\n        registerSharedNode(layoutId, node) {\n            if (!this.sharedNodes.has(layoutId)) {\n                this.sharedNodes.set(layoutId, new NodeStack());\n            }\n            const stack = this.sharedNodes.get(layoutId);\n            stack.add(node);\n            const config = node.options.initialPromotionConfig;\n            node.promote({\n                transition: config ? config.transition : undefined,\n                preserveFollowOpacity: config && config.shouldPreserveFollowOpacity\n                    ? config.shouldPreserveFollowOpacity(node)\n                    : undefined,\n            });\n        }\n        isLead() {\n            const stack = this.getStack();\n            return stack ? stack.lead === this : true;\n        }\n        getLead() {\n            var _a;\n            const { layoutId } = this.options;\n            return layoutId ? ((_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.lead) || this : this;\n        }\n        getPrevLead() {\n            var _a;\n            const { layoutId } = this.options;\n            return layoutId ? (_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.prevLead : undefined;\n        }\n        getStack() {\n            const { layoutId } = this.options;\n            if (layoutId)\n                return this.root.sharedNodes.get(layoutId);\n        }\n        promote({ needsReset, transition, preserveFollowOpacity, } = {}) {\n            const 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 });\n        }\n        relegate() {\n            const stack = this.getStack();\n            if (stack) {\n                return stack.relegate(this);\n            }\n            else {\n                return false;\n            }\n        }\n        resetRotation() {\n            const { visualElement } = this.options;\n            if (!visualElement)\n                return;\n            // If there's no detected rotation values, we can early return without a forced render.\n            let hasRotate = false;\n            /**\n             * An unrolled check for rotation values. Most elements don't have any rotation and\n             * skipping the nested loop and new object creation is 50% faster.\n             */\n            const { latestValues } = visualElement;\n            if (latestValues.rotate ||\n                latestValues.rotateX ||\n                latestValues.rotateY ||\n                latestValues.rotateZ) {\n                hasRotate = true;\n            }\n            // If there's no rotation values, we don't need to do any more.\n            if (!hasRotate)\n                return;\n            const resetValues = {};\n            // Check the rotate value of all axes and reset to 0\n            for (let i = 0; i < transformAxes.length; i++) {\n                const key = \"rotate\" + transformAxes[i];\n                // Record the rotation and then temporarily set it to 0\n                if (latestValues[key]) {\n                    resetValues[key] = latestValues[key];\n                    visualElement.setStaticValue(key, 0);\n                }\n            }\n            // Force a render of this element to apply the transform with all rotations\n            // set to 0.\n            visualElement.render();\n            // Put back all the values we reset\n            for (const 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        getProjectionStyles(styleProp = {}) {\n            var _a, _b;\n            // TODO: Return lifecycle-persistent object\n            const 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            const transformTemplate = this.getTransformTemplate();\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            const lead = this.getLead();\n            if (!this.projectionDelta || !this.layout || !lead.target) {\n                const emptyStyles = {};\n                if (this.options.layoutId) {\n                    emptyStyles.opacity =\n                        this.latestValues.opacity !== undefined\n                            ? this.latestValues.opacity\n                            : 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            const 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            const { x, y } = this.projectionDelta;\n            styles.transformOrigin = `${x.origin * 100}% ${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                        ? (_b = (_a = valuesToRender.opacity) !== null && _a !== void 0 ? _a : this.latestValues.opacity) !== null && _b !== void 0 ? _b : 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 layout\n                 * opacity and other components to hidden.\n                 */\n                styles.opacity =\n                    lead === this\n                        ? valuesToRender.opacity !== undefined\n                            ? valuesToRender.opacity\n                            : \"\"\n                        : valuesToRender.opacityExit !== undefined\n                            ? valuesToRender.opacityExit\n                            : 0;\n            }\n            /**\n             * Apply scale correction\n             */\n            for (const key in scaleCorrectors) {\n                if (valuesToRender[key] === undefined)\n                    continue;\n                const { correct, applyTo } = scaleCorrectors[key];\n                /**\n                 * Only apply scale correction to the value if we have an\n                 * active projection transform. Otherwise these values become\n                 * vulnerable to distortion if the element changes size without\n                 * a corresponding layout animation.\n                 */\n                const corrected = styles.transform === \"none\"\n                    ? valuesToRender[key]\n                    : correct(valuesToRender[key], lead);\n                if (applyTo) {\n                    const num = applyTo.length;\n                    for (let 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        clearSnapshot() {\n            this.resumeFrom = this.snapshot = undefined;\n        }\n        // Only run on root\n        resetTree() {\n            this.root.nodes.forEach((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    };\n}\nfunction updateLayout(node) {\n    node.updateLayout();\n}\nfunction notifyLayoutUpdate(node) {\n    var _a;\n    const snapshot = ((_a = node.resumeFrom) === null || _a === void 0 ? void 0 : _a.snapshot) || node.snapshot;\n    if (node.isLead() &&\n        node.layout &&\n        snapshot &&\n        node.hasListeners(\"didUpdate\")) {\n        const { layoutBox: layout, measuredBox: measuredLayout } = node.layout;\n        const { animationType } = node.options;\n        const isShared = snapshot.source !== node.layout.source;\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 (animationType === \"size\") {\n            eachAxis((axis) => {\n                const axisSnapshot = isShared\n                    ? snapshot.measuredBox[axis]\n                    : snapshot.layoutBox[axis];\n                const length = calcLength(axisSnapshot);\n                axisSnapshot.min = layout[axis].min;\n                axisSnapshot.max = axisSnapshot.min + length;\n            });\n        }\n        else if (shouldAnimatePositionOnly(animationType, snapshot.layoutBox, layout)) {\n            eachAxis((axis) => {\n                const axisSnapshot = isShared\n                    ? snapshot.measuredBox[axis]\n                    : snapshot.layoutBox[axis];\n                const length = calcLength(layout[axis]);\n                axisSnapshot.max = axisSnapshot.min + length;\n            });\n        }\n        const layoutDelta = createDelta();\n        calcBoxDelta(layoutDelta, layout, snapshot.layoutBox);\n        const visualDelta = createDelta();\n        if (isShared) {\n            calcBoxDelta(visualDelta, node.applyTransform(measuredLayout, true), snapshot.measuredBox);\n        }\n        else {\n            calcBoxDelta(visualDelta, layout, snapshot.layoutBox);\n        }\n        const hasLayoutChanged = !isDeltaZero(layoutDelta);\n        let hasRelativeTargetChanged = false;\n        if (!node.resumeFrom) {\n            const 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 (relativeParent && !relativeParent.resumeFrom) {\n                const { snapshot: parentSnapshot, layout: parentLayout } = relativeParent;\n                if (parentSnapshot && parentLayout) {\n                    const relativeSnapshot = createBox();\n                    calcRelativePosition(relativeSnapshot, snapshot.layoutBox, parentSnapshot.layoutBox);\n                    const relativeLayout = createBox();\n                    calcRelativePosition(relativeLayout, layout, parentLayout.layoutBox);\n                    if (!boxEquals(relativeSnapshot, relativeLayout)) {\n                        hasRelativeTargetChanged = true;\n                    }\n                    if (relativeParent.options.layoutRoot) {\n                        node.relativeTarget = relativeLayout;\n                        node.relativeTargetOrigin = relativeSnapshot;\n                        node.relativeParent = relativeParent;\n                    }\n                }\n            }\n        }\n        node.notifyListeners(\"didUpdate\", {\n            layout,\n            snapshot,\n            delta: visualDelta,\n            layoutDelta,\n            hasLayoutChanged,\n            hasRelativeTargetChanged,\n        });\n    }\n    else if (node.isLead()) {\n        const { onExitComplete } = node.options;\n        onExitComplete && onExitComplete();\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 propagateDirtyNodes(node) {\n    /**\n     * Increase debug counter for nodes encountered this frame\n     */\n    projectionFrameData.totalNodes++;\n    if (!node.parent)\n        return;\n    /**\n     * If this node isn't projecting, propagate isProjectionDirty. It will have\n     * no performance impact but it will allow the next child that *is* projecting\n     * but *isn't* dirty to just check its parent to see if *any* ancestor needs\n     * correcting.\n     */\n    if (!node.isProjecting()) {\n        node.isProjectionDirty = node.parent.isProjectionDirty;\n    }\n    /**\n     * Propagate isSharedProjectionDirty and isTransformDirty\n     * throughout the whole tree. A future revision can take another look at\n     * this but for safety we still recalcualte shared nodes.\n     */\n    node.isSharedProjectionDirty || (node.isSharedProjectionDirty = Boolean(node.isProjectionDirty ||\n        node.parent.isProjectionDirty ||\n        node.parent.isSharedProjectionDirty));\n    node.isTransformDirty || (node.isTransformDirty = node.parent.isTransformDirty);\n}\nfunction cleanDirtyNodes(node) {\n    node.isProjectionDirty =\n        node.isSharedProjectionDirty =\n            node.isTransformDirty =\n                false;\n}\nfunction clearSnapshot(node) {\n    node.clearSnapshot();\n}\nfunction clearMeasurements(node) {\n    node.clearMeasurements();\n}\nfunction resetTransformStyle(node) {\n    const { visualElement } = node.options;\n    if (visualElement && visualElement.getProps().onBeforeLayoutMeasure) {\n        visualElement.notify(\"BeforeLayoutMeasure\");\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 = mix(delta.translate, 0, p);\n    output.scale = 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 = mix(from.min, to.min, p);\n    output.max = 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}\nconst defaultLayoutTransition = {\n    duration: 0.45,\n    ease: [0.4, 0, 0.1, 1],\n};\nfunction mountNodeEarly(node, elementId) {\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    let searchNode = node.root;\n    for (let 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    const searchElement = searchNode && searchNode !== node.root ? searchNode.instance : document;\n    const element = searchElement.querySelector(`[data-projection-id=\"${elementId}\"]`);\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}\nfunction shouldAnimatePositionOnly(animationType, snapshot, layout) {\n    return (animationType === \"position\" ||\n        (animationType === \"preserve-aspect\" &&\n            !isNear(aspectRatio(snapshot), aspectRatio(layout), 0.2)));\n}\n\nexport { cleanDirtyNodes, createProjectionNode, mixAxis, mixAxisDelta, mixBox, propagateDirtyNodes };\n","function record(data) {\n    if (window.MotionDebug) {\n        window.MotionDebug.record(data);\n    }\n}\n\nexport { record };\n","import { createMotionValueAnimation } from './index.mjs';\nimport { motionValue } from '../value/index.mjs';\nimport { isMotionValue } from '../value/utils/is-motion-value.mjs';\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    const value = isMotionValue(from) ? from : motionValue(from);\n    value.start(createMotionValueAnimation(\"\", value, to, transition));\n    return {\n        stop: () => value.stop(),\n        isAnimating: () => value.isAnimating(),\n    };\n}\n\nexport { animate };\n","import { createProjectionNode } from './create-projection-node.mjs';\nimport { addDomEvent } from '../../events/add-dom-event.mjs';\n\nconst DocumentProjectionNode = createProjectionNode({\n    attachResizeListener: (ref, notify) => addDomEvent(ref, \"resize\", notify),\n    measureScroll: () => ({\n        x: document.documentElement.scrollLeft || document.body.scrollLeft,\n        y: document.documentElement.scrollTop || document.body.scrollTop,\n    }),\n    checkIsScrollRoot: () => true,\n});\n\nexport { DocumentProjectionNode };\n","import { createProjectionNode } from './create-projection-node.mjs';\nimport { DocumentProjectionNode } from './DocumentProjectionNode.mjs';\n\nconst rootProjectionNode = {\n    current: undefined,\n};\nconst HTMLProjectionNode = createProjectionNode({\n    measureScroll: (instance) => ({\n        x: instance.scrollLeft,\n        y: instance.scrollTop,\n    }),\n    defaultParent: () => {\n        if (!rootProjectionNode.current) {\n            const 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: (instance, value) => {\n        instance.style.transform = value !== undefined ? value : \"none\";\n    },\n    checkIsScrollRoot: (instance) => Boolean(window.getComputedStyle(instance).position === \"fixed\"),\n});\n\nexport { HTMLProjectionNode, rootProjectionNode };\n","import { DragGesture } from '../../gestures/drag/index.mjs';\nimport { PanGesture } from '../../gestures/pan/index.mjs';\nimport { MeasureLayout } from './layout/MeasureLayout.mjs';\nimport { HTMLProjectionNode } from '../../projection/node/HTMLProjectionNode.mjs';\n\nconst drag = {\n    pan: {\n        Feature: PanGesture,\n    },\n    drag: {\n        Feature: DragGesture,\n        ProjectionNode: HTMLProjectionNode,\n        MeasureLayout,\n    },\n};\n\nexport { drag };\n","import { HTMLProjectionNode } from '../../projection/node/HTMLProjectionNode.mjs';\nimport { MeasureLayout } from './layout/MeasureLayout.mjs';\n\nconst layout = {\n    layout: {\n        ProjectionNode: HTMLProjectionNode,\n        MeasureLayout,\n    },\n};\n\nexport { layout };\n","function shallowCompare(next, prev) {\n    if (!Array.isArray(prev))\n        return false;\n    const prevLength = prev.length;\n    if (prevLength !== next.length)\n        return false;\n    for (let i = 0; i < prevLength; i++) {\n        if (prev[i] !== next[i])\n            return false;\n    }\n    return true;\n}\n\nexport { shallowCompare };\n","/**\n * Check if value is a numerical string, ie a string that is purely a number eg \"100\" or \"-100.1\"\n */\nconst isNumericalString = (v) => /^\\-?\\d*\\.?\\d+$/.test(v);\n\nexport { isNumericalString };\n","/**\n * Check if the value is a zero value string like \"0px\" or \"0%\"\n */\nconst isZeroValueString = (v) => /^0[^.\\s]+$/.test(v);\n\nexport { isZeroValueString };\n","/**\n * Tests a provided value against a ValueType\n */\nconst testValueType = (v) => (type) => type.test(v);\n\nexport { testValueType };\n","import { number } from '../../../value/types/numbers/index.mjs';\nimport { px, percent, degrees, vw, vh } from '../../../value/types/numbers/units.mjs';\nimport { testValueType } from './test.mjs';\nimport { auto } from './type-auto.mjs';\n\n/**\n * A list of value types commonly used for dimensions\n */\nconst dimensionValueTypes = [number, px, percent, degrees, vw, vh, auto];\n/**\n * Tests a dimensional value against the list of dimension ValueTypes\n */\nconst findDimensionValueType = (v) => dimensionValueTypes.find(testValueType(v));\n\nexport { dimensionValueTypes, findDimensionValueType };\n","/**\n * ValueType for \"auto\"\n */\nconst auto = {\n    test: (v) => v === \"auto\",\n    parse: (v) => v,\n};\n\nexport { auto };\n","import { color } from '../../../value/types/color/index.mjs';\nimport { complex } from '../../../value/types/complex/index.mjs';\nimport { dimensionValueTypes } from './dimensions.mjs';\nimport { testValueType } from './test.mjs';\n\n/**\n * A list of all ValueTypes\n */\nconst valueTypes = [...dimensionValueTypes, color, complex];\n/**\n * Tests a value against the list of ValueTypes\n */\nconst findValueType = (v) => valueTypes.find(testValueType(v));\n\nexport { findValueType };\n","import { resolveVariantFromProps } from './resolve-variants.mjs';\n\n/**\n * Creates an object containing the latest state of every MotionValue on a VisualElement\n */\nfunction getCurrent(visualElement) {\n    const current = {};\n    visualElement.values.forEach((value, key) => (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(visualElement) {\n    const velocity = {};\n    visualElement.values.forEach((value, key) => (velocity[key] = value.getVelocity()));\n    return velocity;\n}\nfunction resolveVariant(visualElement, definition, custom) {\n    const props = visualElement.getProps();\n    return resolveVariantFromProps(props, definition, custom !== undefined ? custom : props.custom, getCurrent(visualElement), getVelocity(visualElement));\n}\n\nexport { resolveVariant };\n","import { isNumericalString } from '../../utils/is-numerical-string.mjs';\nimport { isZeroValueString } from '../../utils/is-zero-value-string.mjs';\nimport { resolveFinalValueInKeyframes } from '../../utils/resolve-value.mjs';\nimport { motionValue } from '../../value/index.mjs';\nimport { complex } from '../../value/types/complex/index.mjs';\nimport { getAnimatableNone } from '../dom/value-types/animatable-none.mjs';\nimport { findValueType } from '../dom/value-types/find.mjs';\nimport { resolveVariant } from './resolve-dynamic-variants.mjs';\n\n/**\n * Set VisualElement's MotionValue, creating a new MotionValue for it if\n * it doesn't exist.\n */\nfunction setMotionValue(visualElement, key, value) {\n    if (visualElement.hasValue(key)) {\n        visualElement.getValue(key).set(value);\n    }\n    else {\n        visualElement.addValue(key, motionValue(value));\n    }\n}\nfunction setTarget(visualElement, definition) {\n    const resolved = resolveVariant(visualElement, definition);\n    let { transitionEnd = {}, transition = {}, ...target } = resolved ? visualElement.makeTargetAnimatable(resolved, false) : {};\n    target = { ...target, ...transitionEnd };\n    for (const key in target) {\n        const value = resolveFinalValueInKeyframes(target[key]);\n        setMotionValue(visualElement, key, value);\n    }\n}\nfunction setVariants(visualElement, variantLabels) {\n    const reversedLabels = [...variantLabels].reverse();\n    reversedLabels.forEach((key) => {\n        const variant = visualElement.getVariant(key);\n        variant && setTarget(visualElement, variant);\n        if (visualElement.variantChildren) {\n            visualElement.variantChildren.forEach((child) => {\n                setVariants(child, variantLabels);\n            });\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;\n    const newValueKeys = Object.keys(target).filter((key) => !visualElement.hasValue(key));\n    const numNewValues = newValueKeys.length;\n    if (!numNewValues)\n        return;\n    for (let i = 0; i < numNewValues; i++) {\n        const key = newValueKeys[i];\n        const targetValue = target[key];\n        let 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) && complex.test(targetValue)) {\n            value = getAnimatableNone(key, targetValue);\n        }\n        visualElement.addValue(key, motionValue(value, { owner: visualElement }));\n        if (origin[key] === undefined) {\n            origin[key] = value;\n        }\n        if (value !== null)\n            visualElement.setBaseTarget(key, value);\n    }\n}\nfunction getOriginFromTransition(key, transition) {\n    if (!transition)\n        return;\n    const valueTransition = transition[key] || transition[\"default\"] || transition;\n    return valueTransition.from;\n}\nfunction getOrigin(target, transition, visualElement) {\n    const origin = {};\n    for (const key in target) {\n        const transitionOrigin = getOriginFromTransition(key, transition);\n        if (transitionOrigin !== undefined) {\n            origin[key] = transitionOrigin;\n        }\n        else {\n            const value = visualElement.getValue(key);\n            if (value) {\n                origin[key] = value.get();\n            }\n        }\n    }\n    return origin;\n}\n\nexport { checkTargetForNewValues, getOrigin, getOriginFromTransition, setTarget, setValues };\n","import { isMotionValue } from '../utils/is-motion-value.mjs';\n\nfunction isWillChangeMotionValue(value) {\n    return Boolean(isMotionValue(value) && value.add);\n}\n\nexport { isWillChangeMotionValue };\n","import { camelToDash } from '../../render/dom/utils/camel-to-dash.mjs';\n\nconst optimizedAppearDataId = \"framerAppearId\";\nconst optimizedAppearDataAttribute = \"data-\" + camelToDash(optimizedAppearDataId);\n\nexport { optimizedAppearDataAttribute, optimizedAppearDataId };\n","import { setTarget } from './setters.mjs';\nimport { resolveVariant } from './resolve-dynamic-variants.mjs';\nimport { transformProps } from '../html/utils/transform.mjs';\nimport { isWillChangeMotionValue } from '../../value/use-will-change/is.mjs';\nimport { optimizedAppearDataAttribute } from '../../animation/optimized-appear/data-id.mjs';\nimport { createMotionValueAnimation } from '../../animation/index.mjs';\nimport { sync } from '../../frameloop/index.mjs';\n\nfunction animateVisualElement(visualElement, definition, options = {}) {\n    visualElement.notify(\"AnimationStart\", definition);\n    let animation;\n    if (Array.isArray(definition)) {\n        const animations = definition.map((variant) => animateVariant(visualElement, variant, options));\n        animation = Promise.all(animations);\n    }\n    else if (typeof definition === \"string\") {\n        animation = animateVariant(visualElement, definition, options);\n    }\n    else {\n        const resolvedDefinition = typeof definition === \"function\"\n            ? resolveVariant(visualElement, definition, options.custom)\n            : definition;\n        animation = animateTarget(visualElement, resolvedDefinition, options);\n    }\n    return animation.then(() => visualElement.notify(\"AnimationComplete\", definition));\n}\nfunction animateVariant(visualElement, variant, options = {}) {\n    const resolved = resolveVariant(visualElement, variant, options.custom);\n    let { transition = visualElement.getDefaultTransition() || {} } = resolved || {};\n    if (options.transitionOverride) {\n        transition = options.transitionOverride;\n    }\n    /**\n     * If we have a variant, create a callback that runs it as an animation.\n     * Otherwise, we resolve a Promise immediately for a composable no-op.\n     */\n    const getAnimation = resolved\n        ? () => animateTarget(visualElement, resolved, options)\n        : () => Promise.resolve();\n    /**\n     * If we have children, create a callback that runs all their animations.\n     * Otherwise, we resolve a Promise immediately for a composable no-op.\n     */\n    const getChildAnimations = visualElement.variantChildren && visualElement.variantChildren.size\n        ? (forwardDelay = 0) => {\n            const { delayChildren = 0, staggerChildren, staggerDirection, } = transition;\n            return animateChildren(visualElement, variant, delayChildren + forwardDelay, staggerChildren, staggerDirection, options);\n        }\n        : () => Promise.resolve();\n    /**\n     * If the transition explicitly defines a \"when\" option, we need to resolve either\n     * this animation or all children animations before playing the other.\n     */\n    const { when } = transition;\n    if (when) {\n        const [first, last] = when === \"beforeChildren\"\n            ? [getAnimation, getChildAnimations]\n            : [getChildAnimations, getAnimation];\n        return first().then(last);\n    }\n    else {\n        return Promise.all([getAnimation(), getChildAnimations(options.delay)]);\n    }\n}\n/**\n * @internal\n */\nfunction animateTarget(visualElement, definition, { delay = 0, transitionOverride, type } = {}) {\n    let { transition = visualElement.getDefaultTransition(), transitionEnd, ...target } = visualElement.makeTargetAnimatable(definition);\n    const willChange = visualElement.getValue(\"willChange\");\n    if (transitionOverride)\n        transition = transitionOverride;\n    const animations = [];\n    const animationTypeState = type &&\n        visualElement.animationState &&\n        visualElement.animationState.getState()[type];\n    for (const key in target) {\n        const value = visualElement.getValue(key);\n        const valueTarget = target[key];\n        if (!value ||\n            valueTarget === undefined ||\n            (animationTypeState &&\n                shouldBlockAnimation(animationTypeState, key))) {\n            continue;\n        }\n        const valueTransition = { delay, elapsed: 0, ...transition };\n        /**\n         * If this is the first time a value is being animated, check\n         * to see if we're handling off from an existing animation.\n         */\n        if (window.HandoffAppearAnimations && !value.hasAnimated) {\n            const appearId = visualElement.getProps()[optimizedAppearDataAttribute];\n            if (appearId) {\n                valueTransition.elapsed = window.HandoffAppearAnimations(appearId, key, value, sync);\n            }\n        }\n        let animation = value.start(createMotionValueAnimation(key, value, valueTarget, visualElement.shouldReduceMotion && transformProps.has(key)\n            ? { type: false }\n            : valueTransition));\n        if (isWillChangeMotionValue(willChange)) {\n            willChange.add(key);\n            animation = animation.then(() => willChange.remove(key));\n        }\n        animations.push(animation);\n    }\n    return Promise.all(animations).then(() => {\n        transitionEnd && setTarget(visualElement, transitionEnd);\n    });\n}\nfunction animateChildren(visualElement, variant, delayChildren = 0, staggerChildren = 0, staggerDirection = 1, options) {\n    const animations = [];\n    const maxStaggerDuration = (visualElement.variantChildren.size - 1) * staggerChildren;\n    const generateStaggerDuration = staggerDirection === 1\n        ? (i = 0) => i * staggerChildren\n        : (i = 0) => maxStaggerDuration - i * staggerChildren;\n    Array.from(visualElement.variantChildren)\n        .sort(sortByTreeOrder)\n        .forEach((child, i) => {\n        child.notify(\"AnimationStart\", variant);\n        animations.push(animateVariant(child, variant, {\n            ...options,\n            delay: delayChildren + generateStaggerDuration(i),\n        }).then(() => child.notify(\"AnimationComplete\", variant)));\n    });\n    return Promise.all(animations);\n}\nfunction stopAnimation(visualElement) {\n    visualElement.values.forEach((value) => 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({ protectedKeys, needsAnimating }, key) {\n    const shouldBlock = protectedKeys.hasOwnProperty(key) && needsAnimating[key] !== true;\n    needsAnimating[key] = false;\n    return shouldBlock;\n}\n\nexport { animateVisualElement, sortByTreeOrder, stopAnimation };\n","import { isAnimationControls } from '../../animation/utils/is-animation-controls.mjs';\nimport { isKeyframesTarget } from '../../animation/utils/is-keyframes-target.mjs';\nimport { shallowCompare } from '../../utils/shallow-compare.mjs';\nimport { animateVisualElement } from './animation.mjs';\nimport { isVariantLabel } from './is-variant-label.mjs';\nimport { resolveVariant } from './resolve-dynamic-variants.mjs';\nimport { variantPriorityOrder } from './variant-props.mjs';\n\nconst reversePriorityOrder = [...variantPriorityOrder].reverse();\nconst numAnimationTypes = variantPriorityOrder.length;\nfunction animateList(visualElement) {\n    return (animations) => Promise.all(animations.map(({ animation, options }) => animateVisualElement(visualElement, animation, options)));\n}\nfunction createAnimationState(visualElement) {\n    let animate = animateList(visualElement);\n    const state = createState();\n    let isInitialRender = true;\n    /**\n     * This function will be used to reduce the animation definitions for\n     * each active animation type into an object of resolved values for it.\n     */\n    const buildResolvedTypeValues = (acc, definition) => {\n        const resolved = resolveVariant(visualElement, definition);\n        if (resolved) {\n            const { transition, transitionEnd, ...target } = resolved;\n            acc = { ...acc, ...target, ...transitionEnd };\n        }\n        return acc;\n    };\n    /**\n     * This just allows us to inject mocked animation functions\n     * @internal\n     */\n    function setAnimateFunction(makeAnimator) {\n        animate = makeAnimator(visualElement);\n    }\n    /**\n     * When we receive new props, we need to:\n     * 1. Create a list of protected keys for each type. This is a directory of\n     *    value keys that are currently being \"handled\" by types of a higher priority\n     *    so that whenever an animation is played of a given type, these values are\n     *    protected from being animated.\n     * 2. Determine if an animation type needs animating.\n     * 3. Determine if any values have been removed from a type and figure out\n     *    what to animate those to.\n     */\n    function animateChanges(options, changedActiveType) {\n        const props = visualElement.getProps();\n        const 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        const animations = [];\n        /**\n         * Keep track of which values have been removed. Then, as we hit lower priority\n         * animation types, we can check if they contain removed values and animate to that.\n         */\n        const removedKeys = new Set();\n        /**\n         * A dictionary of all encountered keys. This is an object to let us build into and\n         * copy it without iteration. Each time we hit an animation type we set its protected\n         * keys - the keys its not allowed to animate - to the latest version of this object.\n         */\n        let encounteredKeys = {};\n        /**\n         * If a variant has been removed at a given index, and this component is controlling\n         * variant animations, we want to ensure lower-priority variants are forced to animate.\n         */\n        let removedVariantIndex = Infinity;\n        /**\n         * Iterate through all animation types in reverse priority order. For each, we want to\n         * detect which values it's handling and whether or not they've changed (and therefore\n         * need to be animated). If any values have been removed, we want to detect those in\n         * lower priority props and flag for animation.\n         */\n        for (let i = 0; i < numAnimationTypes; i++) {\n            const type = reversePriorityOrder[i];\n            const typeState = state[type];\n            const prop = props[type] !== undefined ? props[type] : context[type];\n            const propIsVariant = isVariantLabel(prop);\n            /**\n             * If this type has *just* changed isActive status, set activeDelta\n             * to that status. Otherwise set to null.\n             */\n            const activeDelta = type === changedActiveType ? typeState.isActive : null;\n            if (activeDelta === false)\n                removedVariantIndex = i;\n            /**\n             * If this prop is an inherited variant, rather than been set directly on the\n             * component itself, we want to make sure we allow the parent to trigger animations.\n             *\n             * TODO: Can probably change this to a !isControllingVariants check\n             */\n            let isInherited = prop === context[type] && 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 = { ...encounteredKeys };\n            // Check if we can skip analysing this prop early\n            if (\n            // If it isn't active and hasn't *just* been set as inactive\n            (!typeState.isActive && activeDelta === null) ||\n                // If we didn't and don't have any defined prop for this animation type\n                (!prop && !typeState.prevProp) ||\n                // Or if the prop doesn't define an animation\n                isAnimationControls(prop) ||\n                typeof prop === \"boolean\") {\n                continue;\n            }\n            /**\n             * As we go look through the values defined on this type, if we detect\n             * a changed value or a value that was removed in a higher priority, we set\n             * this to true and add this prop to the animation list.\n             */\n            const variantDidChange = checkVariantsDidChange(typeState.prevProp, prop);\n            let shouldAnimateType = variantDidChange ||\n                // If we're making this variant active, we want to always make it active\n                (type === changedActiveType &&\n                    typeState.isActive &&\n                    !isInherited &&\n                    propIsVariant) ||\n                // If we removed a higher-priority variant (i is in reverse order)\n                (i > removedVariantIndex && propIsVariant);\n            /**\n             * As animations can be set as variant lists, variants or target objects, we\n             * coerce everything to an array if it isn't one already\n             */\n            const definitionList = Array.isArray(prop) ? prop : [prop];\n            /**\n             * Build an object of all the resolved values. We'll use this in the subsequent\n             * animateChanges calls to determine whether a value has changed.\n             */\n            let resolvedValues = definitionList.reduce(buildResolvedTypeValues, {});\n            if (activeDelta === false)\n                resolvedValues = {};\n            /**\n             * Now we need to loop through all the keys in the prev prop and this prop,\n             * and decide:\n             * 1. If the value has changed, and needs animating\n             * 2. If it has been removed, and needs adding to the removedKeys set\n             * 3. If it has been removed in a higher priority type and needs animating\n             * 4. If it hasn't been removed in a higher priority but hasn't changed, and\n             *    needs adding to the type's protectedKeys list.\n             */\n            const { prevResolvedValues = {} } = typeState;\n            const allKeys = {\n                ...prevResolvedValues,\n                ...resolvedValues,\n            };\n            const markToAnimate = (key) => {\n                shouldAnimateType = true;\n                removedKeys.delete(key);\n                typeState.needsAnimating[key] = true;\n            };\n            for (const key in allKeys) {\n                const next = resolvedValues[key];\n                const prev = prevResolvedValues[key];\n                // If we've already handled this we can just skip ahead\n                if (encounteredKeys.hasOwnProperty(key))\n                    continue;\n                /**\n                 * If the value has changed, we probably want to animate it.\n                 */\n                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 = { ...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(...definitionList.map((animation) => ({\n                    animation: animation,\n                    options: { type, ...options },\n                })));\n            }\n        }\n        /**\n         * If there are some removed value that haven't been dealt with,\n         * we need to create a new animation that falls back either to the value\n         * defined in the style prop, or the last read value.\n         */\n        if (removedKeys.size) {\n            const fallbackAnimation = {};\n            removedKeys.forEach((key) => {\n                const fallbackTarget = visualElement.getBaseTarget(key);\n                if (fallbackTarget !== undefined) {\n                    fallbackAnimation[key] = fallbackTarget;\n                }\n            });\n            animations.push({ animation: fallbackAnimation });\n        }\n        let 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((child) => { var _a; return (_a = child.animationState) === null || _a === void 0 ? void 0 : _a.setActive(type, isActive); });\n        state[type].isActive = isActive;\n        const animations = animateChanges(options, type);\n        for (const key in state) {\n            state[key].protectedKeys = {};\n        }\n        return animations;\n    }\n    return {\n        animateChanges,\n        setActive,\n        setAnimateFunction,\n        getState: () => state,\n    };\n}\nfunction checkVariantsDidChange(prev, next) {\n    if (typeof next === \"string\") {\n        return next !== prev;\n    }\n    else if (Array.isArray(next)) {\n        return !shallowCompare(next, prev);\n    }\n    return false;\n}\nfunction createTypeState(isActive = false) {\n    return {\n        isActive,\n        protectedKeys: {},\n        needsAnimating: {},\n        prevResolvedValues: {},\n    };\n}\nfunction createState() {\n    return {\n        animate: createTypeState(true),\n        whileInView: createTypeState(),\n        whileHover: createTypeState(),\n        whileTap: createTypeState(),\n        whileDrag: createTypeState(),\n        whileFocus: createTypeState(),\n        exit: createTypeState(),\n    };\n}\n\nexport { checkVariantsDidChange, createAnimationState };\n","import { isAnimationControls } from '../../../animation/utils/is-animation-controls.mjs';\nimport { createAnimationState } from '../../../render/utils/animation-state.mjs';\nimport { Feature } from '../Feature.mjs';\n\nclass AnimationFeature extends Feature {\n    /**\n     * We dynamically generate the AnimationState manager as it contains a reference\n     * to the underlying animation library. We only want to load that if we load this,\n     * so people can optionally code split it out using the `m` component.\n     */\n    constructor(node) {\n        super(node);\n        node.animationState || (node.animationState = createAnimationState(node));\n    }\n    updateAnimationControlsSubscription() {\n        const { animate } = this.node.getProps();\n        this.unmount();\n        if (isAnimationControls(animate)) {\n            this.unmount = animate.subscribe(this.node);\n        }\n    }\n    /**\n     * Subscribe any provided AnimationControls to the component's VisualElement\n     */\n    mount() {\n        this.updateAnimationControlsSubscription();\n    }\n    update() {\n        const { animate } = this.node.getProps();\n        const { animate: prevAnimate } = this.node.prevProps || {};\n        if (animate !== prevAnimate) {\n            this.updateAnimationControlsSubscription();\n        }\n    }\n    unmount() { }\n}\n\nexport { AnimationFeature };\n","import { Feature } from '../Feature.mjs';\n\nlet id = 0;\nclass ExitAnimationFeature extends Feature {\n    constructor() {\n        super(...arguments);\n        this.id = id++;\n    }\n    update() {\n        if (!this.node.presenceContext)\n            return;\n        const { isPresent, onExitComplete, custom } = this.node.presenceContext;\n        const { isPresent: prevIsPresent } = this.node.prevPresenceContext || {};\n        if (!this.node.animationState || isPresent === prevIsPresent) {\n            return;\n        }\n        const exitAnimation = this.node.animationState.setActive(\"exit\", !isPresent, { custom: custom !== null && custom !== void 0 ? custom : this.node.getProps().custom });\n        if (onExitComplete && !isPresent) {\n            exitAnimation.then(() => onExitComplete(this.id));\n        }\n    }\n    mount() {\n        const { register } = this.node.presenceContext || {};\n        if (register) {\n            this.unmount = register(this.id);\n        }\n    }\n    unmount() { }\n}\n\nexport { ExitAnimationFeature };\n","import { AnimationFeature } from './animation/index.mjs';\nimport { ExitAnimationFeature } from './animation/exit.mjs';\n\nconst animations = {\n    animation: {\n        Feature: AnimationFeature,\n    },\n    exit: {\n        Feature: ExitAnimationFeature,\n    },\n};\n\nexport { animations };\n","import { addPointerEvent } from '../events/add-pointer-event.mjs';\nimport { pipe } from '../utils/pipe.mjs';\nimport { isDragActive } from './drag/utils/lock.mjs';\nimport { Feature } from '../motion/features/Feature.mjs';\n\nfunction addHoverEvent(node, isActive) {\n    const eventName = \"pointer\" + (isActive ? \"enter\" : \"leave\");\n    const callbackName = \"onHover\" + (isActive ? \"Start\" : \"End\");\n    const handleEvent = (event, info) => {\n        if (event.type === \"touch\" || isDragActive())\n            return;\n        const props = node.getProps();\n        if (node.animationState && props.whileHover) {\n            node.animationState.setActive(\"whileHover\", isActive);\n        }\n        if (props[callbackName]) {\n            props[callbackName](event, info);\n        }\n    };\n    return addPointerEvent(node.current, eventName, handleEvent, {\n        passive: !node.getProps()[callbackName],\n    });\n}\nclass HoverGesture extends Feature {\n    mount() {\n        this.unmount = pipe(addHoverEvent(this.node, true), addHoverEvent(this.node, false));\n    }\n    unmount() { }\n}\n\nexport { HoverGesture };\n","import { addDomEvent } from '../events/add-dom-event.mjs';\nimport { Feature } from '../motion/features/Feature.mjs';\nimport { pipe } from '../utils/pipe.mjs';\n\nclass FocusGesture extends Feature {\n    constructor() {\n        super(...arguments);\n        this.isActive = false;\n    }\n    onFocus() {\n        let isFocusVisible = false;\n        /**\n         * If this element doesn't match focus-visible then don't\n         * apply whileHover. But, if matches throws that focus-visible\n         * is not a valid selector then in that browser outline styles will be applied\n         * to the element by default and we want to match that behaviour with whileFocus.\n         */\n        try {\n            isFocusVisible = this.node.current.matches(\":focus-visible\");\n        }\n        catch (e) {\n            isFocusVisible = true;\n        }\n        if (!isFocusVisible || !this.node.animationState)\n            return;\n        this.node.animationState.setActive(\"whileFocus\", true);\n        this.isActive = true;\n    }\n    onBlur() {\n        if (!this.isActive || !this.node.animationState)\n            return;\n        this.node.animationState.setActive(\"whileFocus\", false);\n        this.isActive = false;\n    }\n    mount() {\n        this.unmount = pipe(addDomEvent(this.node.current, \"focus\", () => this.onFocus()), addDomEvent(this.node.current, \"blur\", () => this.onBlur()));\n    }\n    unmount() { }\n}\n\nexport { FocusGesture };\n","/**\n * Recursively traverse up the tree to check whether the provided child node\n * is the parent or a descendant of it.\n *\n * @param parent - Element to find\n * @param child - Element to test against parent\n */\nconst isNodeOrChild = (parent, child) => {\n    if (!child) {\n        return false;\n    }\n    else if (parent === child) {\n        return true;\n    }\n    else {\n        return isNodeOrChild(parent, child.parentElement);\n    }\n};\n\nexport { isNodeOrChild };\n","import { extractEventInfo } from '../events/event-info.mjs';\nimport { addDomEvent } from '../events/add-dom-event.mjs';\nimport { addPointerEvent } from '../events/add-pointer-event.mjs';\nimport { Feature } from '../motion/features/Feature.mjs';\nimport { pipe } from '../utils/pipe.mjs';\nimport { isDragActive } from './drag/utils/lock.mjs';\nimport { isNodeOrChild } from './utils/is-node-or-child.mjs';\nimport { noop } from '../utils/noop.mjs';\n\nfunction fireSyntheticPointerEvent(name, handler) {\n    if (!handler)\n        return;\n    const syntheticPointerEvent = new PointerEvent(\"pointer\" + name);\n    handler(syntheticPointerEvent, extractEventInfo(syntheticPointerEvent));\n}\nclass PressGesture extends Feature {\n    constructor() {\n        super(...arguments);\n        this.removeStartListeners = noop;\n        this.removeEndListeners = noop;\n        this.removeAccessibleListeners = noop;\n        this.startPointerPress = (startEvent, startInfo) => {\n            this.removeEndListeners();\n            if (this.isPressing)\n                return;\n            const props = this.node.getProps();\n            const endPointerPress = (endEvent, endInfo) => {\n                if (!this.checkPressEnd())\n                    return;\n                const { onTap, onTapCancel } = this.node.getProps();\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(this.node.current, endEvent.target)\n                    ? onTapCancel && onTapCancel(endEvent, endInfo)\n                    : onTap && onTap(endEvent, endInfo);\n            };\n            const removePointerUpListener = addPointerEvent(window, \"pointerup\", endPointerPress, { passive: !(props.onTap || props[\"onPointerUp\"]) });\n            const removePointerCancelListener = addPointerEvent(window, \"pointercancel\", (cancelEvent, cancelInfo) => this.cancelPress(cancelEvent, cancelInfo), { passive: !(props.onTapCancel || props[\"onPointerCancel\"]) });\n            this.removeEndListeners = pipe(removePointerUpListener, removePointerCancelListener);\n            this.startPress(startEvent, startInfo);\n        };\n        this.startAccessiblePress = () => {\n            const handleKeydown = (keydownEvent) => {\n                if (keydownEvent.key !== \"Enter\" || this.isPressing)\n                    return;\n                const handleKeyup = (keyupEvent) => {\n                    if (keyupEvent.key !== \"Enter\" || !this.checkPressEnd())\n                        return;\n                    fireSyntheticPointerEvent(\"up\", this.node.getProps().onTap);\n                };\n                this.removeEndListeners();\n                this.removeEndListeners = addDomEvent(this.node.current, \"keyup\", handleKeyup);\n                fireSyntheticPointerEvent(\"down\", (event, info) => {\n                    this.startPress(event, info);\n                });\n            };\n            const removeKeydownListener = addDomEvent(this.node.current, \"keydown\", handleKeydown);\n            const handleBlur = () => {\n                if (!this.isPressing)\n                    return;\n                fireSyntheticPointerEvent(\"cancel\", (cancelEvent, cancelInfo) => this.cancelPress(cancelEvent, cancelInfo));\n            };\n            const removeBlurListener = addDomEvent(this.node.current, \"blur\", handleBlur);\n            this.removeAccessibleListeners = pipe(removeKeydownListener, removeBlurListener);\n        };\n    }\n    startPress(event, info) {\n        this.isPressing = true;\n        const { onTapStart, whileTap } = this.node.getProps();\n        /**\n         * Ensure we trigger animations before firing event callback\n         */\n        if (whileTap && this.node.animationState) {\n            this.node.animationState.setActive(\"whileTap\", true);\n        }\n        onTapStart && onTapStart(event, info);\n    }\n    checkPressEnd() {\n        this.removeEndListeners();\n        this.isPressing = false;\n        const props = this.node.getProps();\n        if (props.whileTap && this.node.animationState) {\n            this.node.animationState.setActive(\"whileTap\", false);\n        }\n        return !isDragActive();\n    }\n    cancelPress(event, info) {\n        if (!this.checkPressEnd())\n            return;\n        const { onTapCancel } = this.node.getProps();\n        onTapCancel && onTapCancel(event, info);\n    }\n    mount() {\n        const props = this.node.getProps();\n        const removePointerListener = addPointerEvent(this.node.current, \"pointerdown\", this.startPointerPress, { passive: !(props.onTapStart || props[\"onPointerStart\"]) });\n        const removeFocusListener = addDomEvent(this.node.current, \"focus\", this.startAccessiblePress);\n        this.removeStartListeners = pipe(removePointerListener, removeFocusListener);\n    }\n    unmount() {\n        this.removeStartListeners();\n        this.removeEndListeners();\n        this.removeAccessibleListeners();\n    }\n}\n\nexport { PressGesture };\n","/**\n * Map an IntersectionHandler callback to an element. We only ever make one handler for one\n * element, so even though these handlers might all be triggered by different\n * observers, we can keep them in the same map.\n */\nconst observerCallbacks = new WeakMap();\n/**\n * Multiple observers can be created for multiple element/document roots. Each with\n * different settings. So here we store dictionaries of observers to each root,\n * using serialised settings (threshold/margin) as lookup keys.\n */\nconst observers = new WeakMap();\nconst fireObserverCallback = (entry) => {\n    const callback = observerCallbacks.get(entry.target);\n    callback && callback(entry);\n};\nconst fireAllObserverCallbacks = (entries) => {\n    entries.forEach(fireObserverCallback);\n};\nfunction initIntersectionObserver({ root, ...options }) {\n    const lookupRoot = root || document;\n    /**\n     * If we don't have an observer lookup map for this root, create one.\n     */\n    if (!observers.has(lookupRoot)) {\n        observers.set(lookupRoot, {});\n    }\n    const rootObservers = observers.get(lookupRoot);\n    const key = JSON.stringify(options);\n    /**\n     * If we don't have an observer for this combination of root and settings,\n     * create one.\n     */\n    if (!rootObservers[key]) {\n        rootObservers[key] = new IntersectionObserver(fireAllObserverCallbacks, { root, ...options });\n    }\n    return rootObservers[key];\n}\nfunction observeIntersection(element, options, callback) {\n    const rootInteresectionObserver = initIntersectionObserver(options);\n    observerCallbacks.set(element, callback);\n    rootInteresectionObserver.observe(element);\n    return () => {\n        observerCallbacks.delete(element);\n        rootInteresectionObserver.unobserve(element);\n    };\n}\n\nexport { observeIntersection };\n","import { Feature } from '../Feature.mjs';\nimport { observeIntersection } from './observers.mjs';\n\nconst thresholdNames = {\n    some: 0,\n    all: 1,\n};\nclass InViewFeature extends Feature {\n    constructor() {\n        super(...arguments);\n        this.hasEnteredView = false;\n        this.isInView = false;\n    }\n    /**\n     * TODO: Remove this in 10.0\n     */\n    viewportFallback() {\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        requestAnimationFrame(() => {\n            this.hasEnteredView = true;\n            const { onViewportEnter } = this.node.getProps();\n            onViewportEnter && onViewportEnter(null);\n            if (this.node.animationState) {\n                this.node.animationState.setActive(\"whileInView\", true);\n            }\n        });\n    }\n    startObserver() {\n        this.unmount();\n        const { viewport = {} } = this.node.getProps();\n        const { root, margin: rootMargin, amount = \"some\", once, fallback = true, } = viewport;\n        if (typeof IntersectionObserver === \"undefined\") {\n            if (fallback)\n                this.viewportFallback();\n            return;\n        }\n        const options = {\n            root: root ? root.current : undefined,\n            rootMargin,\n            threshold: typeof amount === \"number\" ? amount : thresholdNames[amount],\n        };\n        const onIntersectionUpdate = (entry) => {\n            const { isIntersecting } = entry;\n            /**\n             * If there's been no change in the viewport state, early return.\n             */\n            if (this.isInView === isIntersecting)\n                return;\n            this.isInView = isIntersecting;\n            /**\n             * Handle hasEnteredView. If this is only meant to run once, and\n             * element isn't visible, early return. Otherwise set hasEnteredView to true.\n             */\n            if (once && !isIntersecting && this.hasEnteredView) {\n                return;\n            }\n            else if (isIntersecting) {\n                this.hasEnteredView = true;\n            }\n            if (this.node.animationState) {\n                this.node.animationState.setActive(\"whileInView\", isIntersecting);\n            }\n            /**\n             * Use the latest committed props rather than the ones in scope\n             * when this observer is created\n             */\n            const { onViewportEnter, onViewportLeave } = this.node.getProps();\n            const callback = isIntersecting ? onViewportEnter : onViewportLeave;\n            callback && callback(entry);\n        };\n        return observeIntersection(this.node.current, options, onIntersectionUpdate);\n    }\n    mount() {\n        this.startObserver();\n    }\n    update() {\n        if (typeof IntersectionObserver === \"undefined\")\n            return;\n        const { props, prevProps } = this.node;\n        const hasOptionsChanged = [\"amount\", \"margin\", \"root\"].some(hasViewportOptionChanged(props, prevProps));\n        if (hasOptionsChanged) {\n            this.startObserver();\n        }\n    }\n    unmount() { }\n}\nfunction hasViewportOptionChanged({ viewport = {} }, { viewport: prevViewport = {} } = {}) {\n    return (name) => viewport[name] !== prevViewport[name];\n}\n\nexport { InViewFeature };\n","import { HoverGesture } from '../../gestures/hover.mjs';\nimport { FocusGesture } from '../../gestures/focus.mjs';\nimport { PressGesture } from '../../gestures/press.mjs';\nimport { InViewFeature } from './viewport/index.mjs';\n\nconst gestureAnimations = {\n    inView: {\n        Feature: InViewFeature,\n    },\n    tap: {\n        Feature: PressGesture,\n    },\n    focus: {\n        Feature: FocusGesture,\n    },\n    hover: {\n        Feature: HoverGesture,\n    },\n};\n\nexport { gestureAnimations };\n","import { isKeyframesTarget } from '../../../animation/utils/is-keyframes-target.mjs';\nimport { invariant } from '../../../utils/errors.mjs';\nimport { transformPropOrder } from '../../html/utils/transform.mjs';\nimport { findDimensionValueType } from '../value-types/dimensions.mjs';\nimport { isBrowser } from '../../../utils/is-browser.mjs';\nimport { number } from '../../../value/types/numbers/index.mjs';\nimport { px } from '../../../value/types/numbers/units.mjs';\n\nconst positionalKeys = new Set([\n    \"width\",\n    \"height\",\n    \"top\",\n    \"left\",\n    \"right\",\n    \"bottom\",\n    \"x\",\n    \"y\",\n]);\nconst isPositionalKey = (key) => positionalKeys.has(key);\nconst hasPositionalKey = (target) => {\n    return Object.keys(target).some(isPositionalKey);\n};\nconst isNumOrPxType = (v) => v === number || v === px;\nconst getPosFromMatrix = (matrix, pos) => parseFloat(matrix.split(\", \")[pos]);\nconst getTranslateFromMatrix = (pos2, pos3) => (_bbox, { transform }) => {\n    if (transform === \"none\" || !transform)\n        return 0;\n    const matrix3d = transform.match(/^matrix3d\\((.+)\\)$/);\n    if (matrix3d) {\n        return getPosFromMatrix(matrix3d[1], pos3);\n    }\n    else {\n        const matrix = transform.match(/^matrix\\((.+)\\)$/);\n        if (matrix) {\n            return getPosFromMatrix(matrix[1], pos2);\n        }\n        else {\n            return 0;\n        }\n    }\n};\nconst transformKeys = new Set([\"x\", \"y\", \"z\"]);\nconst nonTranslationalTransformKeys = transformPropOrder.filter((key) => !transformKeys.has(key));\nfunction removeNonTranslationalTransform(visualElement) {\n    const removedTransforms = [];\n    nonTranslationalTransformKeys.forEach((key) => {\n        const value = visualElement.getValue(key);\n        if (value !== undefined) {\n            removedTransforms.push([key, value.get()]);\n            value.set(key.startsWith(\"scale\") ? 1 : 0);\n        }\n    });\n    // Apply changes to element before measurement\n    if (removedTransforms.length)\n        visualElement.render();\n    return removedTransforms;\n}\nconst positionalValues = {\n    // Dimensions\n    width: ({ x }, { paddingLeft = \"0\", paddingRight = \"0\" }) => x.max - x.min - parseFloat(paddingLeft) - parseFloat(paddingRight),\n    height: ({ y }, { paddingTop = \"0\", paddingBottom = \"0\" }) => y.max - y.min - parseFloat(paddingTop) - parseFloat(paddingBottom),\n    top: (_bbox, { top }) => parseFloat(top),\n    left: (_bbox, { left }) => parseFloat(left),\n    bottom: ({ y }, { top }) => parseFloat(top) + (y.max - y.min),\n    right: ({ x }, { left }) => parseFloat(left) + (x.max - x.min),\n    // Transform\n    x: getTranslateFromMatrix(4, 13),\n    y: getTranslateFromMatrix(5, 14),\n};\nconst convertChangedValueTypes = (target, visualElement, changedKeys) => {\n    const originBbox = visualElement.measureViewportBox();\n    const element = visualElement.current;\n    const elementComputedStyle = getComputedStyle(element);\n    const { display } = elementComputedStyle;\n    const 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((key) => {\n        origin[key] = positionalValues[key](originBbox, elementComputedStyle);\n    });\n    // Apply the latest values (as set in checkAndConvertChangedValueTypes)\n    visualElement.render();\n    const targetBbox = visualElement.measureViewportBox();\n    changedKeys.forEach((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        const value = visualElement.getValue(key);\n        value && value.jump(origin[key]);\n        target[key] = positionalValues[key](targetBbox, elementComputedStyle);\n    });\n    return target;\n};\nconst checkAndConvertChangedValueTypes = (visualElement, target, origin = {}, transitionEnd = {}) => {\n    target = { ...target };\n    transitionEnd = { ...transitionEnd };\n    const 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    let removedTransformValues = [];\n    let hasAttemptedToRemoveTransformValues = false;\n    const changedValueTypeKeys = [];\n    targetPositionalKeys.forEach((key) => {\n        const value = visualElement.getValue(key);\n        if (!visualElement.hasValue(key))\n            return;\n        let from = origin[key];\n        let fromType = findDimensionValueType(from);\n        const to = target[key];\n        let 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            const numKeyframes = to.length;\n            const fromIndex = to[0] === null ? 1 : 0;\n            from = to[fromIndex];\n            fromType = findDimensionValueType(from);\n            for (let i = fromIndex; i < numKeyframes; i++) {\n                if (!toType) {\n                    toType = findDimensionValueType(to[i]);\n                    invariant(toType === fromType ||\n                        (isNumOrPxType(fromType) && isNumOrPxType(toType)), \"Keyframes must be of the same dimension as the current value\");\n                }\n                else {\n                    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                const 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 === 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                value.jump(to);\n            }\n        }\n    });\n    if (changedValueTypeKeys.length) {\n        const scrollY = changedValueTypeKeys.indexOf(\"height\") >= 0\n            ? window.pageYOffset\n            : null;\n        const convertedTarget = convertChangedValueTypes(target, visualElement, changedValueTypeKeys);\n        // If we removed transform values, reapply them before the next render\n        if (removedTransformValues.length) {\n            removedTransformValues.forEach(([key, value]) => {\n                visualElement.getValue(key).set(value);\n            });\n        }\n        // Reapply original values\n        visualElement.render();\n        // Restore scroll position\n        if (isBrowser && scrollY !== null) {\n            window.scrollTo({ top: scrollY });\n        }\n        return { target: convertedTarget, transitionEnd };\n    }\n    else {\n        return { target, 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, transitionEnd };\n}\n\nexport { positionalValues, unitConversion };\n","import { resolveCSSVariables } from './css-variables-conversion.mjs';\nimport { unitConversion } from './unit-conversion.mjs';\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 */\nconst parseDomVariant = (visualElement, target, origin, transitionEnd) => {\n    const resolved = resolveCSSVariables(visualElement, target, transitionEnd);\n    target = resolved.target;\n    transitionEnd = resolved.transitionEnd;\n    return unitConversion(visualElement, target, origin, transitionEnd);\n};\n\nexport { parseDomVariant };\n","// Does this device prefer reduced motion? Returns `null` server-side.\nconst prefersReducedMotion = { current: null };\nconst hasReducedMotionListener = { current: false };\n\nexport { hasReducedMotionListener, prefersReducedMotion };\n","import { sync, cancelSync } from '../frameloop/index.mjs';\nimport { warning, invariant } from '../utils/errors.mjs';\nimport { createBox } from '../projection/geometry/models.mjs';\nimport { isRefObject } from '../utils/is-ref-object.mjs';\nimport { initPrefersReducedMotion } from '../utils/reduced-motion/index.mjs';\nimport { hasReducedMotionListener, prefersReducedMotion } from '../utils/reduced-motion/state.mjs';\nimport { SubscriptionManager } from '../utils/subscription-manager.mjs';\nimport { motionValue } from '../value/index.mjs';\nimport { isWillChangeMotionValue } from '../value/use-will-change/is.mjs';\nimport { isMotionValue } from '../value/utils/is-motion-value.mjs';\nimport { transformProps } from './html/utils/transform.mjs';\nimport { isControllingVariants, isVariantNode } from './utils/is-controlling-variants.mjs';\nimport { isVariantLabel } from './utils/is-variant-label.mjs';\nimport { updateMotionValuesFromProps } from './utils/motion-values.mjs';\nimport { resolveVariantFromProps } from './utils/resolve-variants.mjs';\nimport { warnOnce } from '../utils/warn-once.mjs';\nimport { featureDefinitions } from '../motion/features/definitions.mjs';\nimport { variantProps } from './utils/variant-props.mjs';\n\nconst featureNames = Object.keys(featureDefinitions);\nconst numFeatures = featureNames.length;\nconst propEventHandlers = [\n    \"AnimationStart\",\n    \"AnimationComplete\",\n    \"Update\",\n    \"BeforeLayoutMeasure\",\n    \"LayoutMeasure\",\n    \"LayoutAnimationStart\",\n    \"LayoutAnimationComplete\",\n];\nconst numVariantProps = variantProps.length;\n/**\n * A VisualElement is an imperative abstraction around UI elements such as\n * HTMLElement, SVGElement, Three.Object3D etc.\n */\nclass VisualElement {\n    constructor({ parent, props, presenceContext, reducedMotionConfig, visualState, }, options = {}) {\n        /**\n         * A reference to the current underlying Instance, e.g. a HTMLElement\n         * or Three.Mesh etc.\n         */\n        this.current = null;\n        /**\n         * A set containing references to this VisualElement's children.\n         */\n        this.children = new Set();\n        /**\n         * Determine what role this visual element should take in the variant tree.\n         */\n        this.isVariantNode = false;\n        this.isControllingVariants = false;\n        /**\n         * Decides whether this VisualElement should animate in reduced motion\n         * mode.\n         *\n         * TODO: This is currently set on every individual VisualElement but feels\n         * like it could be set globally.\n         */\n        this.shouldReduceMotion = null;\n        /**\n         * A map of all motion values attached to this visual element. Motion\n         * values are source of truth for any given animated value. A motion\n         * value might be provided externally by the component via props.\n         */\n        this.values = new Map();\n        /**\n         * Cleanup functions for active features (hover/tap/exit etc)\n         */\n        this.features = {};\n        /**\n         * A map of every subscription that binds the provided or generated\n         * motion values onChange listeners to this visual element.\n         */\n        this.valueSubscriptions = new Map();\n        /**\n         * A reference to the previously-provided motion values as returned\n         * from scrapeMotionValuesFromProps. We use the keys in here to determine\n         * if any motion values need to be removed after props are updated.\n         */\n        this.prevMotionValues = {};\n        /**\n         * An object containing a SubscriptionManager for each active event.\n         */\n        this.events = {};\n        /**\n         * An object containing an unsubscribe function for each prop event subscription.\n         * For example, every \"Update\" event can have multiple subscribers via\n         * VisualElement.on(), but only one of those can be defined via the onUpdate prop.\n         */\n        this.propEventSubscriptions = {};\n        this.notifyUpdate = () => this.notify(\"Update\", this.latestValues);\n        this.render = () => {\n            if (!this.current)\n                return;\n            this.triggerBuild();\n            this.renderInstance(this.current, this.renderState, this.props.style, this.projection);\n        };\n        this.scheduleRender = () => sync.render(this.render, false, true);\n        const { latestValues, renderState } = visualState;\n        this.latestValues = latestValues;\n        this.baseTarget = { ...latestValues };\n        this.initialValues = props.initial ? { ...latestValues } : {};\n        this.renderState = renderState;\n        this.parent = parent;\n        this.props = props;\n        this.presenceContext = presenceContext;\n        this.depth = parent ? parent.depth + 1 : 0;\n        this.reducedMotionConfig = reducedMotionConfig;\n        this.options = options;\n        this.isControllingVariants = isControllingVariants(props);\n        this.isVariantNode = isVariantNode(props);\n        if (this.isVariantNode) {\n            this.variantChildren = new Set();\n        }\n        this.manuallyAnimateOnMount = Boolean(parent && parent.current);\n        /**\n         * Any motion values that are provided to the element when created\n         * aren't yet bound to the element, as this would technically be impure.\n         * However, we iterate through the motion values and set them to the\n         * initial values for this component.\n         *\n         * TODO: This is impure and we should look at changing this to run on mount.\n         * Doing so will break some tests but this isn't neccessarily a breaking change,\n         * more a reflection of the test.\n         */\n        const { willChange, ...initialMotionValues } = this.scrapeMotionValuesFromProps(props, {});\n        for (const key in initialMotionValues) {\n            const value = initialMotionValues[key];\n            if (latestValues[key] !== undefined && isMotionValue(value)) {\n                value.set(latestValues[key], false);\n                if (isWillChangeMotionValue(willChange)) {\n                    willChange.add(key);\n                }\n            }\n        }\n    }\n    /**\n     * This method takes React props and returns found MotionValues. For example, HTML\n     * MotionValues will be found within the style prop, whereas for Three.js within attribute arrays.\n     *\n     * This isn't an abstract method as it needs calling in the constructor, but it is\n     * intended to be one.\n     */\n    scrapeMotionValuesFromProps(_props, _prevProps) {\n        return {};\n    }\n    mount(instance) {\n        this.current = instance;\n        if (this.projection) {\n            this.projection.mount(instance);\n        }\n        if (this.parent && this.isVariantNode && !this.isControllingVariants) {\n            this.removeFromVariantTree = this.parent.addVariantChild(this);\n        }\n        this.values.forEach((value, key) => this.bindToMotionValue(key, value));\n        if (!hasReducedMotionListener.current) {\n            initPrefersReducedMotion();\n        }\n        this.shouldReduceMotion =\n            this.reducedMotionConfig === \"never\"\n                ? false\n                : this.reducedMotionConfig === \"always\"\n                    ? true\n                    : prefersReducedMotion.current;\n        if (process.env.NODE_ENV !== \"production\") {\n            warnOnce(this.shouldReduceMotion !== true, \"You have Reduced Motion enabled on your device. Animations may not appear as expected.\");\n        }\n        if (this.parent)\n            this.parent.children.add(this);\n        this.update(this.props, this.presenceContext);\n    }\n    unmount() {\n        this.projection && this.projection.unmount();\n        cancelSync.update(this.notifyUpdate);\n        cancelSync.render(this.render);\n        this.valueSubscriptions.forEach((remove) => remove());\n        this.removeFromVariantTree && this.removeFromVariantTree();\n        this.parent && this.parent.children.delete(this);\n        for (const key in this.events) {\n            this.events[key].clear();\n        }\n        for (const key in this.features) {\n            this.features[key].unmount();\n        }\n        this.current = null;\n    }\n    bindToMotionValue(key, value) {\n        const valueIsTransform = transformProps.has(key);\n        const removeOnChange = value.on(\"change\", (latestValue) => {\n            this.latestValues[key] = latestValue;\n            this.props.onUpdate &&\n                sync.update(this.notifyUpdate, false, true);\n            if (valueIsTransform && this.projection) {\n                this.projection.isTransformDirty = true;\n            }\n        });\n        const removeOnRenderRequest = value.on(\"renderRequest\", this.scheduleRender);\n        this.valueSubscriptions.set(key, () => {\n            removeOnChange();\n            removeOnRenderRequest();\n        });\n    }\n    sortNodePosition(other) {\n        /**\n         * If these nodes aren't even of the same type we can't compare their depth.\n         */\n        if (!this.current ||\n            !this.sortInstanceNodePosition ||\n            this.type !== other.type) {\n            return 0;\n        }\n        return this.sortInstanceNodePosition(this.current, other.current);\n    }\n    loadFeatures({ children, ...renderedProps }, isStrict, preloadedFeatures, projectionId, initialLayoutGroupConfig) {\n        let ProjectionNodeConstructor;\n        let MeasureLayout;\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 (process.env.NODE_ENV !== \"production\" &&\n            preloadedFeatures &&\n            isStrict) {\n            const strictMessage = \"You have rendered a `motion` component within a `LazyMotion` component. This will break tree shaking. Import and render a `m` component instead.\";\n            renderedProps.ignoreStrict\n                ? warning(false, strictMessage)\n                : invariant(false, strictMessage);\n        }\n        for (let i = 0; i < numFeatures; i++) {\n            const name = featureNames[i];\n            const { isEnabled, Feature: FeatureConstructor, ProjectionNode, MeasureLayout: MeasureLayoutComponent, } = featureDefinitions[name];\n            if (ProjectionNode)\n                ProjectionNodeConstructor = ProjectionNode;\n            if (isEnabled(renderedProps)) {\n                if (!this.features[name] && FeatureConstructor) {\n                    this.features[name] = new FeatureConstructor(this);\n                }\n                if (MeasureLayoutComponent) {\n                    MeasureLayout = MeasureLayoutComponent;\n                }\n            }\n        }\n        if (!this.projection && ProjectionNodeConstructor) {\n            this.projection = new ProjectionNodeConstructor(projectionId, this.latestValues, this.parent && this.parent.projection);\n            const { layoutId, layout, drag, dragConstraints, layoutScroll, layoutRoot, } = renderedProps;\n            this.projection.setOptions({\n                layoutId,\n                layout,\n                alwaysMeasureLayout: Boolean(drag) ||\n                    (dragConstraints && isRefObject(dragConstraints)),\n                visualElement: this,\n                scheduleRender: () => this.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: initialLayoutGroupConfig,\n                layoutScroll,\n                layoutRoot,\n            });\n        }\n        return MeasureLayout;\n    }\n    updateFeatures() {\n        for (const key in this.features) {\n            const feature = this.features[key];\n            if (feature.isMounted) {\n                feature.update(this.props, this.prevProps);\n            }\n            else {\n                feature.mount();\n                feature.isMounted = true;\n            }\n        }\n    }\n    triggerBuild() {\n        this.build(this.renderState, this.latestValues, this.options, this.props);\n    }\n    /**\n     * Measure the current viewport box with or without transforms.\n     * Only measures axis-aligned boxes, rotate and skew must be manually\n     * removed with a re-render to work.\n     */\n    measureViewportBox() {\n        return this.current\n            ? this.measureInstanceViewportBox(this.current, this.props)\n            : createBox();\n    }\n    getStaticValue(key) {\n        return this.latestValues[key];\n    }\n    setStaticValue(key, value) {\n        this.latestValues[key] = value;\n    }\n    /**\n     * 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(target, canMutate = true) {\n        return this.makeTargetAnimatableFromInstance(target, this.props, canMutate);\n    }\n    /**\n     * Update the provided props. Ensure any newly-added motion values are\n     * added to our map, old ones removed, and listeners updated.\n     */\n    update(props, presenceContext) {\n        if (props.transformTemplate || this.props.transformTemplate) {\n            this.scheduleRender();\n        }\n        this.prevProps = this.props;\n        this.props = props;\n        this.prevPresenceContext = this.presenceContext;\n        this.presenceContext = presenceContext;\n        /**\n         * Update prop event handlers ie onAnimationStart, onAnimationComplete\n         */\n        for (let i = 0; i < propEventHandlers.length; i++) {\n            const key = propEventHandlers[i];\n            if (this.propEventSubscriptions[key]) {\n                this.propEventSubscriptions[key]();\n                delete this.propEventSubscriptions[key];\n            }\n            const listener = props[\"on\" + key];\n            if (listener) {\n                this.propEventSubscriptions[key] = this.on(key, listener);\n            }\n        }\n        this.prevMotionValues = updateMotionValuesFromProps(this, this.scrapeMotionValuesFromProps(props, this.prevProps), this.prevMotionValues);\n        if (this.handleChildMotionValue) {\n            this.handleChildMotionValue();\n        }\n    }\n    getProps() {\n        return this.props;\n    }\n    /**\n     * Returns the variant definition with a given name.\n     */\n    getVariant(name) {\n        return this.props.variants ? this.props.variants[name] : undefined;\n    }\n    /**\n     * Returns the defined default transition on this component.\n     */\n    getDefaultTransition() {\n        return this.props.transition;\n    }\n    getTransformPagePoint() {\n        return this.props.transformPagePoint;\n    }\n    getClosestVariantNode() {\n        return this.isVariantNode\n            ? this\n            : this.parent\n                ? this.parent.getClosestVariantNode()\n                : undefined;\n    }\n    getVariantContext(startAtParent = false) {\n        if (startAtParent) {\n            return this.parent ? this.parent.getVariantContext() : undefined;\n        }\n        if (!this.isControllingVariants) {\n            const context = this.parent\n                ? this.parent.getVariantContext() || {}\n                : {};\n            if (this.props.initial !== undefined) {\n                context.initial = this.props.initial;\n            }\n            return context;\n        }\n        const context = {};\n        for (let i = 0; i < numVariantProps; i++) {\n            const name = variantProps[i];\n            const prop = this.props[name];\n            if (isVariantLabel(prop) || prop === false) {\n                context[name] = prop;\n            }\n        }\n        return context;\n    }\n    /**\n     * Add a child visual element to our set of children.\n     */\n    addVariantChild(child) {\n        const closestVariantNode = this.getClosestVariantNode();\n        if (closestVariantNode) {\n            closestVariantNode.variantChildren &&\n                closestVariantNode.variantChildren.add(child);\n            return () => closestVariantNode.variantChildren.delete(child);\n        }\n    }\n    /**\n     * Add a motion value and bind it to this visual element.\n     */\n    addValue(key, value) {\n        // Remove existing value if it exists\n        if (value !== this.values.get(key)) {\n            this.removeValue(key);\n            this.bindToMotionValue(key, value);\n        }\n        this.values.set(key, value);\n        this.latestValues[key] = value.get();\n    }\n    /**\n     * Remove a motion value and unbind any active subscriptions.\n     */\n    removeValue(key) {\n        this.values.delete(key);\n        const unsubscribe = this.valueSubscriptions.get(key);\n        if (unsubscribe) {\n            unsubscribe();\n            this.valueSubscriptions.delete(key);\n        }\n        delete this.latestValues[key];\n        this.removeValueFromRenderState(key, this.renderState);\n    }\n    /**\n     * Check whether we have a motion value for this key\n     */\n    hasValue(key) {\n        return this.values.has(key);\n    }\n    getValue(key, defaultValue) {\n        if (this.props.values && this.props.values[key]) {\n            return this.props.values[key];\n        }\n        let value = this.values.get(key);\n        if (value === undefined && defaultValue !== undefined) {\n            value = motionValue(defaultValue, { owner: this });\n            this.addValue(key, value);\n        }\n        return value;\n    }\n    /**\n     * If we're trying to animate to a previously unencountered value,\n     * we need to check for it in our state and as a last resort read it\n     * directly from the instance (which might have performance implications).\n     */\n    readValue(key) {\n        return this.latestValues[key] !== undefined || !this.current\n            ? this.latestValues[key]\n            : this.readValueFromInstance(this.current, key, this.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(key, value) {\n        this.baseTarget[key] = value;\n    }\n    /**\n     * Find the base target for a value thats been removed from all animation\n     * props.\n     */\n    getBaseTarget(key) {\n        var _a;\n        const { initial } = this.props;\n        const valueFromInitial = typeof initial === \"string\" || typeof initial === \"object\"\n            ? (_a = resolveVariantFromProps(this.props, initial)) === null || _a === void 0 ? void 0 : _a[key]\n            : undefined;\n        /**\n         * If this value still exists in the current initial variant, read that.\n         */\n        if (initial && valueFromInitial !== undefined) {\n            return valueFromInitial;\n        }\n        /**\n         * Alternatively, if this VisualElement config has defined a getBaseTarget\n         * so we can read the value from an alternative source, try that.\n         */\n        const target = this.getBaseTargetFromProps(this.props, key);\n        if (target !== undefined && !isMotionValue(target))\n            return target;\n        /**\n         * If the value was initially defined on initial, but it doesn't any more,\n         * return undefined. Otherwise return the value as initially read from the DOM.\n         */\n        return this.initialValues[key] !== undefined &&\n            valueFromInitial === undefined\n            ? undefined\n            : this.baseTarget[key];\n    }\n    on(eventName, callback) {\n        if (!this.events[eventName]) {\n            this.events[eventName] = new SubscriptionManager();\n        }\n        return this.events[eventName].add(callback);\n    }\n    notify(eventName, ...args) {\n        if (this.events[eventName]) {\n            this.events[eventName].notify(...args);\n        }\n    }\n}\n\nexport { VisualElement };\n","import { isBrowser } from '../is-browser.mjs';\nimport { hasReducedMotionListener, prefersReducedMotion } from './state.mjs';\n\nfunction initPrefersReducedMotion() {\n    hasReducedMotionListener.current = true;\n    if (!isBrowser)\n        return;\n    if (window.matchMedia) {\n        const motionMediaQuery = window.matchMedia(\"(prefers-reduced-motion)\");\n        const setReducedMotionPreferences = () => (prefersReducedMotion.current = motionMediaQuery.matches);\n        motionMediaQuery.addListener(setReducedMotionPreferences);\n        setReducedMotionPreferences();\n    }\n    else {\n        prefersReducedMotion.current = false;\n    }\n}\n\nexport { initPrefersReducedMotion };\n","import { isWillChangeMotionValue } from '../../value/use-will-change/is.mjs';\nimport { warnOnce } from '../../utils/warn-once.mjs';\nimport { motionValue } from '../../value/index.mjs';\nimport { isMotionValue } from '../../value/utils/is-motion-value.mjs';\n\nfunction updateMotionValuesFromProps(element, next, prev) {\n    const { willChange } = next;\n    for (const key in next) {\n        const nextValue = next[key];\n        const prevValue = prev[key];\n        if (isMotionValue(nextValue)) {\n            /**\n             * If this is a motion value found in props or style, we want to add it\n             * to our visual element's motion value map.\n             */\n            element.addValue(key, nextValue);\n            if (isWillChangeMotionValue(willChange)) {\n                willChange.add(key);\n            }\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 === \"9.1.7\", `Attempting to mix Framer Motion versions ${nextValue.version} with 9.1.7 may not work as expected.`);\n            }\n        }\n        else if (isMotionValue(prevValue)) {\n            /**\n             * If we're swapping from a motion value to a static value,\n             * create a new motion value from that\n             */\n            element.addValue(key, motionValue(nextValue, { owner: element }));\n            if (isWillChangeMotionValue(willChange)) {\n                willChange.remove(key);\n            }\n        }\n        else if (prevValue !== nextValue) {\n            /**\n             * If this is a flat value that has changed, update the motion value\n             * or create one if it doesn't exist. We only want to do this if we're\n             * not handling the value with our animation state.\n             */\n            if (element.hasValue(key)) {\n                const existingValue = element.getValue(key);\n                // TODO: Only update values that aren't being animated or even looked at\n                !existingValue.hasAnimated && existingValue.set(nextValue);\n            }\n            else {\n                const latestValue = element.getStaticValue(key);\n                element.addValue(key, motionValue(latestValue !== undefined ? latestValue : nextValue, { owner: element }));\n            }\n        }\n    }\n    // Handle removed values\n    for (const key in prev) {\n        if (next[key] === undefined)\n            element.removeValue(key);\n    }\n    return next;\n}\n\nexport { updateMotionValuesFromProps };\n","import { getOrigin, checkTargetForNewValues } from '../utils/setters.mjs';\nimport { parseDomVariant } from './utils/parse-dom-variant.mjs';\nimport { VisualElement } from '../VisualElement.mjs';\n\nclass DOMVisualElement extends VisualElement {\n    sortInstanceNodePosition(a, b) {\n        /**\n         * compareDocumentPosition returns a bitmask, by using the bitwise &\n         * we're returning true if 2 in that bitmask is set to true. 2 is set\n         * to true if b preceeds a.\n         */\n        return a.compareDocumentPosition(b) & 2 ? 1 : -1;\n    }\n    getBaseTargetFromProps(props, key) {\n        return props.style ? props.style[key] : undefined;\n    }\n    removeValueFromRenderState(key, { vars, style }) {\n        delete vars[key];\n        delete style[key];\n    }\n    makeTargetAnimatableFromInstance({ transition, transitionEnd, ...target }, { transformValues }, isMounted) {\n        let origin = getOrigin(target, transition || {}, this);\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(this, target, origin);\n            const parsed = parseDomVariant(this, target, origin, transitionEnd);\n            transitionEnd = parsed.transitionEnd;\n            target = parsed.target;\n        }\n        return {\n            transition,\n            transitionEnd,\n            ...target,\n        };\n    }\n}\n\nexport { DOMVisualElement };\n","import { buildHTMLStyles } from './utils/build-styles.mjs';\nimport { isCSSVariableName } from '../dom/utils/is-css-variable.mjs';\nimport { transformProps } from './utils/transform.mjs';\nimport { scrapeMotionValuesFromProps } from './utils/scrape-motion-values.mjs';\nimport { renderHTML } from './utils/render.mjs';\nimport { getDefaultValueType } from '../dom/value-types/defaults.mjs';\nimport { measureViewportBox } from '../../projection/utils/measure.mjs';\nimport { DOMVisualElement } from '../dom/DOMVisualElement.mjs';\nimport { isMotionValue } from '../../value/utils/is-motion-value.mjs';\n\nfunction getComputedStyle(element) {\n    return window.getComputedStyle(element);\n}\nclass HTMLVisualElement extends DOMVisualElement {\n    readValueFromInstance(instance, key) {\n        if (transformProps.has(key)) {\n            const defaultType = getDefaultValueType(key);\n            return defaultType ? defaultType.default || 0 : 0;\n        }\n        else {\n            const computedStyle = getComputedStyle(instance);\n            const value = (isCSSVariableName(key)\n                ? computedStyle.getPropertyValue(key)\n                : computedStyle[key]) || 0;\n            return typeof value === \"string\" ? value.trim() : value;\n        }\n    }\n    measureInstanceViewportBox(instance, { transformPagePoint }) {\n        return measureViewportBox(instance, transformPagePoint);\n    }\n    build(renderState, latestValues, options, props) {\n        buildHTMLStyles(renderState, latestValues, options, props.transformTemplate);\n    }\n    scrapeMotionValuesFromProps(props, prevProps) {\n        return scrapeMotionValuesFromProps(props, prevProps);\n    }\n    handleChildMotionValue() {\n        if (this.childSubscription) {\n            this.childSubscription();\n            delete this.childSubscription;\n        }\n        const { children } = this.props;\n        if (isMotionValue(children)) {\n            this.childSubscription = children.on(\"change\", (latest) => {\n                if (this.current)\n                    this.current.textContent = `${latest}`;\n            });\n        }\n    }\n    renderInstance(instance, renderState, styleProp, projection) {\n        renderHTML(instance, renderState, styleProp, projection);\n    }\n}\n\nexport { HTMLVisualElement, getComputedStyle };\n","import { scrapeMotionValuesFromProps } from './utils/scrape-motion-values.mjs';\nimport { DOMVisualElement } from '../dom/DOMVisualElement.mjs';\nimport { buildSVGAttrs } from './utils/build-attrs.mjs';\nimport { camelToDash } from '../dom/utils/camel-to-dash.mjs';\nimport { camelCaseAttributes } from './utils/camel-case-attrs.mjs';\nimport { transformProps } from '../html/utils/transform.mjs';\nimport { renderSVG } from './utils/render.mjs';\nimport { getDefaultValueType } from '../dom/value-types/defaults.mjs';\nimport { createBox } from '../../projection/geometry/models.mjs';\nimport { isSVGTag } from './utils/is-svg-tag.mjs';\n\nclass SVGVisualElement extends DOMVisualElement {\n    constructor() {\n        super(...arguments);\n        this.isSVGTag = false;\n    }\n    getBaseTargetFromProps(props, key) {\n        return props[key];\n    }\n    readValueFromInstance(instance, key) {\n        if (transformProps.has(key)) {\n            const defaultType = getDefaultValueType(key);\n            return defaultType ? defaultType.default || 0 : 0;\n        }\n        key = !camelCaseAttributes.has(key) ? camelToDash(key) : key;\n        return instance.getAttribute(key);\n    }\n    measureInstanceViewportBox() {\n        return createBox();\n    }\n    scrapeMotionValuesFromProps(props, prevProps) {\n        return scrapeMotionValuesFromProps(props, prevProps);\n    }\n    build(renderState, latestValues, options, props) {\n        buildSVGAttrs(renderState, latestValues, options, this.isSVGTag, props.transformTemplate);\n    }\n    renderInstance(instance, renderState, styleProp, projection) {\n        renderSVG(instance, renderState, styleProp, projection);\n    }\n    mount(instance) {\n        this.isSVGTag = isSVGTag(instance.tagName);\n        super.mount(instance);\n    }\n}\n\nexport { SVGVisualElement };\n","import { animations } from '../../motion/features/animations.mjs';\nimport { gestureAnimations } from '../../motion/features/gestures.mjs';\nimport { createDomVisualElement } from './create-visual-element.mjs';\n\n/**\n * @public\n */\nconst domAnimation = {\n    renderer: createDomVisualElement,\n    ...animations,\n    ...gestureAnimations,\n};\n\nexport { domAnimation };\n","import { HTMLVisualElement } from '../html/HTMLVisualElement.mjs';\nimport { SVGVisualElement } from '../svg/SVGVisualElement.mjs';\nimport { isSVGComponent } from './utils/is-svg-component.mjs';\n\nconst createDomVisualElement = (Component, options) => {\n    return isSVGComponent(Component)\n        ? new SVGVisualElement(options, { enableHardwareAcceleration: false })\n        : new HTMLVisualElement(options, { enableHardwareAcceleration: true });\n};\n\nexport { createDomVisualElement };\n","import { drag } from '../../motion/features/drag.mjs';\nimport { layout } from '../../motion/features/layout.mjs';\nimport { domAnimation } from './features-animation.mjs';\n\n/**\n * @public\n */\nconst domMax = {\n    ...domAnimation,\n    ...drag,\n    ...layout,\n};\n\nexport { domMax };\n"],"names":["_get","Reflect","get","bind","target","property","receiver","base","object","Object","prototype","hasOwnProperty","call","getPrototypeOf","desc","getOwnPropertyDescriptor","arguments","length","value","apply","this","Feature","node","_classCallCheck","isMounted","_createClass","key","isPrimaryPointer","event","pointerType","button","isPrimary","extractEventInfo","pointType","undefined","point","x","y","addPointerInfo","handler","secondsToMilliseconds","seconds","addDomEvent","eventName","options","passive","addEventListener","removeEventListener","addPointerEvent","distance","a","b","Math","abs","PanSession","handlers","_this","transformPagePoint","startEvent","lastMoveEvent","lastMoveEventInfo","updatePoint","info","getPanInfo","history","isPanStarted","isDistancePastThreshold","xDelta","yDelta","sqrt","pow","distance2D","offset","timestamp","frameData","push","_objectSpread","_this$handlers","onStart","onMove","handlePointerMove","transformPoint","sync","handlePointerUp","end","_this$handlers2","onEnd","onSessionEnd","panInfo","type","initialInfo","onSessionStart","removeListeners","pipe","window","cancelSync","subtractPoint","_ref2","delta","lastDevicePoint","startDevicePoint","velocity","getVelocity","timeDelta","i","timestampedPoint","lastPoint","time","currentVelocity","Infinity","createLock","name","lock","globalHorizontalLock","globalVerticalLock","getGlobalLock","drag","openHorizontal","openVertical","isDragActive","openGestureLock","calcLength","axis","max","min","isNear","maxDistance","calcAxisDelta","source","origin","originPoint","mix","scale","isNaN","translate","calcBoxDelta","originX","originY","calcRelativeAxis","relative","parent","calcRelativeAxisPosition","layout","calcRelativePosition","calcRelativeAxisConstraints","calcViewportAxisConstraints","layoutAxis","constraintsAxis","_ref3","defaultElastic","resolveAxisElastic","dragElastic","minLabel","maxLabel","resolvePointElastic","label","createDelta","createBox","eachAxis","callback","convertBoundingBoxToBox","_ref","top","left","right","bottom","isIdentityScale","hasScale","scaleX","scaleY","hasTransform","values","has2DTranslate","z","rotate","rotateX","rotateY","is2DTranslate","scalePoint","applyPointDelta","boxScale","applyAxisDelta","applyBoxDelta","box","snapToDefault","Number","isInteger","translateAxis","transformAxis","transforms","_slicedToArray","scaleKey","originKey","axisOrigin","xKeys","yKeys","transformBox","transform","measureViewportBox","instance","topLeft","bottomRight","transformBoxPoints","getBoundingClientRect","instantAnimationState","mirrorEasing","easing","p","reverseEasing","easeIn","easeOut","easeInOut","calcBezier","t","a1","a2","subdivisionPrecision","subdivisionMaxIterations","cubicBezier","mX1","mY1","mX2","mY2","noop","getTForX","aX","lowerBound","upperBound","currentX","currentT","binarySubdivide","circIn","sin","acos","circOut","circInOut","backOut","backIn","backInOut","easingLookup","linear","anticipate","easingDefinitionToFunction","definition","Array","isArray","invariant","_definition","concat","isEasingArray","ease","keyframes","keyframeValues","_ref$ease","times","_ref$duration","duration","_toConsumableArray","easingFunctions","map","state","done","absoluteTimes","o","convertOffsetToTimes","defaultOffset","createInterpolator","interpolate","splice","interpolator","next","flipTarget","reverse","safeMin","minDuration","maxDuration","minDamping","maxDamping","findSpring","envelope","derivative","_ref$bounce","bounce","_ref$velocity","_ref$mass","mass","warning","dampingRatio","clamp","undampedFreq","exponentialDecay","calcAngularFreq","c","exp","d","e","f","g","initialGuess","result","rootIterations","approximateRoot","stiffness","damping","durationKeys","physicsKeys","isSpringType","keys","some","spring","restDelta","restSpeed","_objectWithoutProperties","_excluded","_getSpringOptions","springOptions","isResolvedFromDuration","derived","getSpringOptions","resolveSpring","zero","initialVelocity","createSpring","initialDelta","undampedAngularFreq","isGranularScale","angularFreq","cos","dampedAngularFreq","freqForT","sinh","cosh","current","prevT","velocityPerSecond","isBelowVelocityThreshold","isBelowDisplacementThreshold","needsInterpolation","_t","types","decay","_ref$keyframes","_ref$power","power","_ref$timeConstant","timeConstant","_ref$restDelta","modifyTarget","amplitude","ideal","tween","loopElapsed","elapsed","framesync","update","passTimestamp","start","stop","animateValue","driverControls","interpolateFromNumber","_ref2$driver","driver","_ref2$elapsed","_ref2$repeat","repeat","repeatMax","_ref2$repeatType","repeatType","_ref2$repeatDelay","repeatDelay","keyframes$1","_ref2$autoplay","autoplay","onPlay","onStop","onComplete","onRepeat","onUpdate","_ref2$type","initialElapsed","repeatCount","computedDuration","isComplete","isForwardPlayback","animator","animation","delay","reverseElapsed","hasRepeatDelayElapsed","currentTime","sample","sampleResolution","sampleElapsed","remaining","cubicBezierAsString","supportedWaapiEasing","mapEasingToNativeEasing","featureTests","waapi","Element","results","supports","_loop","acceleratedValues","Set","createAcceleratedAnimation","valueName","has","_options$duration","_options$elapsed","sampleAnimation","pregeneratedKeyframes","element","_element$animate","_ref$delay","_ref$repeat","_ref$repeatType","animate","_defineProperty","fill","iterations","direction","animateStyle","owner","onfinish","set","getFinalKeyframe","cancel","setWithVelocity","timeout","performance","now","checkElapsed","createInstantAnimation","setValue","underDampedSpring","keyframesTransition","getDefaultTransition","valueKey","transformProps","startsWith","isAnimatable","complex","maxDefaults","applyDefaultFilter","v","_v$slice$split","slice","split","_v$slice$split2","match","floatRegex","number","unit","replace","defaultValue","functionRegex","filter","getAnimatableNone","functions","join","defaultValueTypes","numberValueTypes","color","backgroundColor","outlineColor","stroke","borderColor","borderTopColor","borderRightColor","borderBottomColor","borderLeftColor","WebkitFilter","getDefaultValueType","defaultValueType","isZero","parseFloat","indexOf","getZeroUnit","potentialUnitType","getValueTransition","transition","createMotionValueAnimation","valueTransition","_transition$elapsed","isTargetAnimatable","from","getKeyframes","originKeyframe","targetKeyframe","isOriginAnimatable","currentAnimation","_ref$bounceStiffness","bounceStiffness","_ref$bounceDamping","bounceDamping","isOutOfBounds","findNearestBoundary","startAnimation","startSpring","prev","boundary","heading","inertia","when","delayChildren","staggerChildren","staggerDirection","isTransitionDefined","HTMLElement","getProps","acceleratedAnimation","elementDragControls","WeakMap","VisualElementDragControls","visualElement","openGlobalLock","isDragging","currentDirection","constraints","hasMutatedConstraints","elastic","originEvent","_ref$snapToCursor","snapToCursor","presenceContext","isPresent","panSession","stopAnimation","_this$getProps","dragPropagation","onDragStart","resolveConstraints","projection","isAnimationBlocked","getAxisMotionValue","percent","measuredAxis","layoutBox","animationState","setActive","_this$getProps2","dragDirectionLock","onDirectionLock","onDrag","lockThreshold","getCurrentDirection","updateAxis","render","getTransformPagePoint","onDragEnd","_this$visualElement","_point","shouldDrag","axisValue","applyConstraints","_this2","_this$getProps6","dragConstraints","prevConstraints","isRefObject","resolveRefConstraints","calcRelativeConstraints","resolveDragElastic","relativeConstraints","rebaseAxisConstraints","_this$getProps7","onMeasureDragConstraints","constraintsElement","constraintsBox","rootProjectionNode","viewportBox","scroll","measurePageBox","root","measuredConstraints","calcViewportConstraints","userConstraints","convertBoxToBoundingBox","_this3","_this$getProps8","dragMomentum","dragTransition","dragSnapToOrigin","onDragTransitionEnd","momentumAnimations","startAxisValueAnimation","Promise","all","then","_this4","dragKey","toUpperCase","props","externalMotionValue","getValue","initial","_this5","_projection$layout$la","_this6","_this$getProps9","boxProgress","latest","sourceLength","targetLength","progress","calcOrigin","transformTemplate","style","updateScroll","updateLayout","_this6$constraints$ax","_this7","stopPointerListener","_this7$getProps","_this7$getProps$dragL","dragListener","measureDragConstraints","stopMeasureLayoutListener","stopResizeListener","scalePositionWithinConstraints","stopLayoutUpdateListener","hasLayoutChanged","motionValue","_props$drag","_props$dragDirectionL","_props$dragPropagatio","_props$dragConstraint","_props$dragElastic","_props$dragMomentum","DragGesture","_Feature","_inherits","_super","_createSuper","removeGroupControls","controls","dragControls","subscribe","addListeners","PanGesture","removePointerDownListener","pointerDownEvent","session","createPanHandlers","_this$node$getProps","onPanSessionStart","onPanStart","onPan","onPanEnd","onPointerDown","updateHandlers","pixelsToPercent","pixels","correctBorderRadius","correct","px","cssVariableRegex","maxDepth","getVariableValue","depth","_parseCSSVariable","exec","_match","parseCSSVariable","_parseCSSVariable2","token","fallback","resolved","getComputedStyle","getPropertyValue","trim","isCSSVariableToken","varToken","correctBoxShadow","treeScale","projectionDelta","original","containsCSSVariables","includes","cssVariables","shadow","template","xScale","yScale","averageScale","output","cssVariable","MeasureLayoutWithContext","_React__default$Compo","_this$props","layoutGroup","switchLayoutGroup","layoutId","addScaleCorrector","defaultScaleCorrectors","group","add","register","didUpdate","safeToRemove","setOptions","onExitComplete","globalProjectionState","prevProps","_this$props2","layoutDependency","willUpdate","promote","relegate","stack","getStack","members","isLead","_this$props3","promoteContext","scheduleCheckAfterUnmount","remove","deregister","React__default","MeasureLayout","_usePresence","context","useContext","PresenceContext","id","useId","useEffect","usePresence","_usePresence2","LayoutGroupContext","SwitchLayoutGroupContext","borderRadius","applyTo","borderTopLeftRadius","borderTopRightRadius","borderBottomLeftRadius","borderBottomRightRadius","boxShadow","borders","numBorders","asNumber","isPx","getRadius","radiusName","easeCrossfadeIn","compress","easeCrossfadeOut","copyAxisInto","originAxis","copyBoxInto","originBox","removePointDelta","removeAxisTransforms","sourceAxis","removeAxisDelta","removeBoxTransforms","sourceBox","isAxisDeltaZero","isDeltaZero","boxEquals","aspectRatio","NodeStack","addUniqueItem","scheduleRender","removeItem","prevLead","lead","indexOfNode","findIndex","member","preserveFollowOpacity","show","resumeFrom","preserveOpacity","snapshot","latestValues","animationValues","isUpdating","isLayoutDirty","crossfade","hide","forEach","resumingFrom","buildProjectionTransform","latestTransform","xTranslate","yTranslate","elementScaleX","elementScaleY","compareByDepth","FlatTree","children","isDirty","child","sort","transformAxes","projectionFrameData","totalNodes","resolvedTargetDeltas","recalculatedProjection","createProjectionNode","attachResizeListener","defaultParent","measureScroll","checkIsScrollRoot","resetTransform","ProjectionNode","elementId","animationId","isTreeAnimating","isProjectionDirty","isSharedProjectionDirty","isTransformDirty","updateManuallyBlocked","updateBlockedByResize","isSVG","needsReset","shouldResetTransform","eventHandlers","Map","potentialNodes","checkUpdateFailed","clearAllSnapshots","updateProjection","nodes","propagateDirtyNodes","resolveTargetDelta","calcProjection","cleanDirtyNodes","data","MotionDebug","record","hasProjected","isVisible","animationProgress","sharedNodes","path","registerPotentialNode","SubscriptionManager","subscriptionManager","_len","args","_key","notify","SVGElement","tagName","_this$options","mount","delete","cancelDelay","resizeUnblockUpdate","finishAnimation","registerSharedNode","hasRelativeTargetChanged","newLayout","isTreeAnimationBlocked","relativeTarget","layoutTransition","defaultLayoutTransition","_visualElement$getPro","onLayoutAnimationStart","onLayoutAnimationComplete","targetChanged","targetLayout","hasOnlyRelativeTargetChanged","layoutRoot","setAnimationOrigin","animationOptions","shouldReduceMotion","isUpdateBlocked","resetRotation","shouldNotifyListeners","startUpdate","_this$options2","getTransformTemplate","prevTransformTemplateValue","updateSnapshot","notifyListeners","unblockUpdate","clearMeasurements","size","mountNodeEarly","clear","resetTransformStyle","notifyLayoutUpdate","flushSync","clearSnapshot","removeLeadSnapshots","measure","alwaysMeasureLayout","prevLayout","layoutCorrected","phase","needsMeasurement","Boolean","layoutScroll","isRoot","isResetRequested","hasProjection","transformTemplateValue","transformTemplateHasChanged","removeTransform","pageBox","removeElementScroll","roundAxis","measuredBox","boxWithoutScroll","rootScroll","transformOnly","withTransforms","boxWithoutTransform","targetDelta","scheduleUpdateProjection","_a","getLead","attemptToResolveRelativeTarget","_this$options3","relativeParent","getClosestProjectingParent","relativeTargetOrigin","targetWithTransforms","applyTransform","isProjecting","isShared","canSkip","_this$options4","pendingAnimation","treePath","isSharedTransition","treeLength","display","applyTreeDeltas","projectionDeltaWithTransform","prevTreeScaleX","prevTreeScaleY","prevProjectionTransform","projectionTransform","notifyAll","snapshotLatestValues","mixedValues","prevRelativeTarget","relativeLayout","isSharedLayoutAnimation","isOnlyMember","shouldCrossfadeOpacity","hasOpacityCrossfade","mixTargetDelta","to","mixAxisDelta","setTargetDelta","mixAxis","follow","opacity","opacityExit","borderLabel","followRadius","leadRadius","mixValues","isMotionValue","isAnimating","completeAnimation","exitAnimationComplete","shouldAnimatePositionOnly","animationType","xLength","yLength","config","initialPromotionConfig","shouldPreserveFollowOpacity","hasRotate","rotateZ","resetValues","setStaticValue","_b","styleProp","styles","visibility","pointerEvents","resolveMotionValue","emptyStyles","valuesToRender","applyTransformsToTarget","_this$projectionDelta","transformOrigin","scaleCorrectors","_scaleCorrectors$key","corrected","num","hasListeners","_node$layout","measuredLayout","axisSnapshot","layoutDelta","visualDelta","parentSnapshot","parentLayout","relativeSnapshot","onBeforeLayoutMeasure","removeLeadSnapshot","searchNode","document","querySelector","round","DocumentProjectionNode","ref","documentElement","scrollLeft","body","scrollTop","HTMLProjectionNode","documentNode","position","pan","shallowCompare","prevLength","isZeroValueString","test","testValueType","dimensionValueTypes","degrees","vw","vh","parse","findDimensionValueType","find","valueTypes","findValueType","resolveVariant","custom","resolveVariantFromProps","getCurrent","setMotionValue","hasValue","addValue","setTarget","makeTargetAnimatable","_ref$transitionEnd","transitionEnd","resolveFinalValueInKeyframes","getOriginFromTransition","isWillChangeMotionValue","optimizedAppearDataAttribute","camelToDash","animateVariant","variant","_ref$transition","transitionOverride","getAnimation","animateTarget","resolve","getChildAnimations","variantChildren","forwardDelay","_transition","_transition$delayChil","animations","maxStaggerDuration","generateStaggerDuration","sortByTreeOrder","animateChildren","first","last","_ref4","_ref4$delay","_visualElement$makeTa","_visualElement$makeTa2","willChange","animationTypeState","getState","valueTarget","_ref5","protectedKeys","needsAnimating","shouldBlock","shouldBlockAnimation","HandoffAppearAnimations","hasAnimated","appearId","sortNodePosition","reversePriorityOrder","variantPriorityOrder","numAnimationTypes","animateList","resolvedDefinition","animateVisualElement","createAnimationState","createTypeState","whileInView","whileHover","whileTap","whileDrag","whileFocus","exit","isInitialRender","buildResolvedTypeValues","acc","animateChanges","changedActiveType","getVariantContext","removedKeys","encounteredKeys","removedVariantIndex","typeState","prop","propIsVariant","isVariantLabel","activeDelta","isActive","isInherited","manuallyAnimateOnMount","prevProp","isAnimationControls","variantDidChange","checkVariantsDidChange","shouldAnimateType","definitionList","resolvedValues","reduce","_typeState$prevResolv","prevResolvedValues","allKeys","markToAnimate","isKeyframesTarget","blockInitialAnimation","fallbackAnimation","fallbackTarget","getBaseTarget","shouldAnimate","setAnimateFunction","makeAnimator","AnimationFeature","unmount","updateAnimationControlsSubscription","ExitAnimationFeature","_this$node$presenceCo","prevIsPresent","prevPresenceContext","exitAnimation","addHoverEvent","callbackName","HoverGesture","FocusGesture","isFocusVisible","matches","onFocus","onBlur","isNodeOrChild","parentElement","fireSyntheticPointerEvent","syntheticPointerEvent","PointerEvent","PressGesture","removeStartListeners","removeEndListeners","removeAccessibleListeners","startPointerPress","startInfo","isPressing","removePointerUpListener","endEvent","endInfo","checkPressEnd","onTap","onTapCancel","removePointerCancelListener","cancelEvent","cancelInfo","cancelPress","startPress","startAccessiblePress","removeKeydownListener","keydownEvent","keyupEvent","removeBlurListener","_this$node$getProps2","onTapStart","removePointerListener","removeFocusListener","observerCallbacks","observers","fireObserverCallback","entry","fireAllObserverCallbacks","entries","observeIntersection","rootInteresectionObserver","lookupRoot","rootObservers","JSON","stringify","IntersectionObserver","initIntersectionObserver","observe","unobserve","thresholdNames","InViewFeature","hasEnteredView","isInView","requestAnimationFrame","onViewportEnter","_this$node$getProps$v","viewport","rootMargin","margin","_viewport$amount","amount","once","_viewport$fallback","threshold","isIntersecting","_this3$node$getProps","onViewportLeave","viewportFallback","startObserver","_this$node","hasOptionsChanged","_ref$viewport","_ref2$viewport","prevViewport","hasViewportOptionChanged","gestureAnimations","inView","tap","focus","hover","positionalKeys","isPositionalKey","isNumOrPxType","getPosFromMatrix","matrix","pos","getTranslateFromMatrix","pos2","pos3","_bbox","matrix3d","transformKeys","nonTranslationalTransformKeys","transformPropOrder","positionalValues","width","_ref3$paddingLeft","paddingLeft","_ref3$paddingRight","paddingRight","height","_ref5$paddingTop","paddingTop","_ref5$paddingBottom","paddingBottom","_ref6","_ref7","_ref8","_ref9","_ref10","_ref11","checkAndConvertChangedValueTypes","targetPositionalKeys","removedTransformValues","hasAttemptedToRemoveTransformValues","changedValueTypeKeys","toType","fromType","numKeyframes","fromIndex","removedTransforms","removeNonTranslationalTransform","jump","scrollY","pageYOffset","convertedTarget","changedKeys","originBbox","elementComputedStyle","targetBbox","convertChangedValueTypes","_ref12","_ref13","isBrowser","scrollTo","unitConversion","hasPositionalKey","parseDomVariant","assign","_objectDestructuringEmpty","resolveCSSVariables","prefersReducedMotion","hasReducedMotionListener","featureNames","featureDefinitions","numFeatures","propEventHandlers","numVariantProps","variantProps","VisualElement","reducedMotionConfig","visualState","isVariantNode","isControllingVariants","features","valueSubscriptions","prevMotionValues","events","propEventSubscriptions","notifyUpdate","triggerBuild","renderInstance","renderState","baseTarget","initialValues","_this$scrapeMotionVal","scrapeMotionValuesFromProps","initialMotionValues","_props","_prevProps","removeFromVariantTree","addVariantChild","bindToMotionValue","matchMedia","motionMediaQuery","setReducedMotionPreferences","addListener","initPrefersReducedMotion","valueIsTransform","removeOnChange","on","latestValue","removeOnRenderRequest","other","sortInstanceNodePosition","isStrict","preloadedFeatures","projectionId","initialLayoutGroupConfig","ProjectionNodeConstructor","renderedProps","_excluded2","_featureDefinitions$n","isEnabled","FeatureConstructor","MeasureLayoutComponent","feature","build","measureInstanceViewportBox","canMutate","makeTargetAnimatableFromInstance","listener","nextValue","prevValue","existingValue","getStaticValue","removeValue","updateMotionValuesFromProps","handleChildMotionValue","variants","getClosestVariantNode","closestVariantNode","unsubscribe","removeValueFromRenderState","readValueFromInstance","valueFromInitial","getBaseTargetFromProps","_this$events$eventNam","_key2","DOMVisualElement","_VisualElement","compareDocumentPosition","vars","transformValues","transitionOrigin","getOrigin","newValueKeys","numNewValues","targetValue","readValue","setBaseTarget","checkTargetForNewValues","parsed","HTMLVisualElement","_DOMVisualElement","defaultType","default","computedStyle","isCSSVariableName","buildHTMLStyles","childSubscription","textContent","renderHTML","SVGVisualElement","isSVGTag","camelCaseAttributes","getAttribute","buildSVGAttrs","renderSVG","_getPrototypeOf","domAnimation","renderer","Component","isSVGComponent","enableHardwareAcceleration","domMax"],"sourceRoot":""}