{"version":3,"file":"static/chunks/779-e0beb9ec6f053079.js","mappings":"yJAAA,IAAIA,EAAU,WAAc,EACxBC,EAAY,WAAc,C,wBCD9B,SAASC,EAAoBC,GACzB,MAAoB,kBAANA,GAAqC,oBAAZA,EAAEC,KAC7C,C,uFCFA,IAAIC,EAAoB,SAAUF,GAC9B,OAAOG,MAAMC,QAAQJ,EACzB,C,wHCCA,MAAMK,EAAU,KACVC,EAAc,IACdC,EAAc,GACdC,EAAa,IACbC,EAAa,EACnB,SAASC,GAAW,SAAEC,EAAW,IAAG,OAAEC,EAAS,IAAI,SAAEC,EAAW,EAAC,KAAEC,EAAO,IACtE,IAAIC,EACAC,GACJ,OAAQL,GAA0B,IAAdJ,EAAoB,8CACxC,IAAIU,EAAe,EAAIL,EACvBK,GAAe,EAAAC,EAAA,GAAMV,EAAYC,EAAYQ,GAC7CN,GAAW,EAAAO,EAAA,GAAMZ,EAAaC,EAAaI,EAAW,KAClDM,EAAe,GACfF,EAAYI,IACR,MAAMC,EAAmBD,EAAeF,EAClCI,EAAQD,EAAmBT,EAC3BW,EAAIF,EAAmBP,EACvBU,EAAIC,EAAgBL,EAAcF,GAClCQ,EAAIC,KAAKC,KAAKN,GACpB,OAAOhB,EAAWiB,EAAIC,EAAKE,CAAC,EAEhCT,EAAcG,IACV,MACME,EADmBF,EAAeF,EACPN,EAC3BiB,EAAIP,EAAQR,EAAWA,EACvBgB,EAAIH,KAAKI,IAAIb,EAAc,GAAKS,KAAKI,IAAIX,EAAc,GAAKR,EAC5DoB,EAAIL,KAAKC,KAAKN,GACdW,EAAIR,EAAgBE,KAAKI,IAAIX,EAAc,GAAIF,GAErD,QADgBF,EAASI,GAAgBd,EAAU,GAAK,EAAI,KACzCuB,EAAIC,GAAKE,GAAMC,CAAC,IAIvCjB,EAAYI,GACEO,KAAKC,KAAKR,EAAeR,KACxBQ,EAAeN,GAAYF,EAAW,GACzCN,EAEZW,EAAcG,GACAO,KAAKC,KAAKR,EAAeR,IACIA,EAAWA,GAAvCE,EAAWM,KAI9B,MACMA,EAmBV,SAAyBJ,EAAUC,EAAYiB,GAC3C,IAAIC,EAASD,EACb,IAAK,IAAIE,EAAI,EAAGA,EAAIC,EAAgBD,IAChCD,GAAkBnB,EAASmB,GAAUlB,EAAWkB,GAEpD,OAAOA,CACX,CAzByBG,CAAgBtB,EAAUC,EAD1B,EAAIL,GAGzB,GADAA,GAAsB,IAClB2B,MAAMnB,GACN,MAAO,CACHoB,UAAW,IACXC,QAAS,GACT7B,YAGH,CACD,MAAM4B,EAAYb,KAAKI,IAAIX,EAAc,GAAKL,EAC9C,MAAO,CACHyB,YACAC,QAAwB,EAAfvB,EAAmBS,KAAKe,KAAK3B,EAAOyB,GAC7C5B,WAER,CACJ,CACA,MAAMyB,EAAiB,GAQvB,SAASZ,EAAgBL,EAAcF,GACnC,OAAOE,EAAeO,KAAKe,KAAK,EAAIxB,EAAeA,EACvD,CCzEA,MAAMyB,EAAe,CAAC,WAAY,UAC5BC,EAAc,CAAC,YAAa,UAAW,QAC7C,SAASC,EAAaC,EAASC,GAC3B,OAAOA,EAAKC,MAAMC,QAAyBC,IAAjBJ,EAAQG,IACtC,CAWA,SAASE,EAAOC,GACZ,IAAI,KAAEC,EAAO,EAAG,GAAEC,EAAK,EAAG,UAAEC,EAAY,EAAC,UAAEC,GAAcJ,EAAIN,GAAU,QAAOM,EAAI,CAAC,OAAQ,KAAM,YAAa,cAC9G,MAAMK,EAAQ,CAAEC,MAAM,EAAOC,MAAON,GACpC,IAAI,UAAEb,EAAS,QAAEC,EAAO,KAAE1B,EAAI,SAAED,EAAQ,SAAEF,EAAQ,uBAAEgD,GAbxD,SAA0Bd,GACtB,IAAIe,EAAgBC,OAAOC,OAAO,CAAEjD,SAAU,EAAK0B,UAAW,IAAKC,QAAS,GAAI1B,KAAM,EAAK6C,wBAAwB,GAASd,GAC5H,IAAKD,EAAaC,EAASF,IACvBC,EAAaC,EAASH,GAAe,CACrC,MAAMqB,EAAUrD,EAAWmC,GAC3Be,EAAgBC,OAAOC,OAAOD,OAAOC,OAAOD,OAAOC,OAAO,CAAC,EAAGF,GAAgBG,GAAU,CAAElD,SAAU,EAAKC,KAAM,IAC/G8C,EAAcD,wBAAyB,CAC3C,CACA,OAAOC,CACX,CAIoFI,CAAiBnB,GAC7FoB,EAAgBC,EAChBC,EAAkBD,EACtB,SAASE,IACL,MAAMC,EAAkBxD,GAAaA,EAAW,IAAQ,EAClDyD,EAAejB,EAAKD,EACpBnC,EAAeuB,GAAW,EAAId,KAAKe,KAAKF,EAAYzB,IACpDyD,EAAsB7C,KAAKe,KAAKF,EAAYzB,GAAQ,IAI1D,QAHkBmC,IAAdM,IACAA,EAAY7B,KAAK8C,IAAI9C,KAAK+C,IAAIpB,EAAKD,GAAQ,IAAK,KAEhDnC,EAAe,EAAG,CAClB,MAAMyD,EAAclD,EAAgB+C,EAAqBtD,GACzDgD,EAAiBU,IACb,MAAM5D,EAAWW,KAAKC,KAAKV,EAAesD,EAAsBI,GAChE,OAAQtB,EACJtC,IACOsD,EACCpD,EAAesD,EAAsBD,GACrCI,EACAhD,KAAKkD,IAAIF,EAAcC,GACvBL,EAAe5C,KAAKmD,IAAIH,EAAcC,GAAI,EAE1DR,EAAmBQ,IACf,MAAM5D,EAAWW,KAAKC,KAAKV,EAAesD,EAAsBI,GAChE,OAAQ1D,EACJsD,EACAxD,GACEW,KAAKkD,IAAIF,EAAcC,IACpBN,EACGpD,EACIsD,EACAD,GACRI,EACAJ,EAAe5C,KAAKmD,IAAIH,EAAcC,IAC1C5D,GACKW,KAAKmD,IAAIH,EAAcC,IACnBN,EACGpD,EACIsD,EACAD,GACRI,EACIJ,EACA5C,KAAKkD,IAAIF,EAAcC,GAAI,CAEnD,MACK,GAAqB,IAAjB1D,EACLgD,EAAiBU,GAAMtB,EACnB3B,KAAKC,KAAK4C,EAAsBI,IAC3BL,GACID,EAAkBE,EAAsBD,GACrCK,OAEf,CACD,MAAMG,EAAoBP,EAAsB7C,KAAKe,KAAKxB,EAAeA,EAAe,GACxFgD,EAAiBU,IACb,MAAM5D,EAAWW,KAAKC,KAAKV,EAAesD,EAAsBI,GAC1DI,EAAWrD,KAAK8C,IAAIM,EAAoBH,EAAG,KACjD,OAAQtB,EACHtC,IACKsD,EACEpD,EAAesD,EAAsBD,GACrC5C,KAAKsD,KAAKD,GACVD,EACIR,EACA5C,KAAKuD,KAAKF,IAClBD,CAAkB,CAElC,CACJ,CAEA,OADAV,IACO,CACHc,KAAOP,IACH,MAAMQ,EAAUlB,EAAcU,GAC9B,GAAKhB,EAQDH,EAAMC,KAAOkB,GAAKhE,MARO,CACzB,MAAMyE,EAAuC,IAArBjB,EAAgBQ,GAClCU,EAA2B3D,KAAK+C,IAAIW,IAAoB9B,EACxDgC,EAA+B5D,KAAK+C,IAAIpB,EAAK8B,IAAY5B,EAC/DC,EAAMC,KACF4B,GAA4BC,CACpC,CAKA,OADA9B,EAAME,MAAQF,EAAMC,KAAOJ,EAAK8B,EACzB3B,CAAK,EAEhB+B,WAAY,KACR1E,GAAYA,GACXuC,EAAMC,GAAM,CAACA,EAAID,GAClBgB,GAAc,EAG1B,CACAlB,EAAOsC,mBAAqB,CAAClE,EAAGC,IAAmB,kBAAND,GAA+B,kBAANC,EACtE,MAAM2C,EAAQuB,GAAO,E,2DCpHrB,SAASC,EAASC,EAAGC,EAAGjB,GAKpB,OAJIA,EAAI,IACJA,GAAK,GACLA,EAAI,IACJA,GAAK,GACLA,EAAI,EAAI,EACDgB,EAAc,GAATC,EAAID,GAAShB,EACzBA,EAAI,GACGiB,EACPjB,EAAI,EAAI,EACDgB,GAAKC,EAAID,IAAM,EAAI,EAAIhB,GAAK,EAChCgB,CACX,CACA,SAASE,GAAW,IAAEC,EAAG,WAAEC,EAAU,UAAEC,EAAS,MAAEC,IAC9CH,GAAO,IAEPE,GAAa,IACb,IAAIE,EAAM,EACNC,EAAQ,EACRC,EAAO,EACX,GALAL,GAAc,IAQT,CACD,MAAMH,EAAII,EAAY,GAChBA,GAAa,EAAID,GACjBC,EAAYD,EAAaC,EAAYD,EACrCJ,EAAI,EAAIK,EAAYJ,EAC1BM,EAAMR,EAASC,EAAGC,EAAGE,EAAM,EAAI,GAC/BK,EAAQT,EAASC,EAAGC,EAAGE,GACvBM,EAAOV,EAASC,EAAGC,EAAGE,EAAM,EAAI,EACpC,MAVII,EAAMC,EAAQC,EAAOJ,EAWzB,MAAO,CACHE,IAAKxE,KAAK2E,MAAY,IAANH,GAChBC,MAAOzE,KAAK2E,MAAc,IAARF,GAClBC,KAAM1E,KAAK2E,MAAa,IAAPD,GACjBH,QAER,CCjCA,MAAMK,EAAiB,CAAClD,EAAMC,EAAIrD,KAC9B,MAAMuG,EAAWnD,EAAOA,EAClBoD,EAASnD,EAAKA,EACpB,OAAO3B,KAAKe,KAAKf,KAAK+E,IAAI,EAAGzG,GAAKwG,EAASD,GAAYA,GAAU,EAE/DG,EAAa,CAACC,EAAA,EAAKC,EAAA,EAAMC,EAAA,GACzBC,EAAgB9G,GAAM0G,EAAWK,MAAMC,GAASA,EAAKC,KAAKjH,KAC1DkH,EAAiBC,GAAU,IAAIA,wEAC/BC,EAAW,CAAChE,EAAMC,KACpB,IAAIgE,EAAgBP,EAAa1D,GAC7BkE,EAAcR,EAAazD,IAC/B,SAAYgE,EAAeH,EAAc9D,KACzC,SAAYkE,EAAaJ,EAAc7D,IACvC,IAAIkE,EAAYF,EAAcG,MAAMpE,GAChCqE,EAAUH,EAAYE,MAAMnE,GAC5BgE,IAAkBR,EAAA,IAClBU,EAAY1B,EAAW0B,GACvBF,EAAgBT,EAAA,GAEhBU,IAAgBT,EAAA,IAChBY,EAAU5B,EAAW4B,GACrBH,EAAcV,EAAA,GAElB,MAAMc,EAAU7D,OAAOC,OAAO,CAAC,EAAGyD,GAClC,OAAQvH,IACJ,IAAK,MAAMgD,KAAO0E,EACF,UAAR1E,IACA0E,EAAQ1E,GAAOsD,EAAeiB,EAAUvE,GAAMyE,EAAQzE,GAAMhD,IAIpE,OADA0H,EAAQzB,OAAQ,EAAA0B,EAAA,GAAIJ,EAAUtB,MAAOwB,EAAQxB,MAAOjG,GAC7CqH,EAAcO,UAAUF,EAAQ,CAC1C,E,8CC9BL,SAASG,EAASC,EAAQC,GACtB,OAAI,OAAMD,GACE9H,IAAM,EAAA2H,EAAA,GAAIG,EAAQC,EAAQ/H,GAE7BmH,EAAA,EAAMF,KAAKa,GACTV,EAASU,EAAQC,GAGjBC,EAAWF,EAAQC,EAElC,CACA,MAAME,EAAW,CAAC7E,EAAMC,KACpB,MAAM6E,EAAS,IAAI9E,GACb+E,EAAYD,EAAOE,OACnBC,EAAajF,EAAKkF,KAAI,CAACC,EAAUpG,IAAM0F,EAASU,EAAUlF,EAAGlB,MACnE,OAAQnC,IACJ,IAAK,IAAImC,EAAI,EAAGA,EAAIgG,EAAWhG,IAC3B+F,EAAO/F,GAAKkG,EAAWlG,GAAGnC,GAE9B,OAAOkI,CAAM,CAChB,EAECM,EAAY,CAACV,EAAQC,KACvB,MAAMG,EAASrE,OAAOC,OAAOD,OAAOC,OAAO,CAAC,EAAGgE,GAASC,GAClDM,EAAa,CAAC,EACpB,IAAK,MAAMrF,KAAOkF,OACMjF,IAAhB6E,EAAO9E,SAAsCC,IAAhB8E,EAAO/E,KACpCqF,EAAWrF,GAAO6E,EAASC,EAAO9E,GAAM+E,EAAO/E,KAGvD,OAAQhD,IACJ,IAAK,MAAMgD,KAAOqF,EACdH,EAAOlF,GAAOqF,EAAWrF,GAAKhD,GAElC,OAAOkI,CAAM,CAChB,EAEL,SAASO,EAAQ/E,GACb,MAAMgF,EAASC,EAAA,EAAQnB,MAAM9D,GACvByE,EAAYO,EAAON,OACzB,IAAIQ,EAAa,EACbC,EAAS,EACTC,EAAS,EACb,IAAK,IAAI3G,EAAI,EAAGA,EAAIgG,EAAWhG,IACvByG,GAAmC,kBAAdF,EAAOvG,GAC5ByG,SAGsB3F,IAAlByF,EAAOvG,GAAG2D,IACVgD,IAGAD,IAIZ,MAAO,CAAEH,SAAQE,aAAYC,SAAQC,SACzC,CACA,MAAMd,EAAa,CAACF,EAAQC,KACxB,MAAMgB,EAAWJ,EAAA,EAAQK,kBAAkBjB,GACrCkB,EAAcR,EAAQX,GACtBoB,EAAcT,EAAQV,GAI5B,OAHuBkB,EAAYH,SAAWI,EAAYJ,QACtDG,EAAYJ,SAAWK,EAAYL,QACnCI,EAAYL,YAAcM,EAAYN,YAE/B,EAAAO,EAAA,GAAKlB,EAASgB,EAAYP,OAAQQ,EAAYR,QAASK,KAG9D,QAAQ,EAAM,mBAAmBjB,WAAgBC,6KACzCpC,GAAM,GAAGA,EAAI,EAAIoC,EAASD,IACtC,ECrEEsB,EAAY,CAAChG,EAAMC,IAAQsC,IAAM,EAAAgC,EAAA,GAAIvE,EAAMC,EAAIsC,GAoBrD,SAAS0D,EAAanB,EAAQoB,EAAMC,GAChC,MAAMC,EAAS,GACTC,EAAeF,IApBJ,kBADOvJ,EAqB+BkI,EAAO,IAnBnDkB,EAEW,kBAANpJ,EACRmH,EAAA,EAAMF,KAAKjH,GACJoH,EAGAY,EAGN7H,MAAMC,QAAQJ,GACZiI,EAEW,kBAANjI,EACLwI,OADN,GAfT,IAA4BxI,EAsBxB,MAAM0J,EAAYxB,EAAOE,OAAS,EAClC,IAAK,IAAIjG,EAAI,EAAGA,EAAIuH,EAAWvH,IAAK,CAChC,IAAIwH,EAAQF,EAAavB,EAAO/F,GAAI+F,EAAO/F,EAAI,IAC/C,GAAImH,EAAM,CACN,MAAMM,EAAiBzJ,MAAMC,QAAQkJ,GAAQA,EAAKnH,GAAKmH,EACvDK,GAAQ,EAAAR,EAAA,GAAKS,EAAgBD,EACjC,CACAH,EAAOK,KAAKF,EAChB,CACA,OAAOH,CACX,CA8BA,SAASM,EAAYC,EAAO7B,GAAUhH,MAAO8I,GAAU,EAAI,KAAEV,EAAI,MAAEK,GAAU,CAAC,GAC1E,MAAMM,EAAcF,EAAM3B,QAC1B,OAAU6B,IAAgB/B,EAAOE,OAAQ,yDACzC,QAAWkB,IAASnJ,MAAMC,QAAQkJ,IAASA,EAAKlB,SAAW6B,EAAc,EAAG,oIACxEF,EAAM,GAAKA,EAAME,EAAc,KAC/BF,EAAQ,GAAGG,OAAOH,GAClB7B,EAAS,GAAGgC,OAAOhC,GACnB6B,EAAMI,UACNjC,EAAOiC,WAEX,MAAMX,EAASH,EAAanB,EAAQoB,EAAMK,GACpCS,EAA+B,IAAhBH,EAxCzB,UAA0B7G,EAAMC,IAAMsG,IAClC,OAAQ3J,GAAM2J,GAAM,EAAAU,EAAA,GAASjH,EAAMC,EAAIrD,GAC3C,CAuCUsK,CAAgBP,EAAOP,GAtCjC,SAAyBO,EAAOP,GAC5B,MAAMS,EAAcF,EAAM3B,OACpBmC,EAAiBN,EAAc,EACrC,OAAQjK,IACJ,IAAIwK,EAAa,EACbC,GAAkB,EAQtB,GAPIzK,GAAK+J,EAAM,GACXU,GAAkB,EAEbzK,GAAK+J,EAAMQ,KAChBC,EAAaD,EAAiB,EAC9BE,GAAkB,IAEjBA,EAAiB,CAClB,IAAItI,EAAI,EACR,KAAOA,EAAI8H,KACHF,EAAM5H,GAAKnC,GAAKmC,IAAMoI,GADNpI,KAKxBqI,EAAarI,EAAI,CACrB,CACA,MAAMuI,GAAkB,EAAAL,EAAA,GAASN,EAAMS,GAAaT,EAAMS,EAAa,GAAIxK,GAC3E,OAAOwJ,EAAOgB,GAAYE,EAAgB,CAElD,CAcUC,CAAgBZ,EAAOP,GAC7B,OAAOQ,EACAhK,GAAMoK,GAAa,EAAAlJ,EAAA,GAAM6I,EAAM,GAAIA,EAAME,EAAc,GAAIjK,IAC5DoK,CACV,C,eCtFA,SAASQ,EAAcC,EAAQC,GAC3B,OAAOD,EAAOvC,KAAI,IAAMwC,GAAU,OAAWC,OAAO,EAAGF,EAAOzC,OAAS,EAC3E,CAQA,SAAS4C,GAAU,KAAE5H,EAAO,EAAC,GAAEC,EAAK,EAAC,KAAEiG,EAAI,OAAE2B,EAAM,SAAEtK,EAAW,MAC5D,MAAM6C,EAAQ,CAAEC,MAAM,EAAOC,MAAON,GAC9ByH,EAAS1K,MAAMC,QAAQiD,GAAMA,EAAK,CAACD,EAAMC,GACzC6H,EANV,SAA8BD,EAAQtK,GAClC,OAAOsK,EAAO3C,KAAK6C,GAAMA,EAAIxK,GACjC,CAIkByK,CAAqBH,GAAUA,EAAO7C,SAAWyC,EAAOzC,OAChE6C,EAXV,SAAuBJ,GACnB,MAAM1C,EAAY0C,EAAOzC,OACzB,OAAOyC,EAAOvC,KAAI,CAAC+C,EAAQlJ,IAAY,IAANA,EAAUA,GAAKgG,EAAY,GAAK,GACrE,CASUmD,CAAcT,GAASlK,GAC7B,SAAS4K,IACL,OAAOzB,EAAYoB,EAAOL,EAAQ,CAC9BvB,KAAMnJ,MAAMC,QAAQkJ,GAAQA,EAAOsB,EAAcC,EAAQvB,IAEjE,CACA,IAAIc,EAAemB,IACnB,MAAO,CACHrG,KAAOP,IACHnB,EAAME,MAAQ0G,EAAazF,GAC3BnB,EAAMC,KAAOkB,GAAKhE,EACX6C,GAEX+B,WAAY,KACRsF,EAAOV,UACPC,EAAemB,GAAoB,EAG/C,CChCA,MAAMC,EAAQ,CAAER,UAAS,SAAQ,QCJjC,UAAe,SAAEnK,EAAW,EAAC,KAAEuC,EAAO,EAAC,MAAEqI,EAAQ,GAAG,aAAEC,EAAe,IAAG,UAAEnI,EAAY,GAAG,aAAEoI,IACvF,MAAMnI,EAAQ,CAAEC,MAAM,EAAOC,MAAON,GACpC,IAAIwI,EAAYH,EAAQ5K,EACxB,MAAMgL,EAAQzI,EAAOwI,EACf7D,OAA0B9E,IAAjB0I,EAA6BE,EAAQF,EAAaE,GAGjE,OAFI9D,IAAW8D,IACXD,EAAY7D,EAAS3E,GAClB,CACH8B,KAAOP,IACH,MAAMtD,GAASuK,EAAYlK,KAAKC,KAAKgD,EAAI+G,GAGzC,OAFAlI,EAAMC,OAASpC,EAAQkC,GAAalC,GAASkC,GAC7CC,EAAME,MAAQF,EAAMC,KAAOsE,EAASA,EAAS1G,EACtCmC,CAAK,EAEhB+B,WAAY,OAEpB,G,eChBA,SAASuG,EAAYC,EAASpL,EAAUqL,EAAQ,GAC5C,OAAOD,EAAUpL,EAAWqL,CAChC,CCIA,MAAMC,EAAaC,IACf,MAAMC,EAAgB,EAAG9K,WAAY6K,EAAO7K,GAC5C,MAAO,CACHpB,MAAO,IAAM,KAAKiM,OAAOC,GAAe,GACxCC,KAAM,IAAM,KAAWF,OAAOC,GACjC,EAEL,SAASE,EAAQlJ,GACb,IAAImJ,EAAIC,GACJ,KAAEnJ,EAAI,SAAEoJ,GAAW,EAAI,OAAEC,EAASR,EAAS,QAAEF,EAAU,EAAGW,OAAQC,EAAY,EAAC,WAAEC,EAAa,OAAM,YAAEC,EAAc,EAAC,OAAEC,EAAM,OAAEC,EAAM,WAAEC,EAAU,SAAEC,EAAQ,SAAEC,GAAa/J,EAAIN,GAAU,QAAOM,EAAI,CAAC,OAAQ,WAAY,SAAU,UAAW,SAAU,aAAc,cAAe,SAAU,SAAU,aAAc,WAAY,aACtU,IACIgK,EAGAC,EAGAC,GAPA,GAAEhK,GAAOR,EAETyK,EAAc,EACdC,EAAmB1K,EAAQlC,SAE3B6M,GAAa,EACbC,GAAoB,EAExB,MAAMC,EHnBV,SAAoCC,GAChC,GAAIxN,MAAMC,QAAQuN,EAAOtK,IACrB,OAAO2H,EAEN,GAAIQ,EAAMmC,EAAO3G,MAClB,OAAOwE,EAAMmC,EAAO3G,MAExB,MAAMlE,EAAO,IAAI8K,IAAI/J,OAAOf,KAAK6K,IACjC,OAAI7K,EAAK+K,IAAI,SACR/K,EAAK+K,IAAI,cAAgB/K,EAAK+K,IAAI,gBAC5B7C,EAEFlI,EAAK+K,IAAI,iBACd/K,EAAK+K,IAAI,cACT/K,EAAK+K,IAAI,SACT/K,EAAK+K,IAAI,YACT/K,EAAK+K,IAAI,cACT/K,EAAK+K,IAAI,aACF3K,EAEJ8H,CACX,CGFqB8C,CAA2BjL,IACM,QAA7C0J,GAAMD,EAAKoB,GAAUlI,0BAAuC,IAAP+G,OAAgB,EAASA,EAAGwB,KAAKzB,EAAIlJ,EAAMC,MACjGgK,EAAwBvD,EAAY,CAAC,EAAG,KAAM,CAAC1G,EAAMC,GAAK,CACtDnC,OAAO,IAEXkC,EAAO,EACPC,EAAK,KAET,MAAM2K,EAAYN,EAAS7J,OAAOC,OAAOD,OAAOC,OAAO,CAAC,EAAGjB,GAAU,CAAEO,OAAMC,QAC7E,SAASqJ,IACLY,IACmB,YAAfV,GACAa,EAAoBH,EAAc,IAAM,EACxCvB,EDlCZ,SAAwBA,EAASpL,EAAUqL,EAAQ,EAAGyB,GAAoB,GACtE,OAAOA,EACD3B,EAAYnL,GAAYoL,EAASpL,EAAUqL,GAC3CrL,GAAYoL,EAAUpL,GAAYqL,CAC5C,CC8BsBiC,CAAelC,EAASwB,EAAkBV,EAAaY,KAGjE1B,EAAUD,EAAYC,EAASwB,EAAkBV,GAC9B,WAAfD,GACAoB,EAAUzI,cAElBiI,GAAa,EACbP,GAAYA,GAChB,CAKA,SAASf,EAAO7K,GAIZ,GAHKoM,IACDpM,GAASA,GACb0K,GAAW1K,GACNmM,EAAY,CACb,MAAMhK,EAAQwK,EAAU9I,KAAKxD,KAAK+E,IAAI,EAAGsF,IACzCqB,EAAS5J,EAAME,MACX2J,IACAD,EAASC,EAAsBD,IACnCI,EAAaC,EAAoBjK,EAAMC,KAAOsI,GAAW,CAC7D,CACa,OAAbmB,QAAkC,IAAbA,GAA+BA,EAASE,GACzDI,IACoB,IAAhBF,IACqB,OAArBC,QAAkD,IAArBA,IAAkDA,EAAmBxB,IAClGuB,EAAcX,ED1D9B,SAA+BZ,EAASpL,EAAUqL,EAAOyB,GACrD,OAAOA,EAAoB1B,GAAWpL,EAAWqL,EAAQD,IAAYC,CACzE,CCyDgBkC,CAAsBnC,EAASwB,EAAkBV,EAAaY,IAAsBf,KAnB5FS,EAAef,OACfY,GAAcA,KAwBlB,CAOA,OADAR,IAJe,OAAXM,QAA8B,IAAXA,GAA6BA,IAChDK,EAAiBV,EAAOP,GACxBiB,EAAelN,SAGZ,CACHmM,KAAM,KACS,OAAXW,QAA8B,IAAXA,GAA6BA,IAChDI,EAAef,MAAM,EAGjC,C,8BCpFA,MAAM9K,EAAI,CAAC6M,EAAIC,IAAO,EAAM,EAAMA,EAAK,EAAMD,EACvC5M,GAAI,CAAC4M,EAAIC,IAAO,EAAMA,EAAK,EAAMD,EACjC1M,GAAK0M,GAAO,EAAMA,EAClBE,GAAa,CAAC1J,EAAGwJ,EAAIC,MAAS9M,EAAE6M,EAAIC,GAAMzJ,EAAIpD,GAAE4M,EAAIC,IAAOzJ,EAAIlD,GAAE0M,IAAOxJ,EACxE2J,GAAW,CAAC3J,EAAGwJ,EAAIC,IAAO,EAAM9M,EAAE6M,EAAIC,GAAMzJ,EAAIA,EAAI,EAAMpD,GAAE4M,EAAIC,GAAMzJ,EAAIlD,GAAE0M,GAC5EI,GAAuB,KACvBC,GAA2B,GAkBjC,MAAMC,GAAmB,EAazB,MACMC,GAAkB,GACxB,SAASC,GAAYC,EAAKC,EAAKC,EAAKC,GAChC,GAAIH,IAAQC,GAAOC,IAAQC,EACvB,OAAO,KACX,MAAMC,EAAe,IAAIC,aALJ,IAMrB,IAAK,IAAI9M,EAAI,EAAGA,EANK,KAMmBA,EACpC6M,EAAa7M,GAAKkM,GAAWlM,EAAIuM,GAAiBE,EAAKE,GAE3D,SAASI,EAASC,GACd,IAAIC,EAAgB,EAChBC,EAAgB,EAEpB,KADmBC,KACZD,GAAgCL,EAAaK,IAAkBF,IAAME,EACxED,GAAiBV,KAEnBW,EACF,MAEME,EAAYH,GAFJD,EAAKH,EAAaK,KAC3BL,EAAaK,EAAgB,GAAKL,EAAaK,IACXX,GACnCc,EAAelB,GAASiB,EAAWX,EAAKE,GAC9C,OAAIU,GAjCW,KACvB,SAA8BL,EAAIM,EAASb,EAAKE,GAC5C,IAAK,IAAI3M,EAAI,EAAGA,EAAIsM,KAAoBtM,EAAG,CACvC,MAAMuN,EAAepB,GAASmB,EAASb,EAAKE,GAC5C,GAAqB,IAAjBY,EACA,OAAOD,EAGXA,IADiBpB,GAAWoB,EAASb,EAAKE,GAAOK,GAC3BO,CAC1B,CACA,OAAOD,CACX,CAuBmBE,CAAqBR,EAAII,EAAWX,EAAKE,GAE1B,IAAjBU,EACED,EAvDnB,SAAyBJ,EAAIS,EAAIC,EAAIjB,EAAKE,GACtC,IAAIgB,EACAC,EACA5N,EAAI,EACR,GACI4N,EAAWH,GAAMC,EAAKD,GAAM,EAC5BE,EAAWzB,GAAW0B,EAAUnB,EAAKE,GAAOK,EACxCW,EAAW,EACXD,EAAKE,EAGLH,EAAKG,QAEJrO,KAAK+C,IAAIqL,GAAYvB,MACxBpM,EAAIqM,IACV,OAAOuB,CACX,CA0CmBC,CAAgBb,EAAIC,EAAeA,EAAgBV,GAAiBE,EAAKE,EAExF,CACA,OAAQnK,GAAY,IAANA,GAAiB,IAANA,EAAUA,EAAI0J,GAAWa,EAASvK,GAAIkK,EAAKE,EACxE,CCnEA,IAAIkB,GAAe,CACfC,OAAQ,KACRC,OAAQ,KACRC,UAAW,KACXC,QAAS,KACTC,OAAQ,KACRC,UAAW,KACXC,QAAS,KACTC,OAAQ,KACRC,UAAW,KACXC,QAAS,KACTC,WAAY,KACZC,SAAU,KACVC,YAAa,KACbC,UAAW,MAEXC,GAA6B,SAAUC,GACvC,GAAI9Q,MAAMC,QAAQ6Q,GAAa,EAE3B,OAAgC,IAAtBA,EAAW7I,OAAc,2DACnC,IAAIjF,GAAK,QAAO8N,EAAY,GAC5B,OAAOtC,GAD8BxL,EAAG,GAASA,EAAG,GAASA,EAAG,GAASA,EAAG,GAEhF,CACK,MAA0B,kBAAf8N,IAEZ,YAAuChO,IAA7BgN,GAAagB,GAA2B,wBAAwB/G,OAAO+G,EAAY,MACtFhB,GAAagB,IAEjBA,CACX,EACIC,GAAgB,SAAU5H,GAC1B,OAAOnJ,MAAMC,QAAQkJ,IAA4B,kBAAZA,EAAK,EAC9C,ECzBI6H,GAAe,SAAUnO,EAAKU,GAE9B,MAAY,WAARV,MAKiB,kBAAVU,IAAsBvD,MAAMC,QAAQsD,OAE1B,kBAAVA,IACPiF,EAAA,EAAQ1B,KAAKvD,IACZA,EAAM0N,WAAW,SAK1B,E,YCxBIC,GAAoB,WAAc,MAAO,CACzCrK,KAAM,SACNzE,UAAW,IACXC,QAAS,GACTc,UAAW,GACX,EACAgO,GAAyB,SAAUjO,GAAM,MAAO,CAChD2D,KAAM,SACNzE,UAAW,IACXC,QAAgB,IAAPa,EAAW,EAAI3B,KAAKe,KAAK,KAAO,GACzCa,UAAW,GACX,EACAiO,GAAc,WAAc,MAAO,CACnCvK,KAAM,YACNsC,KAAM,SACN3I,SAAU,GACV,EACA,GAAY,SAAUkK,GAAU,MAAO,CACvC7D,KAAM,YACNrG,SAAU,GACVkK,OAAQA,EACR,EACA2G,GAAqB,CACrBC,EAAGJ,GACHK,EAAGL,GACHM,EAAGN,GACHO,OAAQP,GACRQ,QAASR,GACTS,QAAST,GACTU,QAASV,GACTW,OAAQV,GACRW,OAAQX,GACRY,MAAOZ,GACPa,QAASZ,GACTa,gBAAiBb,GACjBpK,MAAOoK,GACPc,QAASf,IAETgB,GAAuB,SAAUC,EAAUlP,GAC3C,IAAImP,EAQJ,OANIA,GADA,QAAkBnP,GACE,GAIhBmO,GAAmBe,IAAaf,GAAmBa,SAEpD,QAAS,CAAEhP,GAAIA,GAAMmP,EAAkBnP,GAClD,E,YCnDIoP,GAAwB,CACxBtN,SAAS,G,YCmBb,IAAIuN,IAAsB,EAsE1B,SAASC,GAA6BC,EAAY/P,EAASG,GACvD,IAAIG,EAWJ,OAVIhD,MAAMC,QAAQyC,EAAQQ,MACS,QAA9BF,EAAKyP,EAAWjS,gBAA6B,IAAPwC,IAAsByP,EAAWjS,SAAW,KAV3F,SAA0BkC,GAClB1C,MAAMC,QAAQyC,EAAQQ,KAAyB,OAAlBR,EAAQQ,GAAG,KACxCR,EAAQQ,IAAK,QAAc,IAAI,QAAOR,EAAQQ,KAAK,GACnDR,EAAQQ,GAAG,GAAKR,EAAQO,KAGhC,CAMIyP,CAAiBhQ,GA/ErB,SAA6BM,GACzBA,EAAG2P,KAAM3P,EAAG6I,MAAO7I,EAAG4P,cAAe5P,EAAG6P,gBAAiB7P,EAAG8P,iBAAkB9P,EAAGuJ,OAAQvJ,EAAGyJ,WAAYzJ,EAAG0J,YAAa1J,EAAGC,KAAM,IAAIwP,GAAa,QAAOzP,EAAI,CAAC,OAAQ,QAAS,gBAAiB,kBAAmB,mBAAoB,SAAU,aAAc,cAAe,SAC9Q,QAASU,OAAOf,KAAK8P,GAAYxK,MACrC,CAgFS8K,CAAoBN,KACrBA,GAAa,SAAS,QAAS,CAAC,EAAGA,GAAaN,GAAqBtP,EAAKH,EAAQQ,OAE/E,SAAS,QAAS,CAAC,EAAGR,GA9EjC,SAA6CM,GACzC,IAAImG,EAAOnG,EAAGmG,KAAM4B,EAAQ/H,EAAG+H,MAAOiI,EAAOhQ,EAAGgQ,KAAMC,EAAOjQ,EAAGiQ,KAAMC,EAAOlQ,EAAGkQ,KAAMT,GAAa,QAAOzP,EAAI,CAAC,OAAQ,QAAS,OAAQ,OAAQ,SAC5IN,GAAU,QAAS,CAAC,EAAG+P,GA+C3B,OA9CI1H,IACArI,EAAgB,OAAIqI,GAIpB0H,EAAWjS,WACXkC,EAAkB,UAAI,OAAsB+P,EAAWjS,WACvDiS,EAAW/F,cACXhK,EAAQgK,aAAc,OAAsB+F,EAAW/F,cAIvDvD,IACAzG,EAAc,KAAIqO,GAAc5H,GAC1BA,EAAKhB,IAAI0I,IACTA,GAA2B1H,IAKb,UAApBsJ,EAAW5L,OACXnE,EAAQmE,KAAO,cAIfmM,GAAQE,GAAQD,MAChB,QAASV,GAAqB,mGAC9BA,IAAsB,EAClBS,EACAtQ,EAAQ+J,WAAa,UAEhByG,EACLxQ,EAAQ+J,WAAa,OAEhBwG,IACLvQ,EAAQ+J,WAAa,UAEzB/J,EAAQ6J,OAAS2G,GAAQF,GAAQC,GAAQR,EAAWlG,QAOhC,WAApBkG,EAAW5L,OACXnE,EAAQmE,KAAO,aACZnE,CACX,CA4B2CyQ,CAAoCV,GAC/E,CAIA,SAASW,GAAavQ,EAAKU,EAAOqE,EAAQ6K,EAAY5F,GAClD,IAAI7J,EACAqQ,EAAkBC,GAAmBb,EAAY5P,GACjD8E,EAAyC,QAA/B3E,EAAKqQ,EAAgBpQ,YAAyB,IAAPD,EAAgBA,EAAKO,EAAMgQ,MAC5EC,EAAqBxC,GAAanO,EAAK+E,GAC5B,SAAXD,GAAqB6L,GAAwC,kBAAX5L,EAKlDD,GAAS,QAAkB9E,EAAK+E,GAE3B6L,GAAO9L,IAA6B,kBAAXC,EAC9BD,EAAS+L,GAAY9L,IAEf5H,MAAMC,QAAQ2H,IACpB6L,GAAO7L,IACW,kBAAXD,IACPC,EAAS8L,GAAY/L,IAEzB,IAAIgM,EAAqB3C,GAAanO,EAAK8E,GAgC3C,OA/BA,OAAQgM,IAAuBH,EAAoB,6BAA6BzJ,OAAOlH,EAAK,WAAYkH,OAAOpC,EAAQ,UAAYoC,OAAOnC,EAAQ,OAAQmC,OAAOpC,EAAQ,+DAA+DoC,OAAOpC,EAAQ,8BAA8BoC,OAAOnC,EAAQ,+BA+B5R+L,GACHH,IACwB,IAAzBH,EAAgBxM,KAhCpB,WACI,IAAInE,EAAU,CACVO,KAAM0E,EACNzE,GAAI0E,EACJlH,SAAU6C,EAAMqQ,cAChB/G,WAAYA,EACZE,SAAU,SAAUlN,GAAK,OAAO0D,EAAMsQ,IAAIhU,EAAI,GAElD,MAAgC,YAAzBwT,EAAgBxM,MACM,UAAzBwM,EAAgBxM,KCtI5B,UAAiB,KAAE5D,EAAO,EAAC,SAAEvC,EAAW,EAAC,IAAE2D,EAAG,IAAEiC,EAAG,MAAEgF,EAAQ,GAAG,aAAEC,EAAe,IAAG,gBAAEuI,EAAkB,IAAG,cAAEC,EAAgB,GAAE,UAAE3Q,EAAY,EAAC,aAAEoI,EAAY,OAAEc,EAAM,SAAES,EAAQ,WAAEF,EAAU,OAAED,IACxL,IAAIoH,EACJ,SAASC,EAAcpU,GACnB,YAAgBiD,IAARuB,GAAqBxE,EAAIwE,QAAiBvB,IAARwD,GAAqBzG,EAAIyG,CACvE,CACA,SAAS4N,EAAgBrU,GACrB,YAAYiD,IAARuB,EACOiC,OACCxD,IAARwD,GAEG/E,KAAK+C,IAAID,EAAMxE,GAAK0B,KAAK+C,IAAIgC,EAAMzG,GAD/BwE,EAC0CiC,CACzD,CACA,SAAS6N,EAAezR,GACC,OAArBsR,QAAkD,IAArBA,GAAuCA,EAAiB/H,OACrF+H,EAAmB9H,EAAQxI,OAAOC,OAAOD,OAAOC,OAAO,CAAC,EAAGjB,GAAU,CAAE4J,SAAQS,SAAWlN,IAClF,IAAImD,EACS,OAAb+J,QAAkC,IAAbA,GAA+BA,EAASlN,GACjC,QAA3BmD,EAAKN,EAAQqK,gBAA6B,IAAP/J,GAAyBA,EAAG4K,KAAKlL,EAAS7C,EAAE,EACjFgN,aACHD,WACR,CACA,SAASwH,EAAY1R,GACjByR,EAAezQ,OAAOC,OAAO,CAAEkD,KAAM,SAAUzE,UAAW0R,EAAiBzR,QAAS0R,EAAe3Q,aAAaV,GACpH,CACA,GAAIuR,EAAchR,GACdmR,EAAY,CAAEnR,OAAMvC,WAAUwC,GAAIgR,EAAgBjR,SAEjD,CACD,IAAI2E,EAAS0D,EAAQ5K,EAAWuC,EACJ,qBAAjBuI,IACP5D,EAAS4D,EAAa5D,IAC1B,MAAMyM,EAAWH,EAAgBtM,GAC3B0M,EAAUD,IAAahQ,GAAO,EAAI,EACxC,IAAIkQ,EACAvP,EACJ,MAAMwP,EAAiB3U,IACnB0U,EAAOvP,EACPA,EAAUnF,EACVa,GAAW,OAAkBb,EAAI0U,GAAM,UAAerT,QACrC,IAAZoT,GAAiBzU,EAAIwU,IACR,IAAbC,GAAkBzU,EAAIwU,IACvBD,EAAY,CAAEnR,KAAMpD,EAAGqD,GAAImR,EAAU3T,YACzC,EAEJyT,EAAe,CACXtN,KAAM,QACN5D,OACAvC,WACA6K,eACAD,QACAlI,YACAoI,eACAuB,SAAUkH,EAAcrM,GAAU4M,OAAgB1R,GAE1D,CACA,MAAO,CACHmJ,KAAM,IAA2B,OAArB+H,QAAkD,IAArBA,OAA8B,EAASA,EAAiB/H,OAEzG,CD6EcwI,EAAQ,SAAS,QAAS,CAAC,EAAG/R,GAAU2Q,IACxCnH,GAAQ,SAAS,QAAS,CAAC,EAAGsG,GAA6Ba,EAAiB3Q,EAASG,IAAO,CAAEkK,SAAU,SAAUlN,GAC5G,IAAImD,EACJN,EAAQqK,SAASlN,GACmB,QAAnCmD,EAAKqQ,EAAgBtG,gBAA6B,IAAP/J,GAAyBA,EAAG4K,KAAKyF,EAAiBxT,EAClG,EAAGgN,WAAY,WACX,IAAI7J,EACJN,EAAQmK,aAC8B,QAArC7J,EAAKqQ,EAAgBxG,kBAA+B,IAAP7J,GAAyBA,EAAG4K,KAAKyF,EACnF,IACZ,EACA,WACI,IAAIrQ,EAAImJ,EACJuI,GAAc,QAA6B9M,GAK/C,OAJArE,EAAMsQ,IAAIa,GACV7H,IACsG,QAArG7J,EAAyB,OAApBqQ,QAAgD,IAApBA,OAA6B,EAASA,EAAgBtG,gBAA6B,IAAP/J,GAAyBA,EAAG4K,KAAKyF,EAAiBqB,GACxD,QAAvGvI,EAAyB,OAApBkH,QAAgD,IAApBA,OAA6B,EAASA,EAAgBxG,kBAA+B,IAAPV,GAAyBA,EAAGyB,KAAKyF,GAC1I,CAAEpH,KAAM,WAAc,EACjC,CAMJ,CACA,SAASwH,GAAOlQ,GACZ,OAAkB,IAAVA,GACc,kBAAVA,GACkB,IAAtBoR,WAAWpR,KACa,IAAxBA,EAAMqR,QAAQ,IAC1B,CACA,SAASlB,GAAYmB,GACjB,MAAoC,kBAAtBA,EACR,GACA,QAAkB,GAAIA,EAChC,CACA,SAASvB,GAAmBb,EAAY5P,GACpC,OAAO4P,EAAW5P,IAAQ4P,EAAoB,SAAKA,CACvD,CAOA,SAAS0B,GAAetR,EAAKU,EAAOqE,EAAQ6K,GAKxC,YAJmB,IAAfA,IAAyBA,EAAa,CAAC,GACvCH,GAAsBtN,UACtByN,EAAa,CAAE5L,MAAM,IAElBtD,EAAMzD,OAAM,SAAU+M,GACzB,IAAIiI,EACAC,EACAlH,EAAYuF,GAAavQ,EAAKU,EAAOqE,EAAQ6K,EAAY5F,GACzDhB,EApHZ,SAAgC4G,EAAY5P,GACxC,IAAIG,EAAImJ,EAER,OAAiG,QAAzFA,EAAsC,QAAhCnJ,GADQsQ,GAAmBb,EAAY5P,IAAQ,CAAC,GAC3BgJ,aAA0B,IAAP7I,EAAgBA,EAAKyP,EAAW5G,aAA0B,IAAPM,EAAgBA,EAAK,CAClI,CAgHoB6I,CAAuBvC,EAAY5P,GAC3C/C,EAAQ,WAAc,OAAQiV,EAAWlH,GAAc,EAO3D,OANIhC,EACAiJ,EAAaG,OAAOC,WAAWpV,GAAO,OAAsB+L,IAG5D/L,IAEG,WACHqV,aAAaL,GACA,OAAbC,QAAkC,IAAbA,GAA+BA,EAAS9I,MACjE,CACJ,GACJ,C,4DE1MImJ,GAAqB,E,SAAAC,eAAc,CAAC,E,4DCApCC,GAAsB,E,SAAAD,eAAc,CACpCE,mBAAoB,SAAU/P,GAAK,OAAOA,CAAG,EAC7CgQ,UAAU,EACVC,cAAe,S,4DCHfC,GAAkB,E,SAAAL,eAAc,K,2DCAhCM,GAA2B,E,SAAAN,eAAc,CAAC,E,kFCF9C,SAASO,EAAoB/S,EAAKG,GAC9B,IAAI6S,EAAS7S,EAAG6S,OAAQC,EAAW9S,EAAG8S,SACtC,OAAQ,QAAgBjT,KACpB,QAAsBA,KACpBgT,QAAuB/S,IAAbgT,OACL,IAAgBjT,IAAgB,YAARA,EACvC,C,8LCFA,SAASkT,EAAWC,EAAOjE,EAAOkE,GAG9B,OAAOA,EADMlE,GADYiE,EAAQC,EAGrC,CAIA,SAASC,EAAgBF,EAAOG,EAAWpE,EAAOkE,EAAaG,GAI3D,YAHiBtT,IAAbsT,IACAJ,EAAQD,EAAWC,EAAOI,EAAUH,IAEjCF,EAAWC,EAAOjE,EAAOkE,GAAeE,CACnD,CAIA,SAASE,EAAeC,EAAMH,EAAWpE,EAAOkE,EAAaG,QACvC,IAAdD,IAAwBA,EAAY,QAC1B,IAAVpE,IAAoBA,EAAQ,GAChCuE,EAAKjS,IAAM6R,EAAgBI,EAAKjS,IAAK8R,EAAWpE,EAAOkE,EAAaG,GACpEE,EAAKhQ,IAAM4P,EAAgBI,EAAKhQ,IAAK6P,EAAWpE,EAAOkE,EAAaG,EACxE,CAIA,SAASG,EAAcC,EAAKxT,GACxB,IAAIsO,EAAItO,EAAGsO,EAAGC,EAAIvO,EAAGuO,EACrB8E,EAAeG,EAAIlF,EAAGA,EAAE6E,UAAW7E,EAAES,MAAOT,EAAE2E,aAC9CI,EAAeG,EAAIjF,EAAGA,EAAE4E,UAAW5E,EAAEQ,MAAOR,EAAE0E,YAClD,CAOA,SAASQ,EAAgBD,EAAKE,EAAWC,EAAUC,GAC/C,IAAI5T,EAAImJ,OACmB,IAAvByK,IAAiCA,GAAqB,GAC1D,IAAIC,EAAaF,EAAS1O,OAC1B,GAAK4O,EAAL,CAIA,IAAIC,EACA5V,EAFJwV,EAAUpF,EAAIoF,EAAUnF,EAAI,EAG5B,IAAK,IAAIvP,EAAI,EAAGA,EAAI6U,EAAY7U,IAE5Bd,GADA4V,EAAOH,EAAS3U,IACH+U,gBACuH,cAAjD,QAA7E5K,EAA8B,QAAxBnJ,EAAK8T,EAAKE,gBAA6B,IAAPhU,OAAgB,EAASA,EAAGiU,aAA0B,IAAP9K,OAAgB,EAASA,EAAG+K,WAEnHN,GACAE,EAAKpU,QAAQyU,cACbL,EAAKM,QACLN,IAASA,EAAKO,MACdC,EAAad,EAAK,CAAElF,GAAIwF,EAAKM,OAAO9F,EAAGC,GAAIuF,EAAKM,OAAO7F,IAEvDrQ,IAEAwV,EAAUpF,GAAKpQ,EAAMoQ,EAAES,MACvB2E,EAAUnF,GAAKrQ,EAAMqQ,EAAEQ,MAEvBwE,EAAcC,EAAKtV,IAEnB0V,IAAsB,OAAaE,EAAKS,eACxCD,EAAad,EAAKM,EAAKS,cAxBrB,CA2Bd,CACA,SAASC,EAAclB,EAAMmB,GACzBnB,EAAKjS,IAAMiS,EAAKjS,IAAMoT,EACtBnB,EAAKhQ,IAAMgQ,EAAKhQ,IAAMmR,CAC1B,CAMA,SAASC,EAAcpB,EAAMqB,EAAY3U,GACrC,IAAImJ,GAAK,QAAOnJ,EAAI,GAAIH,EAAMsJ,EAAG,GAAIyL,EAAWzL,EAAG,GAAI0L,EAAY1L,EAAG,GAClE2L,OAAuChV,IAA1B6U,EAAWE,GAA2BF,EAAWE,GAAa,GAC3E5B,GAAc,OAAIK,EAAKjS,IAAKiS,EAAKhQ,IAAKwR,GAE1CzB,EAAeC,EAAMqB,EAAW9U,GAAM8U,EAAWC,GAAW3B,EAAa0B,EAAW5F,MACxF,CAIA,IAAIgG,EAAQ,CAAC,IAAK,SAAU,WACxBC,EAAQ,CAAC,IAAK,SAAU,WAI5B,SAASV,EAAad,EAAK/O,GACvBiQ,EAAclB,EAAIlF,EAAG7J,EAAWsQ,GAChCL,EAAclB,EAAIjF,EAAG9J,EAAWuQ,EACpC,C,2JCtGA,SAASC,EAAW3B,GAChB,OAAOA,EAAKhQ,IAAMgQ,EAAKjS,GAC3B,CACA,SAAS6T,EAAO3U,EAAOqE,EAAQuQ,GAG3B,YAFe,IAAXvQ,IAAqBA,EAAS,QACd,IAAhBuQ,IAA0BA,EAAc,MACrC,OAAS5U,EAAOqE,GAAUuQ,CACrC,CACA,SAASC,EAAclX,EAAOmX,EAAQzQ,EAAQD,QAC3B,IAAXA,IAAqBA,EAAS,IAClCzG,EAAMyG,OAASA,EACfzG,EAAM+U,aAAc,OAAIoC,EAAOhU,IAAKgU,EAAO/R,IAAKpF,EAAMyG,QACtDzG,EAAM6Q,MAAQkG,EAAWrQ,GAAUqQ,EAAWI,IAC1CH,EAAOhX,EAAM6Q,MAAO,EAAG,OAAW5P,MAAMjB,EAAM6Q,UAC9C7Q,EAAM6Q,MAAQ,GAClB7Q,EAAMiV,WACF,OAAIvO,EAAOvD,IAAKuD,EAAOtB,IAAKpF,EAAMyG,QAAUzG,EAAM+U,aAClDiC,EAAOhX,EAAMiV,YAAchU,MAAMjB,EAAMiV,cACvCjV,EAAMiV,UAAY,EAC1B,CACA,SAASmC,EAAapX,EAAOmX,EAAQzQ,EAAQD,GACzCyQ,EAAclX,EAAMoQ,EAAG+G,EAAO/G,EAAG1J,EAAO0J,EAAc,OAAX3J,QAA8B,IAAXA,OAAoB,EAASA,EAAO4Q,SAClGH,EAAclX,EAAMqQ,EAAG8G,EAAO9G,EAAG3J,EAAO2J,EAAc,OAAX5J,QAA8B,IAAXA,OAAoB,EAASA,EAAO6Q,QACtG,CACA,SAASC,EAAiB7Q,EAAQ8Q,EAAUC,GACxC/Q,EAAOvD,IAAMsU,EAAOtU,IAAMqU,EAASrU,IACnCuD,EAAOtB,IAAMsB,EAAOvD,IAAM4T,EAAWS,EACzC,CACA,SAASE,EAAgBhR,EAAQ8Q,EAAUC,GACvCF,EAAiB7Q,EAAO0J,EAAGoH,EAASpH,EAAGqH,EAAOrH,GAC9CmH,EAAiB7Q,EAAO2J,EAAGmH,EAASnH,EAAGoH,EAAOpH,EAClD,CACA,SAASsH,EAAyBjR,EAAQiO,EAAQ8C,GAC9C/Q,EAAOvD,IAAMwR,EAAOxR,IAAMsU,EAAOtU,IACjCuD,EAAOtB,IAAMsB,EAAOvD,IAAM4T,EAAWpC,EACzC,CACA,SAASiD,EAAqBlR,EAAQiO,EAAQ8C,GAC1CE,EAAyBjR,EAAO0J,EAAGuE,EAAOvE,EAAGqH,EAAOrH,GACpDuH,EAAyBjR,EAAO2J,EAAGsE,EAAOtE,EAAGoH,EAAOpH,EACxD,C,iFCzCA,IAMIwH,EAAc,WAAc,MAAO,CACnCzH,EAPuC,CACvC6E,UAAW,EACXpE,MAAO,EACPpK,OAAQ,EACRsO,YAAa,GAIb1E,EARuC,CACvC4E,UAAW,EACXpE,MAAO,EACPpK,OAAQ,EACRsO,YAAa,GAKb,EAEA+C,EAAY,WAAc,MAAO,CACjC1H,EAFkC,CAAGjN,IAAK,EAAGiC,IAAK,GAGlDiL,EAHkC,CAAGlN,IAAK,EAAGiC,IAAK,GAIlD,C,sMCXA2S,EAAU,CAAC,UAAW,WAAY,aAAc,eAChDC,EAAaD,EAAQhR,OACrBkR,EAAW,SAAU5V,GACrB,MAAwB,kBAAVA,EAAqBoR,WAAWpR,GAASA,CAC3D,EACI6V,EAAO,SAAU7V,GACjB,MAAwB,kBAAVA,GAAsB,EAAA8V,GAAGvS,KAAKvD,EAChD,EA4CA,SAAS+V,EAAU5O,EAAQ6O,GACvB,IAAIvW,EACJ,OAAqC,QAA7BA,EAAK0H,EAAO6O,UAAgC,IAAPvW,EAAgBA,EAAK0H,EAAO8O,YAC7E,CAwBA,IAAIC,EAAkBC,EAAS,EAAG,GAAK,MACnCC,EAAmBD,EAAS,GAAK,IAAM,MAC3C,SAASA,EAASrV,EAAKiC,EAAKqE,GACxB,OAAO,SAAUnF,GAEb,OAAIA,EAAInB,EACG,EACPmB,EAAIc,EACG,EACJqE,GAAO,EAAAT,EAAA,GAAS7F,EAAKiC,EAAKd,GACrC,CACJ,CCvFA,SAASoU,EAAatD,EAAMuD,GACxBvD,EAAKjS,IAAMwV,EAAWxV,IACtBiS,EAAKhQ,IAAMuT,EAAWvT,GAC1B,CAMA,SAASwT,EAAYtD,EAAKuD,GACtBH,EAAapD,EAAIlF,EAAGyI,EAAUzI,GAC9BsI,EAAapD,EAAIjF,EAAGwI,EAAUxI,EAClC,C,0BCTA,SAASyI,EAAiBhE,EAAOG,EAAWpE,EAAOkE,EAAaG,GAM5D,OALAJ,GAASG,EACTH,GAAQ,QAAWA,EAAO,EAAIjE,EAAOkE,QACpBnT,IAAbsT,IACAJ,GAAQ,QAAWA,EAAO,EAAII,EAAUH,IAErCD,CACX,CA2BA,SAASiE,EAAqB3D,EAAMqB,EAAY3U,EAAI2E,EAAQuS,GACxD,IAAI/N,GAAK,QAAOnJ,EAAI,GAAIH,EAAMsJ,EAAG,GAAIyL,EAAWzL,EAAG,GAAI0L,EAAY1L,EAAG,IAxB1E,SAAyBmK,EAAMH,EAAWpE,EAAOpK,EAAQyO,EAAUyD,EAAYK,GAW3E,QAVkB,IAAd/D,IAAwBA,EAAY,QAC1B,IAAVpE,IAAoBA,EAAQ,QACjB,IAAXpK,IAAqBA,EAAS,SACf,IAAfkS,IAAyBA,EAAavD,QACvB,IAAf4D,IAAyBA,EAAa5D,GACtC,KAAQxP,KAAKqP,KACbA,EAAYxB,WAAWwB,GAEvBA,GADuB,EAAA3O,EAAA,GAAI0S,EAAW7V,IAAK6V,EAAW5T,IAAK6P,EAAY,KACxC+D,EAAW7V,KAErB,kBAAd8R,EAAX,CAEA,IAAIF,GAAc,EAAAzO,EAAA,GAAIqS,EAAWxV,IAAKwV,EAAWvT,IAAKqB,GAClD2O,IAASuD,IACT5D,GAAeE,GACnBG,EAAKjS,IAAM2V,EAAiB1D,EAAKjS,IAAK8R,EAAWpE,EAAOkE,EAAaG,GACrEE,EAAKhQ,IAAM0T,EAAiB1D,EAAKhQ,IAAK6P,EAAWpE,EAAOkE,EAAaG,EAL3D,CAMd,CAOI+D,CAAgB7D,EAAMqB,EAAW9U,GAAM8U,EAAWC,GAAWD,EAAWE,GAAYF,EAAW5F,MAAOpK,EAAQuS,EAClH,CAIA,IAAInC,EAAQ,CAAC,IAAK,SAAU,WACxBC,EAAQ,CAAC,IAAK,SAAU,WAK5B,SAASoC,EAAoB5D,EAAKmB,EAAYoC,EAAWM,GACrDJ,EAAqBzD,EAAIlF,EAAGqG,EAAYI,EAAqB,OAAdgC,QAAoC,IAAdA,OAAuB,EAASA,EAAUzI,EAAiB,OAAd+I,QAAoC,IAAdA,OAAuB,EAASA,EAAU/I,GAClL2I,EAAqBzD,EAAIjF,EAAGoG,EAAYK,EAAqB,OAAd+B,QAAoC,IAAdA,OAAuB,EAASA,EAAUxI,EAAiB,OAAd8I,QAAoC,IAAdA,OAAuB,EAASA,EAAU9I,EACtL,C,eC1DA,SAAS+I,EAAgBpZ,GACrB,OAA2B,IAApBA,EAAMiV,WAAmC,IAAhBjV,EAAM6Q,KAC1C,CACA,SAASwI,EAAYrZ,GACjB,OAAOoZ,EAAgBpZ,EAAMoQ,IAAMgJ,EAAgBpZ,EAAMqQ,EAC7D,CACA,SAASiJ,EAAUrZ,EAAGC,GAClB,OAAQD,EAAEmQ,EAAEjN,MAAQjD,EAAEkQ,EAAEjN,KACpBlD,EAAEmQ,EAAEhL,MAAQlF,EAAEkQ,EAAEhL,KAChBnF,EAAEoQ,EAAElN,MAAQjD,EAAEmQ,EAAElN,KAChBlD,EAAEoQ,EAAEjL,MAAQlF,EAAEmQ,EAAEjL,GACxB,C,eCTImU,EAA2B,WAC3B,SAASA,IACLC,KAAKC,QAAU,EACnB,CAuGA,OAtGAF,EAAUG,UAAUC,IAAM,SAAU/D,IAChC,QAAc4D,KAAKC,QAAS7D,GAC5BA,EAAKgE,gBACT,EACAL,EAAUG,UAAUG,OAAS,SAAUjE,GAKnC,IAJA,QAAW4D,KAAKC,QAAS7D,GACrBA,IAAS4D,KAAKM,WACdN,KAAKM,cAAWlY,GAEhBgU,IAAS4D,KAAKO,KAAM,CACpB,IAAID,EAAWN,KAAKC,QAAQD,KAAKC,QAAQ1S,OAAS,GAC9C+S,GACAN,KAAKQ,QAAQF,EAErB,CACJ,EACAP,EAAUG,UAAUO,SAAW,SAAUrE,GACrC,IAMIkE,EANAI,EAAcV,KAAKC,QAAQU,WAAU,SAAUC,GAAU,OAAOxE,IAASwE,CAAQ,IACrF,GAAoB,IAAhBF,EACA,OAAO,EAKX,IAAK,IAAIpZ,EAAIoZ,EAAapZ,GAAK,EAAGA,IAAK,CACnC,IAAIsZ,EAASZ,KAAKC,QAAQ3Y,GAC1B,IAAyB,IAArBsZ,EAAOC,UAAqB,CAC5BP,EAAWM,EACX,KACJ,CACJ,CACA,QAAIN,IACAN,KAAKQ,QAAQF,IACN,EAKf,EACAP,EAAUG,UAAUM,QAAU,SAAUpE,EAAM0E,GAC1C,IAAIxY,EACAgY,EAAWN,KAAKO,KAChBnE,IAASkE,IAEbN,KAAKM,SAAWA,EAChBN,KAAKO,KAAOnE,EACZA,EAAK2E,OACDT,IACAA,EAAShE,UAAYgE,EAASF,iBAC9BhE,EAAKgE,iBACLhE,EAAK4E,WAAaV,EACdQ,IACA1E,EAAK4E,WAAWC,iBAAkB,GAElCX,EAASY,WACT9E,EAAK8E,SAAWZ,EAASY,SACzB9E,EAAK8E,SAASrE,aACVyD,EAASa,iBAAmBb,EAASzD,aACzCT,EAAK8E,SAASE,UAAW,IAEJ,QAApB9Y,EAAK8T,EAAKO,YAAyB,IAAPrU,OAAgB,EAASA,EAAG+Y,cACzDjF,EAAKkF,eAAgB,IAGP,IADFlF,EAAKpU,QAAQuZ,WAEzBjB,EAASkB,QAerB,EACAzB,EAAUG,UAAUuB,sBAAwB,WACxCzB,KAAKC,QAAQyB,SAAQ,SAAUtF,GAC3B,IAAI9T,EAAImJ,EAAIC,EAAIiQ,EAAIC,EAC0B,QAA7CnQ,GAAMnJ,EAAK8T,EAAKpU,SAAS6Z,sBAAmC,IAAPpQ,GAAyBA,EAAGyB,KAAK5K,GACmB,QAAzGsZ,EAAkC,QAA5BlQ,EAAK0K,EAAK0F,oBAAiC,IAAPpQ,OAAgB,GAAUiQ,EAAKjQ,EAAG1J,SAAS6Z,sBAAmC,IAAPD,GAAyBA,EAAG1O,KAAKyO,EACvJ,GACJ,EACA5B,EAAUG,UAAUE,eAAiB,WACjCJ,KAAKC,QAAQyB,SAAQ,SAAUtF,GAC3BA,EAAKE,UAAYF,EAAKgE,gBAAe,EACzC,GACJ,EAKAL,EAAUG,UAAU6B,mBAAqB,WACjC/B,KAAKO,MAAQP,KAAKO,KAAKW,WACvBlB,KAAKO,KAAKW,cAAW9Y,EAE7B,EACO2X,CACX,CA3G8B,G,WCF1BiC,EAAqB,uCACzB,SAASC,EAAyBzb,EAAOwV,EAAWkG,GAOhD,IAAIC,EAAa3b,EAAMoQ,EAAE6E,UAAYO,EAAUpF,EAC3CwL,EAAa5b,EAAMqQ,EAAE4E,UAAYO,EAAUnF,EAC3C9J,EAAY,eAAesC,OAAO8S,EAAY,QAAQ9S,OAAO+S,EAAY,WAC7E,GAAIF,EAAiB,CACjB,IAAInL,EAASmL,EAAgBnL,OAAQC,EAAUkL,EAAgBlL,QAASC,EAAUiL,EAAgBjL,QAC9FF,IACAhK,GAAa,UAAUsC,OAAO0H,EAAQ,UACtCC,IACAjK,GAAa,WAAWsC,OAAO2H,EAAS,UACxCC,IACAlK,GAAa,WAAWsC,OAAO4H,EAAS,SAChD,CAEA,OADAlK,GAAa,SAASsC,OAAO7I,EAAMoQ,EAAES,MAAO,MAAMhI,OAAO7I,EAAMqQ,EAAEQ,MAAO,QACnD2K,EAAqB,OAASjV,CACvD,C,qCCtBIsV,EAAiB,SAAU5b,EAAGC,GAC9B,OAAOD,EAAE6b,MAAQ5b,EAAE4b,KACvB,ECCIC,EAA0B,WAC1B,SAASA,IACLvC,KAAKwC,SAAW,GAChBxC,KAAKyC,SAAU,CACnB,CAcA,OAbAF,EAASrC,UAAUC,IAAM,SAAUuC,IAC/B,QAAc1C,KAAKwC,SAAUE,GAC7B1C,KAAKyC,SAAU,CACnB,EACAF,EAASrC,UAAUG,OAAS,SAAUqC,IAClC,QAAW1C,KAAKwC,SAAUE,GAC1B1C,KAAKyC,SAAU,CACnB,EACAF,EAASrC,UAAUwB,QAAU,SAAUiB,GACnC3C,KAAKyC,SAAWzC,KAAKwC,SAASI,KAAKP,GACnCrC,KAAKyC,SAAU,EACfzC,KAAKwC,SAASd,QAAQiB,EAC1B,EACOJ,CACX,CAnB6B,G,WCuBzBM,EAAkB,IAMlBC,EAAwB,CAKxBC,wBAAwB,EAKxBC,gBAAgB,GAEpB,SAASC,EAAqB3a,GAC1B,IAAI4a,EAAuB5a,EAAG4a,qBAAsBC,EAAgB7a,EAAG6a,cAAeC,EAAgB9a,EAAG8a,cAAeC,EAAiB/a,EAAG+a,eAC5I,OAAsB,WAClB,SAASC,EAAeC,EAAI1G,EAAcoB,GACtC,IAAIuF,EAAQxD,UACS,IAAjBnD,IAA2BA,EAAe,CAAC,QAChC,IAAXoB,IAAqBA,EAA2B,OAAlBkF,QAA4C,IAAlBA,OAA2B,EAASA,KAOhGnD,KAAKwC,SAAW,IAAIzP,IAKpBiN,KAAKhY,QAAU,CAAC,EAMhBgY,KAAKyD,iBAAkB,EACvBzD,KAAK0D,oBAAqB,EAO1B1D,KAAKsB,eAAgB,EAIrBtB,KAAK2D,uBAAwB,EAC7B3D,KAAK4D,uBAAwB,EAK7B5D,KAAKqB,YAAa,EAIlBrB,KAAK6D,OAAQ,EAKb7D,KAAK8D,YAAa,EAIlB9D,KAAK+D,sBAAuB,EAS5B/D,KAAKhE,UAAY,CAAEpF,EAAG,EAAGC,EAAG,GAI5BmJ,KAAKgE,cAAgB,IAAIC,IAEzBjE,KAAKkE,eAAiB,IAAID,IAC1BjE,KAAKmE,kBAAoB,WACjBX,EAAMnC,aACNmC,EAAMnC,YAAa,EACnBmC,EAAMY,oBAEd,EACApE,KAAKqE,iBAAmB,WACpBb,EAAMc,MAAM5C,QAAQ6C,IACpBf,EAAMc,MAAM5C,QAAQ8C,GACxB,EACAxE,KAAKyE,cAAe,EACpBzE,KAAK0E,WAAY,EACjB1E,KAAK2E,kBAAoB,EAKzB3E,KAAK4E,YAAc,IAAIX,IACvBjE,KAAKuD,GAAKA,EACVvD,KAAKnD,aAAeA,EACpBmD,KAAKrD,KAAOsB,EAASA,EAAOtB,MAAQsB,EAAS+B,KAC7CA,KAAK6E,KAAO5G,GAAS,SAAc,QAAc,IAAI,QAAOA,EAAO4G,OAAO,GAAQ,CAAC5G,IAAS,GAAS,GACrG+B,KAAK/B,OAASA,EACd+B,KAAKsC,MAAQrE,EAASA,EAAOqE,MAAQ,EAAI,EACzCiB,GAAMvD,KAAKrD,KAAKmI,sBAAsBvB,EAAIvD,MAC1C,IAAK,IAAI1Y,EAAI,EAAGA,EAAI0Y,KAAK6E,KAAKtX,OAAQjG,IAClC0Y,KAAK6E,KAAKvd,GAAGyc,sBAAuB,EAEpC/D,KAAKrD,OAASqD,OACdA,KAAKsE,MAAQ,IAAI/B,EACzB,CAm4BA,OAl4BAe,EAAepD,UAAU6E,iBAAmB,SAAUC,EAAMC,GAIxD,OAHKjF,KAAKgE,cAAchR,IAAIgS,IACxBhF,KAAKgE,cAAc7K,IAAI6L,EAAM,IAAI,KAE9BhF,KAAKgE,cAAcnL,IAAImM,GAAM7E,IAAI8E,EAC5C,EACA3B,EAAepD,UAAUgF,gBAAkB,SAAUF,GAEjD,IADA,IAAIG,EAAO,GACFC,EAAK,EAAGA,EAAKC,UAAU9X,OAAQ6X,IACpCD,EAAKC,EAAK,GAAKC,UAAUD,GAE7B,IAAIE,EAAsBtF,KAAKgE,cAAcnL,IAAImM,GACzB,OAAxBM,QAAwD,IAAxBA,GAA0CA,EAAoBC,OAAOC,MAAMF,GAAqB,QAAc,IAAI,QAAOH,IAAO,GACpK,EACA7B,EAAepD,UAAUuF,aAAe,SAAUT,GAC9C,OAAOhF,KAAKgE,cAAchR,IAAIgS,EAClC,EACA1B,EAAepD,UAAU4E,sBAAwB,SAAUvB,EAAInH,GAC3D4D,KAAKkE,eAAe/K,IAAIoK,EAAInH,EAChC,EAIAkH,EAAepD,UAAUwF,MAAQ,SAAUpJ,EAAUgF,GACjD,IACIhZ,EADAkb,EAAQxD,KAGZ,QADsB,IAAlBsB,IAA4BA,GAAgB,IAC5CtB,KAAK1D,SAAT,CAEA0D,KAAK6D,MACDvH,aAAoBqJ,YAAmC,QAArBrJ,EAASsJ,QAC/C5F,KAAK1D,SAAWA,EAChB,IAAI7K,EAAKuO,KAAKhY,QAASoT,EAAW3J,EAAG2J,SAAUD,EAAS1J,EAAG0J,OAAQ0K,EAAgBpU,EAAGoU,cAUtF,GATIA,IAAkBA,EAAcC,eAChCD,EAAcH,MAAMpJ,GAExB0D,KAAKrD,KAAK2H,MAAMnE,IAAIH,MACG,QAAtB1X,EAAK0X,KAAK/B,cAA2B,IAAP3V,GAAyBA,EAAGka,SAASrC,IAAIH,MACxEA,KAAKuD,IAAMvD,KAAKrD,KAAKuH,eAAe6B,OAAO/F,KAAKuD,IAC5CjC,IAAkBnG,GAAUC,KAC5B4E,KAAKsB,eAAgB,GAErB4B,EAAsB,CACtB,IAAI8C,EACAC,EAAwB,WACxB,OAAQzC,EAAM7G,KAAKiH,uBAAwB,CAC/C,EACAV,EAAqB5G,GAAU,WAC3BkH,EAAM7G,KAAKiH,uBAAwB,EACnCnJ,aAAauL,GACbA,EAAmBzL,OAAOC,WAAWyL,EAAuB,KACxDnD,EAAsBC,yBACtBD,EAAsBC,wBAAyB,EAC/CS,EAAMc,MAAM5C,QAAQwE,GAE5B,GACJ,CACI9K,GACA4E,KAAKrD,KAAKwJ,mBAAmB/K,EAAU4E,OAGd,IAAzBA,KAAKhY,QAAQwJ,SACbqU,IACCzK,GAAYD,IACb6E,KAAK+E,iBAAiB,aAAa,SAAUzc,GACzC,IAAImJ,EAAIC,EAAIiQ,EAAIC,EAAIwE,EAChB5f,EAAQ8B,EAAG9B,MAAO6f,EAAmB/d,EAAG+d,iBAAkBC,EAA2Bhe,EAAGge,yBAA0BC,EAAYje,EAAG6S,OACrI,GAAIqI,EAAMgD,yBAGN,OAFAhD,EAAMtW,YAAS9E,OACfob,EAAMiD,oBAAiBre,GAI3B,IAAIse,EAAoI,QAAhHhV,EAAyC,QAAnCD,EAAK+R,EAAMxb,QAAQ+P,kBAA+B,IAAPtG,EAAgBA,EAAKoU,EAAcpO,8BAA2C,IAAP/F,EAAgBA,EAAKiV,GACjKC,EAA4Bf,EAAcgB,WAAWD,0BAKrDE,GAAiBtD,EAAMuD,eACtBjH,EAAU0D,EAAMuD,aAAcR,IAC/BD,EAMAU,GAAgCX,GAAoBC,EACxD,IAAiC,QAA3B3E,EAAK6B,EAAMxC,kBAA+B,IAAPW,OAAgB,EAASA,EAAGrF,WACjE0K,GACCX,IACIS,IAAkBtD,EAAMlK,kBAAoB,CAC7CkK,EAAMxC,aACNwC,EAAM1B,aAAe0B,EAAMxC,WAC3BwC,EAAM1B,aAAaA,kBAAe1Z,GAEtCob,EAAMyD,mBAAmBzgB,EAAOwgB,GAChC,IAAIE,GAAmB,SAAS,QAAS,CAAC,GAAG,QAAmBR,EAAkB,WAAY,CAAEvU,WAAYyU,IACxGf,EAAcsB,qBACdD,EAAiB/V,MAAQ,EACzB+V,EAAiB/a,MAAO,GAE5BqX,EAAM/J,eAAeyN,EACzB,MAOSb,GAC2B,IAA5B7C,EAAMmB,mBACNnB,EAAM0C,kBAEV1C,EAAM4D,WAA4D,QAA9ChB,GAAMxE,EAAK4B,EAAMxb,SAAS6Z,sBAAmC,IAAPuE,GAAyBA,EAAGlT,KAAK0O,IAE/G4B,EAAMuD,aAAeR,CACzB,GAzFM,CA2Fd,EACAjD,EAAepD,UAAUmH,QAAU,WAC/B,IAAI/e,EAAImJ,EACRuO,KAAKhY,QAAQoT,UAAY4E,KAAKsH,aAC9BtH,KAAKrD,KAAK2H,MAAMjE,OAAOL,MACI,QAA1B1X,EAAK0X,KAAKuH,kBAA+B,IAAPjf,GAAyBA,EAAG+X,OAAOL,MAC/C,QAAtBvO,EAAKuO,KAAK/B,cAA2B,IAAPxM,GAAyBA,EAAG+Q,SAASuD,OAAO/F,MAC3EA,KAAK1D,cAAWlU,EAChB,KAAWof,UAAUxH,KAAKqE,iBAC9B,EAEAf,EAAepD,UAAUuH,YAAc,WACnCzH,KAAK2D,uBAAwB,CACjC,EACAL,EAAepD,UAAUwH,cAAgB,WACrC1H,KAAK2D,uBAAwB,CACjC,EACAL,EAAepD,UAAUyH,gBAAkB,WACvC,OAAO3H,KAAK2D,uBAAyB3D,KAAK4D,qBAC9C,EACAN,EAAepD,UAAUsG,uBAAyB,WAC9C,IAAIle,EACJ,OAAQ0X,KAAK0D,qBACe,QAAtBpb,EAAK0X,KAAK/B,cAA2B,IAAP3V,OAAgB,EAASA,EAAGke,4BAC5D,CACR,EAEAlD,EAAepD,UAAU0H,YAAc,WACnC,IAAItf,EACA0X,KAAK2H,oBAET3H,KAAKqB,YAAa,EACI,QAArB/Y,EAAK0X,KAAKsE,aAA0B,IAAPhc,GAAyBA,EAAGoZ,QAAQmG,IACtE,EACAvE,EAAepD,UAAUoH,WAAa,SAAUQ,GAC5C,IAAIxf,EAAImJ,EAAIC,EAEZ,QAD8B,IAA1BoW,IAAoCA,GAAwB,GAC5D9H,KAAKrD,KAAKgL,kBACoC,QAA7ClW,GAAMnJ,EAAK0X,KAAKhY,SAAS6Z,sBAAmC,IAAPpQ,GAAyBA,EAAGyB,KAAK5K,QAI3F,IADC0X,KAAKrD,KAAK0E,YAAcrB,KAAKrD,KAAKiL,eAC/B5H,KAAKsB,cAAT,CAEAtB,KAAKsB,eAAgB,EACrB,IAAK,IAAIha,EAAI,EAAGA,EAAI0Y,KAAK6E,KAAKtX,OAAQjG,IAAK,CACvC,IAAI8U,EAAO4D,KAAK6E,KAAKvd,GACrB8U,EAAK2H,sBAAuB,EAK5B3H,EAAK2L,cACT,CACA,IAAIpG,EAAK3B,KAAKhY,QAASoT,EAAWuG,EAAGvG,SAAUD,EAASwG,EAAGxG,OAC3D,QAAiB/S,IAAbgT,GAA2BD,EAA/B,CAEA,IAAI6M,EAA0D,QAArCtW,EAAKsO,KAAKhY,QAAQ6d,qBAAkC,IAAPnU,OAAgB,EAASA,EAAGmV,WAAWmB,kBAC7GhI,KAAKiI,2BAAmD,OAAtBD,QAAoD,IAAtBA,OAA+B,EAASA,EAAkBhI,KAAKnD,aAAc,IAC7ImD,KAAKkI,iBACLJ,GAAyB9H,KAAKkF,gBAAgB,aAJpC,CAbA,CAkBd,EAEA5B,EAAepD,UAAUiI,UAAY,WAKjC,GAJuBnI,KAAK2H,kBAQxB,OAHA3H,KAAK0H,gBACL1H,KAAKoE,yBACLpE,KAAKsE,MAAM5C,QAAQ0G,GAGlBpI,KAAKqB,aAEVrB,KAAKqB,YAAa,EAOdrB,KAAKkE,eAAemE,OACpBrI,KAAKkE,eAAexC,QAAQ4G,IAC5BtI,KAAKkE,eAAeqE,SAKxBvI,KAAKsE,MAAM5C,QAAQ8G,GAKnBxI,KAAKsE,MAAM5C,QAAQ+G,GAKnBzI,KAAKsE,MAAM5C,QAAQgH,GACnB1I,KAAKoE,oBAEL,KAAU/S,SACV,KAAUmW,YACV,KAAUmB,SACd,EACArF,EAAepD,UAAUkE,kBAAoB,WACzCpE,KAAKsE,MAAM5C,QAAQkH,GACnB5I,KAAK4E,YAAYlD,QAAQmH,GAC7B,EACAvF,EAAepD,UAAU4I,yBAA2B,WAChD,KAAKtB,UAAUxH,KAAKqE,kBAAkB,GAAO,EACjD,EACAf,EAAepD,UAAU6I,0BAA4B,WACjD,IAAIvF,EAAQxD,KAMZ,KAAKgJ,YAAW,WACRxF,EAAMlC,cACNkC,EAAM7G,KAAKwL,YAGX3E,EAAM7G,KAAKwH,mBAEnB,GACJ,EAIAb,EAAepD,UAAUgI,eAAiB,WACtC,IAAIlI,KAAKkB,UAAalB,KAAK1D,SAA3B,CAEA,IAAI2M,EAAWjJ,KAAKkJ,UAChB/N,EAAS6E,KAAKmJ,gBAAgBnJ,KAAKoJ,oBAAoBH,IAC3DI,GAASlO,GACT6E,KAAKkB,SAAW,CACZ+H,SAAUA,EACV9N,OAAQA,EACR0B,aAAc,CAAC,EAPT,CASd,EACAyG,EAAepD,UAAUuI,aAAe,WACpC,IAAIngB,EACJ,GAAK0X,KAAK1D,WAGV0D,KAAK+H,eACC/H,KAAKhY,QAAQshB,qBAAuBtJ,KAAKoH,UAC1CpH,KAAKsB,eADV,CAWA,GAAItB,KAAKgB,aAAehB,KAAKgB,WAAW1E,SACpC,IAAK,IAAIhV,EAAI,EAAGA,EAAI0Y,KAAK6E,KAAKtX,OAAQjG,IAAK,CAC5B0Y,KAAK6E,KAAKvd,GAChBygB,cACT,CAEJ,IAAIkB,EAAWjJ,KAAKkJ,UACpBG,GAASJ,GACT,IAAIM,EAAavJ,KAAK7E,OACtB6E,KAAK7E,OAAS,CACV8N,SAAUA,EACVO,OAAQxJ,KAAKoJ,oBAAoBH,IAErCjJ,KAAKyJ,iBAAkB,UACvBzJ,KAAKsB,eAAgB,EACrBtB,KAAK3D,qBAAkBjU,EACvB4X,KAAKkF,gBAAgB,UAAWlF,KAAK7E,OAAOqO,QACN,QAArClhB,EAAK0X,KAAKhY,QAAQ6d,qBAAkC,IAAPvd,GAAyBA,EAAGohB,oBAAoB1J,KAAK7E,OAAOqO,OAAuB,OAAfD,QAAsC,IAAfA,OAAwB,EAASA,EAAWC,OAzBrL,CA0BJ,EACAlG,EAAepD,UAAU6H,aAAe,WAChC/H,KAAKhY,QAAQyU,cAAgBuD,KAAK1D,WAClC0D,KAAKtD,OAAS0G,EAAcpD,KAAK1D,UAEzC,EACAgH,EAAepD,UAAUmD,eAAiB,WACtC,IAAI/a,EACJ,GAAK+a,EAAL,CAEA,IAAIsG,EAAmB3J,KAAKsB,eAAiBtB,KAAK+D,qBAC9C6F,EAAgB5J,KAAK3D,kBAAoBwD,EAAYG,KAAK3D,iBAC1D2L,EAA0D,QAArC1f,EAAK0X,KAAKhY,QAAQ6d,qBAAkC,IAAPvd,OAAgB,EAASA,EAAGue,WAAWmB,kBACzG6B,EAA+C,OAAtB7B,QAAoD,IAAtBA,OAA+B,EAASA,EAAkBhI,KAAKnD,aAAc,IACpIiN,EAA8BD,IAA2B7J,KAAKiI,2BAC9D0B,IACCC,IACG,OAAa5J,KAAKnD,eAClBiN,KACJzG,EAAerD,KAAK1D,SAAUuN,GAC9B7J,KAAK+D,sBAAuB,EAC5B/D,KAAKI,iBAZC,CAcd,EACAkD,EAAepD,UAAUgJ,QAAU,WAC/B,IAAIrD,EAAgB7F,KAAKhY,QAAQ6d,cACjC,IAAKA,EACD,OAAO,UACX,IAAI/J,EAAM+J,EAAckE,qBAEpBrN,EAASsD,KAAKrD,KAAKD,OAKvB,OAJIA,KACA,QAAcZ,EAAIlF,EAAG8F,EAAO9F,IAC5B,QAAckF,EAAIjF,EAAG6F,EAAO7F,IAEzBiF,CACX,EACAwH,EAAepD,UAAUkJ,oBAAsB,SAAUtN,GACrD,IAAIkO,GAAmB,UACvB5K,EAAY4K,EAAkBlO,GAK9B,IAAK,IAAIxU,EAAI,EAAGA,EAAI0Y,KAAK6E,KAAKtX,OAAQjG,IAAK,CACvC,IAAI8U,EAAO4D,KAAK6E,KAAKvd,GACjB2iB,EAAW7N,EAAKM,OAAQ1U,EAAUoU,EAAKpU,QACvCoU,IAAS4D,KAAKrD,MAAQsN,GAAYjiB,EAAQyU,gBAC1C,QAAcuN,EAAiBpT,EAAGqT,EAASrT,IAC3C,QAAcoT,EAAiBnT,EAAGoT,EAASpT,GAEnD,CACA,OAAOmT,CACX,EACA1G,EAAepD,UAAUgK,eAAiB,SAAUpO,EAAKqO,QAC/B,IAAlBA,IAA4BA,GAAgB,GAChD,IAAIC,GAAiB,UACrBhL,EAAYgL,EAAgBtO,GAC5B,IAAK,IAAIxU,EAAI,EAAGA,EAAI0Y,KAAK6E,KAAKtX,OAAQjG,IAAK,CACvC,IAAI8U,EAAO4D,KAAK6E,KAAKvd,IAChB6iB,GACD/N,EAAKpU,QAAQyU,cACbL,EAAKM,QACLN,IAASA,EAAKO,OACd,QAAayN,EAAgB,CACzBxT,GAAIwF,EAAKM,OAAO9F,EAChBC,GAAIuF,EAAKM,OAAO7F,KAGnB,OAAauF,EAAKS,gBAEvB,QAAauN,EAAgBhO,EAAKS,aACtC,CAIA,OAHI,OAAamD,KAAKnD,gBAClB,QAAauN,EAAgBpK,KAAKnD,cAE/BuN,CACX,EACA9G,EAAepD,UAAUiJ,gBAAkB,SAAUrN,GACjD,IAAIxT,EACA+hB,GAAsB,UAC1BjL,EAAYiL,EAAqBvO,GACjC,IAAK,IAAIxU,EAAI,EAAGA,EAAI0Y,KAAK6E,KAAKtX,OAAQjG,IAAK,CACvC,IAAI8U,EAAO4D,KAAK6E,KAAKvd,GACrB,GAAK8U,EAAKE,WAEL,OAAaF,EAAKS,cAAvB,EAEA,OAAST,EAAKS,eAAiBT,EAAK8L,iBACpC,IAAIvI,GAAY,UAEhBP,EAAYO,EADEvD,EAAK8M,WAEnBxJ,EAAoB2K,EAAqBjO,EAAKS,aAAuC,QAAxBvU,EAAK8T,EAAK8E,gBAA6B,IAAP5Y,OAAgB,EAASA,EAAG6S,OAAQwE,EALrH,CAMhB,CAIA,OAHI,OAAaK,KAAKnD,eAClB6C,EAAoB2K,EAAqBrK,KAAKnD,cAE3CwN,CACX,EAIA/G,EAAepD,UAAUoK,eAAiB,SAAU9jB,GAChDwZ,KAAKuK,YAAc/jB,EACnBwZ,KAAKrD,KAAKmM,0BACd,EACAxF,EAAepD,UAAUsK,WAAa,SAAUxiB,GAC5C,IAAIM,EACJ0X,KAAKhY,SAAU,SAAS,SAAS,QAAS,CAAC,EAAGgY,KAAKhY,SAAUA,GAAU,CAAEuZ,UAAwC,QAA5BjZ,EAAKN,EAAQuZ,iBAA8B,IAAPjZ,GAAgBA,GAC7I,EACAgb,EAAepD,UAAUkI,kBAAoB,WACzCpI,KAAKtD,YAAStU,EACd4X,KAAK7E,YAAS/S,EACd4X,KAAKkB,cAAW9Y,EAChB4X,KAAKiI,gCAA6B7f,EAClC4X,KAAKuK,iBAAcniB,EACnB4X,KAAK9S,YAAS9E,EACd4X,KAAKsB,eAAgB,CACzB,EAIAgC,EAAepD,UAAUqE,mBAAqB,WAC1C,IAAIjc,EACAmJ,EAAKuO,KAAKhY,QAASmT,EAAS1J,EAAG0J,OAAQC,EAAW3J,EAAG2J,SAIpD4E,KAAK7E,SAAYA,GAAUC,KAQ3B4E,KAAKuK,aAAgBvK,KAAKyG,iBAE3BzG,KAAKyK,eAAiBzK,KAAK0K,6BACvB1K,KAAKyK,gBAAkBzK,KAAKyK,eAAetP,SAC3C6E,KAAKyG,gBAAiB,UACtBzG,KAAK2K,sBAAuB,WAC5B,QAAqB3K,KAAK2K,qBAAsB3K,KAAK7E,OAAOqO,OAAQxJ,KAAKyK,eAAetP,OAAOqO,QAC/FpK,EAAYY,KAAKyG,eAAgBzG,KAAK2K,yBAOzC3K,KAAKyG,gBAAmBzG,KAAKuK,eAK7BvK,KAAK9S,SACN8S,KAAK9S,QAAS,UACd8S,KAAK4K,sBAAuB,WAK5B5K,KAAKyG,gBACLzG,KAAK2K,uBAC2B,QAA9BriB,EAAK0X,KAAKyK,sBAAmC,IAAPniB,OAAgB,EAASA,EAAG4E,SACpE,QAAgB8S,KAAK9S,OAAQ8S,KAAKyG,eAAgBzG,KAAKyK,eAAevd,QAKjE8S,KAAKuK,aACNM,QAAQ7K,KAAK8B,cAEb9B,KAAK9S,OAAS8S,KAAKkK,eAAelK,KAAK7E,OAAOqO,QAG9CpK,EAAYY,KAAK9S,OAAQ8S,KAAK7E,OAAOqO,SAEzC,QAAcxJ,KAAK9S,OAAQ8S,KAAKuK,cAMhCnL,EAAYY,KAAK9S,OAAQ8S,KAAK7E,OAAOqO,QAKrCxJ,KAAK8K,iCACL9K,KAAK8K,gCAAiC,EACtC9K,KAAKyK,eAAiBzK,KAAK0K,6BACvB1K,KAAKyK,gBACLI,QAAQ7K,KAAKyK,eAAe3I,gBACxB+I,QAAQ7K,KAAK8B,gBAChB9B,KAAKyK,eAAeziB,QAAQyU,cAC7BuD,KAAKyK,eAAevd,SACpB8S,KAAKyG,gBAAiB,UACtBzG,KAAK2K,sBAAuB,WAC5B,QAAqB3K,KAAK2K,qBAAsB3K,KAAK9S,OAAQ8S,KAAKyK,eAAevd,QACjFkS,EAAYY,KAAKyG,eAAgBzG,KAAK2K,yBAGlD,EACArH,EAAepD,UAAUwK,2BAA6B,WAClD,GAAK1K,KAAK/B,UAAU,OAAa+B,KAAK/B,OAAOpB,cAE7C,OAAKmD,KAAK/B,OAAOwI,gBAAkBzG,KAAK/B,OAAOsM,cAC3CvK,KAAK/B,OAAO9C,OACL6E,KAAK/B,OAGL+B,KAAK/B,OAAOyM,4BAE3B,EACApH,EAAepD,UAAUsE,eAAiB,WACtC,IAAIlc,EACAmJ,EAAKuO,KAAKhY,QAASmT,EAAS1J,EAAG0J,OAAQC,EAAW3J,EAAG2J,SAWzD,GANA4E,KAAKyD,gBAAkBoH,SAAgC,QAAtBviB,EAAK0X,KAAK/B,cAA2B,IAAP3V,OAAgB,EAASA,EAAGmb,kBACvFzD,KAAK1G,kBACL0G,KAAK+K,kBACJ/K,KAAKyD,kBACNzD,KAAKuK,YAAcvK,KAAKyG,oBAAiBre,GAExC4X,KAAK7E,SAAYA,GAAUC,GAAhC,CAEA,IAAImF,EAAOP,KAAKgL,UAKhB5L,EAAYY,KAAKyJ,gBAAiBzJ,KAAK7E,OAAOqO,SAK9C,QAAgBxJ,KAAKyJ,gBAAiBzJ,KAAKhE,UAAWgE,KAAK6E,KAAMgG,QAAQ7K,KAAK8B,eAAiB9B,OAASO,GACxG,IAAIrT,EAASqT,EAAKrT,OAClB,GAAKA,EAAL,CAEK8S,KAAK3D,kBACN2D,KAAK3D,iBAAkB,UACvB2D,KAAKiL,8BAA+B,WAExC,IAAIC,EAAiBlL,KAAKhE,UAAUpF,EAChCuU,EAAiBnL,KAAKhE,UAAUnF,EAChCuU,EAA0BpL,KAAKqL,qBAUnC,QAAarL,KAAK3D,gBAAiB2D,KAAKyJ,gBAAiBvc,EAAQ8S,KAAKnD,cACtEmD,KAAKqL,oBAAsBpJ,EAAyBjC,KAAK3D,gBAAiB2D,KAAKhE,WAC3EgE,KAAKqL,sBAAwBD,GAC7BpL,KAAKhE,UAAUpF,IAAMsU,GACrBlL,KAAKhE,UAAUnF,IAAMsU,IACrBnL,KAAKyE,cAAe,EACpBzE,KAAKI,iBACLJ,KAAKkF,gBAAgB,mBAAoBhY,GAxBnC,CAdA,CAwCd,EACAoW,EAAepD,UAAUsB,KAAO,WAC5BxB,KAAK0E,WAAY,CAErB,EACApB,EAAepD,UAAUa,KAAO,WAC5Bf,KAAK0E,WAAY,CAErB,EACApB,EAAepD,UAAUE,eAAiB,SAAUkL,GAChD,IAAIhjB,EAAImJ,EAAIC,OACM,IAAd4Z,IAAwBA,GAAY,GACM,QAA7C7Z,GAAMnJ,EAAK0X,KAAKhY,SAASoY,sBAAmC,IAAP3O,GAAyBA,EAAGyB,KAAK5K,GACvFgjB,IAAyC,QAA1B5Z,EAAKsO,KAAKuH,kBAA+B,IAAP7V,GAAyBA,EAAG0O,kBACzEJ,KAAK8B,eAAiB9B,KAAK8B,aAAaxF,WACxC0D,KAAK8B,kBAAe1Z,EAE5B,EACAkb,EAAepD,UAAU+G,mBAAqB,SAAUzgB,EAAOwgB,GAC3D,IACI1e,EADAkb,EAAQxD,UAEyB,IAAjCgH,IAA2CA,GAA+B,GAC9E,IAAI9F,EAAWlB,KAAKkB,SAChBqK,GAAqC,OAAbrK,QAAkC,IAAbA,OAAsB,EAASA,EAASrE,eAAiB,CAAC,EACvG2O,GAAc,QAAS,CAAC,EAAGxL,KAAKnD,cAChC0N,GAAc,UAClBvK,KAAKyG,eAAiBzG,KAAK2K,0BAAuBviB,EAClD4X,KAAK8K,gCAAkC9D,EACvC,IAAIyE,GAAiB,UACjBC,EAAuC,OAAbxK,QAAkC,IAAbA,OAAsB,EAASA,EAASE,SACvFuK,IAA4C,QAA1BrjB,EAAK0X,KAAKuH,kBAA+B,IAAPjf,OAAgB,EAASA,EAAG2X,QAAQ1S,SAAW,IAAM,EACzGqe,EAAyBf,QAAQa,IAChCC,IAC0B,IAA3B3L,KAAKhY,QAAQuZ,YACZvB,KAAK6E,KAAK3c,KAAK2jB,KACpB7L,KAAK2E,kBAAoB,EACzB3E,KAAK8L,eAAiB,SAAUvZ,GAC5B,IAAIjK,EAgaJ+E,EAAQ9E,EAAMC,EAAIsC,EA/Zd0E,EAAW+C,EAAS,IACxBwZ,GAAaxB,EAAY3T,EAAGpQ,EAAMoQ,EAAGpH,GACrCuc,GAAaxB,EAAY1T,EAAGrQ,EAAMqQ,EAAGrH,GACrCgU,EAAM8G,eAAeC,GACjB/G,EAAMiD,gBACNjD,EAAMmH,sBACNnH,EAAMrI,SAC2B,QAA/B7S,EAAKkb,EAAMiH,sBAAmC,IAAPniB,OAAgB,EAASA,EAAG6S,WACrE,QAAqBsQ,EAAgBjI,EAAMrI,OAAOqO,OAAQhG,EAAMiH,eAAetP,OAAOqO,QAuZ1Fnc,EAtZWmW,EAAMiD,eAsZTle,EAtZyBib,EAAMmH,qBAsZzBniB,EAtZ+CijB,EAsZ3C3gB,EAtZ2D0E,EAuZzFwc,GAAQ3e,EAAOuJ,EAAGrO,EAAKqO,EAAGpO,EAAGoO,EAAG9L,GAChCkhB,GAAQ3e,EAAOwJ,EAAGtO,EAAKsO,EAAGrO,EAAGqO,EAAG/L,IAtZhB4gB,IACAlI,EAAMrC,gBAAkBqK,ERjvB5C,SAAmBte,EAAQ+e,EAAQ1L,EAAM/Q,EAAUoc,EAAwBD,GACvE,IAAIrjB,EAAImJ,EAAIC,EAAIiQ,EACZiK,GACA1e,EAAOoK,SAAU,EAAAxK,EAAA,GAAI,EAGG,QAAvBxE,EAAKiY,EAAKjJ,eAA4B,IAAPhP,EAAgBA,EAAK,EAAGyW,EAAgBvP,IACxEtC,EAAOgf,aAAc,EAAApf,EAAA,GAA8B,QAAzB2E,EAAKwa,EAAO3U,eAA4B,IAAP7F,EAAgBA,EAAK,EAAG,EAAGwN,EAAiBzP,KAElGmc,IACLze,EAAOoK,SAAU,EAAAxK,EAAA,GAA8B,QAAzB4E,EAAKua,EAAO3U,eAA4B,IAAP5F,EAAgBA,EAAK,EAA2B,QAAvBiQ,EAAKpB,EAAKjJ,eAA4B,IAAPqK,EAAgBA,EAAK,EAAGnS,IAK3I,IAAK,IAAIlI,EAAI,EAAGA,EAAIkX,EAAYlX,IAAK,CACjC,IAAI6kB,EAAc,SAAS9c,OAAOkP,EAAQjX,GAAI,UAC1C8kB,EAAexN,EAAUqN,EAAQE,GACjCE,EAAazN,EAAU2B,EAAM4L,QACZ/jB,IAAjBgkB,QAA6ChkB,IAAfikB,IAElCD,IAAiBA,EAAe,GAChCC,IAAeA,EAAa,GACE,IAAjBD,GACM,IAAfC,GACA3N,EAAK0N,KAAkB1N,EAAK2N,IAE5Bnf,EAAOif,GAAetlB,KAAK+E,KAAI,EAAAkB,EAAA,GAAI2R,EAAS2N,GAAe3N,EAAS4N,GAAa7c,GAAW,IACxF,KAAQpD,KAAKigB,IAAe,KAAQjgB,KAAKggB,MACzClf,EAAOif,IAAgB,MAI3Bjf,EAAOif,GAAeE,EAE9B,EAIIJ,EAAOlV,QAAUwJ,EAAKxJ,UACtB7J,EAAO6J,QAAS,EAAAjK,EAAA,GAAImf,EAAOlV,QAAU,EAAGwJ,EAAKxJ,QAAU,EAAGvH,GAElE,CQwsBoB8c,CAAUd,EAAaD,EAAsB/H,EAAM3G,aAAcrN,EAAUoc,EAAwBD,IAEvGnI,EAAM7G,KAAKmM,2BACXtF,EAAMpD,iBACNoD,EAAMmB,kBAAoBnV,CAC9B,EACAwQ,KAAK8L,eAAe,EACxB,EACAxI,EAAepD,UAAUzG,eAAiB,SAAUzR,GAChD,IACIM,EAAImJ,EADJ+R,EAAQxD,KAEqB,QAAhC1X,EAAK0X,KAAK1G,wBAAqC,IAAPhR,GAAyBA,EAAGiJ,OACjEyO,KAAK8B,eACyC,QAA7CrQ,EAAKuO,KAAK8B,aAAaxI,wBAAqC,IAAP7H,GAAyBA,EAAGF,QAElFyO,KAAK+K,mBACL,KAAW1Z,OAAO2O,KAAK+K,kBACvB/K,KAAK+K,sBAAmB3iB,GAO5B4X,KAAK+K,iBAAmB,KAAK1Z,QAAO,WAChCyR,EAAsBC,wBAAyB,EAC/CS,EAAMlK,iBCxvBtB,SAAiB/Q,EAAMC,EAAIuP,QACJ,IAAfA,IAAyBA,EAAa,CAAC,GAC3C,IAAIlP,GAAQ,IAAAvB,GAAciB,GAAQA,GAAO,OAAYA,GAErD,OADA,QAAe,GAAIM,EAAOL,EAAIuP,GACvB,CACHxG,KAAM,WAAc,OAAO1I,EAAM0I,MAAQ,EACzCgb,YAAa,WAAc,OAAO1jB,EAAM0jB,aAAe,EAE/D,CDgvByC/a,CAAQ,EAAGqR,GAAiB,SAAS,QAAS,CAAC,EAAG7a,GAAU,CAAEqK,SAAU,SAAUE,GACnG,IAAIjK,EACJkb,EAAMsI,eAAevZ,GACO,QAA3BjK,EAAKN,EAAQqK,gBAA6B,IAAP/J,GAAyBA,EAAG4K,KAAKlL,EAASuK,EAClF,EAAGJ,WAAY,WACX,IAAI7J,EAC0B,QAA7BA,EAAKN,EAAQmK,kBAA+B,IAAP7J,GAAyBA,EAAG4K,KAAKlL,GACvEwb,EAAMgJ,mBACV,KACAhJ,EAAM1B,eACN0B,EAAM1B,aAAaxI,iBAAmBkK,EAAMlK,kBAEhDkK,EAAMuH,sBAAmB3iB,CAC7B,GACJ,EACAkb,EAAepD,UAAUsM,kBAAoB,WACzC,IAAIlkB,EACA0X,KAAK8B,eACL9B,KAAK8B,aAAaxI,sBAAmBlR,EACrC4X,KAAK8B,aAAab,qBAAkB7Y,GAEb,QAA1BE,EAAK0X,KAAKuH,kBAA+B,IAAPjf,GAAyBA,EAAGmZ,wBAC/DzB,KAAK8B,aACD9B,KAAK1G,iBACD0G,KAAKmB,qBACD/Y,EACZ4X,KAAKkF,gBAAgB,oBACzB,EACA5B,EAAepD,UAAUgG,gBAAkB,WACvC,IAAI5d,EACA0X,KAAK1G,mBAC0B,QAA9BhR,EAAK0X,KAAK8L,sBAAmC,IAAPxjB,GAAyBA,EAAG4K,KAAK8M,KAAM6C,GAC9E7C,KAAK1G,iBAAiB/H,QAE1ByO,KAAKwM,mBACT,EACAlJ,EAAepD,UAAUuM,wBAA0B,WAC/C,IAAInkB,EAAK0X,KAAKgL,UAAWJ,EAAuBtiB,EAAGsiB,qBAAsB1d,EAAS5E,EAAG4E,OAAQiO,EAAS7S,EAAG6S,OAAQ0B,EAAevU,EAAGuU,aAC9H+N,GAAyB1d,GAAWiO,IAEzCiE,EAAYwL,EAAsB1d,IAMlC,QAAa0d,EAAsB/N,IAOnC,QAAamD,KAAKiL,6BAA8BjL,KAAKyJ,gBAAiBmB,EAAsB/N,GAChG,EACAyG,EAAepD,UAAUiG,mBAAqB,SAAU/K,EAAUgB,GAC9D,IAAI9T,EAAImJ,EAAIC,EACPsO,KAAK4E,YAAY5R,IAAIoI,IACtB4E,KAAK4E,YAAYzL,IAAIiC,EAAU,IAAI2E,GAE3BC,KAAK4E,YAAY/L,IAAIuC,GAC3B+E,IAAI/D,GACVA,EAAKoE,QAAQ,CACTzI,WAA2D,QAA9CzP,EAAK8T,EAAKpU,QAAQ0kB,8BAA2C,IAAPpkB,OAAgB,EAASA,EAAGyP,WAC/F+I,sBAAiJ,QAAzHpP,EAAoD,QAA9CD,EAAK2K,EAAKpU,QAAQ0kB,8BAA2C,IAAPjb,OAAgB,EAASA,EAAGkb,mCAAgD,IAAPjb,OAAgB,EAASA,EAAGwB,KAAKzB,EAAI2K,IAEtM,EACAkH,EAAepD,UAAUkH,OAAS,WAC9B,IAAIwF,EAAQ5M,KAAKuH,WACjB,OAAOqF,GAAQA,EAAMrM,OAASP,IAClC,EACAsD,EAAepD,UAAU8K,QAAU,WAC/B,IAAI1iB,EAEJ,OADe0X,KAAKhY,QAAQoT,WACkB,QAA1B9S,EAAK0X,KAAKuH,kBAA+B,IAAPjf,OAAgB,EAASA,EAAGiY,OAAgBP,IACtG,EACAsD,EAAepD,UAAU2M,YAAc,WACnC,IAAIvkB,EAEJ,OADe0X,KAAKhY,QAAQoT,SACiB,QAA1B9S,EAAK0X,KAAKuH,kBAA+B,IAAPjf,OAAgB,EAASA,EAAGgY,cAAWlY,CAChG,EACAkb,EAAepD,UAAUqH,SAAW,WAChC,IAAInM,EAAW4E,KAAKhY,QAAQoT,SAC5B,GAAIA,EACA,OAAO4E,KAAKrD,KAAKiI,YAAY/L,IAAIuC,EACzC,EACAkI,EAAepD,UAAUM,QAAU,SAAUlY,GACzC,IAAImJ,OAAY,IAAPnJ,EAAgB,CAAC,EAAIA,EAAIwb,EAAarS,EAAGqS,WAAY/L,EAAatG,EAAGsG,WAAY+I,EAAwBrP,EAAGqP,sBACjH8L,EAAQ5M,KAAKuH,WACbqF,GACAA,EAAMpM,QAAQR,KAAMc,GACpBgD,IACA9D,KAAK3D,qBAAkBjU,EACvB4X,KAAK8D,YAAa,GAElB/L,GACAiI,KAAKwK,WAAW,CAAEzS,WAAYA,GACtC,EACAuL,EAAepD,UAAUO,SAAW,WAChC,IAAImM,EAAQ5M,KAAKuH,WACjB,QAAIqF,GACOA,EAAMnM,SAAST,KAK9B,EACAsD,EAAepD,UAAU2H,cAAgB,WACrC,IAAIhC,EAAgB7F,KAAKhY,QAAQ6d,cACjC,GAAKA,EAAL,CAOA,IAJA,IAAIiH,GAAY,EAEZC,EAAc,CAAC,EAEVzlB,EAAI,EAAGA,EAAIyF,EAAA,GAAcQ,OAAQjG,IAAK,CAC3C,IACIa,EAAM,SADC4E,EAAA,GAAczF,GAIpBue,EAAcmH,eAAe7kB,KAGlC2kB,GAAY,EAEZC,EAAY5kB,GAAO0d,EAAcmH,eAAe7kB,GAChD0d,EAAcoH,eAAe9kB,EAAK,GACtC,CAEA,GAAK2kB,EAAL,CAMA,IAAK,IAAI3kB,KAFS,OAAlB0d,QAA4C,IAAlBA,GAAoCA,EAAcqH,aAE5DH,EACZlH,EAAcoH,eAAe9kB,EAAK4kB,EAAY5kB,IAIlD0d,EAAczF,gBAVJ,CArBA,CAgCd,EACAkD,EAAepD,UAAUiN,oBAAsB,SAAUC,GACrD,IAAI9kB,EAAImJ,EAAIC,EAAIiQ,EAAIC,EAAIwE,OACN,IAAdgH,IAAwBA,EAAY,CAAC,GAEzC,IAAIC,EAAS,CAAC,EACd,IAAKrN,KAAK1D,UAAY0D,KAAK6D,MACvB,OAAOwJ,EACX,IAAKrN,KAAK0E,UACN,MAAO,CAAE4I,WAAY,UAGrBD,EAAOC,WAAa,GAExB,IAAItF,EAA0D,QAArC1f,EAAK0X,KAAKhY,QAAQ6d,qBAAkC,IAAPvd,OAAgB,EAASA,EAAGue,WAAWmB,kBAC7G,GAAIhI,KAAK8D,WAQL,OAPA9D,KAAK8D,YAAa,EAClBuJ,EAAO/V,QAAU,GACjB+V,EAAOE,eACH,OAAmBH,EAAUG,gBAAkB,GACnDF,EAAOtgB,UAAYib,EACbA,EAAkBhI,KAAKnD,aAAc,IACrC,OACCwQ,EAEX,IAAI9M,EAAOP,KAAKgL,UAChB,IAAKhL,KAAK3D,kBAAoB2D,KAAK7E,SAAWoF,EAAKrT,OAAQ,CACvD,IAAIsgB,EAAc,CAAC,EAYnB,OAXIxN,KAAKhY,QAAQoT,WACboS,EAAYlW,QAA+C,QAApC7F,EAAKuO,KAAKnD,aAAavF,eAA4B,IAAP7F,EAAgBA,EAAK,EACxF+b,EAAYD,eACR,OAAmBH,EAAUG,gBAAkB,IAEnDvN,KAAKyE,gBAAiB,OAAazE,KAAKnD,gBACxC2Q,EAAYzgB,UAAYib,EAClBA,EAAkB,CAAC,EAAG,IACtB,OACNhI,KAAKyE,cAAe,GAEjB+I,CACX,CACA,IAAIC,EAAiBlN,EAAKY,iBAAmBZ,EAAK1D,aAClDmD,KAAKyM,0BACLY,EAAOtgB,UAAYkV,EAAyBjC,KAAKiL,6BAA8BjL,KAAKhE,UAAWyR,GAC3FzF,IACAqF,EAAOtgB,UAAYib,EAAkByF,EAAgBJ,EAAOtgB,YAEhE,IAAI2gB,EAAK1N,KAAK3D,gBAAiBzF,EAAI8W,EAAG9W,EAAGC,EAAI6W,EAAG7W,EA2BhD,IAAK,IAAI1O,KA1BTklB,EAAOM,gBAAkB,GAAGte,OAAkB,IAAXuH,EAAE3J,OAAc,MAAMoC,OAAkB,IAAXwH,EAAE5J,OAAc,OAC5EsT,EAAKY,gBAKLkM,EAAO/V,QACHiJ,IAASP,KACiG,QAAnG2B,EAAuC,QAAjCjQ,EAAK+b,EAAenW,eAA4B,IAAP5F,EAAgBA,EAAKsO,KAAKnD,aAAavF,eAA4B,IAAPqK,EAAgBA,EAAK,EACjI3B,KAAKiB,gBACDjB,KAAKnD,aAAavF,QAClBmW,EAAevB,YAO7BmB,EAAO/V,QACHiJ,IAASP,KAC+B,QAAjC4B,EAAK6L,EAAenW,eAA4B,IAAPsK,EAAgBA,EAAK,GACzB,QAArCwE,EAAKqH,EAAevB,mBAAgC,IAAP9F,EAAgBA,EAAK,EAKjE,IACZ,QAA4Bhe,IAAxBqlB,EAAetlB,GAAnB,CAEA,IAAIylB,EAAK,IAAgBzlB,GAAM0lB,EAAUD,EAAGC,QAASC,EAAUF,EAAGE,QAC9DC,EAAYF,EAAQJ,EAAetlB,GAAMoY,GAC7C,GAAIuN,EAEA,IADA,IAAIE,EAAMF,EAAQvgB,OACTjG,EAAI,EAAGA,EAAI0mB,EAAK1mB,IACrB+lB,EAAOS,EAAQxmB,IAAMymB,OAIzBV,EAAOllB,GAAO4lB,CAVN,CAwBhB,OANI/N,KAAKhY,QAAQoT,WACbiS,EAAOE,cACHhN,IAASP,MACH,OAAmBoN,EAAUG,gBAAkB,GAC/C,QAEPF,CACX,EACA/J,EAAepD,UAAU0I,cAAgB,WACrC5I,KAAKgB,WAAahB,KAAKkB,cAAW9Y,CACtC,EAEAkb,EAAepD,UAAU+N,UAAY,WACjCjO,KAAKrD,KAAK2H,MAAM5C,SAAQ,SAAUtF,GAAQ,IAAI9T,EAAI,OAAwC,QAAhCA,EAAK8T,EAAK9C,wBAAqC,IAAPhR,OAAgB,EAASA,EAAGiJ,MAAQ,IACtIyO,KAAKrD,KAAK2H,MAAM5C,QAAQ0G,GACxBpI,KAAKrD,KAAKiI,YAAY2D,OAC1B,EACOjF,CACX,CAv+BqB,EAw+BzB,CACA,SAASmF,EAAarM,GAClBA,EAAKqM,cACT,CACA,SAASC,EAAmBtM,GACxB,IAAI9T,EAAImJ,EAAIC,EAAIiQ,EACZT,EAA8F,QAAlFzP,EAAgC,QAA1BnJ,EAAK8T,EAAK4E,kBAA+B,IAAP1Y,OAAgB,EAASA,EAAG4Y,gBAA6B,IAAPzP,EAAgBA,EAAK2K,EAAK8E,SACpI,GAAI9E,EAAKgL,UACLhL,EAAKjB,QACL+F,GACA9E,EAAKqJ,aAAa,aAAc,CAChC,IAAI7D,EAAKxF,EAAKjB,OAAQ+S,EAAWtM,EAAG4H,OAAQ2E,EAAiBvM,EAAGqH,SAG7B,SAA/B7M,EAAKpU,QAAQomB,eACb,QAAS,SAAUxS,GACf,IAAIyS,EAAenN,EAASE,SACtBF,EAAS+H,SAASrN,GAClBsF,EAAS/F,OAAOS,GAClBrO,GAAS,QAAW8gB,GACxBA,EAAa1kB,IAAMukB,EAAStS,GAAMjS,IAClC0kB,EAAaziB,IAAMyiB,EAAa1kB,IAAM4D,CAC1C,IAEoC,aAA/B6O,EAAKpU,QAAQomB,gBAClB,QAAS,SAAUxS,GACf,IAAIyS,EAAenN,EAASE,SACtBF,EAAS+H,SAASrN,GAClBsF,EAAS/F,OAAOS,GAClBrO,GAAS,QAAW2gB,EAAStS,IACjCyS,EAAaziB,IAAMyiB,EAAa1kB,IAAM4D,CAC1C,IAEJ,IAAI+gB,GAAc,WAClB,QAAaA,EAAaJ,EAAUhN,EAAS/F,QAC7C,IAAIoT,GAAc,UACdrN,EAASE,UACT,QAAamN,EAAanS,EAAK8N,eAAeiE,GAAgB,GAAOjN,EAAS+H,WAG9E,QAAasF,EAAaL,EAAUhN,EAAS/F,QAEjD,IAAIkL,GAAoBxG,EAAYyO,GAChChI,GAA2B,EAC/B,IAAKlK,EAAK4E,aACN5E,EAAKqO,eAAiBrO,EAAKsO,6BAKvBtO,EAAKqO,iBAAmBrO,EAAKqO,eAAezJ,YAAY,CACxD,IAAIoF,EAAKhK,EAAKqO,eAAgB+D,EAAiBpI,EAAGlF,SAAUuN,EAAerI,EAAGjL,OAC9E,GAAIqT,GAAkBC,EAAc,CAChC,IAAIC,GAAmB,WACvB,QAAqBA,EAAkBxN,EAAS/F,OAAQqT,EAAerT,QACvE,IAAIsQ,GAAiB,WACrB,QAAqBA,EAAgByC,EAAUO,EAAajF,QACvD1J,EAAU4O,EAAkBjD,KAC7BnF,GAA2B,EAEnC,CACJ,CAEJlK,EAAK8I,gBAAgB,YAAa,CAC9B/J,OAAQ+S,EACRhN,SAAUA,EACV1a,MAAO+nB,EACPD,YAAaA,EACbjI,iBAAkBA,EAClBC,yBAA0BA,GAElC,MACSlK,EAAKgL,WACoC,QAA7CzF,GAAMjQ,EAAK0K,EAAKpU,SAAS6Z,sBAAmC,IAAPF,GAAyBA,EAAGzO,KAAKxB,IAO3F0K,EAAKpU,QAAQ+P,gBAAa3P,CAC9B,CACA,SAASwgB,EAAcxM,GACnBA,EAAKwM,eACT,CACA,SAASR,EAAkBhM,GACvBA,EAAKgM,mBACT,CACA,SAASI,EAAoBpM,GACzB,IAAIyJ,EAAgBzJ,EAAKpU,QAAQ6d,eACX,OAAlBA,QAA4C,IAAlBA,OAA2B,EAASA,EAAcgB,WAAW8H,wBACvF9I,EAAc+I,4BAElBxS,EAAKiH,gBACT,CACA,SAAS6C,EAAgB9J,GACrBA,EAAK8J,kBACL9J,EAAKmO,YAAcnO,EAAKqK,eAAiBrK,EAAKlP,YAAS9E,CAC3D,CACA,SAASmc,GAAmBnI,GACxBA,EAAKmI,oBACT,CACA,SAASC,GAAepI,GACpBA,EAAKoI,gBACT,CACA,SAASqD,GAAczL,GACnBA,EAAKyL,eACT,CACA,SAASgB,GAAoB+D,GACzBA,EAAM7K,oBACV,CACA,SAASgK,GAAa1e,EAAQ7G,EAAOsE,GACjCuC,EAAOoO,WAAY,EAAA3O,EAAA,GAAItG,EAAMiV,UAAW,EAAG3Q,GAC3CuC,EAAOgK,OAAQ,EAAAvK,EAAA,GAAItG,EAAM6Q,MAAO,EAAGvM,GACnCuC,EAAOJ,OAASzG,EAAMyG,OACtBI,EAAOkO,YAAc/U,EAAM+U,WAC/B,CACA,SAASyQ,GAAQ3e,EAAQ9E,EAAMC,EAAIsC,GAC/BuC,EAAO1D,KAAM,EAAAmD,EAAA,GAAIvE,EAAKoB,IAAKnB,EAAGmB,IAAKmB,GACnCuC,EAAOzB,KAAM,EAAAkB,EAAA,GAAIvE,EAAKqD,IAAKpD,EAAGoD,IAAKd,EACvC,CAKA,SAAS+gB,GAAoBzP,GACzB,OAAQA,EAAK+E,sBAAwD/Y,IAArCgU,EAAK+E,gBAAgB+K,WACzD,CACA,IAAIvF,GAA0B,CAC1B7gB,SAAU,IACV2I,KAAM,CAAC,GAAK,EAAG,GAAK,IAExB,SAAS6Z,GAAelM,EAAMmH,GAM1B,IADA,IAAIsL,EAAazS,EAAKO,KACbrV,EAAI8U,EAAKyI,KAAKtX,OAAS,EAAGjG,GAAK,EAAGA,IACvC,GAAIujB,QAAQzO,EAAKyI,KAAKvd,GAAGgV,UAAW,CAChCuS,EAAazS,EAAKyI,KAAKvd,GACvB,KACJ,CAEJ,IACIwnB,GADgBD,GAAcA,IAAezS,EAAKO,KAAOkS,EAAWvS,SAAWyS,UACvDC,cAAc,wBAAyB3f,OAAOkU,EAAI,OAC1EuL,GACA1S,EAAKsJ,MAAMoJ,GAAS,EAC5B,CACA,SAASG,GAAUrT,GACfA,EAAKjS,IAAM9C,KAAK2E,MAAMoQ,EAAKjS,KAC3BiS,EAAKhQ,IAAM/E,KAAK2E,MAAMoQ,EAAKhQ,IAC/B,CACA,SAASyd,GAASvN,GACdmT,GAAUnT,EAAIlF,GACdqY,GAAUnT,EAAIjF,EAClB,C,+EElrCA,IAAIqY,EAAkB,CAAC,EACvB,SAASC,EAAkBC,GACvBpmB,OAAOC,OAAOimB,EAAiBE,EACnC,C,wBCHA,SAASC,EAAS1M,GACd,MAAO,CAACA,EAAS,KAAMA,EAAS,KACpC,C,uDCFA,SAAS2M,EAAgBjY,GACrB,YAAiBjP,IAAViP,GAAiC,IAAVA,CAClC,CACA,SAASkY,EAASjnB,GACd,IAAI+O,EAAQ/O,EAAG+O,MAAOF,EAAS7O,EAAG6O,OAAQC,EAAS9O,EAAG8O,OACtD,OAASkY,EAAgBjY,KACpBiY,EAAgBnY,KAChBmY,EAAgBlY,EACzB,CACA,SAASoY,EAAaxf,GAClB,OAAQuf,EAASvf,IACbyf,EAAazf,EAAO4G,IACpB6Y,EAAazf,EAAO6G,IACpB7G,EAAO8G,GACP9G,EAAO+G,QACP/G,EAAOgH,SACPhH,EAAOiH,OACf,CACA,SAASwY,EAAa5mB,GAClB,OAAOA,GAAmB,OAAVA,CACpB,C,8GCpBA,IAAI6mB,EAAqB,kBAKrBC,EAAc,SAAUC,GACxB,OAAOA,EAAIC,QAAQH,EALA,SAKsCI,aAC7D,C,wBCJA,SAASC,EAAc5nB,GACnB,OAAOA,EAAIoO,WAAW,KAC1B,C,uFCDA,IAAIyZ,EAAuB,CACvB,UACA,SACA,OACA,OACA,UACA,IACA,QACA,OACA,SACA,SACA,OACA,WACA,OACA,UACA,UACA,WACA,OACA,OACA,MACA,SACA,SACA,OACA,QACA,MACA,QC3BJ,SAASC,EAAeC,GACpB,MAKqB,kBAAdA,IAIHA,EAAUC,SAAS,SAOvBH,EAAqB9V,QAAQgW,IAAc,GAIvC,QAAQ9jB,KAAK8jB,GAIrB,C,6FCxBA,SAASE,EAAkBjoB,EAAKU,GAC5B,IAAIP,EACA+nB,GAAmB,OAAoBloB,GAI3C,OAHIkoB,IAAqB,MACrBA,EAAmB,KAE8B,QAA7C/nB,EAAK+nB,EAAiBD,yBAAsC,IAAP9nB,OAAgB,EAASA,EAAG4K,KAAKmd,EAAkBxnB,EACpH,C,wGCHIynB,GAAoB,SAAS,QAAS,CAAC,EAAG,KAAmB,CAE7DhkB,MAAO,IAAOiL,gBAAiB,IAAOgZ,aAAc,IAAOC,KAAM,IAAOC,OAAQ,IAEhFC,YAAa,IAAOC,eAAgB,IAAOC,iBAAkB,IAAOC,kBAAmB,IAAOC,gBAAiB,IAAOC,OAAQ,IAAQC,aAAc,MAIpJC,EAAsB,SAAU9oB,GAAO,OAAOmoB,EAAkBnoB,EAAM,C,6FCZtE,GAAM,SAAS,QAAS,CAAC,EAAG,MAAS,CAAE4E,UAAWlG,KAAK2E,QCAvD0lB,EAAmB,CAEnBC,YAAa,EAAAxS,GACbyS,eAAgB,EAAAzS,GAChB0S,iBAAkB,EAAA1S,GAClB2S,kBAAmB,EAAA3S,GACnB4S,gBAAiB,EAAA5S,GACjBG,aAAc,EAAAH,GACd6S,OAAQ,EAAA7S,GACR8S,oBAAqB,EAAA9S,GACrB+S,qBAAsB,EAAA/S,GACtBgT,wBAAyB,EAAAhT,GACzBiT,uBAAwB,EAAAjT,GAExBkT,MAAO,EAAAlT,GACPmT,SAAU,EAAAnT,GACVoT,OAAQ,EAAApT,GACRqT,UAAW,EAAArT,GACX0J,KAAM,EAAA1J,GACNsT,IAAK,EAAAtT,GACLuT,MAAO,EAAAvT,GACPwT,OAAQ,EAAAxT,GACRyT,KAAM,EAAAzT,GAEN0T,QAAS,EAAA1T,GACT2T,WAAY,EAAA3T,GACZ4T,aAAc,EAAA5T,GACd6T,cAAe,EAAA7T,GACf8T,YAAa,EAAA9T,GACb+T,OAAQ,EAAA/T,GACRgU,UAAW,EAAAhU,GACXiU,YAAa,EAAAjU,GACbkU,aAAc,EAAAlU,GACdmU,WAAY,EAAAnU,GAEZ5H,OAAQ,KACRC,QAAS,KACTC,QAAS,KACTC,QAAS,KACTG,MAAO,KACPF,OAAQ,KACRC,OAAQ,KACR2b,OAAQ,KACRC,KAAM,KACNC,MAAO,KACPC,MAAO,KACPnW,SAAU,EAAA4B,GACVwU,WAAY,EAAAxU,GACZyU,WAAY,EAAAzU,GACZ0U,WAAY,EAAA1U,GACZ/H,EAAG,EAAA+H,GACH9H,EAAG,EAAA8H,GACH7H,EAAG,EAAA6H,GACH2U,YAAa,EAAA3U,GACb4U,qBAAsB,EAAA5U,GACtBrH,QAAS,KACTuG,QAAS,KACTC,QAAS,KACT0V,QAAS,EAAA7U,GAET8U,OAAQ,EAERC,YAAa,KACbC,cAAe,KACfC,WAAY,E,uECjEZC,EAAiB,CACjBjd,EAAG,aACHC,EAAG,aACHC,EAAG,aACHyc,qBAAsB,e,eCHtBO,EAAiB,SAAUjrB,EAAOsD,GAClC,OAAOA,GAAyB,kBAAVtD,EAChBsD,EAAKY,UAAUlE,GACfA,CACV,E,WCDA,SAASkrB,EAAgBprB,EAAOkU,EAAc7U,EAASggB,GACnD,IAAI1f,EACAiU,EAAQ5T,EAAM4T,MAAOyX,EAAOrrB,EAAMqrB,KAAMjnB,EAAYpE,EAAMoE,UAAWknB,EAAgBtrB,EAAMsrB,cAAetG,EAAkBhlB,EAAMglB,gBAItIsG,EAAc1mB,OAAS,EAEvB,IAAIiiB,GAAe,EACf0E,GAAqB,EAErBC,GAAkB,EAOtB,IAAK,IAAIhsB,KAAO0U,EAAc,CAC1B,IAAIhU,EAAQgU,EAAa1U,GAIzB,IAAI,OAAcA,GACd6rB,EAAK7rB,GAAOU,MADhB,CAKA,IAAIurB,EAAYC,EAAA,EAAiBlsB,GAC7BmsB,EAAcR,EAAejrB,EAAOurB,GACxC,IAAI,QAAgBjsB,GAAM,CAMtB,GAJAqnB,GAAe,EACfziB,EAAU5E,GAAOmsB,EACjBL,EAAcjlB,KAAK7G,IAEdgsB,EACD,SAEAtrB,KAAwC,QAA5BP,EAAK8rB,EAAU5c,eAA4B,IAAPlP,EAAgBA,EAAK,KACrE6rB,GAAkB,EAC1B,MACS,QAAsBhsB,IAC3BwlB,EAAgBxlB,GAAOmsB,EAEvBJ,GAAqB,GAGrB3X,EAAMpU,GAAOmsB,CAtBjB,CAwBJ,CACI9E,EACAjT,EAAMxP,UF5Cd,SAAwBzE,EAAImJ,EAAI8iB,EAAoBvM,GAChD,IAAIjb,EAAYzE,EAAGyE,UAAWknB,EAAgB3rB,EAAG2rB,cAC7CviB,EAAKD,EAAG+iB,2BAA4BA,OAAoC,IAAP9iB,GAAuBA,EAAIiQ,EAAKlQ,EAAGgjB,mBAAoBA,OAA4B,IAAP9S,GAAuBA,EAEpK+S,EAAkB,GAEtBT,EAAcrR,KAAK,MAMnB,IAHA,IAAI+R,GAAgB,EAEhBC,EAAmBX,EAAc1mB,OAC5BjG,EAAI,EAAGA,EAAIstB,EAAkBttB,IAAK,CACvC,IAAIa,EAAM8rB,EAAc3sB,GACxBotB,GAAmB,GAAGrlB,OAAOwkB,EAAe1rB,IAAQA,EAAK,KAAKkH,OAAOtC,EAAU5E,GAAM,MACzE,MAARA,IACAwsB,GAAgB,EACxB,CAeA,OAdKA,GAAiBH,EAClBE,GAAmB,gBAGnBA,EAAkBA,EAAgBG,OAIlC7M,EACA0M,EAAkB1M,EAAkBjb,EAAWwnB,EAAqB,GAAKG,GAEpED,GAAsBF,IAC3BG,EAAkB,QAEfA,CACX,CEW0BI,CAAensB,EAAOX,EAASmsB,EAAiBnM,GAE7DA,EACLzL,EAAMxP,UAAYib,EAAkB,CAAC,EAAG,KAElCnL,EAAa9P,WAAawP,EAAMxP,YACtCwP,EAAMxP,UAAY,QAElBmnB,IACA3X,EAAMoR,gBFfd,SAA8BrlB,GAC1B,IAAImJ,EAAKnJ,EAAGuV,QAASA,OAAiB,IAAPpM,EAAgB,MAAQA,EAAIC,EAAKpJ,EAAGwV,QAASA,OAAiB,IAAPpM,EAAgB,MAAQA,EAAIiQ,EAAKrZ,EAAGkrB,QAASA,OAAiB,IAAP7R,EAAgB,EAAIA,EACjK,MAAO,GAAGtS,OAAOwO,EAAS,KAAKxO,OAAOyO,EAAS,KAAKzO,OAAOmkB,EAC/D,CEYgCuB,CAAqBpH,GAErD,C,wBCrEA,SAASqH,EAAWlG,EAASxmB,EAAI8kB,EAAW6H,GACxC,IAAI1Y,EAAQjU,EAAGiU,MAAOyX,EAAO1rB,EAAG0rB,KAGhC,IAAK,IAAI7rB,KAFTa,OAAOC,OAAO6lB,EAAQvS,MAAOA,EAAO0Y,GAAcA,EAAW9H,oBAAoBC,IAEjE4G,EACZlF,EAAQvS,MAAM2Y,YAAY/sB,EAAK6rB,EAAK7rB,GAE5C,C,gHCJA,SAASgtB,EAA4BC,GACjC,IAAI7Y,EAAQ6Y,EAAM7Y,MACd8Y,EAAY,CAAC,EACjB,IAAK,IAAIltB,KAAOoU,IACR,IAAAjV,GAAciV,EAAMpU,MAAS,OAAoBA,EAAKitB,MACtDC,EAAUltB,GAAOoU,EAAMpU,IAG/B,OAAOktB,CACX,C,yJCRA,IAAIC,EAAgB,CAAC,GAAI,IAAK,IAAK,KAS/BC,EAAiB,CAAC,uBAAwB,IAAK,IAAK,KASxD,SAASC,EAAmB/uB,EAAGC,GAC3B,OAAO6uB,EAAerb,QAAQzT,GAAK8uB,EAAerb,QAAQxT,EAC9D,CAfY,CAAC,YAAa,QAAS,SAAU,QAKvCgb,SAAQ,SAAU+T,GACpB,OAAOH,EAAc5T,SAAQ,SAAUgU,GACnC,OAAOH,EAAevmB,KAAKymB,EAAeC,EAC9C,GACJ,IAUA,IAAIC,EAAmB,IAAI5iB,IAAIwiB,GAC/B,SAASK,EAAgBztB,GACrB,OAAOwtB,EAAiB3iB,IAAI7K,EAChC,CAIA,IAAI0tB,EAAuB,IAAI9iB,IAAI,CAAC,UAAW,UAAW,YAC1D,SAAS+iB,EAAsB3tB,GAC3B,OAAO0tB,EAAqB7iB,IAAI7K,EACpC,C,6FCpCA,SAAS4tB,EAAW9oB,EAAQmD,EAAQiY,GAChC,MAAyB,kBAAXpb,EACRA,EACA,EAAA0R,GAAG5R,UAAUqD,EAASiY,EAAOpb,EACvC,CCJA,IAAI+oB,EAAW,CACX5lB,OAAQ,oBACR6lB,MAAO,oBAEPC,EAAY,CACZ9lB,OAAQ,mBACR6lB,MAAO,mBCAX,SAASE,EAAcxtB,EAAOL,EAAIN,EAASggB,GACvC,IAAIoO,EAAQ9tB,EAAG8tB,MAAOC,EAAQ/tB,EAAG+tB,MAAOxY,EAAUvV,EAAGuV,QAASC,EAAUxV,EAAGwV,QAASwY,EAAahuB,EAAGguB,WAAY7kB,EAAKnJ,EAAGiuB,YAAaA,OAAqB,IAAP9kB,EAAgB,EAAIA,EAAIC,EAAKpJ,EAAGkuB,WAAYA,OAAoB,IAAP9kB,EAAgB,EAAIA,EAEhOa,GAAS,QAAOjK,EAAI,CAAC,QAAS,QAAS,UAAW,UAAW,aAAc,cAAe,gBAC1F,OAAgBK,EAAO4J,EAAQvK,EAASggB,GACxCrf,EAAM8tB,MAAQ9tB,EAAM4T,MACpB5T,EAAM4T,MAAQ,CAAC,EACf,IAAIka,EAAQ9tB,EAAM8tB,MAAOla,EAAQ5T,EAAM4T,MAAOma,EAAa/tB,EAAM+tB,WAK7DD,EAAM1pB,YACF2pB,IACAna,EAAMxP,UAAY0pB,EAAM1pB,kBACrB0pB,EAAM1pB,WAGb2pB,SACatuB,IAAZyV,QAAqCzV,IAAZ0V,GAAyBvB,EAAMxP,aACzDwP,EAAMoR,gBFjBd,SAAgC+I,EAAY7Y,EAASC,GACjD,IAAI6Y,EAAYZ,EAAWlY,EAAS6Y,EAAW9f,EAAG8f,EAAW7E,OACzD+E,EAAYb,EAAWjY,EAAS4Y,EAAW7f,EAAG6f,EAAW3E,QAC7D,MAAO,GAAG1iB,OAAOsnB,EAAW,KAAKtnB,OAAOunB,EAC5C,CEagCC,CAAuBH,OAAwBtuB,IAAZyV,EAAwBA,EAAU,QAAiBzV,IAAZ0V,EAAwBA,EAAU,UAG1H1V,IAAVguB,IACAK,EAAM7f,EAAIwf,QACAhuB,IAAViuB,IACAI,EAAM5f,EAAIwf,QAEKjuB,IAAfkuB,GDnBR,SAAsBG,EAAOlpB,EAAQupB,EAAS1mB,EAAQ2mB,QAClC,IAAZD,IAAsBA,EAAU,QACrB,IAAX1mB,IAAqBA,EAAS,QACd,IAAhB2mB,IAA0BA,GAAc,GAE5CN,EAAMH,WAAa,EAGnB,IAAIruB,EAAO8uB,EAAcf,EAAWE,EAEpCO,EAAMxuB,EAAKmI,QAAU,EAAAuO,GAAG5R,WAAWqD,GAEnC,IAAIkmB,EAAa,EAAA3X,GAAG5R,UAAUQ,GAC1BgpB,EAAc,EAAA5X,GAAG5R,UAAU+pB,GAC/BL,EAAMxuB,EAAKguB,OAAS,GAAG5mB,OAAOinB,EAAY,KAAKjnB,OAAOknB,EAC1D,CCKQS,CAAaP,EAAOH,EAAYC,EAAaC,GAAY,EAEjE,C,wDCpCA,IAAIS,EAAsB,IAAIlkB,IAAI,CAC9B,gBACA,kBACA,eACA,mBACA,aACA,WACA,oBACA,eACA,cACA,aACA,UACA,UACA,eACA,mBACA,mBACA,eACA,cACA,UACA,oBACA,c,6FCnBJ,SAASmkB,EAAUpI,EAASqI,GAExB,IAAK,IAAIhvB,KADT,OAAW2mB,EAASqI,GACJA,EAAYV,MACxB3H,EAAQsI,aAAc,IAAoBpkB,IAAI7K,GAA0BA,GAAnB,OAAYA,GAAYgvB,EAAYV,MAAMtuB,GAEvG,C,iFCNA,SAASgtB,EAA4BC,GACjC,IAAIC,GAAY,OAA8BD,GAC9C,IAAK,IAAIjtB,KAAOitB,EAAO,CACnB,IAAI,IAAA9tB,GAAc8tB,EAAMjtB,IAEpBktB,EADwB,MAARltB,GAAuB,MAARA,EAAc,OAASA,EAAIkvB,cAAgBlvB,GACnDitB,EAAMjtB,EAErC,CACA,OAAOktB,CACX,C,wBCTA,SAASiC,EAAgBnyB,GACrB,OAAOG,MAAMC,QAAQJ,EACzB,CAIA,SAASoyB,EAAepyB,GACpB,MAAoB,kBAANA,GAAkBmyB,EAAgBnyB,EACpD,CAiBA,SAASqyB,EAAwBpC,EAAOhf,EAAYqhB,EAAQC,EAAentB,GACvE,IAAIjC,EAwBJ,YAvBsB,IAAlBovB,IAA4BA,EAAgB,CAAC,QACzB,IAApBntB,IAA8BA,EAAkB,CAAC,GAI3B,oBAAf6L,IACPA,EAAaA,EAAsB,OAAXqhB,QAA8B,IAAXA,EAAoBA,EAASrC,EAAMqC,OAAQC,EAAentB,IAM/E,kBAAf6L,IACPA,EAAuC,QAAzB9N,EAAK8sB,EAAMuC,gBAA6B,IAAPrvB,OAAgB,EAASA,EAAG8N,IAOrD,oBAAfA,IACPA,EAAaA,EAAsB,OAAXqhB,QAA8B,IAAXA,EAAoBA,EAASrC,EAAMqC,OAAQC,EAAentB,IAElG6L,CACX,CACA,SAASwhB,EAAe/R,EAAezP,EAAYqhB,GAC/C,IAAIrC,EAAQvP,EAAcgB,WAC1B,OAAO2Q,EAAwBpC,EAAOhf,EAAuB,OAAXqhB,QAA8B,IAAXA,EAAoBA,EAASrC,EAAMqC,OA1C5G,SAAoB5R,GAChB,IAAIvb,EAAU,CAAC,EAEf,OADAub,EAAcgS,cAAa,SAAUhvB,EAAOV,GAAO,OAAQmC,EAAQnC,GAAOU,EAAMgQ,KAAQ,IACjFvO,CACX,CAsCoHwtB,CAAWjS,GAlC/H,SAAqBA,GACjB,IAAI7f,EAAW,CAAC,EAEhB,OADA6f,EAAcgS,cAAa,SAAUhvB,EAAOV,GAAO,OAAQnC,EAASmC,GAAOU,EAAMqQ,aAAgB,IAC1FlT,CACX,CA8B+IkT,CAAY2M,GAC3J,CACA,SAASkS,EAA2B3C,GAChC,IAAI9sB,EACJ,MAAwF,oBAA/C,QAAxBA,EAAK8sB,EAAM5jB,eAA4B,IAAPlJ,OAAgB,EAASA,EAAGlD,QACzEmyB,EAAenC,EAAM4C,UACrBT,EAAenC,EAAM5jB,UACrB+lB,EAAenC,EAAM6C,aACrBV,EAAenC,EAAM8C,YACrBX,EAAenC,EAAM+C,WACrBZ,EAAenC,EAAMgD,aACrBb,EAAenC,EAAMiD,KAC7B,CACA,SAASC,EAAmBlD,GACxB,OAAOvK,QAAQkN,EAA2B3C,IAAUA,EAAMuC,SAC9D,C,gLCtEA,SAASY,EAAcC,EAAKC,IACD,IAAvBD,EAAIte,QAAQue,IAAgBD,EAAIxpB,KAAKypB,EACzC,CACA,SAASC,EAAWF,EAAKC,GACrB,IAAIE,EAAQH,EAAIte,QAAQue,GACxBE,GAAS,GAAKH,EAAItoB,OAAOyoB,EAAO,EACpC,C,gHCRA,IAAIC,EAA8B,qBAAXre,M,uBCAvB,SAASse,EAAYC,GACjB,MAAuB,kBAARA,GACX9vB,OAAOkX,UAAU6Y,eAAe7lB,KAAK4lB,EAAK,UAClD,C,6HCDIE,EAAgB,SAAU7zB,GAC1B,OAAO0lB,QAAQ1lB,GAAkB,kBAANA,GAAkBA,EAAE2H,KAAO3H,EAAE8zB,QAC5D,EACIC,EAA+B,SAAU/zB,GAEzC,OAAO,OAAkBA,GAAKA,EAAEA,EAAEoI,OAAS,IAAM,EAAIpI,CACzD,C,uECNIg0B,EAAqC,WACrC,SAASA,IACLnZ,KAAKoZ,cAAgB,EACzB,CAiCA,OAhCAD,EAAoBjZ,UAAUC,IAAM,SAAU8E,GAC1C,IAAIzB,EAAQxD,KAEZ,OADA,QAAcA,KAAKoZ,cAAenU,GAC3B,WAAc,OAAO,QAAWzB,EAAM4V,cAAenU,EAAU,CAC1E,EACAkU,EAAoBjZ,UAAUqF,OAAS,SAAU9e,EAAGC,EAAGE,GACnD,IAAIyyB,EAAmBrZ,KAAKoZ,cAAc7rB,OAC1C,GAAK8rB,EAEL,GAAyB,IAArBA,EAIArZ,KAAKoZ,cAAc,GAAG3yB,EAAGC,EAAGE,QAG5B,IAAK,IAAIU,EAAI,EAAGA,EAAI+xB,EAAkB/xB,IAAK,CAKvC,IAAI2d,EAAUjF,KAAKoZ,cAAc9xB,GACjC2d,GAAWA,EAAQxe,EAAGC,EAAGE,EAC7B,CAER,EACAuyB,EAAoBjZ,UAAUoZ,QAAU,WACpC,OAAOtZ,KAAKoZ,cAAc7rB,MAC9B,EACA4rB,EAAoBjZ,UAAUqI,MAAQ,WAClCvI,KAAKoZ,cAAc7rB,OAAS,CAChC,EACO4rB,CACX,CArCwC,E,wDCIxC,IAAII,EAAwB,SAAUC,GAAW,OAAiB,IAAVA,CAAgB,C,uECGxE,SAASC,EAAYC,GACjB,IAAIZ,GAAM,IAAAa,QAAO,MAIjB,OAHoB,OAAhBb,EAAIxuB,UACJwuB,EAAIxuB,QAAUovB,KAEXZ,EAAIxuB,OACf,C,6FCHIsvB,EAA6B,WAS7B,SAASA,EAAYF,GACjB,IAlBgB7wB,EAkBZ2a,EAAQxD,KAMZA,KAAK6Z,UAAY,EAMjB7Z,KAAK8Z,YAAc,EAMnB9Z,KAAK+Z,kBAAoB,IAAI,IAM7B/Z,KAAKga,0BAA4B,IAAI,IAMrCha,KAAKia,kBAAoB,IAAI,IAQ7Bja,KAAKka,kBAAmB,EACxBla,KAAKma,gBAAkB,SAAUh1B,EAAGwjB,QACjB,IAAXA,IAAqBA,GAAS,GAClCnF,EAAM3J,KAAO2J,EAAMlZ,QACnBkZ,EAAMlZ,QAAUnF,EAEhB,IAAImD,GAAK,UAAgB9B,EAAQ8B,EAAG9B,MAAO4zB,EAAY9xB,EAAG8xB,UACtD5W,EAAMsW,cAAgBM,IACtB5W,EAAMqW,UAAYrzB,EAClBgd,EAAMsW,YAAcM,EACpB,KAAKpR,WAAWxF,EAAM6W,wBAGtB7W,EAAM3J,OAAS2J,EAAMlZ,SACrBkZ,EAAMuW,kBAAkBxU,OAAO/B,EAAMlZ,SAGrCkZ,EAAMwW,0BAA0BV,WAChC9V,EAAMwW,0BAA0BzU,OAAO/B,EAAMtK,eAG7CyP,GACAnF,EAAMyW,kBAAkB1U,OAAO/B,EAAMlZ,QAE7C,EASA0V,KAAKqa,sBAAwB,WAAc,OAAO,KAAKrR,WAAWxF,EAAM8W,cAAgB,EAUxFta,KAAKsa,cAAgB,SAAUhyB,GACXA,EAAG8xB,YACD5W,EAAMsW,cACpBtW,EAAM3J,KAAO2J,EAAMlZ,QACnBkZ,EAAMwW,0BAA0BzU,OAAO/B,EAAMtK,eAErD,EACA8G,KAAKua,aAAc,EACnBva,KAAKnG,KAAOmG,KAAK1V,QAAUovB,EAC3B1Z,KAAKka,kBA5GWrxB,EA4GgBmX,KAAK1V,SA3GjC7C,MAAMwS,WAAWpR,IA4GzB,CA0LA,OAzIA+wB,EAAY1Z,UAAUsa,SAAW,SAAUC,GACvC,OAAOza,KAAK+Z,kBAAkB5Z,IAAIsa,EACtC,EACAb,EAAY1Z,UAAUwa,eAAiB,WACnC1a,KAAK+Z,kBAAkBxR,OAC3B,EASAqR,EAAY1Z,UAAUya,gBAAkB,SAAUF,GAG9C,OADAA,EAAaza,KAAKnH,OACXmH,KAAKia,kBAAkB9Z,IAAIsa,EACtC,EAMAb,EAAY1Z,UAAU0a,OAAS,SAAUC,GACrC7a,KAAK6a,cAAgBA,CACzB,EAgBAjB,EAAY1Z,UAAU/G,IAAM,SAAUhU,EAAGwjB,QACtB,IAAXA,IAAqBA,GAAS,GAC7BA,GAAW3I,KAAK6a,cAIjB7a,KAAK6a,cAAc11B,EAAG6a,KAAKma,iBAH3Bna,KAAKma,gBAAgBh1B,EAAGwjB,EAKhC,EAQAiR,EAAY1Z,UAAUrH,IAAM,WACxB,OAAOmH,KAAK1V,OAChB,EAIAsvB,EAAY1Z,UAAU4a,YAAc,WAChC,OAAO9a,KAAKnG,IAChB,EAQA+f,EAAY1Z,UAAUhH,YAAc,WAEhC,OAAO8G,KAAKka,kBAEJ,OAAkBjgB,WAAW+F,KAAK1V,SAC9B2P,WAAW+F,KAAKnG,MAAOmG,KAAK6Z,WAClC,CACV,EAaAD,EAAY1Z,UAAU9a,MAAQ,SAAU+N,GACpC,IAAIqQ,EAAQxD,KAEZ,OADAA,KAAKzO,OACE,IAAIwpB,SAAQ,SAAUC,GACzBxX,EAAM+W,aAAc,EACpB/W,EAAMyX,cAAgB9nB,EAAU6nB,EACpC,IAAGE,MAAK,WAAc,OAAO1X,EAAM2X,gBAAkB,GACzD,EAMAvB,EAAY1Z,UAAU3O,KAAO,WACrByO,KAAKib,eACLjb,KAAKib,gBACTjb,KAAKmb,gBACT,EAMAvB,EAAY1Z,UAAUqM,YAAc,WAChC,QAASvM,KAAKib,aAClB,EACArB,EAAY1Z,UAAUib,eAAiB,WACnCnb,KAAKib,cAAgB,IACzB,EAUArB,EAAY1Z,UAAUkb,QAAU,WAC5Bpb,KAAK+Z,kBAAkBxR,QACvBvI,KAAKia,kBAAkB1R,QACvBvI,KAAKzO,MACT,EACOqoB,CACX,CAhSgC,GAoShC,SAASyB,EAAY3B,GACjB,OAAO,IAAIE,EAAYF,EAC3B,C,uDClTA,IAAI4B,EAAgB,SAAUzyB,GAC1B,OAAOgiB,QAAkB,OAAVhiB,GAAmC,kBAAVA,GAAsBA,EAAMqQ,YACxE,C,iFCQA,SAASqiB,EAAmB1yB,GACxB,IAAI2yB,GAAiB,IAAAl0B,GAAcuB,GAASA,EAAMgQ,MAAQhQ,EAC1D,OAAO,OAAc2yB,GACfA,EAAevC,UACfuC,CACV,C,iICfA,MAAMC,EAAmB,EAAI,GAAM,IAC7BC,EAAwC,qBAAhBC,YACxB,IAAMA,YAAYC,MAClB,IAAMC,KAAKD,MACXE,EAAgC,qBAAXvhB,OACpBoI,GAAapI,OAAOwhB,sBAAsBpZ,GAC1CA,GAAanI,YAAW,IAAMmI,EAAS+Y,MAAmBD,GCFjE,IAAIO,GAAoB,EACpBC,GAAe,EACfC,GAAe,EACnB,MAAM,EAAQ,CACV11B,MAAO,EACP4zB,UAAW,GAET+B,EAAa,CACf,OACA,SACA,YACA,SACA,cAEEC,EAAQD,EAAWE,QAAO,CAACC,EAAKn0B,KAClCm0B,EAAIn0B,GCnBR,SAA0B8zB,GACtB,IAAIM,EAAQ,GACRC,EAAiB,GACjBC,EAAW,EACXP,GAAe,EACfQ,GAAiB,EACrB,MAAMC,EAAc,IAAIC,QAClBC,EAAO,CACTC,SAAU,CAACna,EAAUoa,GAAY,EAAOC,GAAY,KAChD,MAAMC,EAAoBD,GAAad,EACjCgB,EAASD,EAAoBV,EAAQC,EAQ3C,OAPIO,GACAJ,EAAYxc,IAAIwC,IACc,IAA9Bua,EAAOhjB,QAAQyI,KACfua,EAAOluB,KAAK2T,GACRsa,GAAqBf,IACrBO,EAAWF,EAAMhvB,SAElBoV,CAAQ,EAEnBwa,OAASxa,IACL,MAAMgW,EAAQ6D,EAAetiB,QAAQyI,IACtB,IAAXgW,GACA6D,EAAetsB,OAAOyoB,EAAO,GACjCgE,EAAY5W,OAAOpD,EAAS,EAEhCya,QAAUC,IACN,GAAInB,EACAQ,GAAiB,MADrB,CAQA,GAJAR,GAAe,GACdK,EAAOC,GAAkB,CAACA,EAAgBD,GAC3CC,EAAejvB,OAAS,EACxBkvB,EAAWF,EAAMhvB,OACbkvB,EACA,IAAK,IAAIn1B,EAAI,EAAGA,EAAIm1B,EAAUn1B,IAAK,CAC/B,MAAMqb,EAAW4Z,EAAMj1B,GACvBqb,EAAS0a,GACLV,EAAY3pB,IAAI2P,KAChBka,EAAKC,SAASna,GACdsZ,IAER,CAEJC,GAAe,EACXQ,IACAA,GAAiB,EACjBG,EAAKO,QAAQC,GAlBjB,CAmBA,GAGR,OAAOR,CACX,CDlCeS,EAAiB,IAAOrB,GAAe,IAC3CK,IACR,CAAC,GACEiB,EAAOpB,EAAWE,QAAO,CAACC,EAAKn0B,KACjC,MAAM00B,EAAOT,EAAMj0B,GAMnB,OALAm0B,EAAIn0B,GAAO,CAACi1B,EAASL,GAAY,EAAOC,GAAY,KAC3Cf,GACDuB,IACGX,EAAKC,SAASM,EAASL,EAAWC,IAEtCV,CAAG,GACX,CAAC,GACEmB,EAAatB,EAAWE,QAAO,CAACC,EAAKn0B,KACvCm0B,EAAIn0B,GAAOi0B,EAAMj0B,GAAKg1B,OACfb,IACR,CAAC,GACEoB,EAAYvB,EAAWE,QAAO,CAACC,EAAKn0B,KACtCm0B,EAAIn0B,GAAO,IAAMi0B,EAAMj0B,GAAKi1B,QAAQ,GAC7Bd,IACR,CAAC,GACEqB,EAAeC,GAAWxB,EAAMwB,GAAQR,QAAQ,GAChDS,EAAgBzD,IAClB6B,GAAe,EACf,EAAMz1B,MAAQw1B,EACRP,EACA50B,KAAK+E,IAAI/E,KAAK8C,IAAIywB,EAAY,EAAMA,UAzC3B,IAyCmD,GAClE,EAAMA,UAAYA,EAClB8B,GAAe,EACfC,EAAWza,QAAQic,GACnBzB,GAAe,EACXD,IACAD,GAAoB,EACpBF,EAAY+B,GAChB,EAEEL,EAAY,KACdvB,GAAe,EACfD,GAAoB,EACfE,GACDJ,EAAY+B,EAAa,EAE3BC,EAAe,IAAM,EAE3B,O,iXE9DA,MAAMC,EAAgB9tB,GAAUnF,GAAK,EAAImF,EAAO,EAAInF,GAC9CkzB,EAAe/tB,GAAUnF,GAAKA,GAAK,GAAMmF,EAAO,EAAInF,GAAK,GAAK,EAAImF,EAAO,GAAK,EAAInF,KAAO,EAEzFmzB,EAAgBrtB,GAAU9F,GAAKA,EAAIA,IAAM8F,EAAQ,GAAK9F,EAAI8F,GCG1DyE,EAASvK,GAAKA,EACdwK,GDLgB1E,ECKM,EDLI9F,GAAKjE,KAAKI,IAAI6D,EAAG8F,IAA5B,IAACA,ECMtB,MAAM4E,EAAUuoB,EAAczoB,GACxBC,EAAYyoB,EAAa1oB,GACzBG,EAAS3K,GAAK,EAAIjE,KAAKkD,IAAIlD,KAAKq3B,KAAKpzB,IACrC6K,EAAUooB,EAActoB,GACxBC,EAAYsoB,EAAaroB,GACzBC,EAASqoB,EAXoB,OAY7BnoB,EAAUioB,EAAcnoB,GACxBC,EAAYmoB,EAAapoB,GACzBG,EDZmB,CAACnF,IACtB,MAAMutB,EAAaF,EAAartB,GAChC,OAAO9F,IAAMA,GAAK,GAAK,EACjB,GAAMqzB,EAAWrzB,GACjB,IAAO,EAAIjE,KAAKI,IAAI,GAAI,IAAM6D,EAAI,IAAI,ECQ7BszB,CAdgB,OAkB7BloB,EAAapL,IACf,GAAU,IAANA,GAAiB,IAANA,EACX,OAAOA,EACX,MAAMuzB,EAAKvzB,EAAIA,EACf,OAAOA,EArBoB,mBAsBrB,OAASuzB,EACTvzB,EAtBsB,kBAuBlB,MAAQuzB,EAAK,IAAMvzB,EAAI,IACvBA,EAvBiB,GAYpB,mBAYYuzB,EAXZ,kBAWsBvzB,EAVtB,kBAWO,KAAOA,EAAIA,EAAI,MAAQA,EAAI,KAAK,EAE5CkL,EAAW+nB,EAAc7nB,GACzBD,EAAenL,GAAMA,EAAI,GACzB,IAAO,EAAMoL,EAAU,EAAU,EAAJpL,IAC7B,GAAMoL,EAAc,EAAJpL,EAAU,GAAO,E,wDCnCvC,MAAMzE,EAAQ,CAACsD,EAAKiC,EAAKzG,IAAM0B,KAAK8C,IAAI9C,KAAK+E,IAAIzG,EAAGwE,GAAMiC,E,wDCA1D,MAAM0yB,EAAWhjB,GAAUA,EAAMyd,eAAe,MAAQzd,EAAMyd,eAAe,KCEvEwF,EAAajjB,GAAUgjB,EAAQhjB,IAAUA,EAAMyd,eAAe,K,cCEpE,MAAMyF,EAAa,CAAC/3B,EAAGC,IAAMG,KAAK+C,IAAInD,EAAIC,GAC1C,SAASqW,EAAStW,EAAGC,GACjB,IAAI,OAAMD,KAAM,OAAMC,GAClB,OAAO83B,EAAW/3B,EAAGC,GAEpB,GAAI43B,EAAQ73B,IAAM63B,EAAQ53B,GAAI,CAC/B,MAAM+3B,EAASD,EAAW/3B,EAAEmQ,EAAGlQ,EAAEkQ,GAC3B8nB,EAASF,EAAW/3B,EAAEoQ,EAAGnQ,EAAEmQ,GAC3B8nB,EAASJ,EAAU93B,IAAM83B,EAAU73B,GAAK83B,EAAW/3B,EAAEqQ,EAAGpQ,EAAEoQ,GAAK,EACrE,OAAOjQ,KAAKe,KAAKf,KAAKI,IAAIw3B,EAAQ,GAAK53B,KAAKI,IAAIy3B,EAAQ,GAAK73B,KAAKI,IAAI03B,EAAQ,GAClF,CACJ,C,uDCfA,MAKMC,EAASz5B,GAAmB,kBAANA,C,wDCL5B,MAAM2H,EAAM,CAACvE,EAAMC,EAAIgH,KAAcA,EAAWjH,EAAOiH,EAAWhH,EAAKD,C,uDCAvE,MAAMs2B,EAAmB,CAACp4B,EAAGC,IAAOvB,GAAMuB,EAAED,EAAEtB,IACxCmJ,EAAO,IAAIwwB,IAAiBA,EAAazC,OAAOwC,E,wDCDtD,MAAMrvB,EAAW,CAACjH,EAAMC,EAAIK,KACxB,MAAMk2B,EAAmBv2B,EAAKD,EAC9B,OAA4B,IAArBw2B,EAAyB,GAAKl2B,EAAQN,GAAQw2B,CAAgB,C,wBCFzE,SAASC,EAAkBh5B,EAAUi5B,GACjC,OAAOA,EAAgBj5B,GAAY,IAAOi5B,GAAiB,CAC/D,C,sGC6BA,MAAMnzB,EAAM,CACRM,MAAM,E,SAAA9E,GAAc,KACpBqF,MA9BJ,SAAkBxH,GACd,IAAI+5B,EAAI,GACJ/3B,EAAI,GACJT,EAAI,GACJD,EAAI,GAiBR,OAhBItB,EAAEoI,OAAS,GACX2xB,EAAI/5B,EAAEg6B,OAAO,EAAG,GAChBh4B,EAAIhC,EAAEg6B,OAAO,EAAG,GAChBz4B,EAAIvB,EAAEg6B,OAAO,EAAG,GAChB14B,EAAItB,EAAEg6B,OAAO,EAAG,KAGhBD,EAAI/5B,EAAEg6B,OAAO,EAAG,GAChBh4B,EAAIhC,EAAEg6B,OAAO,EAAG,GAChBz4B,EAAIvB,EAAEg6B,OAAO,EAAG,GAChB14B,EAAItB,EAAEg6B,OAAO,EAAG,GAChBD,GAAKA,EACL/3B,GAAKA,EACLT,GAAKA,EACLD,GAAKA,GAEF,CACH4E,IAAK+zB,SAASF,EAAG,IACjB5zB,MAAO8zB,SAASj4B,EAAG,IACnBoE,KAAM6zB,SAAS14B,EAAG,IAClB0E,MAAO3E,EAAI24B,SAAS34B,EAAG,IAAM,IAAM,EAE3C,EAIIsG,UAAW,IAAKA,U,wGC7BpB,MAAMf,EAAO,CACTI,MAAM,IAAA9E,GAAc,MAAO,OAC3BqF,OAAO,OAAW,MAAO,aAAc,aACvCI,UAAW,EAAG9B,MAAKC,aAAYC,YAAWC,MAAOi0B,EAAU,KAC/C,QACJx4B,KAAK2E,MAAMP,GACX,KACA,KAAQ8B,WAAU,QAAS7B,IAC3B,KACA,KAAQ6B,WAAU,QAAS5B,IAC3B,MACA,QAAS,KAAM4B,UAAUsyB,IACzB,I,wGCZZ,MAAM/yB,EAAQ,CACVF,KAAOjH,GAAM,IAAKiH,KAAKjH,IAAM,IAAIiH,KAAKjH,IAAM,IAAKiH,KAAKjH,GACtDwH,MAAQxH,GACA,IAAKiH,KAAKjH,GACH,IAAKwH,MAAMxH,GAEb,IAAKiH,KAAKjH,GACR,IAAKwH,MAAMxH,GAGX,IAAIwH,MAAMxH,GAGzB4H,UAAY5H,IACD,QAASA,GACVA,EACAA,EAAE4zB,eAAe,OACb,IAAKhsB,UAAU5H,GACf,IAAK4H,UAAU5H,G,6FCnBjC,MAAMm6B,GAAe,QAAM,EAAG,KACxBC,EAAUv2B,OAAOC,OAAOD,OAAOC,OAAO,CAAC,EAAG,MAAS,CAAE8D,UAAY5H,GAAM0B,KAAK2E,MAAM8zB,EAAan6B,MAC/F4G,EAAO,CACTK,MAAM,IAAA9E,GAAc,MAAO,OAC3BqF,OAAO,OAAW,MAAO,QAAS,QAClCI,UAAW,EAAG1B,MAAKC,QAAOC,OAAMH,MAAOi0B,EAAU,KAAQ,QACrDE,EAAQxyB,UAAU1B,GAClB,KACAk0B,EAAQxyB,UAAUzB,GAClB,KACAi0B,EAAQxyB,UAAUxB,GAClB,MACA,QAAS,KAAMwB,UAAUsyB,IACzB,I,8FCfR,MAAMG,EAAgB,CAACrzB,EAAMszB,IAAct6B,GAChC0lB,SAAS,QAAS1lB,IAAM,KAAiBiH,KAAKjH,IAAMA,EAAEoR,WAAWpK,IACnEszB,GAAYz2B,OAAOkX,UAAU6Y,eAAe7lB,KAAK/N,EAAGs6B,IAEvDC,EAAa,CAACC,EAAOC,EAAOC,IAAW16B,IACzC,KAAK,QAASA,GACV,OAAOA,EACX,MAAOsB,EAAGC,EAAGE,EAAGwE,GAASjG,EAAE26B,MAAM,MACjC,MAAO,CACH,CAACH,GAAQ1lB,WAAWxT,GACpB,CAACm5B,GAAQ3lB,WAAWvT,GACpB,CAACm5B,GAAQ5lB,WAAWrT,GACpBwE,WAAiBhD,IAAVgD,EAAsB6O,WAAW7O,GAAS,EACpD,C,kFCZL,MAAM20B,EAAc,IAAIhtB,IAAI,CAAC,aAAc,WAAY,WAAY,YACnE,SAASitB,EAAmB76B,GACxB,IAAK6f,EAAMnc,GAAS1D,EAAE86B,MAAM,GAAI,GAAGC,MAAM,KACzC,GAAa,gBAATlb,EACA,OAAO7f,EACX,MAAOkvB,GAAUxrB,EAAMi3B,MAAM,OAAe,GAC5C,IAAKzL,EACD,OAAOlvB,EACX,MAAMg7B,EAAOt3B,EAAMgnB,QAAQwE,EAAQ,IACnC,IAAI+L,EAAeL,EAAY/sB,IAAIgS,GAAQ,EAAI,EAG/C,OAFIqP,IAAWxrB,IACXu3B,GAAgB,KACbpb,EAAO,IAAMob,EAAeD,EAAO,GAC9C,CACA,MAAME,EAAgB,oBAChBtP,EAAS/nB,OAAOC,OAAOD,OAAOC,OAAO,CAAC,EAAG,KAAU,CAAEmnB,kBAAoBjrB,IACvE,MAAMm7B,EAAYn7B,EAAE26B,MAAMO,GAC1B,OAAOC,EAAYA,EAAU7yB,IAAIuyB,GAAoBO,KAAK,KAAOp7B,CAAC,G,6FChB1E,MAAMq7B,EAAa,OACbC,EAAc,OAOpB,SAAS7yB,EAAQzI,GACI,kBAANA,IACPA,EAAI,GAAGA,KACX,MAAM6K,EAAS,GACf,IAAI0wB,EAAY,EAChB,MAAMC,EAASx7B,EAAE26B,MAAM,MACnBa,IACAD,EAAYC,EAAOpzB,OACnBpI,EAAIA,EAAE0qB,QAAQ,KAAY2Q,GAC1BxwB,EAAOhB,QAAQ2xB,EAAOlzB,IAAI,IAAMd,SAEpC,MAAMi0B,EAAUz7B,EAAE26B,MAAM,MAKxB,OAJIc,IACAz7B,EAAIA,EAAE0qB,QAAQ,KAAY4Q,GAC1BzwB,EAAOhB,QAAQ4xB,EAAQnzB,IAAI,KAAOd,SAE/B,CAAEqD,SAAQ0wB,YAAWG,UAAW17B,EAC3C,CACA,SAASwH,EAAMxH,GACX,OAAOyI,EAAQzI,GAAG6K,MACtB,CACA,SAAS7B,EAAkBhJ,GACvB,MAAM,OAAE6K,EAAM,UAAE0wB,EAAS,UAAEG,GAAcjzB,EAAQzI,GAC3CmI,EAAY0C,EAAOzC,OACzB,OAAQpI,IACJ,IAAIkI,EAASwzB,EACb,IAAK,IAAIv5B,EAAI,EAAGA,EAAIgG,EAAWhG,IAC3B+F,EAASA,EAAOwiB,QAAQvoB,EAAIo5B,EAAYF,EAAaC,EAAan5B,EAAIo5B,EAAY,IAAM3zB,UAAU5H,EAAEmC,KAAM,QAASnC,EAAEmC,KAEzH,OAAO+F,CAAM,CAErB,CACA,MAAMyzB,EAAwB37B,GAAmB,kBAANA,EAAiB,EAAIA,EAMhE,MAAM2I,EAAU,CAAE1B,KA5ClB,SAAcjH,GACV,IAAImD,EAAImJ,EAAIC,EAAIiQ,EAChB,OAAQla,MAAMtC,KACV,QAASA,KAC6E,QAApFsM,EAAoC,QAA9BnJ,EAAKnD,EAAE26B,MAAM,aAAgC,IAAPx3B,OAAgB,EAASA,EAAGiF,cAA2B,IAAPkE,EAAgBA,EAAK,IAA2F,QAApFkQ,EAAoC,QAA9BjQ,EAAKvM,EAAE26B,MAAM,aAAgC,IAAPpuB,OAAgB,EAASA,EAAGnE,cAA2B,IAAPoU,EAAgBA,EAAK,GAAK,CACxP,EAuCwBhV,QAAOwB,oBAAmBiiB,kBALlD,SAA2BjrB,GACvB,MAAM0I,EAASlB,EAAMxH,GAErB,OADoBgJ,EAAkBhJ,EAC/B47B,CAAYlzB,EAAOJ,IAAIqzB,GAClC,E,wHC/CA,MAAMzM,EAAS,CACXjoB,KAAOjH,GAAmB,kBAANA,EACpBwH,MAAOsN,WACPlN,UAAY5H,GAAMA,GAEhBiG,EAAQpC,OAAOC,OAAOD,OAAOC,OAAO,CAAC,EAAGorB,GAAS,CAAEtnB,WAAW,QAAM,EAAG,KACvEsK,EAAQrO,OAAOC,OAAOD,OAAOC,OAAO,CAAC,EAAGorB,GAAS,CAAE7c,QAAS,G,gMCNlE,MAAMwpB,EAAkBb,IAAS,CAC7B/zB,KAAOjH,IAAM,QAASA,IAAMA,EAAE87B,SAASd,IAAiC,IAAxBh7B,EAAE+6B,MAAM,KAAK3yB,OAC7DZ,MAAOsN,WACPlN,UAAY5H,GAAM,GAAGA,IAAIg7B,MAEvBe,EAAUF,EAAe,OACzBG,EAAUH,EAAe,KACzBriB,EAAKqiB,EAAe,MACpBI,EAAKJ,EAAe,MACpBK,EAAKL,EAAe,MACpBM,EAAqBt4B,OAAOC,OAAOD,OAAOC,OAAO,CAAC,EAAGk4B,GAAU,CAAEx0B,MAAQxH,GAAMg8B,EAAQx0B,MAAMxH,GAAK,IAAK4H,UAAY5H,GAAMg8B,EAAQp0B,UAAc,IAAJ5H,I,iLCZjJ,MAAMkB,EAAQ,CAACsD,EAAKiC,IAASzG,GAAM0B,KAAK+E,IAAI/E,KAAK8C,IAAIxE,EAAGyG,GAAMjC,GACxD43B,EAAYp8B,GAAOA,EAAI,EAAIq8B,OAAOr8B,EAAEs8B,QAAQ,IAAMt8B,EAClDu8B,EAAa,uBACbC,EAAa,gHACbC,EAAmB,oGACzB,SAASC,EAAS18B,GACd,MAAoB,kBAANA,CAClB,C","sources":["webpack://_N_E/../node_modules/hey-listen/dist/hey-listen.es.js","webpack://_N_E/../node_modules/framer-motion/dist/es/animation/utils/is-animation-controls.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/animation/utils/is-keyframes-target.mjs","webpack://_N_E/../node_modules/popmotion/dist/es/animations/utils/find-spring.mjs","webpack://_N_E/../node_modules/popmotion/dist/es/animations/generators/spring.mjs","webpack://_N_E/../node_modules/popmotion/dist/es/utils/hsla-to-rgba.mjs","webpack://_N_E/../node_modules/popmotion/dist/es/utils/mix-color.mjs","webpack://_N_E/../node_modules/popmotion/dist/es/utils/mix-complex.mjs","webpack://_N_E/../node_modules/popmotion/dist/es/utils/interpolate.mjs","webpack://_N_E/../node_modules/popmotion/dist/es/animations/generators/keyframes.mjs","webpack://_N_E/../node_modules/popmotion/dist/es/animations/utils/detect-animation-from-options.mjs","webpack://_N_E/../node_modules/popmotion/dist/es/animations/generators/decay.mjs","webpack://_N_E/../node_modules/popmotion/dist/es/animations/utils/elapsed.mjs","webpack://_N_E/../node_modules/popmotion/dist/es/animations/index.mjs","webpack://_N_E/../node_modules/popmotion/dist/es/easing/cubic-bezier.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/animation/utils/easing.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/animation/utils/is-animatable.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/animation/utils/default-transitions.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/utils/use-instant-transition-state.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/animation/utils/transitions.mjs","webpack://_N_E/../node_modules/popmotion/dist/es/animations/inertia.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/context/LayoutGroupContext.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/context/MotionConfigContext.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/context/PresenceContext.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/context/SwitchLayoutGroupContext.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/motion/utils/is-forced-motion-value.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/projection/geometry/delta-apply.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/projection/geometry/delta-calc.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/projection/geometry/models.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/projection/animation/mix-values.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/projection/geometry/copy.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/projection/geometry/delta-remove.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/projection/geometry/utils.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/projection/shared/stack.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/projection/styles/transform.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/render/utils/compare-by-depth.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/render/utils/flat-tree.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/projection/node/create-projection-node.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/animation/animate.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/projection/styles/scale-correction.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/projection/utils/each-axis.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/projection/utils/has-transform.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/render/dom/utils/camel-to-dash.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/render/dom/utils/is-css-variable.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/render/svg/lowercase-elements.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/render/dom/utils/is-svg-component.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/render/dom/value-types/animatable-none.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/render/dom/value-types/defaults.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/render/dom/value-types/type-int.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/render/dom/value-types/number.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/render/html/utils/build-transform.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/render/dom/value-types/get-as-type.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/render/html/utils/build-styles.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/render/html/utils/render.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/render/html/utils/scrape-motion-values.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/render/html/utils/transform.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/render/svg/utils/transform-origin.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/render/svg/utils/path.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/render/svg/utils/build-attrs.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/render/svg/utils/camel-case-attrs.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/render/svg/utils/render.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/render/svg/utils/scrape-motion-values.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/render/utils/variants.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/utils/array.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/utils/is-browser.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/utils/is-ref-object.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/utils/resolve-value.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/utils/subscription-manager.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/utils/time-conversion.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/utils/use-constant.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/value/index.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/value/utils/is-motion-value.mjs","webpack://_N_E/../node_modules/framer-motion/dist/es/value/utils/resolve-motion-value.mjs","webpack://_N_E/../node_modules/framesync/dist/es/on-next-frame.mjs","webpack://_N_E/../node_modules/framesync/dist/es/index.mjs","webpack://_N_E/../node_modules/framesync/dist/es/create-render-step.mjs","webpack://_N_E/../node_modules/popmotion/dist/es/easing/utils.mjs","webpack://_N_E/../node_modules/popmotion/dist/es/easing/index.mjs","webpack://_N_E/../node_modules/popmotion/dist/es/utils/clamp.mjs","webpack://_N_E/../node_modules/popmotion/dist/es/utils/is-point.mjs","webpack://_N_E/../node_modules/popmotion/dist/es/utils/is-point-3d.mjs","webpack://_N_E/../node_modules/popmotion/dist/es/utils/distance.mjs","webpack://_N_E/../node_modules/popmotion/dist/es/utils/inc.mjs","webpack://_N_E/../node_modules/popmotion/dist/es/utils/mix.mjs","webpack://_N_E/../node_modules/popmotion/dist/es/utils/pipe.mjs","webpack://_N_E/../node_modules/popmotion/dist/es/utils/progress.mjs","webpack://_N_E/../node_modules/popmotion/dist/es/utils/velocity-per-second.mjs","webpack://_N_E/../node_modules/style-value-types/dist/es/color/hex.mjs","webpack://_N_E/../node_modules/style-value-types/dist/es/color/hsla.mjs","webpack://_N_E/../node_modules/style-value-types/dist/es/color/index.mjs","webpack://_N_E/../node_modules/style-value-types/dist/es/color/rgba.mjs","webpack://_N_E/../node_modules/style-value-types/dist/es/color/utils.mjs","webpack://_N_E/../node_modules/style-value-types/dist/es/complex/filter.mjs","webpack://_N_E/../node_modules/style-value-types/dist/es/complex/index.mjs","webpack://_N_E/../node_modules/style-value-types/dist/es/numbers/index.mjs","webpack://_N_E/../node_modules/style-value-types/dist/es/numbers/units.mjs","webpack://_N_E/../node_modules/style-value-types/dist/es/utils.mjs"],"sourcesContent":["var warning = function () { };\r\nvar invariant = function () { };\r\nif (process.env.NODE_ENV !== 'production') {\r\n    warning = function (check, message) {\r\n        if (!check && typeof console !== 'undefined') {\r\n            console.warn(message);\r\n        }\r\n    };\r\n    invariant = function (check, message) {\r\n        if (!check) {\r\n            throw new Error(message);\r\n        }\r\n    };\r\n}\n\nexport { invariant, warning };\n","function isAnimationControls(v) {\n    return typeof v === \"object\" && typeof v.start === \"function\";\n}\n\nexport { isAnimationControls };\n","var isKeyframesTarget = function (v) {\n    return Array.isArray(v);\n};\n\nexport { isKeyframesTarget };\n","import { warning } from 'hey-listen';\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    dampingRatio = clamp(minDamping, maxDamping, dampingRatio);\n    duration = clamp(minDuration, maxDuration, duration / 1000);\n    if (dampingRatio < 1) {\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        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 { __rest } from 'tslib';\nimport { findSpring, calcAngularFreq } from '../utils/find-spring.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 = Object.assign({ velocity: 0.0, stiffness: 100, damping: 10, mass: 1.0, isResolvedFromDuration: false }, options);\n    if (!isSpringType(options, physicsKeys) &&\n        isSpringType(options, durationKeys)) {\n        const derived = findSpring(options);\n        springOptions = Object.assign(Object.assign(Object.assign({}, springOptions), derived), { velocity: 0.0, mass: 1.0 });\n        springOptions.isResolvedFromDuration = true;\n    }\n    return springOptions;\n}\nfunction spring(_a) {\n    var { from = 0.0, to = 1.0, restSpeed = 2, restDelta } = _a, options = __rest(_a, [\"from\", \"to\", \"restSpeed\", \"restDelta\"]);\n    const state = { done: false, value: from };\n    let { stiffness, damping, mass, velocity, duration, isResolvedFromDuration, } = getSpringOptions(options);\n    let resolveSpring = zero;\n    let resolveVelocity = zero;\n    function createSpring() {\n        const initialVelocity = velocity ? -(velocity / 1000) : 0.0;\n        const initialDelta = to - from;\n        const dampingRatio = damping / (2 * Math.sqrt(stiffness * mass));\n        const undampedAngularFreq = Math.sqrt(stiffness / mass) / 1000;\n        if (restDelta === undefined) {\n            restDelta = Math.min(Math.abs(to - from) / 100, 0.4);\n        }\n        if (dampingRatio < 1) {\n            const angularFreq = calcAngularFreq(undampedAngularFreq, dampingRatio);\n            resolveSpring = (t) => {\n                const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n                return (to -\n                    envelope *\n                        (((initialVelocity +\n                            dampingRatio * undampedAngularFreq * initialDelta) /\n                            angularFreq) *\n                            Math.sin(angularFreq * t) +\n                            initialDelta * Math.cos(angularFreq * t)));\n            };\n            resolveVelocity = (t) => {\n                const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n                return (dampingRatio *\n                    undampedAngularFreq *\n                    envelope *\n                    ((Math.sin(angularFreq * t) *\n                        (initialVelocity +\n                            dampingRatio *\n                                undampedAngularFreq *\n                                initialDelta)) /\n                        angularFreq +\n                        initialDelta * Math.cos(angularFreq * t)) -\n                    envelope *\n                        (Math.cos(angularFreq * t) *\n                            (initialVelocity +\n                                dampingRatio *\n                                    undampedAngularFreq *\n                                    initialDelta) -\n                            angularFreq *\n                                initialDelta *\n                                Math.sin(angularFreq * t)));\n            };\n        }\n        else if (dampingRatio === 1) {\n            resolveSpring = (t) => to -\n                Math.exp(-undampedAngularFreq * t) *\n                    (initialDelta +\n                        (initialVelocity + undampedAngularFreq * initialDelta) *\n                            t);\n        }\n        else {\n            const dampedAngularFreq = undampedAngularFreq * Math.sqrt(dampingRatio * dampingRatio - 1);\n            resolveSpring = (t) => {\n                const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n                const freqForT = Math.min(dampedAngularFreq * t, 300);\n                return (to -\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                const currentVelocity = resolveVelocity(t) * 1000;\n                const isBelowVelocityThreshold = Math.abs(currentVelocity) <= restSpeed;\n                const isBelowDisplacementThreshold = Math.abs(to - current) <= restDelta;\n                state.done =\n                    isBelowVelocityThreshold && isBelowDisplacementThreshold;\n            }\n            else {\n                state.done = t >= duration;\n            }\n            state.value = state.done ? to : current;\n            return state;\n        },\n        flipTarget: () => {\n            velocity = -velocity;\n            [from, to] = [to, from];\n            createSpring();\n        },\n    };\n}\nspring.needsInterpolation = (a, b) => typeof a === \"string\" || typeof b === \"string\";\nconst zero = (_t) => 0;\n\nexport { spring };\n","function hueToRgb(p, q, t) {\n    if (t < 0)\n        t += 1;\n    if (t > 1)\n        t -= 1;\n    if (t < 1 / 6)\n        return p + (q - p) * 6 * t;\n    if (t < 1 / 2)\n        return q;\n    if (t < 2 / 3)\n        return p + (q - p) * (2 / 3 - t) * 6;\n    return p;\n}\nfunction hslaToRgba({ hue, saturation, lightness, alpha }) {\n    hue /= 360;\n    saturation /= 100;\n    lightness /= 100;\n    let red = 0;\n    let green = 0;\n    let blue = 0;\n    if (!saturation) {\n        red = green = blue = lightness;\n    }\n    else {\n        const q = lightness < 0.5\n            ? lightness * (1 + saturation)\n            : lightness + saturation - lightness * saturation;\n        const p = 2 * lightness - q;\n        red = hueToRgb(p, q, hue + 1 / 3);\n        green = hueToRgb(p, q, hue);\n        blue = hueToRgb(p, q, hue - 1 / 3);\n    }\n    return {\n        red: Math.round(red * 255),\n        green: Math.round(green * 255),\n        blue: Math.round(blue * 255),\n        alpha,\n    };\n}\n\nexport { hslaToRgba };\n","import { mix } from './mix.mjs';\nimport { hsla, rgba, hex } from 'style-value-types';\nimport { invariant } from 'hey-listen';\nimport { hslaToRgba } from './hsla-to-rgba.mjs';\n\nconst mixLinearColor = (from, to, v) => {\n    const fromExpo = from * from;\n    const toExpo = to * to;\n    return Math.sqrt(Math.max(0, v * (toExpo - fromExpo) + fromExpo));\n};\nconst colorTypes = [hex, rgba, hsla];\nconst getColorType = (v) => colorTypes.find((type) => type.test(v));\nconst notAnimatable = (color) => `'${color}' is not an animatable color. Use the equivalent color code instead.`;\nconst mixColor = (from, to) => {\n    let fromColorType = getColorType(from);\n    let toColorType = getColorType(to);\n    invariant(!!fromColorType, notAnimatable(from));\n    invariant(!!toColorType, notAnimatable(to));\n    let fromColor = fromColorType.parse(from);\n    let toColor = toColorType.parse(to);\n    if (fromColorType === hsla) {\n        fromColor = hslaToRgba(fromColor);\n        fromColorType = rgba;\n    }\n    if (toColorType === hsla) {\n        toColor = hslaToRgba(toColor);\n        toColorType = rgba;\n    }\n    const blended = Object.assign({}, fromColor);\n    return (v) => {\n        for (const key in blended) {\n            if (key !== \"alpha\") {\n                blended[key] = mixLinearColor(fromColor[key], toColor[key], v);\n            }\n        }\n        blended.alpha = mix(fromColor.alpha, toColor.alpha, v);\n        return fromColorType.transform(blended);\n    };\n};\n\nexport { mixColor, mixLinearColor };\n","import { complex, color } from 'style-value-types';\nimport { mix } from './mix.mjs';\nimport { mixColor } from './mix-color.mjs';\nimport { isNum } from './inc.mjs';\nimport { pipe } from './pipe.mjs';\nimport { warning } from 'hey-listen';\n\nfunction getMixer(origin, target) {\n    if (isNum(origin)) {\n        return (v) => mix(origin, target, v);\n    }\n    else if (color.test(origin)) {\n        return mixColor(origin, target);\n    }\n    else {\n        return mixComplex(origin, target);\n    }\n}\nconst mixArray = (from, to) => {\n    const output = [...from];\n    const numValues = output.length;\n    const blendValue = from.map((fromThis, i) => getMixer(fromThis, to[i]));\n    return (v) => {\n        for (let i = 0; i < numValues; i++) {\n            output[i] = blendValue[i](v);\n        }\n        return output;\n    };\n};\nconst mixObject = (origin, target) => {\n    const output = Object.assign(Object.assign({}, origin), target);\n    const blendValue = {};\n    for (const key in output) {\n        if (origin[key] !== undefined && target[key] !== undefined) {\n            blendValue[key] = getMixer(origin[key], target[key]);\n        }\n    }\n    return (v) => {\n        for (const key in blendValue) {\n            output[key] = blendValue[key](v);\n        }\n        return output;\n    };\n};\nfunction analyse(value) {\n    const parsed = complex.parse(value);\n    const numValues = parsed.length;\n    let numNumbers = 0;\n    let numRGB = 0;\n    let numHSL = 0;\n    for (let i = 0; i < numValues; i++) {\n        if (numNumbers || typeof parsed[i] === \"number\") {\n            numNumbers++;\n        }\n        else {\n            if (parsed[i].hue !== undefined) {\n                numHSL++;\n            }\n            else {\n                numRGB++;\n            }\n        }\n    }\n    return { parsed, numNumbers, numRGB, numHSL };\n}\nconst mixComplex = (origin, target) => {\n    const template = complex.createTransformer(target);\n    const originStats = analyse(origin);\n    const targetStats = analyse(target);\n    const canInterpolate = originStats.numHSL === targetStats.numHSL &&\n        originStats.numRGB === targetStats.numRGB &&\n        originStats.numNumbers >= targetStats.numNumbers;\n    if (canInterpolate) {\n        return pipe(mixArray(originStats.parsed, targetStats.parsed), template);\n    }\n    else {\n        warning(true, `Complex values '${origin}' and '${target}' too different to mix. Ensure all colors are of the same type, and that each contains the same quantity of number and color values. Falling back to instant transition.`);\n        return (p) => `${p > 0 ? target : origin}`;\n    }\n};\n\nexport { mixArray, mixComplex, mixObject };\n","import { progress } from './progress.mjs';\nimport { mix } from './mix.mjs';\nimport { mixColor } from './mix-color.mjs';\nimport { mixComplex, mixArray, mixObject } from './mix-complex.mjs';\nimport { color } from 'style-value-types';\nimport { clamp } from './clamp.mjs';\nimport { pipe } from './pipe.mjs';\nimport { invariant } from 'hey-listen';\n\nconst mixNumber = (from, to) => (p) => mix(from, to, p);\nfunction detectMixerFactory(v) {\n    if (typeof v === 'number') {\n        return mixNumber;\n    }\n    else if (typeof v === 'string') {\n        if (color.test(v)) {\n            return mixColor;\n        }\n        else {\n            return mixComplex;\n        }\n    }\n    else if (Array.isArray(v)) {\n        return mixArray;\n    }\n    else if (typeof v === 'object') {\n        return mixObject;\n    }\n}\nfunction createMixers(output, ease, customMixer) {\n    const mixers = [];\n    const mixerFactory = customMixer || detectMixerFactory(output[0]);\n    const numMixers = output.length - 1;\n    for (let i = 0; i < numMixers; i++) {\n        let mixer = mixerFactory(output[i], output[i + 1]);\n        if (ease) {\n            const easingFunction = Array.isArray(ease) ? ease[i] : ease;\n            mixer = pipe(easingFunction, mixer);\n        }\n        mixers.push(mixer);\n    }\n    return mixers;\n}\nfunction fastInterpolate([from, to], [mixer]) {\n    return (v) => mixer(progress(from, to, v));\n}\nfunction slowInterpolate(input, mixers) {\n    const inputLength = input.length;\n    const lastInputIndex = inputLength - 1;\n    return (v) => {\n        let mixerIndex = 0;\n        let foundMixerIndex = false;\n        if (v <= input[0]) {\n            foundMixerIndex = true;\n        }\n        else if (v >= input[lastInputIndex]) {\n            mixerIndex = lastInputIndex - 1;\n            foundMixerIndex = true;\n        }\n        if (!foundMixerIndex) {\n            let i = 1;\n            for (; i < inputLength; i++) {\n                if (input[i] > v || i === lastInputIndex) {\n                    break;\n                }\n            }\n            mixerIndex = i - 1;\n        }\n        const progressInRange = progress(input[mixerIndex], input[mixerIndex + 1], v);\n        return mixers[mixerIndex](progressInRange);\n    };\n}\nfunction interpolate(input, output, { clamp: isClamp = true, ease, mixer } = {}) {\n    const inputLength = input.length;\n    invariant(inputLength === output.length, 'Both input and output ranges must be the same length');\n    invariant(!ease || !Array.isArray(ease) || ease.length === inputLength - 1, 'Array of easing functions must be of length `input.length - 1`, as it applies to the transitions **between** the defined values.');\n    if (input[0] > input[inputLength - 1]) {\n        input = [].concat(input);\n        output = [].concat(output);\n        input.reverse();\n        output.reverse();\n    }\n    const mixers = createMixers(output, ease, mixer);\n    const interpolator = inputLength === 2\n        ? fastInterpolate(input, mixers)\n        : slowInterpolate(input, mixers);\n    return isClamp\n        ? (v) => interpolator(clamp(input[0], input[inputLength - 1], v))\n        : interpolator;\n}\n\nexport { interpolate };\n","import { interpolate } from '../../utils/interpolate.mjs';\nimport { easeInOut } from '../../easing/index.mjs';\n\nfunction defaultEasing(values, easing) {\n    return values.map(() => easing || easeInOut).splice(0, values.length - 1);\n}\nfunction defaultOffset(values) {\n    const numValues = values.length;\n    return values.map((_value, i) => i !== 0 ? i / (numValues - 1) : 0);\n}\nfunction convertOffsetToTimes(offset, duration) {\n    return offset.map((o) => o * duration);\n}\nfunction keyframes({ from = 0, to = 1, ease, offset, duration = 300, }) {\n    const state = { done: false, value: from };\n    const values = Array.isArray(to) ? to : [from, to];\n    const times = convertOffsetToTimes(offset && offset.length === values.length\n        ? offset\n        : defaultOffset(values), duration);\n    function createInterpolator() {\n        return interpolate(times, values, {\n            ease: Array.isArray(ease) ? ease : defaultEasing(values, ease),\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            values.reverse();\n            interpolator = createInterpolator();\n        },\n    };\n}\n\nexport { convertOffsetToTimes, defaultEasing, defaultOffset, keyframes };\n","import { spring } from '../generators/spring.mjs';\nimport { keyframes } from '../generators/keyframes.mjs';\nimport { decay } from '../generators/decay.mjs';\n\nconst types = { keyframes, spring, decay };\nfunction detectAnimationFromOptions(config) {\n    if (Array.isArray(config.to)) {\n        return keyframes;\n    }\n    else if (types[config.type]) {\n        return types[config.type];\n    }\n    const keys = new Set(Object.keys(config));\n    if (keys.has(\"ease\") ||\n        (keys.has(\"duration\") && !keys.has(\"dampingRatio\"))) {\n        return keyframes;\n    }\n    else if (keys.has(\"dampingRatio\") ||\n        keys.has(\"stiffness\") ||\n        keys.has(\"mass\") ||\n        keys.has(\"damping\") ||\n        keys.has(\"restSpeed\") ||\n        keys.has(\"restDelta\")) {\n        return spring;\n    }\n    return keyframes;\n}\n\nexport { detectAnimationFromOptions };\n","function decay({ velocity = 0, from = 0, power = 0.8, timeConstant = 350, restDelta = 0.5, modifyTarget, }) {\n    const state = { done: false, value: from };\n    let amplitude = power * velocity;\n    const ideal = from + amplitude;\n    const target = modifyTarget === undefined ? ideal : modifyTarget(ideal);\n    if (target !== ideal)\n        amplitude = target - from;\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 loopElapsed(elapsed, duration, delay = 0) {\n    return elapsed - duration - delay;\n}\nfunction reverseElapsed(elapsed, duration, 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}\n\nexport { hasRepeatDelayElapsed, loopElapsed, reverseElapsed };\n","import { __rest } from 'tslib';\nimport { detectAnimationFromOptions } from './utils/detect-animation-from-options.mjs';\nimport sync, { cancelSync } from 'framesync';\nimport { interpolate } from '../utils/interpolate.mjs';\nimport { hasRepeatDelayElapsed, reverseElapsed, loopElapsed } from './utils/elapsed.mjs';\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 animate(_a) {\n    var _b, _c;\n    var { from, autoplay = true, driver = framesync, elapsed = 0, repeat: repeatMax = 0, repeatType = \"loop\", repeatDelay = 0, onPlay, onStop, onComplete, onRepeat, onUpdate } = _a, options = __rest(_a, [\"from\", \"autoplay\", \"driver\", \"elapsed\", \"repeat\", \"repeatType\", \"repeatDelay\", \"onPlay\", \"onStop\", \"onComplete\", \"onRepeat\", \"onUpdate\"]);\n    let { to } = options;\n    let driverControls;\n    let repeatCount = 0;\n    let computedDuration = options.duration;\n    let latest;\n    let isComplete = false;\n    let isForwardPlayback = true;\n    let interpolateFromNumber;\n    const animator = detectAnimationFromOptions(options);\n    if ((_c = (_b = animator).needsInterpolation) === null || _c === void 0 ? void 0 : _c.call(_b, from, to)) {\n        interpolateFromNumber = interpolate([0, 100], [from, to], {\n            clamp: false,\n        });\n        from = 0;\n        to = 100;\n    }\n    const animation = animator(Object.assign(Object.assign({}, options), { from, to }));\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.stop();\n        onComplete && onComplete();\n    }\n    function update(delta) {\n        if (!isForwardPlayback)\n            delta = -delta;\n        elapsed += delta;\n        if (!isComplete) {\n            const state = animation.next(Math.max(0, elapsed));\n            latest = state.value;\n            if (interpolateFromNumber)\n                latest = interpolateFromNumber(latest);\n            isComplete = isForwardPlayback ? state.done : elapsed <= 0;\n        }\n        onUpdate === null || onUpdate === void 0 ? void 0 : onUpdate(latest);\n        if (isComplete) {\n            if (repeatCount === 0)\n                computedDuration !== null && computedDuration !== void 0 ? computedDuration : (computedDuration = elapsed);\n            if (repeatCount < repeatMax) {\n                hasRepeatDelayElapsed(elapsed, computedDuration, repeatDelay, isForwardPlayback) && repeat();\n            }\n            else {\n                complete();\n            }\n        }\n    }\n    function play() {\n        onPlay === null || onPlay === void 0 ? void 0 : onPlay();\n        driverControls = driver(update);\n        driverControls.start();\n    }\n    autoplay && play();\n    return {\n        stop: () => {\n            onStop === null || onStop === void 0 ? void 0 : onStop();\n            driverControls.stop();\n        },\n    };\n}\n\nexport { animate };\n","import { linear } from './index.mjs';\n\nconst a = (a1, a2) => 1.0 - 3.0 * a2 + 3.0 * a1;\nconst b = (a1, a2) => 3.0 * a2 - 6.0 * a1;\nconst c = (a1) => 3.0 * a1;\nconst calcBezier = (t, a1, a2) => ((a(a1, a2) * t + b(a1, a2)) * t + c(a1)) * t;\nconst getSlope = (t, a1, a2) => 3.0 * a(a1, a2) * t * t + 2.0 * b(a1, a2) * t + c(a1);\nconst subdivisionPrecision = 0.0000001;\nconst subdivisionMaxIterations = 10;\nfunction binarySubdivide(aX, aA, aB, mX1, mX2) {\n    let currentX;\n    let currentT;\n    let i = 0;\n    do {\n        currentT = aA + (aB - aA) / 2.0;\n        currentX = calcBezier(currentT, mX1, mX2) - aX;\n        if (currentX > 0.0) {\n            aB = currentT;\n        }\n        else {\n            aA = currentT;\n        }\n    } while (Math.abs(currentX) > subdivisionPrecision &&\n        ++i < subdivisionMaxIterations);\n    return currentT;\n}\nconst newtonIterations = 8;\nconst newtonMinSlope = 0.001;\nfunction newtonRaphsonIterate(aX, aGuessT, mX1, mX2) {\n    for (let i = 0; i < newtonIterations; ++i) {\n        const currentSlope = getSlope(aGuessT, mX1, mX2);\n        if (currentSlope === 0.0) {\n            return aGuessT;\n        }\n        const currentX = calcBezier(aGuessT, mX1, mX2) - aX;\n        aGuessT -= currentX / currentSlope;\n    }\n    return aGuessT;\n}\nconst kSplineTableSize = 11;\nconst kSampleStepSize = 1.0 / (kSplineTableSize - 1.0);\nfunction cubicBezier(mX1, mY1, mX2, mY2) {\n    if (mX1 === mY1 && mX2 === mY2)\n        return linear;\n    const sampleValues = new Float32Array(kSplineTableSize);\n    for (let i = 0; i < kSplineTableSize; ++i) {\n        sampleValues[i] = calcBezier(i * kSampleStepSize, mX1, mX2);\n    }\n    function getTForX(aX) {\n        let intervalStart = 0.0;\n        let currentSample = 1;\n        const lastSample = kSplineTableSize - 1;\n        for (; currentSample !== lastSample && sampleValues[currentSample] <= aX; ++currentSample) {\n            intervalStart += kSampleStepSize;\n        }\n        --currentSample;\n        const dist = (aX - sampleValues[currentSample]) /\n            (sampleValues[currentSample + 1] - sampleValues[currentSample]);\n        const guessForT = intervalStart + dist * kSampleStepSize;\n        const initialSlope = getSlope(guessForT, mX1, mX2);\n        if (initialSlope >= newtonMinSlope) {\n            return newtonRaphsonIterate(aX, guessForT, mX1, mX2);\n        }\n        else if (initialSlope === 0.0) {\n            return guessForT;\n        }\n        else {\n            return binarySubdivide(aX, intervalStart, intervalStart + kSampleStepSize, mX1, mX2);\n        }\n    }\n    return (t) => t === 0 || t === 1 ? t : calcBezier(getTForX(t), mY1, mY2);\n}\n\nexport { cubicBezier };\n","import { __read } from 'tslib';\nimport { invariant } from 'hey-listen';\nimport { cubicBezier, linear, easeIn, easeInOut, easeOut, circIn, circInOut, circOut, backIn, backInOut, backOut, anticipate, bounceIn, bounceInOut, bounceOut } from 'popmotion';\n\nvar easingLookup = {\n    linear: linear,\n    easeIn: easeIn,\n    easeInOut: easeInOut,\n    easeOut: easeOut,\n    circIn: circIn,\n    circInOut: circInOut,\n    circOut: circOut,\n    backIn: backIn,\n    backInOut: backInOut,\n    backOut: backOut,\n    anticipate: anticipate,\n    bounceIn: bounceIn,\n    bounceInOut: bounceInOut,\n    bounceOut: bounceOut,\n};\nvar easingDefinitionToFunction = function (definition) {\n    if (Array.isArray(definition)) {\n        // If cubic bezier definition, create bezier curve\n        invariant(definition.length === 4, \"Cubic bezier arrays must contain four numerical values.\");\n        var _a = __read(definition, 4), x1 = _a[0], y1 = _a[1], x2 = _a[2], y2 = _a[3];\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 '\".concat(definition, \"'\"));\n        return easingLookup[definition];\n    }\n    return definition;\n};\nvar isEasingArray = function (ease) {\n    return Array.isArray(ease) && typeof ease[0] !== \"number\";\n};\n\nexport { easingDefinitionToFunction, isEasingArray };\n","import { complex } from 'style-value-types';\n\n/**\n * Check if a value is animatable. Examples:\n *\n * ✅: 100, \"100px\", \"#fff\"\n * ❌: \"block\", \"url(2.jpg)\"\n * @param value\n *\n * @internal\n */\nvar isAnimatable = function (key, value) {\n    // If the list of keys tat might be non-animatable grows, replace with Set\n    if (key === \"zIndex\")\n        return false;\n    // If it's a number or a keyframes array, we can animate it. We might at some point\n    // need to do a deep isAnimatable check of keyframes, or let Popmotion handle this,\n    // but for now lets leave it like this for performance reasons\n    if (typeof value === \"number\" || Array.isArray(value))\n        return true;\n    if (typeof value === \"string\" && // It's animatable if we have a string\n        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 { __assign } from 'tslib';\nimport { isKeyframesTarget } from './is-keyframes-target.mjs';\n\nvar underDampedSpring = function () { return ({\n    type: \"spring\",\n    stiffness: 500,\n    damping: 25,\n    restSpeed: 10,\n}); };\nvar criticallyDampedSpring = function (to) { return ({\n    type: \"spring\",\n    stiffness: 550,\n    damping: to === 0 ? 2 * Math.sqrt(550) : 30,\n    restSpeed: 10,\n}); };\nvar linearTween = function () { return ({\n    type: \"keyframes\",\n    ease: \"linear\",\n    duration: 0.3,\n}); };\nvar keyframes = function (values) { return ({\n    type: \"keyframes\",\n    duration: 0.8,\n    values: values,\n}); };\nvar defaultTransitions = {\n    x: underDampedSpring,\n    y: underDampedSpring,\n    z: underDampedSpring,\n    rotate: underDampedSpring,\n    rotateX: underDampedSpring,\n    rotateY: underDampedSpring,\n    rotateZ: underDampedSpring,\n    scaleX: criticallyDampedSpring,\n    scaleY: criticallyDampedSpring,\n    scale: criticallyDampedSpring,\n    opacity: linearTween,\n    backgroundColor: linearTween,\n    color: linearTween,\n    default: criticallyDampedSpring,\n};\nvar getDefaultTransition = function (valueKey, to) {\n    var transitionFactory;\n    if (isKeyframesTarget(to)) {\n        transitionFactory = keyframes;\n    }\n    else {\n        transitionFactory =\n            defaultTransitions[valueKey] || defaultTransitions.default;\n    }\n    return __assign({ to: to }, transitionFactory(to));\n};\n\nexport { criticallyDampedSpring, getDefaultTransition, linearTween, underDampedSpring };\n","var instantAnimationState = {\n    current: false,\n};\n\nexport { instantAnimationState };\n","import { __assign, __rest, __spreadArray, __read } from 'tslib';\nimport { inertia, animate } from 'popmotion';\nimport { secondsToMilliseconds } from '../../utils/time-conversion.mjs';\nimport { isEasingArray, easingDefinitionToFunction } from './easing.mjs';\nimport { isAnimatable } from './is-animatable.mjs';\nimport { getDefaultTransition } from './default-transitions.mjs';\nimport { warning } from 'hey-listen';\nimport { getAnimatableNone } from '../../render/dom/value-types/animatable-none.mjs';\nimport { instantAnimationState } from '../../utils/use-instant-transition-state.mjs';\nimport { resolveFinalValueInKeyframes } from '../../utils/resolve-value.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(_a) {\n    _a.when; _a.delay; _a.delayChildren; _a.staggerChildren; _a.staggerDirection; _a.repeat; _a.repeatType; _a.repeatDelay; _a.from; var transition = __rest(_a, [\"when\", \"delay\", \"delayChildren\", \"staggerChildren\", \"staggerDirection\", \"repeat\", \"repeatType\", \"repeatDelay\", \"from\"]);\n    return !!Object.keys(transition).length;\n}\nvar legacyRepeatWarning = false;\n/**\n * Convert Framer Motion's Transition type into Popmotion-compatible options.\n */\nfunction convertTransitionToAnimationOptions(_a) {\n    var ease = _a.ease, times = _a.times, yoyo = _a.yoyo, flip = _a.flip, loop = _a.loop, transition = __rest(_a, [\"ease\", \"times\", \"yoyo\", \"flip\", \"loop\"]);\n    var options = __assign({}, transition);\n    if (times)\n        options[\"offset\"] = times;\n    /**\n     * Convert any existing durations from seconds to milliseconds\n     */\n    if (transition.duration)\n        options[\"duration\"] = secondsToMilliseconds(transition.duration);\n    if (transition.repeatDelay)\n        options.repeatDelay = secondsToMilliseconds(transition.repeatDelay);\n    /**\n     * Map easing names to Popmotion's easing functions\n     */\n    if (ease) {\n        options[\"ease\"] = isEasingArray(ease)\n            ? ease.map(easingDefinitionToFunction)\n            : easingDefinitionToFunction(ease);\n    }\n    /**\n     * Support legacy transition API\n     */\n    if (transition.type === \"tween\")\n        options.type = \"keyframes\";\n    /**\n     * TODO: These options are officially removed from the API.\n     */\n    if (yoyo || loop || flip) {\n        warning(!legacyRepeatWarning, \"yoyo, loop and flip have been removed from the API. Replace with repeat and repeatType options.\");\n        legacyRepeatWarning = true;\n        if (yoyo) {\n            options.repeatType = \"reverse\";\n        }\n        else if (loop) {\n            options.repeatType = \"loop\";\n        }\n        else if (flip) {\n            options.repeatType = \"mirror\";\n        }\n        options.repeat = loop || yoyo || flip || transition.repeat;\n    }\n    /**\n     * TODO: Popmotion 9 has the ability to automatically detect whether to use\n     * a keyframes or spring animation, but does so by detecting velocity and other spring options.\n     * It'd be good to introduce a similar thing here.\n     */\n    if (transition.type !== \"spring\")\n        options.type = \"keyframes\";\n    return options;\n}\n/**\n * Get the delay for a value by checking Transition with decreasing specificity.\n */\nfunction getDelayFromTransition(transition, key) {\n    var _a, _b;\n    var valueTransition = getValueTransition(transition, key) || {};\n    return (_b = (_a = valueTransition.delay) !== null && _a !== void 0 ? _a : transition.delay) !== null && _b !== void 0 ? _b : 0;\n}\nfunction hydrateKeyframes(options) {\n    if (Array.isArray(options.to) && options.to[0] === null) {\n        options.to = __spreadArray([], __read(options.to), false);\n        options.to[0] = options.from;\n    }\n    return options;\n}\nfunction getPopmotionAnimationOptions(transition, options, key) {\n    var _a;\n    if (Array.isArray(options.to)) {\n        (_a = transition.duration) !== null && _a !== void 0 ? _a : (transition.duration = 0.8);\n    }\n    hydrateKeyframes(options);\n    /**\n     * Get a default transition if none is determined to be defined.\n     */\n    if (!isTransitionDefined(transition)) {\n        transition = __assign(__assign({}, transition), getDefaultTransition(key, options.to));\n    }\n    return __assign(__assign({}, options), convertTransitionToAnimationOptions(transition));\n}\n/**\n *\n */\nfunction getAnimation(key, value, target, transition, onComplete) {\n    var _a;\n    var valueTransition = getValueTransition(transition, key);\n    var origin = (_a = valueTransition.from) !== null && _a !== void 0 ? _a : value.get();\n    var isTargetAnimatable = isAnimatable(key, target);\n    if (origin === \"none\" && isTargetAnimatable && typeof target === \"string\") {\n        /**\n         * If we're trying to animate from \"none\", try and get an animatable version\n         * of the target. This could be improved to work both ways.\n         */\n        origin = getAnimatableNone(key, target);\n    }\n    else if (isZero(origin) && typeof target === \"string\") {\n        origin = getZeroUnit(target);\n    }\n    else if (!Array.isArray(target) &&\n        isZero(target) &&\n        typeof origin === \"string\") {\n        target = getZeroUnit(origin);\n    }\n    var isOriginAnimatable = isAnimatable(key, origin);\n    warning(isOriginAnimatable === isTargetAnimatable, \"You are trying to animate \".concat(key, \" from \\\"\").concat(origin, \"\\\" to \\\"\").concat(target, \"\\\". \").concat(origin, \" is not an animatable value - to enable this animation set \").concat(origin, \" to a value animatable to \").concat(target, \" via the `style` property.\"));\n    function start() {\n        var options = {\n            from: origin,\n            to: target,\n            velocity: value.getVelocity(),\n            onComplete: onComplete,\n            onUpdate: function (v) { return value.set(v); },\n        };\n        return valueTransition.type === \"inertia\" ||\n            valueTransition.type === \"decay\"\n            ? inertia(__assign(__assign({}, options), valueTransition))\n            : animate(__assign(__assign({}, getPopmotionAnimationOptions(valueTransition, options, key)), { onUpdate: function (v) {\n                    var _a;\n                    options.onUpdate(v);\n                    (_a = valueTransition.onUpdate) === null || _a === void 0 ? void 0 : _a.call(valueTransition, v);\n                }, onComplete: function () {\n                    var _a;\n                    options.onComplete();\n                    (_a = valueTransition.onComplete) === null || _a === void 0 ? void 0 : _a.call(valueTransition);\n                } }));\n    }\n    function set() {\n        var _a, _b;\n        var finalTarget = resolveFinalValueInKeyframes(target);\n        value.set(finalTarget);\n        onComplete();\n        (_a = valueTransition === null || valueTransition === void 0 ? void 0 : valueTransition.onUpdate) === null || _a === void 0 ? void 0 : _a.call(valueTransition, finalTarget);\n        (_b = valueTransition === null || valueTransition === void 0 ? void 0 : valueTransition.onComplete) === null || _b === void 0 ? void 0 : _b.call(valueTransition);\n        return { stop: function () { } };\n    }\n    return !isOriginAnimatable ||\n        !isTargetAnimatable ||\n        valueTransition.type === false\n        ? set\n        : start;\n}\nfunction isZero(value) {\n    return (value === 0 ||\n        (typeof value === \"string\" &&\n            parseFloat(value) === 0 &&\n            value.indexOf(\" \") === -1));\n}\nfunction getZeroUnit(potentialUnitType) {\n    return typeof potentialUnitType === \"number\"\n        ? 0\n        : getAnimatableNone(\"\", potentialUnitType);\n}\nfunction getValueTransition(transition, key) {\n    return transition[key] || transition[\"default\"] || transition;\n}\n/**\n * Start animation on a MotionValue. This function is an interface between\n * Framer Motion and Popmotion\n *\n * @internal\n */\nfunction startAnimation(key, value, target, transition) {\n    if (transition === void 0) { transition = {}; }\n    if (instantAnimationState.current) {\n        transition = { type: false };\n    }\n    return value.start(function (onComplete) {\n        var delayTimer;\n        var controls;\n        var animation = getAnimation(key, value, target, transition, onComplete);\n        var delay = getDelayFromTransition(transition, key);\n        var start = function () { return (controls = animation()); };\n        if (delay) {\n            delayTimer = window.setTimeout(start, secondsToMilliseconds(delay));\n        }\n        else {\n            start();\n        }\n        return function () {\n            clearTimeout(delayTimer);\n            controls === null || controls === void 0 ? void 0 : controls.stop();\n        };\n    });\n}\n\nexport { convertTransitionToAnimationOptions, getDelayFromTransition, getPopmotionAnimationOptions, getValueTransition, getZeroUnit, hydrateKeyframes, isTransitionDefined, isZero, startAnimation };\n","import { animate } from './index.mjs';\nimport { velocityPerSecond } from '../utils/velocity-per-second.mjs';\nimport { getFrameData } from 'framesync';\n\nfunction inertia({ from = 0, velocity = 0, min, max, power = 0.8, timeConstant = 750, bounceStiffness = 500, bounceDamping = 10, restDelta = 1, modifyTarget, driver, onUpdate, onComplete, onStop, }) {\n    let currentAnimation;\n    function isOutOfBounds(v) {\n        return (min !== undefined && v < min) || (max !== undefined && v > max);\n    }\n    function boundaryNearest(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 === null || currentAnimation === void 0 ? void 0 : currentAnimation.stop();\n        currentAnimation = animate(Object.assign(Object.assign({}, options), { driver, onUpdate: (v) => {\n                var _a;\n                onUpdate === null || onUpdate === void 0 ? void 0 : onUpdate(v);\n                (_a = options.onUpdate) === null || _a === void 0 ? void 0 : _a.call(options, v);\n            }, onComplete,\n            onStop }));\n    }\n    function startSpring(options) {\n        startAnimation(Object.assign({ type: \"spring\", stiffness: bounceStiffness, damping: bounceDamping, restDelta }, options));\n    }\n    if (isOutOfBounds(from)) {\n        startSpring({ from, velocity, to: boundaryNearest(from) });\n    }\n    else {\n        let target = power * velocity + from;\n        if (typeof modifyTarget !== \"undefined\")\n            target = modifyTarget(target);\n        const boundary = boundaryNearest(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, getFrameData().delta);\n            if ((heading === 1 && v > boundary) ||\n                (heading === -1 && v < boundary)) {\n                startSpring({ from: v, to: boundary, velocity });\n            }\n        };\n        startAnimation({\n            type: \"decay\",\n            from,\n            velocity,\n            timeConstant,\n            power,\n            restDelta,\n            modifyTarget,\n            onUpdate: isOutOfBounds(target) ? checkBoundary : undefined,\n        });\n    }\n    return {\n        stop: () => currentAnimation === null || currentAnimation === void 0 ? void 0 : currentAnimation.stop(),\n    };\n}\n\nexport { inertia };\n","import { createContext } from 'react';\n\n/**\n * @internal\n */\nvar LayoutGroupContext = createContext({});\n\nexport { LayoutGroupContext };\n","import { createContext } from 'react';\n\n/**\n * @public\n */\nvar MotionConfigContext = createContext({\n    transformPagePoint: function (p) { return p; },\n    isStatic: false,\n    reducedMotion: \"never\",\n});\n\nexport { MotionConfigContext };\n","import { createContext } from 'react';\n\n/**\n * @public\n */\nvar PresenceContext = createContext(null);\n\nexport { PresenceContext };\n","import { createContext } from 'react';\n\n/**\n * @internal\n */\nvar SwitchLayoutGroupContext = createContext({});\n\nexport { SwitchLayoutGroupContext };\n","import { scaleCorrectors } from '../../projection/styles/scale-correction.mjs';\nimport { isTransformProp, isTransformOriginProp } from '../../render/html/utils/transform.mjs';\n\nfunction isForcedMotionValue(key, _a) {\n    var layout = _a.layout, layoutId = _a.layoutId;\n    return (isTransformProp(key) ||\n        isTransformOriginProp(key) ||\n        ((layout || layoutId !== undefined) &&\n            (!!scaleCorrectors[key] || key === \"opacity\")));\n}\n\nexport { isForcedMotionValue };\n","import { __read } from 'tslib';\nimport { mix } from 'popmotion';\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    var distanceFromOrigin = point - originPoint;\n    var scaled = scale * distanceFromOrigin;\n    return originPoint + scaled;\n}\n/**\n * Applies a translate/scale delta to a point\n */\nfunction applyPointDelta(point, translate, scale, originPoint, boxScale) {\n    if (boxScale !== undefined) {\n        point = scalePoint(point, boxScale, originPoint);\n    }\n    return scalePoint(point, scale, originPoint) + translate;\n}\n/**\n * Applies a translate/scale delta to an axis\n */\nfunction applyAxisDelta(axis, translate, scale, originPoint, boxScale) {\n    if (translate === void 0) { translate = 0; }\n    if (scale === void 0) { scale = 1; }\n    axis.min = applyPointDelta(axis.min, translate, scale, originPoint, boxScale);\n    axis.max = applyPointDelta(axis.max, translate, scale, originPoint, boxScale);\n}\n/**\n * Applies a translate/scale delta to a box\n */\nfunction applyBoxDelta(box, _a) {\n    var x = _a.x, y = _a.y;\n    applyAxisDelta(box.x, x.translate, x.scale, x.originPoint);\n    applyAxisDelta(box.y, y.translate, y.scale, y.originPoint);\n}\n/**\n * Apply a tree of deltas to a box. We do this to calculate the effect of all the transforms\n * in a tree upon our box before then calculating how to project it into our desired viewport-relative box\n *\n * This is the final nested loop within updateLayoutDelta for future refactoring\n */\nfunction applyTreeDeltas(box, treeScale, treePath, isSharedTransition) {\n    var _a, _b;\n    if (isSharedTransition === void 0) { isSharedTransition = false; }\n    var treeLength = treePath.length;\n    if (!treeLength)\n        return;\n    // Reset the treeScale\n    treeScale.x = treeScale.y = 1;\n    var node;\n    var delta;\n    for (var i = 0; i < treeLength; i++) {\n        node = treePath[i];\n        delta = node.projectionDelta;\n        if (((_b = (_a = node.instance) === null || _a === void 0 ? void 0 : _a.style) === null || _b === void 0 ? void 0 : _b.display) === \"contents\")\n            continue;\n        if (isSharedTransition &&\n            node.options.layoutScroll &&\n            node.scroll &&\n            node !== node.root) {\n            transformBox(box, { x: -node.scroll.x, y: -node.scroll.y });\n        }\n        if (delta) {\n            // Incoporate each ancestor's scale into a culmulative treeScale for this component\n            treeScale.x *= delta.x.scale;\n            treeScale.y *= delta.y.scale;\n            // Apply each ancestor's calculated delta into this component's recorded layout box\n            applyBoxDelta(box, delta);\n        }\n        if (isSharedTransition && hasTransform(node.latestValues)) {\n            transformBox(box, node.latestValues);\n        }\n    }\n}\nfunction translateAxis(axis, distance) {\n    axis.min = axis.min + distance;\n    axis.max = axis.max + distance;\n}\n/**\n * Apply a transform to an axis from the latest resolved motion values.\n * This function basically acts as a bridge between a flat motion value map\n * and applyAxisDelta\n */\nfunction transformAxis(axis, transforms, _a) {\n    var _b = __read(_a, 3), key = _b[0], scaleKey = _b[1], originKey = _b[2];\n    var axisOrigin = transforms[originKey] !== undefined ? transforms[originKey] : 0.5;\n    var originPoint = mix(axis.min, axis.max, axisOrigin);\n    // Apply the axis delta to the final axis\n    applyAxisDelta(axis, transforms[key], transforms[scaleKey], originPoint, transforms.scale);\n}\n/**\n * The names of the motion values we want to apply as translation, scale and origin.\n */\nvar xKeys = [\"x\", \"scaleX\", \"originX\"];\nvar 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 { mix, distance } from 'popmotion';\n\nfunction calcLength(axis) {\n    return axis.max - axis.min;\n}\nfunction isNear(value, target, maxDistance) {\n    if (target === void 0) { target = 0; }\n    if (maxDistance === void 0) { maxDistance = 0.01; }\n    return distance(value, target) < maxDistance;\n}\nfunction calcAxisDelta(delta, source, target, origin) {\n    if (origin === void 0) { origin = 0.5; }\n    delta.origin = origin;\n    delta.originPoint = 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 === null || origin === void 0 ? void 0 : origin.originX);\n    calcAxisDelta(delta.y, source.y, target.y, origin === null || origin === void 0 ? void 0 : origin.originY);\n}\nfunction calcRelativeAxis(target, relative, parent) {\n    target.min = parent.min + relative.min;\n    target.max = target.min + calcLength(relative);\n}\nfunction calcRelativeBox(target, relative, parent) {\n    calcRelativeAxis(target.x, relative.x, parent.x);\n    calcRelativeAxis(target.y, relative.y, parent.y);\n}\nfunction calcRelativeAxisPosition(target, layout, parent) {\n    target.min = layout.min - parent.min;\n    target.max = target.min + calcLength(layout);\n}\nfunction calcRelativePosition(target, layout, parent) {\n    calcRelativeAxisPosition(target.x, layout.x, parent.x);\n    calcRelativeAxisPosition(target.y, layout.y, parent.y);\n}\n\nexport { calcAxisDelta, calcBoxDelta, calcLength, calcRelativeAxis, calcRelativeAxisPosition, calcRelativeBox, calcRelativePosition, isNear };\n","var createAxisDelta = function () { return ({\n    translate: 0,\n    scale: 1,\n    origin: 0,\n    originPoint: 0,\n}); };\nvar createDelta = function () { return ({\n    x: createAxisDelta(),\n    y: createAxisDelta(),\n}); };\nvar createAxis = function () { return ({ min: 0, max: 0 }); };\nvar createBox = function () { return ({\n    x: createAxis(),\n    y: createAxis(),\n}); };\n\nexport { createAxis, createAxisDelta, createBox, createDelta };\n","import { mix, progress, linear, circOut } from 'popmotion';\nimport { px, percent } from 'style-value-types';\n\nvar borders = [\"TopLeft\", \"TopRight\", \"BottomLeft\", \"BottomRight\"];\nvar numBorders = borders.length;\nvar asNumber = function (value) {\n    return typeof value === \"string\" ? parseFloat(value) : value;\n};\nvar isPx = function (value) {\n    return typeof value === \"number\" || px.test(value);\n};\nfunction mixValues(target, follow, lead, progress, shouldCrossfadeOpacity, isOnlyMember) {\n    var _a, _b, _c, _d;\n    if (shouldCrossfadeOpacity) {\n        target.opacity = mix(0, \n        // (follow?.opacity as number) ?? 0,\n        // TODO Reinstate this if only child\n        (_a = lead.opacity) !== null && _a !== void 0 ? _a : 1, easeCrossfadeIn(progress));\n        target.opacityExit = mix((_b = follow.opacity) !== null && _b !== void 0 ? _b : 1, 0, easeCrossfadeOut(progress));\n    }\n    else if (isOnlyMember) {\n        target.opacity = mix((_c = follow.opacity) !== null && _c !== void 0 ? _c : 1, (_d = lead.opacity) !== null && _d !== void 0 ? _d : 1, progress);\n    }\n    /**\n     * Mix border radius\n     */\n    for (var i = 0; i < numBorders; i++) {\n        var borderLabel = \"border\".concat(borders[i], \"Radius\");\n        var followRadius = getRadius(follow, borderLabel);\n        var leadRadius = getRadius(lead, borderLabel);\n        if (followRadius === undefined && leadRadius === undefined)\n            continue;\n        followRadius || (followRadius = 0);\n        leadRadius || (leadRadius = 0);\n        var canMix = followRadius === 0 ||\n            leadRadius === 0 ||\n            isPx(followRadius) === isPx(leadRadius);\n        if (canMix) {\n            target[borderLabel] = Math.max(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    var _a;\n    return (_a = values[radiusName]) !== null && _a !== void 0 ? _a : values.borderRadius;\n}\n// /**\n//  * We only want to mix the background color if there's a follow element\n//  * that we're not crossfading opacity between. For instance with switch\n//  * AnimateSharedLayout animations, this helps the illusion of a continuous\n//  * element being animated but also cuts down on the number of paints triggered\n//  * for elements where opacity is doing that work for us.\n//  */\n// if (\n//     !hasFollowElement &&\n//     latestLeadValues.backgroundColor &&\n//     latestFollowValues.backgroundColor\n// ) {\n//     /**\n//      * This isn't ideal performance-wise as mixColor is creating a new function every frame.\n//      * We could probably create a mixer that runs at the start of the animation but\n//      * the idea behind the crossfader is that it runs dynamically between two potentially\n//      * changing targets (ie opacity or borderRadius may be animating independently via variants)\n//      */\n//     leadState.backgroundColor = followState.backgroundColor = mixColor(\n//         latestFollowValues.backgroundColor as string,\n//         latestLeadValues.backgroundColor as string\n//     )(p)\n// }\nvar easeCrossfadeIn = compress(0, 0.5, circOut);\nvar easeCrossfadeOut = compress(0.5, 0.95, linear);\nfunction compress(min, max, easing) {\n    return function (p) {\n        // Could replace ifs with clamp\n        if (p < min)\n            return 0;\n        if (p > max)\n            return 1;\n        return easing(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 { __read } from 'tslib';\nimport { mix } from 'popmotion';\nimport { percent } from 'style-value-types';\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, scale, origin, boxScale, originAxis, sourceAxis) {\n    if (translate === void 0) { translate = 0; }\n    if (scale === void 0) { scale = 1; }\n    if (origin === void 0) { origin = 0.5; }\n    if (originAxis === void 0) { originAxis = axis; }\n    if (sourceAxis === void 0) { sourceAxis = axis; }\n    if (percent.test(translate)) {\n        translate = parseFloat(translate);\n        var relativeProgress = mix(sourceAxis.min, sourceAxis.max, translate / 100);\n        translate = relativeProgress - sourceAxis.min;\n    }\n    if (typeof translate !== \"number\")\n        return;\n    var 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, _a, origin, sourceAxis) {\n    var _b = __read(_a, 3), key = _b[0], scaleKey = _b[1], originKey = _b[2];\n    removeAxisDelta(axis, transforms[key], transforms[scaleKey], transforms[originKey], transforms.scale, origin, sourceAxis);\n}\n/**\n * The names of the motion values we want to apply as translation, scale and origin.\n */\nvar xKeys = [\"x\", \"scaleX\", \"originX\"];\nvar yKeys = [\"y\", \"scaleY\", \"originY\"];\n/**\n * Remove a transforms from an box. This is essentially the steps of applyAxisBox in reverse\n * and acts as a bridge between motion values and removeAxisDelta\n */\nfunction removeBoxTransforms(box, transforms, originBox, sourceBox) {\n    removeAxisTransforms(box.x, transforms, xKeys, originBox === null || originBox === void 0 ? void 0 : originBox.x, sourceBox === null || sourceBox === void 0 ? void 0 : sourceBox.x);\n    removeAxisTransforms(box.y, transforms, yKeys, originBox === null || originBox === void 0 ? void 0 : originBox.y, sourceBox === null || sourceBox === void 0 ? void 0 : sourceBox.y);\n}\n\nexport { removeAxisDelta, removeAxisTransforms, removeBoxTransforms, removePointDelta };\n","function isAxisDeltaZero(delta) {\n    return delta.translate === 0 && delta.scale === 1;\n}\nfunction isDeltaZero(delta) {\n    return isAxisDeltaZero(delta.x) && isAxisDeltaZero(delta.y);\n}\nfunction boxEquals(a, b) {\n    return (a.x.min === b.x.min &&\n        a.x.max === b.x.max &&\n        a.y.min === b.y.min &&\n        a.y.max === b.y.max);\n}\n\nexport { boxEquals, isDeltaZero };\n","import { addUniqueItem, removeItem } from '../../utils/array.mjs';\n\nvar NodeStack = /** @class */ (function () {\n    function NodeStack() {\n        this.members = [];\n    }\n    NodeStack.prototype.add = function (node) {\n        addUniqueItem(this.members, node);\n        node.scheduleRender();\n    };\n    NodeStack.prototype.remove = function (node) {\n        removeItem(this.members, node);\n        if (node === this.prevLead) {\n            this.prevLead = undefined;\n        }\n        if (node === this.lead) {\n            var prevLead = this.members[this.members.length - 1];\n            if (prevLead) {\n                this.promote(prevLead);\n            }\n        }\n    };\n    NodeStack.prototype.relegate = function (node) {\n        var indexOfNode = this.members.findIndex(function (member) { return node === member; });\n        if (indexOfNode === 0)\n            return false;\n        /**\n         * Find the next projection node that is present\n         */\n        var prevLead;\n        for (var i = indexOfNode; i >= 0; i--) {\n            var member = this.members[i];\n            if (member.isPresent !== false) {\n                prevLead = member;\n                break;\n            }\n        }\n        if (prevLead) {\n            this.promote(prevLead);\n            return true;\n        }\n        else {\n            return false;\n        }\n    };\n    NodeStack.prototype.promote = function (node, preserveFollowOpacity) {\n        var _a;\n        var prevLead = this.lead;\n        if (node === prevLead)\n            return;\n        this.prevLead = prevLead;\n        this.lead = node;\n        node.show();\n        if (prevLead) {\n            prevLead.instance && prevLead.scheduleRender();\n            node.scheduleRender();\n            node.resumeFrom = prevLead;\n            if (preserveFollowOpacity) {\n                node.resumeFrom.preserveOpacity = true;\n            }\n            if (prevLead.snapshot) {\n                node.snapshot = prevLead.snapshot;\n                node.snapshot.latestValues =\n                    prevLead.animationValues || prevLead.latestValues;\n                node.snapshot.isShared = true;\n            }\n            if ((_a = node.root) === null || _a === void 0 ? void 0 : _a.isUpdating) {\n                node.isLayoutDirty = true;\n            }\n            var crossfade = node.options.crossfade;\n            if (crossfade === false) {\n                prevLead.hide();\n            }\n            /**\n             * TODO:\n             *   - Test border radius when previous node was deleted\n             *   - boxShadow mixing\n             *   - Shared between element A in scrolled container and element B (scroll stays the same or changes)\n             *   - Shared between element A in transformed container and element B (transform stays the same or changes)\n             *   - Shared between element A in scrolled page and element B (scroll stays the same or changes)\n             * ---\n             *   - Crossfade opacity of root nodes\n             *   - layoutId changes after animation\n             *   - layoutId changes mid animation\n             */\n        }\n    };\n    NodeStack.prototype.exitAnimationComplete = function () {\n        this.members.forEach(function (node) {\n            var _a, _b, _c, _d, _e;\n            (_b = (_a = node.options).onExitComplete) === null || _b === void 0 ? void 0 : _b.call(_a);\n            (_e = (_c = node.resumingFrom) === null || _c === void 0 ? void 0 : (_d = _c.options).onExitComplete) === null || _e === void 0 ? void 0 : _e.call(_d);\n        });\n    };\n    NodeStack.prototype.scheduleRender = function () {\n        this.members.forEach(function (node) {\n            node.instance && node.scheduleRender(false);\n        });\n    };\n    /**\n     * Clear any leads that have been removed this render to prevent them from being\n     * used in future animations and to prevent memory leaks\n     */\n    NodeStack.prototype.removeLeadSnapshot = function () {\n        if (this.lead && this.lead.snapshot) {\n            this.lead.snapshot = undefined;\n        }\n    };\n    return NodeStack;\n}());\n\nexport { NodeStack };\n","var identityProjection = \"translate3d(0px, 0px, 0) scale(1, 1)\";\nfunction buildProjectionTransform(delta, treeScale, latestTransform) {\n    /**\n     * The translations we use to calculate are always relative to the viewport coordinate space.\n     * But when we apply scales, we also scale the coordinate space of an element and its children.\n     * For instance if we have a treeScale (the culmination of all parent scales) of 0.5 and we need\n     * to move an element 100 pixels, we actually need to move it 200 in within that scaled space.\n     */\n    var xTranslate = delta.x.translate / treeScale.x;\n    var yTranslate = delta.y.translate / treeScale.y;\n    var transform = \"translate3d(\".concat(xTranslate, \"px, \").concat(yTranslate, \"px, 0) \");\n    if (latestTransform) {\n        var rotate = latestTransform.rotate, rotateX = latestTransform.rotateX, rotateY = latestTransform.rotateY;\n        if (rotate)\n            transform += \"rotate(\".concat(rotate, \"deg) \");\n        if (rotateX)\n            transform += \"rotateX(\".concat(rotateX, \"deg) \");\n        if (rotateY)\n            transform += \"rotateY(\".concat(rotateY, \"deg) \");\n    }\n    transform += \"scale(\".concat(delta.x.scale, \", \").concat(delta.y.scale, \")\");\n    return transform === identityProjection ? \"none\" : transform;\n}\n\nexport { buildProjectionTransform, identityProjection };\n","var compareByDepth = function (a, b) {\n    return a.depth - b.depth;\n};\n\nexport { compareByDepth };\n","import { addUniqueItem, removeItem } from '../../utils/array.mjs';\nimport { compareByDepth } from './compare-by-depth.mjs';\n\nvar FlatTree = /** @class */ (function () {\n    function FlatTree() {\n        this.children = [];\n        this.isDirty = false;\n    }\n    FlatTree.prototype.add = function (child) {\n        addUniqueItem(this.children, child);\n        this.isDirty = true;\n    };\n    FlatTree.prototype.remove = function (child) {\n        removeItem(this.children, child);\n        this.isDirty = true;\n    };\n    FlatTree.prototype.forEach = function (callback) {\n        this.isDirty && this.children.sort(compareByDepth);\n        this.isDirty = false;\n        this.children.forEach(callback);\n    };\n    return FlatTree;\n}());\n\nexport { FlatTree };\n","import { __spreadArray, __read, __assign } from 'tslib';\nimport sync, { cancelSync, flushSync } from 'framesync';\nimport { mix } from 'popmotion';\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 } 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 } 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 } from '../utils/has-transform.mjs';\nimport { transformAxes } from '../../render/html/utils/transform.mjs';\nimport { FlatTree } from '../../render/utils/flat-tree.mjs';\nimport { resolveMotionValue } from '../../value/utils/resolve-motion-value.mjs';\n\n/**\n * We use 1000 as the animation target as 0-1000 maps better to pixels than 0-1\n * which has a noticeable difference in spring animations\n */\nvar animationTarget = 1000;\n/**\n * This should only ever be modified on the client otherwise it'll\n * persist through server requests. If we need instanced states we\n * could lazy-init via root.\n */\nvar globalProjectionState = {\n    /**\n     * Global flag as to whether the tree has animated since the last time\n     * we resized the window\n     */\n    hasAnimatedSinceResize: true,\n    /**\n     * We set this to true once, on the first update. Any nodes added to the tree beyond that\n     * update will be given a `data-projection-id` attribute.\n     */\n    hasEverUpdated: false,\n};\nfunction createProjectionNode(_a) {\n    var attachResizeListener = _a.attachResizeListener, defaultParent = _a.defaultParent, measureScroll = _a.measureScroll, resetTransform = _a.resetTransform;\n    return /** @class */ (function () {\n        function ProjectionNode(id, latestValues, parent) {\n            var _this = this;\n            if (latestValues === void 0) { latestValues = {}; }\n            if (parent === void 0) { parent = defaultParent === null || defaultParent === void 0 ? void 0 : defaultParent(); }\n            /**\n             * A Set containing all this component's children. This is used to iterate\n             * through the children.\n             *\n             * TODO: This could be faster to iterate as a flat array stored on the root node.\n             */\n            this.children = new Set();\n            /**\n             * Options for the node. We use this to configure what kind of layout animations\n             * we should perform (if any).\n             */\n            this.options = {};\n            /**\n             * We use this to detect when its safe to shut down part of a projection tree.\n             * We have to keep projecting children for scale correction and relative projection\n             * until all their parents stop performing layout animations.\n             */\n            this.isTreeAnimating = false;\n            this.isAnimationBlocked = false;\n            /**\n             * Flag to true if we think this layout has been changed. We can't always know this,\n             * currently we set it to true every time a component renders, or if it has a layoutDependency\n             * if that has changed between renders. Additionally, components can be grouped by LayoutGroup\n             * and if one node is dirtied, they all are.\n             */\n            this.isLayoutDirty = false;\n            /**\n             * Block layout updates for instant layout transitions throughout the tree.\n             */\n            this.updateManuallyBlocked = false;\n            this.updateBlockedByResize = false;\n            /**\n             * Set to true between the start of the first `willUpdate` call and the end of the `didUpdate`\n             * call.\n             */\n            this.isUpdating = false;\n            /**\n             * If this is an SVG element we currently disable projection transforms\n             */\n            this.isSVG = false;\n            /**\n             * Flag to true (during promotion) if a node doing an instant layout transition needs to reset\n             * its projection styles.\n             */\n            this.needsReset = false;\n            /**\n             * Flags whether this node should have its transform reset prior to measuring.\n             */\n            this.shouldResetTransform = false;\n            /**\n             * An object representing the calculated contextual/accumulated/tree scale.\n             * This will be used to scale calculcated projection transforms, as these are\n             * calculated in screen-space but need to be scaled for elements to actually\n             * make it to their calculated destinations.\n             *\n             * TODO: Lazy-init\n             */\n            this.treeScale = { x: 1, y: 1 };\n            /**\n             *\n             */\n            this.eventHandlers = new Map();\n            // Note: Currently only running on root node\n            this.potentialNodes = new Map();\n            this.checkUpdateFailed = function () {\n                if (_this.isUpdating) {\n                    _this.isUpdating = false;\n                    _this.clearAllSnapshots();\n                }\n            };\n            this.updateProjection = function () {\n                _this.nodes.forEach(resolveTargetDelta);\n                _this.nodes.forEach(calcProjection);\n            };\n            this.hasProjected = false;\n            this.isVisible = true;\n            this.animationProgress = 0;\n            /**\n             * Shared layout\n             */\n            // TODO Only running on root node\n            this.sharedNodes = new Map();\n            this.id = id;\n            this.latestValues = latestValues;\n            this.root = parent ? parent.root || parent : this;\n            this.path = parent ? __spreadArray(__spreadArray([], __read(parent.path), false), [parent], false) : [];\n            this.parent = parent;\n            this.depth = parent ? parent.depth + 1 : 0;\n            id && this.root.registerPotentialNode(id, this);\n            for (var i = 0; i < this.path.length; i++) {\n                this.path[i].shouldResetTransform = true;\n            }\n            if (this.root === this)\n                this.nodes = new FlatTree();\n        }\n        ProjectionNode.prototype.addEventListener = function (name, handler) {\n            if (!this.eventHandlers.has(name)) {\n                this.eventHandlers.set(name, new SubscriptionManager());\n            }\n            return this.eventHandlers.get(name).add(handler);\n        };\n        ProjectionNode.prototype.notifyListeners = function (name) {\n            var args = [];\n            for (var _i = 1; _i < arguments.length; _i++) {\n                args[_i - 1] = arguments[_i];\n            }\n            var subscriptionManager = this.eventHandlers.get(name);\n            subscriptionManager === null || subscriptionManager === void 0 ? void 0 : subscriptionManager.notify.apply(subscriptionManager, __spreadArray([], __read(args), false));\n        };\n        ProjectionNode.prototype.hasListeners = function (name) {\n            return this.eventHandlers.has(name);\n        };\n        ProjectionNode.prototype.registerPotentialNode = function (id, node) {\n            this.potentialNodes.set(id, node);\n        };\n        /**\n         * Lifecycles\n         */\n        ProjectionNode.prototype.mount = function (instance, isLayoutDirty) {\n            var _this = this;\n            var _a;\n            if (isLayoutDirty === void 0) { isLayoutDirty = false; }\n            if (this.instance)\n                return;\n            this.isSVG =\n                instance instanceof SVGElement && instance.tagName !== \"svg\";\n            this.instance = instance;\n            var _b = this.options, layoutId = _b.layoutId, layout = _b.layout, visualElement = _b.visualElement;\n            if (visualElement && !visualElement.getInstance()) {\n                visualElement.mount(instance);\n            }\n            this.root.nodes.add(this);\n            (_a = this.parent) === null || _a === void 0 ? void 0 : _a.children.add(this);\n            this.id && this.root.potentialNodes.delete(this.id);\n            if (isLayoutDirty && (layout || layoutId)) {\n                this.isLayoutDirty = true;\n            }\n            if (attachResizeListener) {\n                var unblockTimeout_1;\n                var resizeUnblockUpdate_1 = function () {\n                    return (_this.root.updateBlockedByResize = false);\n                };\n                attachResizeListener(instance, function () {\n                    _this.root.updateBlockedByResize = true;\n                    clearTimeout(unblockTimeout_1);\n                    unblockTimeout_1 = window.setTimeout(resizeUnblockUpdate_1, 250);\n                    if (globalProjectionState.hasAnimatedSinceResize) {\n                        globalProjectionState.hasAnimatedSinceResize = false;\n                        _this.nodes.forEach(finishAnimation);\n                    }\n                });\n            }\n            if (layoutId) {\n                this.root.registerSharedNode(layoutId, this);\n            }\n            // Only register the handler if it requires layout animation\n            if (this.options.animate !== false &&\n                visualElement &&\n                (layoutId || layout)) {\n                this.addEventListener(\"didUpdate\", function (_a) {\n                    var _b, _c, _d, _e, _f;\n                    var delta = _a.delta, hasLayoutChanged = _a.hasLayoutChanged, hasRelativeTargetChanged = _a.hasRelativeTargetChanged, newLayout = _a.layout;\n                    if (_this.isTreeAnimationBlocked()) {\n                        _this.target = undefined;\n                        _this.relativeTarget = undefined;\n                        return;\n                    }\n                    // TODO: Check here if an animation exists\n                    var layoutTransition = (_c = (_b = _this.options.transition) !== null && _b !== void 0 ? _b : visualElement.getDefaultTransition()) !== null && _c !== void 0 ? _c : defaultLayoutTransition;\n                    var onLayoutAnimationComplete = visualElement.getProps().onLayoutAnimationComplete;\n                    /**\n                     * The target layout of the element might stay the same,\n                     * but its position relative to its parent has changed.\n                     */\n                    var targetChanged = !_this.targetLayout ||\n                        !boxEquals(_this.targetLayout, newLayout) ||\n                        hasRelativeTargetChanged;\n                    /**\n                     * If the layout hasn't seemed to have changed, it might be that the\n                     * element is visually in the same place in the document but its position\n                     * relative to its parent has indeed changed. So here we check for that.\n                     */\n                    var hasOnlyRelativeTargetChanged = !hasLayoutChanged && hasRelativeTargetChanged;\n                    if (((_d = _this.resumeFrom) === null || _d === void 0 ? void 0 : _d.instance) ||\n                        hasOnlyRelativeTargetChanged ||\n                        (hasLayoutChanged &&\n                            (targetChanged || !_this.currentAnimation))) {\n                        if (_this.resumeFrom) {\n                            _this.resumingFrom = _this.resumeFrom;\n                            _this.resumingFrom.resumingFrom = undefined;\n                        }\n                        _this.setAnimationOrigin(delta, hasOnlyRelativeTargetChanged);\n                        var animationOptions = __assign(__assign({}, getValueTransition(layoutTransition, \"layout\")), { onComplete: onLayoutAnimationComplete });\n                        if (visualElement.shouldReduceMotion) {\n                            animationOptions.delay = 0;\n                            animationOptions.type = false;\n                        }\n                        _this.startAnimation(animationOptions);\n                    }\n                    else {\n                        /**\n                         * If the layout hasn't changed and we have an animation that hasn't started yet,\n                         * finish it immediately. Otherwise it will be animating from a location\n                         * that was probably never commited to screen and look like a jumpy box.\n                         */\n                        if (!hasLayoutChanged &&\n                            _this.animationProgress === 0) {\n                            _this.finishAnimation();\n                        }\n                        _this.isLead() && ((_f = (_e = _this.options).onExitComplete) === null || _f === void 0 ? void 0 : _f.call(_e));\n                    }\n                    _this.targetLayout = newLayout;\n                });\n            }\n        };\n        ProjectionNode.prototype.unmount = function () {\n            var _a, _b;\n            this.options.layoutId && this.willUpdate();\n            this.root.nodes.remove(this);\n            (_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.remove(this);\n            (_b = this.parent) === null || _b === void 0 ? void 0 : _b.children.delete(this);\n            this.instance = undefined;\n            cancelSync.preRender(this.updateProjection);\n        };\n        // only on the root\n        ProjectionNode.prototype.blockUpdate = function () {\n            this.updateManuallyBlocked = true;\n        };\n        ProjectionNode.prototype.unblockUpdate = function () {\n            this.updateManuallyBlocked = false;\n        };\n        ProjectionNode.prototype.isUpdateBlocked = function () {\n            return this.updateManuallyBlocked || this.updateBlockedByResize;\n        };\n        ProjectionNode.prototype.isTreeAnimationBlocked = function () {\n            var _a;\n            return (this.isAnimationBlocked ||\n                ((_a = this.parent) === null || _a === void 0 ? void 0 : _a.isTreeAnimationBlocked()) ||\n                false);\n        };\n        // Note: currently only running on root node\n        ProjectionNode.prototype.startUpdate = function () {\n            var _a;\n            if (this.isUpdateBlocked())\n                return;\n            this.isUpdating = true;\n            (_a = this.nodes) === null || _a === void 0 ? void 0 : _a.forEach(resetRotation);\n        };\n        ProjectionNode.prototype.willUpdate = function (shouldNotifyListeners) {\n            var _a, _b, _c;\n            if (shouldNotifyListeners === void 0) { shouldNotifyListeners = true; }\n            if (this.root.isUpdateBlocked()) {\n                (_b = (_a = this.options).onExitComplete) === null || _b === void 0 ? void 0 : _b.call(_a);\n                return;\n            }\n            !this.root.isUpdating && this.root.startUpdate();\n            if (this.isLayoutDirty)\n                return;\n            this.isLayoutDirty = true;\n            for (var i = 0; i < this.path.length; i++) {\n                var node = this.path[i];\n                node.shouldResetTransform = true;\n                /**\n                 * TODO: Check we haven't updated the scroll\n                 * since the last didUpdate\n                 */\n                node.updateScroll();\n            }\n            var _d = this.options, layoutId = _d.layoutId, layout = _d.layout;\n            if (layoutId === undefined && !layout)\n                return;\n            var transformTemplate = (_c = this.options.visualElement) === null || _c === void 0 ? void 0 : _c.getProps().transformTemplate;\n            this.prevTransformTemplateValue = transformTemplate === null || transformTemplate === void 0 ? void 0 : transformTemplate(this.latestValues, \"\");\n            this.updateSnapshot();\n            shouldNotifyListeners && this.notifyListeners(\"willUpdate\");\n        };\n        // Note: Currently only running on root node\n        ProjectionNode.prototype.didUpdate = function () {\n            var updateWasBlocked = this.isUpdateBlocked();\n            // When doing an instant transition, we skip the layout update,\n            // but should still clean up the measurements so that the next\n            // snapshot could be taken correctly.\n            if (updateWasBlocked) {\n                this.unblockUpdate();\n                this.clearAllSnapshots();\n                this.nodes.forEach(clearMeasurements);\n                return;\n            }\n            if (!this.isUpdating)\n                return;\n            this.isUpdating = false;\n            /**\n             * Search for and mount newly-added projection elements.\n             *\n             * TODO: Every time a new component is rendered we could search up the tree for\n             * the closest mounted node and query from there rather than document.\n             */\n            if (this.potentialNodes.size) {\n                this.potentialNodes.forEach(mountNodeEarly);\n                this.potentialNodes.clear();\n            }\n            /**\n             * Write\n             */\n            this.nodes.forEach(resetTransformStyle);\n            /**\n             * Read ==================\n             */\n            // Update layout measurements of updated children\n            this.nodes.forEach(updateLayout);\n            /**\n             * Write\n             */\n            // Notify listeners that the layout is updated\n            this.nodes.forEach(notifyLayoutUpdate);\n            this.clearAllSnapshots();\n            // Flush any scheduled updates\n            flushSync.update();\n            flushSync.preRender();\n            flushSync.render();\n        };\n        ProjectionNode.prototype.clearAllSnapshots = function () {\n            this.nodes.forEach(clearSnapshot);\n            this.sharedNodes.forEach(removeLeadSnapshots);\n        };\n        ProjectionNode.prototype.scheduleUpdateProjection = function () {\n            sync.preRender(this.updateProjection, false, true);\n        };\n        ProjectionNode.prototype.scheduleCheckAfterUnmount = function () {\n            var _this = this;\n            /**\n             * If the unmounting node is in a layoutGroup and did trigger a willUpdate,\n             * we manually call didUpdate to give a chance to the siblings to animate.\n             * Otherwise, cleanup all snapshots to prevents future nodes from reusing them.\n             */\n            sync.postRender(function () {\n                if (_this.isLayoutDirty) {\n                    _this.root.didUpdate();\n                }\n                else {\n                    _this.root.checkUpdateFailed();\n                }\n            });\n        };\n        /**\n         * Update measurements\n         */\n        ProjectionNode.prototype.updateSnapshot = function () {\n            if (this.snapshot || !this.instance)\n                return;\n            var measured = this.measure();\n            var layout = this.removeTransform(this.removeElementScroll(measured));\n            roundBox(layout);\n            this.snapshot = {\n                measured: measured,\n                layout: layout,\n                latestValues: {},\n            };\n        };\n        ProjectionNode.prototype.updateLayout = function () {\n            var _a;\n            if (!this.instance)\n                return;\n            // TODO: Incorporate into a forwarded scroll offset\n            this.updateScroll();\n            if (!(this.options.alwaysMeasureLayout && this.isLead()) &&\n                !this.isLayoutDirty) {\n                return;\n            }\n            /**\n             * When a node is mounted, it simply resumes from the prevLead's\n             * snapshot instead of taking a new one, but the ancestors scroll\n             * might have updated while the prevLead is unmounted. We need to\n             * update the scroll again to make sure the layout we measure is\n             * up to date.\n             */\n            if (this.resumeFrom && !this.resumeFrom.instance) {\n                for (var i = 0; i < this.path.length; i++) {\n                    var node = this.path[i];\n                    node.updateScroll();\n                }\n            }\n            var measured = this.measure();\n            roundBox(measured);\n            var prevLayout = this.layout;\n            this.layout = {\n                measured: measured,\n                actual: this.removeElementScroll(measured),\n            };\n            this.layoutCorrected = createBox();\n            this.isLayoutDirty = false;\n            this.projectionDelta = undefined;\n            this.notifyListeners(\"measure\", this.layout.actual);\n            (_a = this.options.visualElement) === null || _a === void 0 ? void 0 : _a.notifyLayoutMeasure(this.layout.actual, prevLayout === null || prevLayout === void 0 ? void 0 : prevLayout.actual);\n        };\n        ProjectionNode.prototype.updateScroll = function () {\n            if (this.options.layoutScroll && this.instance) {\n                this.scroll = measureScroll(this.instance);\n            }\n        };\n        ProjectionNode.prototype.resetTransform = function () {\n            var _a;\n            if (!resetTransform)\n                return;\n            var isResetRequested = this.isLayoutDirty || this.shouldResetTransform;\n            var hasProjection = this.projectionDelta && !isDeltaZero(this.projectionDelta);\n            var transformTemplate = (_a = this.options.visualElement) === null || _a === void 0 ? void 0 : _a.getProps().transformTemplate;\n            var transformTemplateValue = transformTemplate === null || transformTemplate === void 0 ? void 0 : transformTemplate(this.latestValues, \"\");\n            var transformTemplateHasChanged = transformTemplateValue !== this.prevTransformTemplateValue;\n            if (isResetRequested &&\n                (hasProjection ||\n                    hasTransform(this.latestValues) ||\n                    transformTemplateHasChanged)) {\n                resetTransform(this.instance, transformTemplateValue);\n                this.shouldResetTransform = false;\n                this.scheduleRender();\n            }\n        };\n        ProjectionNode.prototype.measure = function () {\n            var visualElement = this.options.visualElement;\n            if (!visualElement)\n                return createBox();\n            var box = visualElement.measureViewportBox();\n            // Remove viewport scroll to give page-relative coordinates\n            var scroll = this.root.scroll;\n            if (scroll) {\n                translateAxis(box.x, scroll.x);\n                translateAxis(box.y, scroll.y);\n            }\n            return box;\n        };\n        ProjectionNode.prototype.removeElementScroll = function (box) {\n            var boxWithoutScroll = createBox();\n            copyBoxInto(boxWithoutScroll, box);\n            /**\n             * Performance TODO: Keep a cumulative scroll offset down the tree\n             * rather than loop back up the path.\n             */\n            for (var i = 0; i < this.path.length; i++) {\n                var node = this.path[i];\n                var scroll_1 = node.scroll, options = node.options;\n                if (node !== this.root && scroll_1 && options.layoutScroll) {\n                    translateAxis(boxWithoutScroll.x, scroll_1.x);\n                    translateAxis(boxWithoutScroll.y, scroll_1.y);\n                }\n            }\n            return boxWithoutScroll;\n        };\n        ProjectionNode.prototype.applyTransform = function (box, transformOnly) {\n            if (transformOnly === void 0) { transformOnly = false; }\n            var withTransforms = createBox();\n            copyBoxInto(withTransforms, box);\n            for (var i = 0; i < this.path.length; i++) {\n                var node = this.path[i];\n                if (!transformOnly &&\n                    node.options.layoutScroll &&\n                    node.scroll &&\n                    node !== node.root) {\n                    transformBox(withTransforms, {\n                        x: -node.scroll.x,\n                        y: -node.scroll.y,\n                    });\n                }\n                if (!hasTransform(node.latestValues))\n                    continue;\n                transformBox(withTransforms, node.latestValues);\n            }\n            if (hasTransform(this.latestValues)) {\n                transformBox(withTransforms, this.latestValues);\n            }\n            return withTransforms;\n        };\n        ProjectionNode.prototype.removeTransform = function (box) {\n            var _a;\n            var boxWithoutTransform = createBox();\n            copyBoxInto(boxWithoutTransform, box);\n            for (var i = 0; i < this.path.length; i++) {\n                var node = this.path[i];\n                if (!node.instance)\n                    continue;\n                if (!hasTransform(node.latestValues))\n                    continue;\n                hasScale(node.latestValues) && node.updateSnapshot();\n                var sourceBox = createBox();\n                var nodeBox = node.measure();\n                copyBoxInto(sourceBox, nodeBox);\n                removeBoxTransforms(boxWithoutTransform, node.latestValues, (_a = node.snapshot) === null || _a === void 0 ? void 0 : _a.layout, sourceBox);\n            }\n            if (hasTransform(this.latestValues)) {\n                removeBoxTransforms(boxWithoutTransform, this.latestValues);\n            }\n            return boxWithoutTransform;\n        };\n        /**\n         *\n         */\n        ProjectionNode.prototype.setTargetDelta = function (delta) {\n            this.targetDelta = delta;\n            this.root.scheduleUpdateProjection();\n        };\n        ProjectionNode.prototype.setOptions = function (options) {\n            var _a;\n            this.options = __assign(__assign(__assign({}, this.options), options), { crossfade: (_a = options.crossfade) !== null && _a !== void 0 ? _a : true });\n        };\n        ProjectionNode.prototype.clearMeasurements = function () {\n            this.scroll = undefined;\n            this.layout = undefined;\n            this.snapshot = undefined;\n            this.prevTransformTemplateValue = undefined;\n            this.targetDelta = undefined;\n            this.target = undefined;\n            this.isLayoutDirty = false;\n        };\n        /**\n         * Frame calculations\n         */\n        ProjectionNode.prototype.resolveTargetDelta = function () {\n            var _a;\n            var _b = this.options, layout = _b.layout, layoutId = _b.layoutId;\n            /**\n             * If we have no layout, we can't perform projection, so early return\n             */\n            if (!this.layout || !(layout || layoutId))\n                return;\n            /**\n             * If we don't have a targetDelta but do have a layout, we can attempt to resolve\n             * a relativeParent. This will allow a component to perform scale correction\n             * even if no animation has started.\n             */\n            // TODO If this is unsuccessful this currently happens every frame\n            if (!this.targetDelta && !this.relativeTarget) {\n                // TODO: This is a semi-repetition of further down this function, make DRY\n                this.relativeParent = this.getClosestProjectingParent();\n                if (this.relativeParent && this.relativeParent.layout) {\n                    this.relativeTarget = createBox();\n                    this.relativeTargetOrigin = createBox();\n                    calcRelativePosition(this.relativeTargetOrigin, this.layout.actual, this.relativeParent.layout.actual);\n                    copyBoxInto(this.relativeTarget, this.relativeTargetOrigin);\n                }\n            }\n            /**\n             * If we have no relative target or no target delta our target isn't valid\n             * for this frame.\n             */\n            if (!this.relativeTarget && !this.targetDelta)\n                return;\n            /**\n             * Lazy-init target data structure\n             */\n            if (!this.target) {\n                this.target = createBox();\n                this.targetWithTransforms = createBox();\n            }\n            /**\n             * If we've got a relative box for this component, resolve it into a target relative to the parent.\n             */\n            if (this.relativeTarget &&\n                this.relativeTargetOrigin &&\n                ((_a = this.relativeParent) === null || _a === void 0 ? void 0 : _a.target)) {\n                calcRelativeBox(this.target, this.relativeTarget, this.relativeParent.target);\n                /**\n                 * If we've only got a targetDelta, resolve it into a target\n                 */\n            }\n            else if (this.targetDelta) {\n                if (Boolean(this.resumingFrom)) {\n                    // TODO: This is creating a new object every frame\n                    this.target = this.applyTransform(this.layout.actual);\n                }\n                else {\n                    copyBoxInto(this.target, this.layout.actual);\n                }\n                applyBoxDelta(this.target, this.targetDelta);\n            }\n            else {\n                /**\n                 * If no target, use own layout as target\n                 */\n                copyBoxInto(this.target, this.layout.actual);\n            }\n            /**\n             * If we've been told to attempt to resolve a relative target, do so.\n             */\n            if (this.attemptToResolveRelativeTarget) {\n                this.attemptToResolveRelativeTarget = false;\n                this.relativeParent = this.getClosestProjectingParent();\n                if (this.relativeParent &&\n                    Boolean(this.relativeParent.resumingFrom) ===\n                        Boolean(this.resumingFrom) &&\n                    !this.relativeParent.options.layoutScroll &&\n                    this.relativeParent.target) {\n                    this.relativeTarget = createBox();\n                    this.relativeTargetOrigin = createBox();\n                    calcRelativePosition(this.relativeTargetOrigin, this.target, this.relativeParent.target);\n                    copyBoxInto(this.relativeTarget, this.relativeTargetOrigin);\n                }\n            }\n        };\n        ProjectionNode.prototype.getClosestProjectingParent = function () {\n            if (!this.parent || hasTransform(this.parent.latestValues))\n                return undefined;\n            if ((this.parent.relativeTarget || this.parent.targetDelta) &&\n                this.parent.layout) {\n                return this.parent;\n            }\n            else {\n                return this.parent.getClosestProjectingParent();\n            }\n        };\n        ProjectionNode.prototype.calcProjection = function () {\n            var _a;\n            var _b = this.options, layout = _b.layout, layoutId = _b.layoutId;\n            /**\n             * If this section of the tree isn't animating we can\n             * delete our target sources for the following frame.\n             */\n            this.isTreeAnimating = Boolean(((_a = this.parent) === null || _a === void 0 ? void 0 : _a.isTreeAnimating) ||\n                this.currentAnimation ||\n                this.pendingAnimation);\n            if (!this.isTreeAnimating) {\n                this.targetDelta = this.relativeTarget = undefined;\n            }\n            if (!this.layout || !(layout || layoutId))\n                return;\n            var lead = this.getLead();\n            /**\n             * Reset the corrected box with the latest values from box, as we're then going\n             * to perform mutative operations on it.\n             */\n            copyBoxInto(this.layoutCorrected, this.layout.actual);\n            /**\n             * Apply all the parent deltas to this box to produce the corrected box. This\n             * is the layout box, as it will appear on screen as a result of the transforms of its parents.\n             */\n            applyTreeDeltas(this.layoutCorrected, this.treeScale, this.path, Boolean(this.resumingFrom) || this !== lead);\n            var target = lead.target;\n            if (!target)\n                return;\n            if (!this.projectionDelta) {\n                this.projectionDelta = createDelta();\n                this.projectionDeltaWithTransform = createDelta();\n            }\n            var prevTreeScaleX = this.treeScale.x;\n            var prevTreeScaleY = this.treeScale.y;\n            var prevProjectionTransform = this.projectionTransform;\n            /**\n             * Update the delta between the corrected box and the target box before user-set transforms were applied.\n             * This will allow us to calculate the corrected borderRadius and boxShadow to compensate\n             * for our layout reprojection, but still allow them to be scaled correctly by the user.\n             * It might be that to simplify this we may want to accept that user-set scale is also corrected\n             * and we wouldn't have to keep and calc both deltas, OR we could support a user setting\n             * to allow people to choose whether these styles are corrected based on just the\n             * layout reprojection or the final bounding box.\n             */\n            calcBoxDelta(this.projectionDelta, this.layoutCorrected, target, this.latestValues);\n            this.projectionTransform = buildProjectionTransform(this.projectionDelta, this.treeScale);\n            if (this.projectionTransform !== prevProjectionTransform ||\n                this.treeScale.x !== prevTreeScaleX ||\n                this.treeScale.y !== prevTreeScaleY) {\n                this.hasProjected = true;\n                this.scheduleRender();\n                this.notifyListeners(\"projectionUpdate\", target);\n            }\n        };\n        ProjectionNode.prototype.hide = function () {\n            this.isVisible = false;\n            // TODO: Schedule render\n        };\n        ProjectionNode.prototype.show = function () {\n            this.isVisible = true;\n            // TODO: Schedule render\n        };\n        ProjectionNode.prototype.scheduleRender = function (notifyAll) {\n            var _a, _b, _c;\n            if (notifyAll === void 0) { notifyAll = true; }\n            (_b = (_a = this.options).scheduleRender) === null || _b === void 0 ? void 0 : _b.call(_a);\n            notifyAll && ((_c = this.getStack()) === null || _c === void 0 ? void 0 : _c.scheduleRender());\n            if (this.resumingFrom && !this.resumingFrom.instance) {\n                this.resumingFrom = undefined;\n            }\n        };\n        ProjectionNode.prototype.setAnimationOrigin = function (delta, hasOnlyRelativeTargetChanged) {\n            var _this = this;\n            var _a;\n            if (hasOnlyRelativeTargetChanged === void 0) { hasOnlyRelativeTargetChanged = false; }\n            var snapshot = this.snapshot;\n            var snapshotLatestValues = (snapshot === null || snapshot === void 0 ? void 0 : snapshot.latestValues) || {};\n            var mixedValues = __assign({}, this.latestValues);\n            var targetDelta = createDelta();\n            this.relativeTarget = this.relativeTargetOrigin = undefined;\n            this.attemptToResolveRelativeTarget = !hasOnlyRelativeTargetChanged;\n            var relativeLayout = createBox();\n            var isSharedLayoutAnimation = snapshot === null || snapshot === void 0 ? void 0 : snapshot.isShared;\n            var isOnlyMember = (((_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.members.length) || 0) <= 1;\n            var shouldCrossfadeOpacity = Boolean(isSharedLayoutAnimation &&\n                !isOnlyMember &&\n                this.options.crossfade === true &&\n                !this.path.some(hasOpacityCrossfade));\n            this.animationProgress = 0;\n            this.mixTargetDelta = function (latest) {\n                var _a;\n                var progress = latest / 1000;\n                mixAxisDelta(targetDelta.x, delta.x, progress);\n                mixAxisDelta(targetDelta.y, delta.y, progress);\n                _this.setTargetDelta(targetDelta);\n                if (_this.relativeTarget &&\n                    _this.relativeTargetOrigin &&\n                    _this.layout &&\n                    ((_a = _this.relativeParent) === null || _a === void 0 ? void 0 : _a.layout)) {\n                    calcRelativePosition(relativeLayout, _this.layout.actual, _this.relativeParent.layout.actual);\n                    mixBox(_this.relativeTarget, _this.relativeTargetOrigin, relativeLayout, progress);\n                }\n                if (isSharedLayoutAnimation) {\n                    _this.animationValues = mixedValues;\n                    mixValues(mixedValues, snapshotLatestValues, _this.latestValues, progress, shouldCrossfadeOpacity, isOnlyMember);\n                }\n                _this.root.scheduleUpdateProjection();\n                _this.scheduleRender();\n                _this.animationProgress = progress;\n            };\n            this.mixTargetDelta(0);\n        };\n        ProjectionNode.prototype.startAnimation = function (options) {\n            var _this = this;\n            var _a, _b;\n            (_a = this.currentAnimation) === null || _a === void 0 ? void 0 : _a.stop();\n            if (this.resumingFrom) {\n                (_b = this.resumingFrom.currentAnimation) === null || _b === void 0 ? void 0 : _b.stop();\n            }\n            if (this.pendingAnimation) {\n                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(function () {\n                globalProjectionState.hasAnimatedSinceResize = true;\n                _this.currentAnimation = animate(0, animationTarget, __assign(__assign({}, options), { onUpdate: function (latest) {\n                        var _a;\n                        _this.mixTargetDelta(latest);\n                        (_a = options.onUpdate) === null || _a === void 0 ? void 0 : _a.call(options, latest);\n                    }, onComplete: function () {\n                        var _a;\n                        (_a = options.onComplete) === null || _a === void 0 ? void 0 : _a.call(options);\n                        _this.completeAnimation();\n                    } }));\n                if (_this.resumingFrom) {\n                    _this.resumingFrom.currentAnimation = _this.currentAnimation;\n                }\n                _this.pendingAnimation = undefined;\n            });\n        };\n        ProjectionNode.prototype.completeAnimation = function () {\n            var _a;\n            if (this.resumingFrom) {\n                this.resumingFrom.currentAnimation = undefined;\n                this.resumingFrom.preserveOpacity = undefined;\n            }\n            (_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.exitAnimationComplete();\n            this.resumingFrom =\n                this.currentAnimation =\n                    this.animationValues =\n                        undefined;\n            this.notifyListeners(\"animationComplete\");\n        };\n        ProjectionNode.prototype.finishAnimation = function () {\n            var _a;\n            if (this.currentAnimation) {\n                (_a = this.mixTargetDelta) === null || _a === void 0 ? void 0 : _a.call(this, animationTarget);\n                this.currentAnimation.stop();\n            }\n            this.completeAnimation();\n        };\n        ProjectionNode.prototype.applyTransformsToTarget = function () {\n            var _a = this.getLead(), targetWithTransforms = _a.targetWithTransforms, target = _a.target, layout = _a.layout, latestValues = _a.latestValues;\n            if (!targetWithTransforms || !target || !layout)\n                return;\n            copyBoxInto(targetWithTransforms, target);\n            /**\n             * Apply the latest user-set transforms to the targetBox to produce the targetBoxFinal.\n             * This is the final box that we will then project into by calculating a transform delta and\n             * applying it to the corrected box.\n             */\n            transformBox(targetWithTransforms, latestValues);\n            /**\n             * Update the delta between the corrected box and the final target box, after\n             * user-set transforms are applied to it. This will be used by the renderer to\n             * create a transform style that will reproject the element from its actual layout\n             * into the desired bounding box.\n             */\n            calcBoxDelta(this.projectionDeltaWithTransform, this.layoutCorrected, targetWithTransforms, latestValues);\n        };\n        ProjectionNode.prototype.registerSharedNode = function (layoutId, node) {\n            var _a, _b, _c;\n            if (!this.sharedNodes.has(layoutId)) {\n                this.sharedNodes.set(layoutId, new NodeStack());\n            }\n            var stack = this.sharedNodes.get(layoutId);\n            stack.add(node);\n            node.promote({\n                transition: (_a = node.options.initialPromotionConfig) === null || _a === void 0 ? void 0 : _a.transition,\n                preserveFollowOpacity: (_c = (_b = node.options.initialPromotionConfig) === null || _b === void 0 ? void 0 : _b.shouldPreserveFollowOpacity) === null || _c === void 0 ? void 0 : _c.call(_b, node),\n            });\n        };\n        ProjectionNode.prototype.isLead = function () {\n            var stack = this.getStack();\n            return stack ? stack.lead === this : true;\n        };\n        ProjectionNode.prototype.getLead = function () {\n            var _a;\n            var layoutId = this.options.layoutId;\n            return layoutId ? ((_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.lead) || this : this;\n        };\n        ProjectionNode.prototype.getPrevLead = function () {\n            var _a;\n            var layoutId = this.options.layoutId;\n            return layoutId ? (_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.prevLead : undefined;\n        };\n        ProjectionNode.prototype.getStack = function () {\n            var layoutId = this.options.layoutId;\n            if (layoutId)\n                return this.root.sharedNodes.get(layoutId);\n        };\n        ProjectionNode.prototype.promote = function (_a) {\n            var _b = _a === void 0 ? {} : _a, needsReset = _b.needsReset, transition = _b.transition, preserveFollowOpacity = _b.preserveFollowOpacity;\n            var stack = this.getStack();\n            if (stack)\n                stack.promote(this, preserveFollowOpacity);\n            if (needsReset) {\n                this.projectionDelta = undefined;\n                this.needsReset = true;\n            }\n            if (transition)\n                this.setOptions({ transition: transition });\n        };\n        ProjectionNode.prototype.relegate = function () {\n            var stack = this.getStack();\n            if (stack) {\n                return stack.relegate(this);\n            }\n            else {\n                return false;\n            }\n        };\n        ProjectionNode.prototype.resetRotation = function () {\n            var visualElement = this.options.visualElement;\n            if (!visualElement)\n                return;\n            // If there's no detected rotation values, we can early return without a forced render.\n            var hasRotate = false;\n            // Keep a record of all the values we've reset\n            var resetValues = {};\n            // Check the rotate value of all axes and reset to 0\n            for (var i = 0; i < transformAxes.length; i++) {\n                var axis = transformAxes[i];\n                var key = \"rotate\" + axis;\n                // If this rotation doesn't exist as a motion value, then we don't\n                // need to reset it\n                if (!visualElement.getStaticValue(key)) {\n                    continue;\n                }\n                hasRotate = true;\n                // Record the rotation and then temporarily set it to 0\n                resetValues[key] = visualElement.getStaticValue(key);\n                visualElement.setStaticValue(key, 0);\n            }\n            // If there's no rotation values, we don't need to do any more.\n            if (!hasRotate)\n                return;\n            // Force a render of this element to apply the transform with all rotations\n            // set to 0.\n            visualElement === null || visualElement === void 0 ? void 0 : visualElement.syncRender();\n            // Put back all the values we reset\n            for (var key in resetValues) {\n                visualElement.setStaticValue(key, resetValues[key]);\n            }\n            // Schedule a render for the next frame. This ensures we won't visually\n            // see the element with the reset rotate value applied.\n            visualElement.scheduleRender();\n        };\n        ProjectionNode.prototype.getProjectionStyles = function (styleProp) {\n            var _a, _b, _c, _d, _e, _f;\n            if (styleProp === void 0) { styleProp = {}; }\n            // TODO: Return lifecycle-persistent object\n            var styles = {};\n            if (!this.instance || this.isSVG)\n                return styles;\n            if (!this.isVisible) {\n                return { visibility: \"hidden\" };\n            }\n            else {\n                styles.visibility = \"\";\n            }\n            var transformTemplate = (_a = this.options.visualElement) === null || _a === void 0 ? void 0 : _a.getProps().transformTemplate;\n            if (this.needsReset) {\n                this.needsReset = false;\n                styles.opacity = \"\";\n                styles.pointerEvents =\n                    resolveMotionValue(styleProp.pointerEvents) || \"\";\n                styles.transform = transformTemplate\n                    ? transformTemplate(this.latestValues, \"\")\n                    : \"none\";\n                return styles;\n            }\n            var lead = this.getLead();\n            if (!this.projectionDelta || !this.layout || !lead.target) {\n                var emptyStyles = {};\n                if (this.options.layoutId) {\n                    emptyStyles.opacity = (_b = this.latestValues.opacity) !== null && _b !== void 0 ? _b : 1;\n                    emptyStyles.pointerEvents =\n                        resolveMotionValue(styleProp.pointerEvents) || \"\";\n                }\n                if (this.hasProjected && !hasTransform(this.latestValues)) {\n                    emptyStyles.transform = transformTemplate\n                        ? transformTemplate({}, \"\")\n                        : \"none\";\n                    this.hasProjected = false;\n                }\n                return emptyStyles;\n            }\n            var valuesToRender = lead.animationValues || lead.latestValues;\n            this.applyTransformsToTarget();\n            styles.transform = buildProjectionTransform(this.projectionDeltaWithTransform, this.treeScale, valuesToRender);\n            if (transformTemplate) {\n                styles.transform = transformTemplate(valuesToRender, styles.transform);\n            }\n            var _g = this.projectionDelta, x = _g.x, y = _g.y;\n            styles.transformOrigin = \"\".concat(x.origin * 100, \"% \").concat(y.origin * 100, \"% 0\");\n            if (lead.animationValues) {\n                /**\n                 * If the lead component is animating, assign this either the entering/leaving\n                 * opacity\n                 */\n                styles.opacity =\n                    lead === this\n                        ? (_d = (_c = valuesToRender.opacity) !== null && _c !== void 0 ? _c : this.latestValues.opacity) !== null && _d !== void 0 ? _d : 1\n                        : this.preserveOpacity\n                            ? this.latestValues.opacity\n                            : valuesToRender.opacityExit;\n            }\n            else {\n                /**\n                 * Or we're not animating at all, set the lead component to its actual\n                 * opacity and other components to hidden.\n                 */\n                styles.opacity =\n                    lead === this\n                        ? (_e = valuesToRender.opacity) !== null && _e !== void 0 ? _e : \"\"\n                        : (_f = valuesToRender.opacityExit) !== null && _f !== void 0 ? _f : 0;\n            }\n            /**\n             * Apply scale correction\n             */\n            for (var key in scaleCorrectors) {\n                if (valuesToRender[key] === undefined)\n                    continue;\n                var _h = scaleCorrectors[key], correct = _h.correct, applyTo = _h.applyTo;\n                var corrected = correct(valuesToRender[key], lead);\n                if (applyTo) {\n                    var num = applyTo.length;\n                    for (var i = 0; i < num; i++) {\n                        styles[applyTo[i]] = corrected;\n                    }\n                }\n                else {\n                    styles[key] = corrected;\n                }\n            }\n            /**\n             * Disable pointer events on follow components. This is to ensure\n             * that if a follow component covers a lead component it doesn't block\n             * pointer events on the lead.\n             */\n            if (this.options.layoutId) {\n                styles.pointerEvents =\n                    lead === this\n                        ? resolveMotionValue(styleProp.pointerEvents) || \"\"\n                        : \"none\";\n            }\n            return styles;\n        };\n        ProjectionNode.prototype.clearSnapshot = function () {\n            this.resumeFrom = this.snapshot = undefined;\n        };\n        // Only run on root\n        ProjectionNode.prototype.resetTree = function () {\n            this.root.nodes.forEach(function (node) { var _a; return (_a = node.currentAnimation) === null || _a === void 0 ? void 0 : _a.stop(); });\n            this.root.nodes.forEach(clearMeasurements);\n            this.root.sharedNodes.clear();\n        };\n        return ProjectionNode;\n    }());\n}\nfunction updateLayout(node) {\n    node.updateLayout();\n}\nfunction notifyLayoutUpdate(node) {\n    var _a, _b, _c, _d;\n    var snapshot = (_b = (_a = node.resumeFrom) === null || _a === void 0 ? void 0 : _a.snapshot) !== null && _b !== void 0 ? _b : node.snapshot;\n    if (node.isLead() &&\n        node.layout &&\n        snapshot &&\n        node.hasListeners(\"didUpdate\")) {\n        var _e = node.layout, layout_1 = _e.actual, measuredLayout = _e.measured;\n        // TODO Maybe we want to also resize the layout snapshot so we don't trigger\n        // animations for instance if layout=\"size\" and an element has only changed position\n        if (node.options.animationType === \"size\") {\n            eachAxis(function (axis) {\n                var axisSnapshot = snapshot.isShared\n                    ? snapshot.measured[axis]\n                    : snapshot.layout[axis];\n                var length = calcLength(axisSnapshot);\n                axisSnapshot.min = layout_1[axis].min;\n                axisSnapshot.max = axisSnapshot.min + length;\n            });\n        }\n        else if (node.options.animationType === \"position\") {\n            eachAxis(function (axis) {\n                var axisSnapshot = snapshot.isShared\n                    ? snapshot.measured[axis]\n                    : snapshot.layout[axis];\n                var length = calcLength(layout_1[axis]);\n                axisSnapshot.max = axisSnapshot.min + length;\n            });\n        }\n        var layoutDelta = createDelta();\n        calcBoxDelta(layoutDelta, layout_1, snapshot.layout);\n        var visualDelta = createDelta();\n        if (snapshot.isShared) {\n            calcBoxDelta(visualDelta, node.applyTransform(measuredLayout, true), snapshot.measured);\n        }\n        else {\n            calcBoxDelta(visualDelta, layout_1, snapshot.layout);\n        }\n        var hasLayoutChanged = !isDeltaZero(layoutDelta);\n        var hasRelativeTargetChanged = false;\n        if (!node.resumeFrom) {\n            node.relativeParent = node.getClosestProjectingParent();\n            /**\n             * If the relativeParent is itself resuming from a different element then\n             * the relative snapshot is not relavent\n             */\n            if (node.relativeParent && !node.relativeParent.resumeFrom) {\n                var _f = node.relativeParent, parentSnapshot = _f.snapshot, parentLayout = _f.layout;\n                if (parentSnapshot && parentLayout) {\n                    var relativeSnapshot = createBox();\n                    calcRelativePosition(relativeSnapshot, snapshot.layout, parentSnapshot.layout);\n                    var relativeLayout = createBox();\n                    calcRelativePosition(relativeLayout, layout_1, parentLayout.actual);\n                    if (!boxEquals(relativeSnapshot, relativeLayout)) {\n                        hasRelativeTargetChanged = true;\n                    }\n                }\n            }\n        }\n        node.notifyListeners(\"didUpdate\", {\n            layout: layout_1,\n            snapshot: snapshot,\n            delta: visualDelta,\n            layoutDelta: layoutDelta,\n            hasLayoutChanged: hasLayoutChanged,\n            hasRelativeTargetChanged: hasRelativeTargetChanged,\n        });\n    }\n    else if (node.isLead()) {\n        (_d = (_c = node.options).onExitComplete) === null || _d === void 0 ? void 0 : _d.call(_c);\n    }\n    /**\n     * Clearing transition\n     * TODO: Investigate why this transition is being passed in as {type: false } from Framer\n     * and why we need it at all\n     */\n    node.options.transition = undefined;\n}\nfunction clearSnapshot(node) {\n    node.clearSnapshot();\n}\nfunction clearMeasurements(node) {\n    node.clearMeasurements();\n}\nfunction resetTransformStyle(node) {\n    var visualElement = node.options.visualElement;\n    if (visualElement === null || visualElement === void 0 ? void 0 : visualElement.getProps().onBeforeLayoutMeasure) {\n        visualElement.notifyBeforeLayoutMeasure();\n    }\n    node.resetTransform();\n}\nfunction finishAnimation(node) {\n    node.finishAnimation();\n    node.targetDelta = node.relativeTarget = node.target = undefined;\n}\nfunction resolveTargetDelta(node) {\n    node.resolveTargetDelta();\n}\nfunction calcProjection(node) {\n    node.calcProjection();\n}\nfunction resetRotation(node) {\n    node.resetRotation();\n}\nfunction removeLeadSnapshots(stack) {\n    stack.removeLeadSnapshot();\n}\nfunction mixAxisDelta(output, delta, p) {\n    output.translate = 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}\nvar defaultLayoutTransition = {\n    duration: 0.45,\n    ease: [0.4, 0, 0.1, 1],\n};\nfunction mountNodeEarly(node, id) {\n    /**\n     * Rather than searching the DOM from document we can search the\n     * path for the deepest mounted ancestor and search from there\n     */\n    var searchNode = node.root;\n    for (var i = node.path.length - 1; i >= 0; i--) {\n        if (Boolean(node.path[i].instance)) {\n            searchNode = node.path[i];\n            break;\n        }\n    }\n    var searchElement = searchNode && searchNode !== node.root ? searchNode.instance : document;\n    var element = searchElement.querySelector(\"[data-projection-id=\\\"\".concat(id, \"\\\"]\"));\n    if (element)\n        node.mount(element, true);\n}\nfunction roundAxis(axis) {\n    axis.min = Math.round(axis.min);\n    axis.max = Math.round(axis.max);\n}\nfunction roundBox(box) {\n    roundAxis(box.x);\n    roundAxis(box.y);\n}\n\nexport { createProjectionNode, globalProjectionState, mixAxis, mixAxisDelta, mixBox };\n","import { motionValue } from '../value/index.mjs';\nimport { isMotionValue } from '../value/utils/is-motion-value.mjs';\nimport { startAnimation } from './utils/transitions.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    if (transition === void 0) { transition = {}; }\n    var value = isMotionValue(from) ? from : motionValue(from);\n    startAnimation(\"\", value, to, transition);\n    return {\n        stop: function () { return value.stop(); },\n        isAnimating: function () { return value.isAnimating(); },\n    };\n}\n\nexport { animate };\n","var scaleCorrectors = {};\nfunction addScaleCorrector(correctors) {\n    Object.assign(scaleCorrectors, correctors);\n}\n\nexport { addScaleCorrector, scaleCorrectors };\n","function eachAxis(callback) {\n    return [callback(\"x\"), callback(\"y\")];\n}\n\nexport { eachAxis };\n","function isIdentityScale(scale) {\n    return scale === undefined || scale === 1;\n}\nfunction hasScale(_a) {\n    var scale = _a.scale, scaleX = _a.scaleX, scaleY = _a.scaleY;\n    return (!isIdentityScale(scale) ||\n        !isIdentityScale(scaleX) ||\n        !isIdentityScale(scaleY));\n}\nfunction hasTransform(values) {\n    return (hasScale(values) ||\n        hasTranslate(values.x) ||\n        hasTranslate(values.y) ||\n        values.z ||\n        values.rotate ||\n        values.rotateX ||\n        values.rotateY);\n}\nfunction hasTranslate(value) {\n    return value && value !== \"0%\";\n}\n\nexport { hasScale, hasTransform };\n","var CAMEL_CASE_PATTERN = /([a-z])([A-Z])/g;\nvar REPLACE_TEMPLATE = \"$1-$2\";\n/**\n * Convert camelCase to dash-case properties.\n */\nvar camelToDash = function (str) {\n    return str.replace(CAMEL_CASE_PATTERN, REPLACE_TEMPLATE).toLowerCase();\n};\n\nexport { camelToDash };\n","/**\n * Returns true if the provided key is a CSS variable\n */\nfunction isCSSVariable(key) {\n    return key.startsWith(\"--\");\n}\n\nexport { isCSSVariable };\n","/**\n * We keep these listed seperately as we use the lowercase tag names as part\n * of the runtime bundle to detect SVG components\n */\nvar lowercaseSVGElements = [\n    \"animate\",\n    \"circle\",\n    \"defs\",\n    \"desc\",\n    \"ellipse\",\n    \"g\",\n    \"image\",\n    \"line\",\n    \"filter\",\n    \"marker\",\n    \"mask\",\n    \"metadata\",\n    \"path\",\n    \"pattern\",\n    \"polygon\",\n    \"polyline\",\n    \"rect\",\n    \"stop\",\n    \"svg\",\n    \"switch\",\n    \"symbol\",\n    \"text\",\n    \"tspan\",\n    \"use\",\n    \"view\",\n];\n\nexport { lowercaseSVGElements };\n","import { lowercaseSVGElements } from '../../svg/lowercase-elements.mjs';\n\nfunction isSVGComponent(Component) {\n    if (\n    /**\n     * If it's not a string, it's a custom React component. Currently we only support\n     * HTML custom React components.\n     */\n    typeof Component !== \"string\" ||\n        /**\n         * If it contains a dash, the element is a custom HTML webcomponent.\n         */\n        Component.includes(\"-\")) {\n        return false;\n    }\n    else if (\n    /**\n     * If it's in our list of lowercase SVG tags, it's an SVG component\n     */\n    lowercaseSVGElements.indexOf(Component) > -1 ||\n        /**\n         * If it contains a capital letter, it's an SVG component\n         */\n        /[A-Z]/.test(Component)) {\n        return true;\n    }\n    return false;\n}\n\nexport { isSVGComponent };\n","import { filter, complex } from 'style-value-types';\nimport { getDefaultValueType } from './defaults.mjs';\n\nfunction getAnimatableNone(key, value) {\n    var _a;\n    var 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 (_a = defaultValueType.getAnimatableNone) === null || _a === void 0 ? void 0 : _a.call(defaultValueType, value);\n}\n\nexport { getAnimatableNone };\n","import { __assign } from 'tslib';\nimport { color, filter } from 'style-value-types';\nimport { numberValueTypes } from './number.mjs';\n\n/**\n * A map of default value types for common values\n */\nvar defaultValueTypes = __assign(__assign({}, numberValueTypes), { \n    // Color props\n    color: color, backgroundColor: color, outlineColor: color, fill: color, stroke: color, \n    // Border props\n    borderColor: color, borderTopColor: color, borderRightColor: color, borderBottomColor: color, borderLeftColor: color, filter: filter, WebkitFilter: filter });\n/**\n * Gets the default ValueType for the provided value key\n */\nvar getDefaultValueType = function (key) { return defaultValueTypes[key]; };\n\nexport { defaultValueTypes, getDefaultValueType };\n","import { __assign } from 'tslib';\nimport { number } from 'style-value-types';\n\nvar int = __assign(__assign({}, number), { transform: Math.round });\n\nexport { int };\n","import { px, degrees, scale, alpha, progressPercentage } from 'style-value-types';\nimport { int } from './type-int.mjs';\n\nvar numberValueTypes = {\n    // Border props\n    borderWidth: px,\n    borderTopWidth: px,\n    borderRightWidth: px,\n    borderBottomWidth: px,\n    borderLeftWidth: px,\n    borderRadius: px,\n    radius: px,\n    borderTopLeftRadius: px,\n    borderTopRightRadius: px,\n    borderBottomRightRadius: px,\n    borderBottomLeftRadius: px,\n    // Positioning props\n    width: px,\n    maxWidth: px,\n    height: px,\n    maxHeight: px,\n    size: px,\n    top: px,\n    right: px,\n    bottom: px,\n    left: px,\n    // Spacing props\n    padding: px,\n    paddingTop: px,\n    paddingRight: px,\n    paddingBottom: px,\n    paddingLeft: px,\n    margin: px,\n    marginTop: px,\n    marginRight: px,\n    marginBottom: px,\n    marginLeft: px,\n    // Transform props\n    rotate: degrees,\n    rotateX: degrees,\n    rotateY: degrees,\n    rotateZ: degrees,\n    scale: scale,\n    scaleX: scale,\n    scaleY: scale,\n    scaleZ: scale,\n    skew: degrees,\n    skewX: degrees,\n    skewY: degrees,\n    distance: px,\n    translateX: px,\n    translateY: px,\n    translateZ: px,\n    x: px,\n    y: px,\n    z: px,\n    perspective: px,\n    transformPerspective: px,\n    opacity: alpha,\n    originX: progressPercentage,\n    originY: progressPercentage,\n    originZ: px,\n    // Misc\n    zIndex: int,\n    // SVG\n    fillOpacity: alpha,\n    strokeOpacity: alpha,\n    numOctaves: int,\n};\n\nexport { numberValueTypes };\n","import { sortTransformProps } from './transform.mjs';\n\nvar translateAlias = {\n    x: \"translateX\",\n    y: \"translateY\",\n    z: \"translateZ\",\n    transformPerspective: \"perspective\",\n};\n/**\n * Build a CSS transform style from individual x/y/scale etc properties.\n *\n * This outputs with a default order of transforms/scales/rotations, this can be customised by\n * providing a transformTemplate function.\n */\nfunction buildTransform(_a, _b, transformIsDefault, transformTemplate) {\n    var transform = _a.transform, transformKeys = _a.transformKeys;\n    var _c = _b.enableHardwareAcceleration, enableHardwareAcceleration = _c === void 0 ? true : _c, _d = _b.allowTransformNone, allowTransformNone = _d === void 0 ? true : _d;\n    // The transform string we're going to build into.\n    var transformString = \"\";\n    // Transform keys into their default order - this will determine the output order.\n    transformKeys.sort(sortTransformProps);\n    // Track whether the defined transform has a defined z so we don't add a\n    // second to enable hardware acceleration\n    var transformHasZ = false;\n    // Loop over each transform and build them into transformString\n    var numTransformKeys = transformKeys.length;\n    for (var i = 0; i < numTransformKeys; i++) {\n        var key = transformKeys[i];\n        transformString += \"\".concat(translateAlias[key] || key, \"(\").concat(transform[key], \") \");\n        if (key === \"z\")\n            transformHasZ = true;\n    }\n    if (!transformHasZ && enableHardwareAcceleration) {\n        transformString += \"translateZ(0)\";\n    }\n    else {\n        transformString = transformString.trim();\n    }\n    // If we have a custom `transform` template, pass our transform values and\n    // generated transformString to that before returning\n    if (transformTemplate) {\n        transformString = transformTemplate(transform, transformIsDefault ? \"\" : transformString);\n    }\n    else if (allowTransformNone && transformIsDefault) {\n        transformString = \"none\";\n    }\n    return transformString;\n}\n/**\n * Build a transformOrigin style. Uses the same defaults as the browser for\n * undefined origins.\n */\nfunction buildTransformOrigin(_a) {\n    var _b = _a.originX, originX = _b === void 0 ? \"50%\" : _b, _c = _a.originY, originY = _c === void 0 ? \"50%\" : _c, _d = _a.originZ, originZ = _d === void 0 ? 0 : _d;\n    return \"\".concat(originX, \" \").concat(originY, \" \").concat(originZ);\n}\n\nexport { buildTransform, buildTransformOrigin };\n","/**\n * Provided a value and a ValueType, returns the value as that value type.\n */\nvar getValueAsType = function (value, type) {\n    return type && typeof value === \"number\"\n        ? type.transform(value)\n        : value;\n};\n\nexport { getValueAsType };\n","import { buildTransform, buildTransformOrigin } from './build-transform.mjs';\nimport { isCSSVariable } from '../../dom/utils/is-css-variable.mjs';\nimport { isTransformProp, isTransformOriginProp } from './transform.mjs';\nimport { getValueAsType } from '../../dom/value-types/get-as-type.mjs';\nimport { numberValueTypes } from '../../dom/value-types/number.mjs';\n\nfunction buildHTMLStyles(state, latestValues, options, transformTemplate) {\n    var _a;\n    var style = state.style, vars = state.vars, transform = state.transform, transformKeys = state.transformKeys, transformOrigin = state.transformOrigin;\n    // Empty the transformKeys array. As we're throwing out refs to its items\n    // this might not be as cheap as suspected. Maybe using the array as a buffer\n    // with a manual incrementation would be better.\n    transformKeys.length = 0;\n    // Track whether we encounter any transform or transformOrigin values.\n    var hasTransform = false;\n    var hasTransformOrigin = false;\n    // Does the calculated transform essentially equal \"none\"?\n    var transformIsNone = true;\n    /**\n     * Loop over all our latest animated values and decide whether to handle them\n     * as a style or CSS variable.\n     *\n     * Transforms and transform origins are kept seperately for further processing.\n     */\n    for (var key in latestValues) {\n        var value = latestValues[key];\n        /**\n         * If this is a CSS variable we don't do any further processing.\n         */\n        if (isCSSVariable(key)) {\n            vars[key] = value;\n            continue;\n        }\n        // Convert the value to its default value type, ie 0 -> \"0px\"\n        var valueType = numberValueTypes[key];\n        var valueAsType = getValueAsType(value, valueType);\n        if (isTransformProp(key)) {\n            // If this is a transform, flag to enable further transform processing\n            hasTransform = true;\n            transform[key] = valueAsType;\n            transformKeys.push(key);\n            // If we already know we have a non-default transform, early return\n            if (!transformIsNone)\n                continue;\n            // Otherwise check to see if this is a default transform\n            if (value !== ((_a = valueType.default) !== null && _a !== void 0 ? _a : 0))\n                transformIsNone = false;\n        }\n        else if (isTransformOriginProp(key)) {\n            transformOrigin[key] = valueAsType;\n            // If this is a transform origin, flag and enable further transform-origin processing\n            hasTransformOrigin = true;\n        }\n        else {\n            style[key] = valueAsType;\n        }\n    }\n    if (hasTransform) {\n        style.transform = buildTransform(state, options, transformIsNone, transformTemplate);\n    }\n    else if (transformTemplate) {\n        style.transform = transformTemplate({}, \"\");\n    }\n    else if (!latestValues.transform && style.transform) {\n        style.transform = \"none\";\n    }\n    if (hasTransformOrigin) {\n        style.transformOrigin = buildTransformOrigin(transformOrigin);\n    }\n}\n\nexport { buildHTMLStyles };\n","function renderHTML(element, _a, styleProp, projection) {\n    var style = _a.style, vars = _a.vars;\n    Object.assign(element.style, style, projection && projection.getProjectionStyles(styleProp));\n    // Loop over any CSS variables and assign those.\n    for (var key in vars) {\n        element.style.setProperty(key, vars[key]);\n    }\n}\n\nexport { renderHTML };\n","import { isForcedMotionValue } from '../../../motion/utils/is-forced-motion-value.mjs';\nimport { isMotionValue } from '../../../value/utils/is-motion-value.mjs';\n\nfunction scrapeMotionValuesFromProps(props) {\n    var style = props.style;\n    var newValues = {};\n    for (var key in style) {\n        if (isMotionValue(style[key]) || isForcedMotionValue(key, props)) {\n            newValues[key] = style[key];\n        }\n    }\n    return newValues;\n}\n\nexport { scrapeMotionValuesFromProps };\n","/**\n * A list of all transformable axes. We'll use this list to generated a version\n * of each axes for each transform.\n */\nvar transformAxes = [\"\", \"X\", \"Y\", \"Z\"];\n/**\n * An ordered array of each transformable value. By default, transform values\n * will be sorted to this order.\n */\nvar order = [\"translate\", \"scale\", \"rotate\", \"skew\"];\n/**\n * Generate a list of every possible transform key.\n */\nvar transformProps = [\"transformPerspective\", \"x\", \"y\", \"z\"];\norder.forEach(function (operationKey) {\n    return transformAxes.forEach(function (axesKey) {\n        return transformProps.push(operationKey + axesKey);\n    });\n});\n/**\n * A function to use with Array.sort to sort transform keys by their default order.\n */\nfunction sortTransformProps(a, b) {\n    return transformProps.indexOf(a) - transformProps.indexOf(b);\n}\n/**\n * A quick lookup for transform props.\n */\nvar transformPropSet = new Set(transformProps);\nfunction isTransformProp(key) {\n    return transformPropSet.has(key);\n}\n/**\n * A quick lookup for transform origin props\n */\nvar transformOriginProps = new Set([\"originX\", \"originY\", \"originZ\"]);\nfunction isTransformOriginProp(key) {\n    return transformOriginProps.has(key);\n}\n\nexport { isTransformOriginProp, isTransformProp, sortTransformProps, transformAxes, transformProps };\n","import { px } from 'style-value-types';\n\nfunction calcOrigin(origin, offset, size) {\n    return typeof origin === \"string\"\n        ? origin\n        : px.transform(offset + size * origin);\n}\n/**\n * The SVG transform origin defaults are different to CSS and is less intuitive,\n * so we use the measured dimensions of the SVG to reconcile these.\n */\nfunction calcSVGTransformOrigin(dimensions, originX, originY) {\n    var pxOriginX = calcOrigin(originX, dimensions.x, dimensions.width);\n    var pxOriginY = calcOrigin(originY, dimensions.y, dimensions.height);\n    return \"\".concat(pxOriginX, \" \").concat(pxOriginY);\n}\n\nexport { calcSVGTransformOrigin };\n","import { px } from 'style-value-types';\n\nvar dashKeys = {\n    offset: \"stroke-dashoffset\",\n    array: \"stroke-dasharray\",\n};\nvar camelKeys = {\n    offset: \"strokeDashoffset\",\n    array: \"strokeDasharray\",\n};\n/**\n * Build SVG path properties. Uses the path's measured length to convert\n * our custom pathLength, pathSpacing and pathOffset into stroke-dashoffset\n * and stroke-dasharray attributes.\n *\n * This function is mutative to reduce per-frame GC.\n */\nfunction buildSVGPath(attrs, length, spacing, offset, useDashCase) {\n    if (spacing === void 0) { spacing = 1; }\n    if (offset === void 0) { offset = 0; }\n    if (useDashCase === void 0) { useDashCase = true; }\n    // Normalise path length by setting SVG attribute pathLength to 1\n    attrs.pathLength = 1;\n    // We use dash case when setting attributes directly to the DOM node and camel case\n    // when defining props on a React component.\n    var keys = useDashCase ? dashKeys : camelKeys;\n    // Build the dash offset\n    attrs[keys.offset] = px.transform(-offset);\n    // Build the dash array\n    var pathLength = px.transform(length);\n    var pathSpacing = px.transform(spacing);\n    attrs[keys.array] = \"\".concat(pathLength, \" \").concat(pathSpacing);\n}\n\nexport { buildSVGPath };\n","import { __rest } from 'tslib';\nimport { buildHTMLStyles } from '../../html/utils/build-styles.mjs';\nimport { calcSVGTransformOrigin } from './transform-origin.mjs';\nimport { buildSVGPath } from './path.mjs';\n\n/**\n * Build SVG visual attrbutes, like cx and style.transform\n */\nfunction buildSVGAttrs(state, _a, options, transformTemplate) {\n    var attrX = _a.attrX, attrY = _a.attrY, originX = _a.originX, originY = _a.originY, pathLength = _a.pathLength, _b = _a.pathSpacing, pathSpacing = _b === void 0 ? 1 : _b, _c = _a.pathOffset, pathOffset = _c === void 0 ? 0 : _c, \n    // This is object creation, which we try to avoid per-frame.\n    latest = __rest(_a, [\"attrX\", \"attrY\", \"originX\", \"originY\", \"pathLength\", \"pathSpacing\", \"pathOffset\"]);\n    buildHTMLStyles(state, latest, options, transformTemplate);\n    state.attrs = state.style;\n    state.style = {};\n    var attrs = state.attrs, style = state.style, dimensions = state.dimensions;\n    /**\n     * However, we apply transforms as CSS transforms. So if we detect a transform we take it from attrs\n     * and copy it into style.\n     */\n    if (attrs.transform) {\n        if (dimensions)\n            style.transform = attrs.transform;\n        delete attrs.transform;\n    }\n    // Parse transformOrigin\n    if (dimensions &&\n        (originX !== undefined || originY !== undefined || style.transform)) {\n        style.transformOrigin = calcSVGTransformOrigin(dimensions, originX !== undefined ? originX : 0.5, originY !== undefined ? originY : 0.5);\n    }\n    // Treat x/y not as shortcuts but as actual attributes\n    if (attrX !== undefined)\n        attrs.x = attrX;\n    if (attrY !== undefined)\n        attrs.y = attrY;\n    // Build SVG path if one has been defined\n    if (pathLength !== undefined) {\n        buildSVGPath(attrs, pathLength, pathSpacing, pathOffset, false);\n    }\n}\n\nexport { buildSVGAttrs };\n","/**\n * A set of attribute names that are always read/written as camel case.\n */\nvar camelCaseAttributes = new Set([\n    \"baseFrequency\",\n    \"diffuseConstant\",\n    \"kernelMatrix\",\n    \"kernelUnitLength\",\n    \"keySplines\",\n    \"keyTimes\",\n    \"limitingConeAngle\",\n    \"markerHeight\",\n    \"markerWidth\",\n    \"numOctaves\",\n    \"targetX\",\n    \"targetY\",\n    \"surfaceScale\",\n    \"specularConstant\",\n    \"specularExponent\",\n    \"stdDeviation\",\n    \"tableValues\",\n    \"viewBox\",\n    \"gradientTransform\",\n    \"pathLength\",\n]);\n\nexport { camelCaseAttributes };\n","import { camelToDash } from '../../dom/utils/camel-to-dash.mjs';\nimport { renderHTML } from '../../html/utils/render.mjs';\nimport { camelCaseAttributes } from './camel-case-attrs.mjs';\n\nfunction renderSVG(element, renderState) {\n    renderHTML(element, renderState);\n    for (var key in renderState.attrs) {\n        element.setAttribute(!camelCaseAttributes.has(key) ? camelToDash(key) : key, renderState.attrs[key]);\n    }\n}\n\nexport { renderSVG };\n","import { isMotionValue } from '../../../value/utils/is-motion-value.mjs';\nimport { scrapeMotionValuesFromProps as scrapeMotionValuesFromProps$1 } from '../../html/utils/scrape-motion-values.mjs';\n\nfunction scrapeMotionValuesFromProps(props) {\n    var newValues = scrapeMotionValuesFromProps$1(props);\n    for (var key in props) {\n        if (isMotionValue(props[key])) {\n            var targetKey = key === \"x\" || key === \"y\" ? \"attr\" + key.toUpperCase() : key;\n            newValues[targetKey] = props[key];\n        }\n    }\n    return newValues;\n}\n\nexport { scrapeMotionValuesFromProps };\n","/**\n * Decides if the supplied variable is an array of variant labels\n */\nfunction isVariantLabels(v) {\n    return Array.isArray(v);\n}\n/**\n * Decides if the supplied variable is variant label\n */\nfunction isVariantLabel(v) {\n    return typeof v === \"string\" || isVariantLabels(v);\n}\n/**\n * Creates an object containing the latest state of every MotionValue on a VisualElement\n */\nfunction getCurrent(visualElement) {\n    var current = {};\n    visualElement.forEachValue(function (value, key) { return (current[key] = value.get()); });\n    return current;\n}\n/**\n * Creates an object containing the latest velocity of every MotionValue on a VisualElement\n */\nfunction getVelocity(visualElement) {\n    var velocity = {};\n    visualElement.forEachValue(function (value, key) { return (velocity[key] = value.getVelocity()); });\n    return velocity;\n}\nfunction resolveVariantFromProps(props, definition, custom, currentValues, currentVelocity) {\n    var _a;\n    if (currentValues === void 0) { currentValues = {}; }\n    if (currentVelocity === void 0) { currentVelocity = {}; }\n    /**\n     * If the variant definition is a function, resolve.\n     */\n    if (typeof definition === \"function\") {\n        definition = definition(custom !== null && custom !== void 0 ? custom : props.custom, currentValues, currentVelocity);\n    }\n    /**\n     * If the variant definition is a variant label, or\n     * the function returned a variant label, resolve.\n     */\n    if (typeof definition === \"string\") {\n        definition = (_a = props.variants) === null || _a === void 0 ? void 0 : _a[definition];\n    }\n    /**\n     * At this point we've resolved both functions and variant labels,\n     * but the resolved variant label might itself have been a function.\n     * If so, resolve. This can only have returned a valid target object.\n     */\n    if (typeof definition === \"function\") {\n        definition = definition(custom !== null && custom !== void 0 ? custom : props.custom, currentValues, currentVelocity);\n    }\n    return definition;\n}\nfunction resolveVariant(visualElement, definition, custom) {\n    var props = visualElement.getProps();\n    return resolveVariantFromProps(props, definition, custom !== null && custom !== void 0 ? custom : props.custom, getCurrent(visualElement), getVelocity(visualElement));\n}\nfunction checkIfControllingVariants(props) {\n    var _a;\n    return (typeof ((_a = props.animate) === null || _a === void 0 ? void 0 : _a.start) === \"function\" ||\n        isVariantLabel(props.initial) ||\n        isVariantLabel(props.animate) ||\n        isVariantLabel(props.whileHover) ||\n        isVariantLabel(props.whileDrag) ||\n        isVariantLabel(props.whileTap) ||\n        isVariantLabel(props.whileFocus) ||\n        isVariantLabel(props.exit));\n}\nfunction checkIfVariantNode(props) {\n    return Boolean(checkIfControllingVariants(props) || props.variants);\n}\n\nexport { checkIfControllingVariants, checkIfVariantNode, isVariantLabel, isVariantLabels, resolveVariant, resolveVariantFromProps };\n","import { __read } from 'tslib';\n\nfunction addUniqueItem(arr, item) {\n    arr.indexOf(item) === -1 && arr.push(item);\n}\nfunction removeItem(arr, item) {\n    var index = arr.indexOf(item);\n    index > -1 && arr.splice(index, 1);\n}\n// Adapted from array-move\nfunction moveItem(_a, fromIndex, toIndex) {\n    var _b = __read(_a), arr = _b.slice(0);\n    var startIndex = fromIndex < 0 ? arr.length + fromIndex : fromIndex;\n    if (startIndex >= 0 && startIndex < arr.length) {\n        var endIndex = toIndex < 0 ? arr.length + toIndex : toIndex;\n        var _c = __read(arr.splice(fromIndex, 1), 1), item = _c[0];\n        arr.splice(endIndex, 0, item);\n    }\n    return arr;\n}\n\nexport { addUniqueItem, moveItem, removeItem };\n","var isBrowser = typeof window !== \"undefined\";\n\nexport { isBrowser };\n","function isRefObject(ref) {\n    return (typeof ref === \"object\" &&\n        Object.prototype.hasOwnProperty.call(ref, \"current\"));\n}\n\nexport { isRefObject };\n","import { isKeyframesTarget } from '../animation/utils/is-keyframes-target.mjs';\n\nvar isCustomValue = function (v) {\n    return Boolean(v && typeof v === \"object\" && v.mix && v.toValue);\n};\nvar resolveFinalValueInKeyframes = function (v) {\n    // TODO maybe throw if v.length - 1 is placeholder token?\n    return isKeyframesTarget(v) ? v[v.length - 1] || 0 : v;\n};\n\nexport { isCustomValue, resolveFinalValueInKeyframes };\n","import { addUniqueItem, removeItem } from './array.mjs';\n\nvar SubscriptionManager = /** @class */ (function () {\n    function SubscriptionManager() {\n        this.subscriptions = [];\n    }\n    SubscriptionManager.prototype.add = function (handler) {\n        var _this = this;\n        addUniqueItem(this.subscriptions, handler);\n        return function () { return removeItem(_this.subscriptions, handler); };\n    };\n    SubscriptionManager.prototype.notify = function (a, b, c) {\n        var numSubscriptions = this.subscriptions.length;\n        if (!numSubscriptions)\n            return;\n        if (numSubscriptions === 1) {\n            /**\n             * If there's only a single handler we can just call it without invoking a loop.\n             */\n            this.subscriptions[0](a, b, c);\n        }\n        else {\n            for (var i = 0; i < numSubscriptions; i++) {\n                /**\n                 * Check whether the handler exists before firing as it's possible\n                 * the subscriptions were modified during this loop running.\n                 */\n                var handler = this.subscriptions[i];\n                handler && handler(a, b, c);\n            }\n        }\n    };\n    SubscriptionManager.prototype.getSize = function () {\n        return this.subscriptions.length;\n    };\n    SubscriptionManager.prototype.clear = function () {\n        this.subscriptions.length = 0;\n    };\n    return SubscriptionManager;\n}());\n\nexport { SubscriptionManager };\n","/**\n * Converts seconds to milliseconds\n *\n * @param seconds - Time in seconds.\n * @return milliseconds - Converted time in milliseconds.\n */\nvar secondsToMilliseconds = function (seconds) { return seconds * 1000; };\n\nexport { secondsToMilliseconds };\n","import { useRef } from 'react';\n\n/**\n * Creates a constant value over the lifecycle of a component.\n *\n * Even if `useMemo` is provided an empty array as its final argument, it doesn't offer\n * a guarantee that it won't re-run for performance reasons later on. By using `useConstant`\n * you can ensure that initialisers don't execute twice or more.\n */\nfunction useConstant(init) {\n    var ref = useRef(null);\n    if (ref.current === null) {\n        ref.current = init();\n    }\n    return ref.current;\n}\n\nexport { useConstant };\n","import sync, { getFrameData } from 'framesync';\nimport { velocityPerSecond } from 'popmotion';\nimport { SubscriptionManager } from '../utils/subscription-manager.mjs';\n\nvar isFloat = function (value) {\n    return !isNaN(parseFloat(value));\n};\n/**\n * `MotionValue` is used to track the state and velocity of motion values.\n *\n * @public\n */\nvar MotionValue = /** @class */ (function () {\n    /**\n     * @param init - The initiating value\n     * @param config - Optional configuration options\n     *\n     * -  `transformer`: A function to transform incoming values with.\n     *\n     * @internal\n     */\n    function MotionValue(init) {\n        var _this = this;\n        /**\n         * Duration, in milliseconds, since last updating frame.\n         *\n         * @internal\n         */\n        this.timeDelta = 0;\n        /**\n         * Timestamp of the last time this `MotionValue` was updated.\n         *\n         * @internal\n         */\n        this.lastUpdated = 0;\n        /**\n         * Functions to notify when the `MotionValue` updates.\n         *\n         * @internal\n         */\n        this.updateSubscribers = new SubscriptionManager();\n        /**\n         * Functions to notify when the velocity updates.\n         *\n         * @internal\n         */\n        this.velocityUpdateSubscribers = new SubscriptionManager();\n        /**\n         * Functions to notify when the `MotionValue` updates and `render` is set to `true`.\n         *\n         * @internal\n         */\n        this.renderSubscribers = new SubscriptionManager();\n        /**\n         * Tracks whether this value can output a velocity. Currently this is only true\n         * if the value is numerical, but we might be able to widen the scope here and support\n         * other value types.\n         *\n         * @internal\n         */\n        this.canTrackVelocity = false;\n        this.updateAndNotify = function (v, render) {\n            if (render === void 0) { render = true; }\n            _this.prev = _this.current;\n            _this.current = v;\n            // Update timestamp\n            var _a = getFrameData(), delta = _a.delta, timestamp = _a.timestamp;\n            if (_this.lastUpdated !== timestamp) {\n                _this.timeDelta = delta;\n                _this.lastUpdated = timestamp;\n                sync.postRender(_this.scheduleVelocityCheck);\n            }\n            // Update update subscribers\n            if (_this.prev !== _this.current) {\n                _this.updateSubscribers.notify(_this.current);\n            }\n            // Update velocity subscribers\n            if (_this.velocityUpdateSubscribers.getSize()) {\n                _this.velocityUpdateSubscribers.notify(_this.getVelocity());\n            }\n            // Update render subscribers\n            if (render) {\n                _this.renderSubscribers.notify(_this.current);\n            }\n        };\n        /**\n         * Schedule a velocity check for the next frame.\n         *\n         * This is an instanced and bound function to prevent generating a new\n         * function once per frame.\n         *\n         * @internal\n         */\n        this.scheduleVelocityCheck = function () { return sync.postRender(_this.velocityCheck); };\n        /**\n         * Updates `prev` with `current` if the value hasn't been updated this frame.\n         * This ensures velocity calculations return `0`.\n         *\n         * This is an instanced and bound function to prevent generating a new\n         * function once per frame.\n         *\n         * @internal\n         */\n        this.velocityCheck = function (_a) {\n            var timestamp = _a.timestamp;\n            if (timestamp !== _this.lastUpdated) {\n                _this.prev = _this.current;\n                _this.velocityUpdateSubscribers.notify(_this.getVelocity());\n            }\n        };\n        this.hasAnimated = false;\n        this.prev = this.current = init;\n        this.canTrackVelocity = isFloat(this.current);\n    }\n    /**\n     * Adds a function that will be notified when the `MotionValue` is updated.\n     *\n     * It returns a function that, when called, will cancel the subscription.\n     *\n     * When calling `onChange` inside a React component, it should be wrapped with the\n     * `useEffect` hook. As it returns an unsubscribe function, this should be returned\n     * from the `useEffect` function to ensure you don't add duplicate subscribers..\n     *\n     * ```jsx\n     * export const MyComponent = () => {\n     *   const x = useMotionValue(0)\n     *   const y = useMotionValue(0)\n     *   const opacity = useMotionValue(1)\n     *\n     *   useEffect(() => {\n     *     function updateOpacity() {\n     *       const maxXY = Math.max(x.get(), y.get())\n     *       const newOpacity = transform(maxXY, [0, 100], [1, 0])\n     *       opacity.set(newOpacity)\n     *     }\n     *\n     *     const unsubscribeX = x.onChange(updateOpacity)\n     *     const unsubscribeY = y.onChange(updateOpacity)\n     *\n     *     return () => {\n     *       unsubscribeX()\n     *       unsubscribeY()\n     *     }\n     *   }, [])\n     *\n     *   return <motion.div style={{ x }} />\n     * }\n     * ```\n     *\n     * @internalremarks\n     *\n     * We could look into a `useOnChange` hook if the above lifecycle management proves confusing.\n     *\n     * ```jsx\n     * useOnChange(x, () => {})\n     * ```\n     *\n     * @param subscriber - A function that receives the latest value.\n     * @returns A function that, when called, will cancel this subscription.\n     *\n     * @public\n     */\n    MotionValue.prototype.onChange = function (subscription) {\n        return this.updateSubscribers.add(subscription);\n    };\n    MotionValue.prototype.clearListeners = function () {\n        this.updateSubscribers.clear();\n    };\n    /**\n     * Adds a function that will be notified when the `MotionValue` requests a render.\n     *\n     * @param subscriber - A function that's provided the latest value.\n     * @returns A function that, when called, will cancel this subscription.\n     *\n     * @internal\n     */\n    MotionValue.prototype.onRenderRequest = function (subscription) {\n        // Render immediately\n        subscription(this.get());\n        return this.renderSubscribers.add(subscription);\n    };\n    /**\n     * Attaches a passive effect to the `MotionValue`.\n     *\n     * @internal\n     */\n    MotionValue.prototype.attach = function (passiveEffect) {\n        this.passiveEffect = passiveEffect;\n    };\n    /**\n     * Sets the state of the `MotionValue`.\n     *\n     * @remarks\n     *\n     * ```jsx\n     * const x = useMotionValue(0)\n     * x.set(10)\n     * ```\n     *\n     * @param latest - Latest value to set.\n     * @param render - Whether to notify render subscribers. Defaults to `true`\n     *\n     * @public\n     */\n    MotionValue.prototype.set = function (v, render) {\n        if (render === void 0) { render = true; }\n        if (!render || !this.passiveEffect) {\n            this.updateAndNotify(v, render);\n        }\n        else {\n            this.passiveEffect(v, this.updateAndNotify);\n        }\n    };\n    /**\n     * Returns the latest state of `MotionValue`\n     *\n     * @returns - The latest state of `MotionValue`\n     *\n     * @public\n     */\n    MotionValue.prototype.get = function () {\n        return this.current;\n    };\n    /**\n     * @public\n     */\n    MotionValue.prototype.getPrevious = function () {\n        return this.prev;\n    };\n    /**\n     * Returns the latest velocity of `MotionValue`\n     *\n     * @returns - The latest velocity of `MotionValue`. Returns `0` if the state is non-numerical.\n     *\n     * @public\n     */\n    MotionValue.prototype.getVelocity = function () {\n        // This could be isFloat(this.prev) && isFloat(this.current), but that would be wasteful\n        return this.canTrackVelocity\n            ? // These casts could be avoided if parseFloat would be typed better\n                velocityPerSecond(parseFloat(this.current) -\n                    parseFloat(this.prev), this.timeDelta)\n            : 0;\n    };\n    /**\n     * Registers a new animation to control this `MotionValue`. Only one\n     * animation can drive a `MotionValue` at one time.\n     *\n     * ```jsx\n     * value.start()\n     * ```\n     *\n     * @param animation - A function that starts the provided animation\n     *\n     * @internal\n     */\n    MotionValue.prototype.start = function (animation) {\n        var _this = this;\n        this.stop();\n        return new Promise(function (resolve) {\n            _this.hasAnimated = true;\n            _this.stopAnimation = animation(resolve);\n        }).then(function () { return _this.clearAnimation(); });\n    };\n    /**\n     * Stop the currently active animation.\n     *\n     * @public\n     */\n    MotionValue.prototype.stop = function () {\n        if (this.stopAnimation)\n            this.stopAnimation();\n        this.clearAnimation();\n    };\n    /**\n     * Returns `true` if this value is currently animating.\n     *\n     * @public\n     */\n    MotionValue.prototype.isAnimating = function () {\n        return !!this.stopAnimation;\n    };\n    MotionValue.prototype.clearAnimation = function () {\n        this.stopAnimation = null;\n    };\n    /**\n     * Destroy and clean up subscribers to this `MotionValue`.\n     *\n     * The `MotionValue` hooks like `useMotionValue` and `useTransform` automatically\n     * handle the lifecycle of the returned `MotionValue`, so this method is only necessary if you've manually\n     * created a `MotionValue` via the `motionValue` function.\n     *\n     * @public\n     */\n    MotionValue.prototype.destroy = function () {\n        this.updateSubscribers.clear();\n        this.renderSubscribers.clear();\n        this.stop();\n    };\n    return MotionValue;\n}());\n/**\n * @internal\n */\nfunction motionValue(init) {\n    return new MotionValue(init);\n}\n\nexport { MotionValue, motionValue };\n","var isMotionValue = function (value) {\n    return Boolean(value !== null && typeof value === \"object\" && value.getVelocity);\n};\n\nexport { isMotionValue };\n","import { isCustomValue } from '../../utils/resolve-value.mjs';\nimport { isMotionValue } from './is-motion-value.mjs';\n\n/**\n * If the provided value is a MotionValue, this returns the actual value, otherwise just the value itself\n *\n * TODO: Remove and move to library\n *\n * @internal\n */\nfunction resolveMotionValue(value) {\n    var unwrappedValue = isMotionValue(value) ? value.get() : value;\n    return isCustomValue(unwrappedValue)\n        ? unwrappedValue.toValue()\n        : unwrappedValue;\n}\n\nexport { resolveMotionValue };\n","const defaultTimestep = (1 / 60) * 1000;\nconst getCurrentTime = typeof performance !== \"undefined\"\n    ? () => performance.now()\n    : () => Date.now();\nconst onNextFrame = typeof window !== \"undefined\"\n    ? (callback) => window.requestAnimationFrame(callback)\n    : (callback) => setTimeout(() => callback(getCurrentTime()), defaultTimestep);\n\nexport { defaultTimestep, onNextFrame };\n","import { onNextFrame, defaultTimestep } from './on-next-frame.mjs';\nimport { createRenderStep } from './create-render-step.mjs';\n\nconst maxElapsed = 40;\nlet useDefaultElapsed = true;\nlet runNextFrame = false;\nlet isProcessing = false;\nconst frame = {\n    delta: 0,\n    timestamp: 0,\n};\nconst stepsOrder = [\n    \"read\",\n    \"update\",\n    \"preRender\",\n    \"render\",\n    \"postRender\",\n];\nconst steps = stepsOrder.reduce((acc, key) => {\n    acc[key] = createRenderStep(() => (runNextFrame = true));\n    return acc;\n}, {});\nconst sync = stepsOrder.reduce((acc, key) => {\n    const step = steps[key];\n    acc[key] = (process, keepAlive = false, immediate = false) => {\n        if (!runNextFrame)\n            startLoop();\n        return step.schedule(process, keepAlive, immediate);\n    };\n    return acc;\n}, {});\nconst cancelSync = stepsOrder.reduce((acc, key) => {\n    acc[key] = steps[key].cancel;\n    return acc;\n}, {});\nconst flushSync = stepsOrder.reduce((acc, key) => {\n    acc[key] = () => steps[key].process(frame);\n    return acc;\n}, {});\nconst processStep = (stepId) => steps[stepId].process(frame);\nconst processFrame = (timestamp) => {\n    runNextFrame = false;\n    frame.delta = useDefaultElapsed\n        ? defaultTimestep\n        : Math.max(Math.min(timestamp - frame.timestamp, maxElapsed), 1);\n    frame.timestamp = timestamp;\n    isProcessing = true;\n    stepsOrder.forEach(processStep);\n    isProcessing = false;\n    if (runNextFrame) {\n        useDefaultElapsed = false;\n        onNextFrame(processFrame);\n    }\n};\nconst startLoop = () => {\n    runNextFrame = true;\n    useDefaultElapsed = true;\n    if (!isProcessing)\n        onNextFrame(processFrame);\n};\nconst getFrameData = () => frame;\n\nexport default sync;\nexport { cancelSync, flushSync, getFrameData };\n","function createRenderStep(runNextFrame) {\n    let toRun = [];\n    let toRunNextFrame = [];\n    let numToRun = 0;\n    let isProcessing = false;\n    let flushNextFrame = false;\n    const toKeepAlive = new WeakSet();\n    const step = {\n        schedule: (callback, keepAlive = false, immediate = false) => {\n            const addToCurrentFrame = immediate && isProcessing;\n            const buffer = addToCurrentFrame ? toRun : toRunNextFrame;\n            if (keepAlive)\n                toKeepAlive.add(callback);\n            if (buffer.indexOf(callback) === -1) {\n                buffer.push(callback);\n                if (addToCurrentFrame && isProcessing)\n                    numToRun = toRun.length;\n            }\n            return callback;\n        },\n        cancel: (callback) => {\n            const index = toRunNextFrame.indexOf(callback);\n            if (index !== -1)\n                toRunNextFrame.splice(index, 1);\n            toKeepAlive.delete(callback);\n        },\n        process: (frameData) => {\n            if (isProcessing) {\n                flushNextFrame = true;\n                return;\n            }\n            isProcessing = true;\n            [toRun, toRunNextFrame] = [toRunNextFrame, toRun];\n            toRunNextFrame.length = 0;\n            numToRun = toRun.length;\n            if (numToRun) {\n                for (let i = 0; i < numToRun; i++) {\n                    const callback = toRun[i];\n                    callback(frameData);\n                    if (toKeepAlive.has(callback)) {\n                        step.schedule(callback);\n                        runNextFrame();\n                    }\n                }\n            }\n            isProcessing = false;\n            if (flushNextFrame) {\n                flushNextFrame = false;\n                step.process(frameData);\n            }\n        },\n    };\n    return step;\n}\n\nexport { createRenderStep };\n","const reverseEasing = easing => p => 1 - easing(1 - p);\nconst mirrorEasing = easing => p => p <= 0.5 ? easing(2 * p) / 2 : (2 - easing(2 * (1 - p))) / 2;\nconst createExpoIn = (power) => p => Math.pow(p, power);\nconst createBackIn = (power) => p => p * p * ((power + 1) * p - power);\nconst createAnticipate = (power) => {\n    const backEasing = createBackIn(power);\n    return p => (p *= 2) < 1\n        ? 0.5 * backEasing(p)\n        : 0.5 * (2 - Math.pow(2, -10 * (p - 1)));\n};\n\nexport { createAnticipate, createBackIn, createExpoIn, mirrorEasing, reverseEasing };\n","import { createExpoIn, reverseEasing, mirrorEasing, createBackIn, createAnticipate } from './utils.mjs';\n\nconst DEFAULT_OVERSHOOT_STRENGTH = 1.525;\nconst BOUNCE_FIRST_THRESHOLD = 4.0 / 11.0;\nconst BOUNCE_SECOND_THRESHOLD = 8.0 / 11.0;\nconst BOUNCE_THIRD_THRESHOLD = 9.0 / 10.0;\nconst linear = p => p;\nconst easeIn = createExpoIn(2);\nconst easeOut = reverseEasing(easeIn);\nconst easeInOut = mirrorEasing(easeIn);\nconst circIn = p => 1 - Math.sin(Math.acos(p));\nconst circOut = reverseEasing(circIn);\nconst circInOut = mirrorEasing(circOut);\nconst backIn = createBackIn(DEFAULT_OVERSHOOT_STRENGTH);\nconst backOut = reverseEasing(backIn);\nconst backInOut = mirrorEasing(backIn);\nconst anticipate = createAnticipate(DEFAULT_OVERSHOOT_STRENGTH);\nconst ca = 4356.0 / 361.0;\nconst cb = 35442.0 / 1805.0;\nconst cc = 16061.0 / 1805.0;\nconst bounceOut = (p) => {\n    if (p === 1 || p === 0)\n        return p;\n    const p2 = p * p;\n    return p < BOUNCE_FIRST_THRESHOLD\n        ? 7.5625 * p2\n        : p < BOUNCE_SECOND_THRESHOLD\n            ? 9.075 * p2 - 9.9 * p + 3.4\n            : p < BOUNCE_THIRD_THRESHOLD\n                ? ca * p2 - cb * p + cc\n                : 10.8 * p * p - 20.52 * p + 10.72;\n};\nconst bounceIn = reverseEasing(bounceOut);\nconst bounceInOut = (p) => p < 0.5\n    ? 0.5 * (1.0 - bounceOut(1.0 - p * 2.0))\n    : 0.5 * bounceOut(p * 2.0 - 1.0) + 0.5;\n\nexport { anticipate, backIn, backInOut, backOut, bounceIn, bounceInOut, bounceOut, circIn, circInOut, circOut, easeIn, easeInOut, easeOut, linear };\n","const clamp = (min, max, v) => Math.min(Math.max(v, min), max);\n\nexport { clamp };\n","const isPoint = (point) => point.hasOwnProperty('x') && point.hasOwnProperty('y');\n\nexport { isPoint };\n","import { isPoint } from './is-point.mjs';\n\nconst isPoint3D = (point) => isPoint(point) && point.hasOwnProperty('z');\n\nexport { isPoint3D };\n","import { isPoint } from './is-point.mjs';\nimport { isPoint3D } from './is-point-3d.mjs';\nimport { isNum } from './inc.mjs';\n\nconst distance1D = (a, b) => Math.abs(a - b);\nfunction distance(a, b) {\n    if (isNum(a) && isNum(b)) {\n        return distance1D(a, b);\n    }\n    else if (isPoint(a) && isPoint(b)) {\n        const xDelta = distance1D(a.x, b.x);\n        const yDelta = distance1D(a.y, b.y);\n        const zDelta = isPoint3D(a) && isPoint3D(b) ? distance1D(a.z, b.z) : 0;\n        return Math.sqrt(Math.pow(xDelta, 2) + Math.pow(yDelta, 2) + Math.pow(zDelta, 2));\n    }\n}\n\nexport { distance };\n","const zeroPoint = {\n    x: 0,\n    y: 0,\n    z: 0\n};\nconst isNum = (v) => typeof v === 'number';\n\nexport { isNum, zeroPoint };\n","const mix = (from, to, progress) => -progress * from + progress * to + from;\n\nexport { mix };\n","const combineFunctions = (a, b) => (v) => b(a(v));\nconst pipe = (...transformers) => transformers.reduce(combineFunctions);\n\nexport { pipe };\n","const progress = (from, to, value) => {\n    const toFromDifference = to - from;\n    return toFromDifference === 0 ? 1 : (value - from) / toFromDifference;\n};\n\nexport { progress };\n","function velocityPerSecond(velocity, frameDuration) {\n    return frameDuration ? velocity * (1000 / frameDuration) : 0;\n}\n\nexport { velocityPerSecond };\n","import { rgba } from './rgba.mjs';\nimport { isColorString } from './utils.mjs';\n\nfunction parseHex(v) {\n    let r = '';\n    let g = '';\n    let b = '';\n    let a = '';\n    if (v.length > 5) {\n        r = v.substr(1, 2);\n        g = v.substr(3, 2);\n        b = v.substr(5, 2);\n        a = v.substr(7, 2);\n    }\n    else {\n        r = v.substr(1, 1);\n        g = v.substr(2, 1);\n        b = v.substr(3, 1);\n        a = v.substr(4, 1);\n        r += r;\n        g += g;\n        b += b;\n        a += a;\n    }\n    return {\n        red: parseInt(r, 16),\n        green: parseInt(g, 16),\n        blue: parseInt(b, 16),\n        alpha: a ? parseInt(a, 16) / 255 : 1,\n    };\n}\nconst hex = {\n    test: isColorString('#'),\n    parse: parseHex,\n    transform: rgba.transform,\n};\n\nexport { hex };\n","import { alpha } from '../numbers/index.mjs';\nimport { percent } from '../numbers/units.mjs';\nimport { sanitize } from '../utils.mjs';\nimport { isColorString, splitColor } from './utils.mjs';\n\nconst hsla = {\n    test: isColorString('hsl', 'hue'),\n    parse: splitColor('hue', 'saturation', 'lightness'),\n    transform: ({ hue, saturation, lightness, alpha: alpha$1 = 1 }) => {\n        return ('hsla(' +\n            Math.round(hue) +\n            ', ' +\n            percent.transform(sanitize(saturation)) +\n            ', ' +\n            percent.transform(sanitize(lightness)) +\n            ', ' +\n            sanitize(alpha.transform(alpha$1)) +\n            ')');\n    },\n};\n\nexport { hsla };\n","import { isString } from '../utils.mjs';\nimport { hex } from './hex.mjs';\nimport { hsla } from './hsla.mjs';\nimport { rgba } from './rgba.mjs';\n\nconst color = {\n    test: (v) => rgba.test(v) || hex.test(v) || hsla.test(v),\n    parse: (v) => {\n        if (rgba.test(v)) {\n            return rgba.parse(v);\n        }\n        else if (hsla.test(v)) {\n            return hsla.parse(v);\n        }\n        else {\n            return hex.parse(v);\n        }\n    },\n    transform: (v) => {\n        return isString(v)\n            ? v\n            : v.hasOwnProperty('red')\n                ? rgba.transform(v)\n                : hsla.transform(v);\n    },\n};\n\nexport { color };\n","import { number, alpha } from '../numbers/index.mjs';\nimport { sanitize, clamp } from '../utils.mjs';\nimport { isColorString, splitColor } from './utils.mjs';\n\nconst clampRgbUnit = clamp(0, 255);\nconst rgbUnit = Object.assign(Object.assign({}, number), { transform: (v) => Math.round(clampRgbUnit(v)) });\nconst rgba = {\n    test: isColorString('rgb', 'red'),\n    parse: splitColor('red', 'green', 'blue'),\n    transform: ({ red, green, blue, alpha: alpha$1 = 1 }) => 'rgba(' +\n        rgbUnit.transform(red) +\n        ', ' +\n        rgbUnit.transform(green) +\n        ', ' +\n        rgbUnit.transform(blue) +\n        ', ' +\n        sanitize(alpha.transform(alpha$1)) +\n        ')',\n};\n\nexport { rgbUnit, rgba };\n","import { isString, singleColorRegex, floatRegex } from '../utils.mjs';\n\nconst isColorString = (type, testProp) => (v) => {\n    return Boolean((isString(v) && singleColorRegex.test(v) && v.startsWith(type)) ||\n        (testProp && Object.prototype.hasOwnProperty.call(v, testProp)));\n};\nconst splitColor = (aName, bName, cName) => (v) => {\n    if (!isString(v))\n        return v;\n    const [a, b, c, alpha] = v.match(floatRegex);\n    return {\n        [aName]: parseFloat(a),\n        [bName]: parseFloat(b),\n        [cName]: parseFloat(c),\n        alpha: alpha !== undefined ? parseFloat(alpha) : 1,\n    };\n};\n\nexport { isColorString, splitColor };\n","import { complex } from './index.mjs';\nimport { floatRegex } from '../utils.mjs';\n\nconst maxDefaults = new Set(['brightness', 'contrast', 'saturate', 'opacity']);\nfunction applyDefaultFilter(v) {\n    let [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 = Object.assign(Object.assign({}, complex), { getAnimatableNone: (v) => {\n        const functions = v.match(functionRegex);\n        return functions ? functions.map(applyDefaultFilter).join(' ') : v;\n    } });\n\nexport { filter };\n","import { color } from '../color/index.mjs';\nimport { number } from '../numbers/index.mjs';\nimport { isString, floatRegex, colorRegex, sanitize } from '../utils.mjs';\n\nconst colorToken = '${c}';\nconst numberToken = '${n}';\nfunction test(v) {\n    var _a, _b, _c, _d;\n    return (isNaN(v) &&\n        isString(v) &&\n        ((_b = (_a = v.match(floatRegex)) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) + ((_d = (_c = v.match(colorRegex)) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0) > 0);\n}\nfunction analyse(v) {\n    if (typeof v === 'number')\n        v = `${v}`;\n    const values = [];\n    let numColors = 0;\n    const colors = v.match(colorRegex);\n    if (colors) {\n        numColors = colors.length;\n        v = v.replace(colorRegex, colorToken);\n        values.push(...colors.map(color.parse));\n    }\n    const numbers = v.match(floatRegex);\n    if (numbers) {\n        v = v.replace(floatRegex, numberToken);\n        values.push(...numbers.map(number.parse));\n    }\n    return { values, numColors, tokenised: v };\n}\nfunction parse(v) {\n    return analyse(v).values;\n}\nfunction createTransformer(v) {\n    const { values, numColors, tokenised } = analyse(v);\n    const numValues = values.length;\n    return (v) => {\n        let output = tokenised;\n        for (let i = 0; i < numValues; i++) {\n            output = output.replace(i < numColors ? colorToken : numberToken, i < numColors ? color.transform(v[i]) : sanitize(v[i]));\n        }\n        return output;\n    };\n}\nconst convertNumbersToZero = (v) => typeof v === 'number' ? 0 : v;\nfunction getAnimatableNone(v) {\n    const parsed = parse(v);\n    const transformer = createTransformer(v);\n    return transformer(parsed.map(convertNumbersToZero));\n}\nconst complex = { test, parse, createTransformer, getAnimatableNone };\n\nexport { complex };\n","import { clamp } from '../utils.mjs';\n\nconst number = {\n    test: (v) => typeof v === 'number',\n    parse: parseFloat,\n    transform: (v) => v,\n};\nconst alpha = Object.assign(Object.assign({}, number), { transform: clamp(0, 1) });\nconst scale = Object.assign(Object.assign({}, number), { default: 1 });\n\nexport { alpha, number, scale };\n","import { isString } from '../utils.mjs';\n\nconst createUnitType = (unit) => ({\n    test: (v) => isString(v) && v.endsWith(unit) && v.split(' ').length === 1,\n    parse: parseFloat,\n    transform: (v) => `${v}${unit}`,\n});\nconst degrees = createUnitType('deg');\nconst percent = createUnitType('%');\nconst px = createUnitType('px');\nconst vh = createUnitType('vh');\nconst vw = createUnitType('vw');\nconst progressPercentage = Object.assign(Object.assign({}, percent), { parse: (v) => percent.parse(v) / 100, transform: (v) => percent.transform(v * 100) });\n\nexport { degrees, percent, progressPercentage, px, vh, vw };\n","const clamp = (min, max) => (v) => Math.max(Math.min(v, max), min);\nconst sanitize = (v) => (v % 1 ? Number(v.toFixed(5)) : v);\nconst floatRegex = /(-)?([\\d]*\\.?[\\d])+/g;\nconst colorRegex = /(#[0-9a-f]{6}|#[0-9a-f]{3}|#(?:[0-9a-f]{2}){2,4}|(rgb|hsl)a?\\((-?[\\d\\.]+%?[,\\s]+){2,3}\\s*\\/*\\s*[\\d\\.]+%?\\))/gi;\nconst singleColorRegex = /^(#[0-9a-f]{3}|#(?:[0-9a-f]{2}){2,4}|(rgb|hsl)a?\\((-?[\\d\\.]+%?[,\\s]+){2,3}\\s*\\/*\\s*[\\d\\.]+%?\\))$/i;\nfunction isString(v) {\n    return typeof v === 'string';\n}\n\nexport { clamp, colorRegex, floatRegex, isString, sanitize, singleColorRegex };\n"],"names":["warning","invariant","isAnimationControls","v","start","isKeyframesTarget","Array","isArray","safeMin","minDuration","maxDuration","minDamping","maxDamping","findSpring","duration","bounce","velocity","mass","envelope","derivative","dampingRatio","clamp","undampedFreq","exponentialDecay","delta","a","b","calcAngularFreq","c","Math","exp","d","e","pow","f","g","initialGuess","result","i","rootIterations","approximateRoot","isNaN","stiffness","damping","sqrt","durationKeys","physicsKeys","isSpringType","options","keys","some","key","undefined","spring","_a","from","to","restSpeed","restDelta","state","done","value","isResolvedFromDuration","springOptions","Object","assign","derived","getSpringOptions","resolveSpring","zero","resolveVelocity","createSpring","initialVelocity","initialDelta","undampedAngularFreq","min","abs","angularFreq","t","sin","cos","dampedAngularFreq","freqForT","sinh","cosh","next","current","currentVelocity","isBelowVelocityThreshold","isBelowDisplacementThreshold","flipTarget","needsInterpolation","_t","hueToRgb","p","q","hslaToRgba","hue","saturation","lightness","alpha","red","green","blue","round","mixLinearColor","fromExpo","toExpo","max","colorTypes","hex","rgba","hsla","getColorType","find","type","test","notAnimatable","color","mixColor","fromColorType","toColorType","fromColor","parse","toColor","blended","mix","transform","getMixer","origin","target","mixComplex","mixArray","output","numValues","length","blendValue","map","fromThis","mixObject","analyse","parsed","complex","numNumbers","numRGB","numHSL","template","createTransformer","originStats","targetStats","pipe","mixNumber","createMixers","ease","customMixer","mixers","mixerFactory","numMixers","mixer","easingFunction","push","interpolate","input","isClamp","inputLength","concat","reverse","interpolator","progress","fastInterpolate","lastInputIndex","mixerIndex","foundMixerIndex","progressInRange","slowInterpolate","defaultEasing","values","easing","splice","keyframes","offset","times","o","convertOffsetToTimes","_value","defaultOffset","createInterpolator","types","power","timeConstant","modifyTarget","amplitude","ideal","loopElapsed","elapsed","delay","framesync","update","passTimestamp","stop","animate","_b","_c","autoplay","driver","repeat","repeatMax","repeatType","repeatDelay","onPlay","onStop","onComplete","onRepeat","onUpdate","driverControls","latest","interpolateFromNumber","repeatCount","computedDuration","isComplete","isForwardPlayback","animator","config","Set","has","detectAnimationFromOptions","call","animation","reverseElapsed","hasRepeatDelayElapsed","a1","a2","calcBezier","getSlope","subdivisionPrecision","subdivisionMaxIterations","newtonIterations","kSampleStepSize","cubicBezier","mX1","mY1","mX2","mY2","sampleValues","Float32Array","getTForX","aX","intervalStart","currentSample","kSplineTableSize","guessForT","initialSlope","aGuessT","currentSlope","newtonRaphsonIterate","aA","aB","currentX","currentT","binarySubdivide","easingLookup","linear","easeIn","easeInOut","easeOut","circIn","circInOut","circOut","backIn","backInOut","backOut","anticipate","bounceIn","bounceInOut","bounceOut","easingDefinitionToFunction","definition","isEasingArray","isAnimatable","startsWith","underDampedSpring","criticallyDampedSpring","linearTween","defaultTransitions","x","y","z","rotate","rotateX","rotateY","rotateZ","scaleX","scaleY","scale","opacity","backgroundColor","default","getDefaultTransition","valueKey","transitionFactory","instantAnimationState","legacyRepeatWarning","getPopmotionAnimationOptions","transition","hydrateKeyframes","when","delayChildren","staggerChildren","staggerDirection","isTransitionDefined","yoyo","flip","loop","convertTransitionToAnimationOptions","getAnimation","valueTransition","getValueTransition","get","isTargetAnimatable","isZero","getZeroUnit","isOriginAnimatable","getVelocity","set","bounceStiffness","bounceDamping","currentAnimation","isOutOfBounds","boundaryNearest","startAnimation","startSpring","boundary","heading","prev","checkBoundary","inertia","finalTarget","parseFloat","indexOf","potentialUnitType","delayTimer","controls","getDelayFromTransition","window","setTimeout","clearTimeout","LayoutGroupContext","createContext","MotionConfigContext","transformPagePoint","isStatic","reducedMotion","PresenceContext","SwitchLayoutGroupContext","isForcedMotionValue","layout","layoutId","scalePoint","point","originPoint","applyPointDelta","translate","boxScale","applyAxisDelta","axis","applyBoxDelta","box","applyTreeDeltas","treeScale","treePath","isSharedTransition","treeLength","node","projectionDelta","instance","style","display","layoutScroll","scroll","root","transformBox","latestValues","translateAxis","distance","transformAxis","transforms","scaleKey","originKey","axisOrigin","xKeys","yKeys","calcLength","isNear","maxDistance","calcAxisDelta","source","calcBoxDelta","originX","originY","calcRelativeAxis","relative","parent","calcRelativeBox","calcRelativeAxisPosition","calcRelativePosition","createDelta","createBox","borders","numBorders","asNumber","isPx","px","getRadius","radiusName","borderRadius","easeCrossfadeIn","compress","easeCrossfadeOut","copyAxisInto","originAxis","copyBoxInto","originBox","removePointDelta","removeAxisTransforms","sourceAxis","removeAxisDelta","removeBoxTransforms","sourceBox","isAxisDeltaZero","isDeltaZero","boxEquals","NodeStack","this","members","prototype","add","scheduleRender","remove","prevLead","lead","promote","relegate","indexOfNode","findIndex","member","isPresent","preserveFollowOpacity","show","resumeFrom","preserveOpacity","snapshot","animationValues","isShared","isUpdating","isLayoutDirty","crossfade","hide","exitAnimationComplete","forEach","_d","_e","onExitComplete","resumingFrom","removeLeadSnapshot","identityProjection","buildProjectionTransform","latestTransform","xTranslate","yTranslate","compareByDepth","depth","FlatTree","children","isDirty","child","callback","sort","animationTarget","globalProjectionState","hasAnimatedSinceResize","hasEverUpdated","createProjectionNode","attachResizeListener","defaultParent","measureScroll","resetTransform","ProjectionNode","id","_this","isTreeAnimating","isAnimationBlocked","updateManuallyBlocked","updateBlockedByResize","isSVG","needsReset","shouldResetTransform","eventHandlers","Map","potentialNodes","checkUpdateFailed","clearAllSnapshots","updateProjection","nodes","resolveTargetDelta","calcProjection","hasProjected","isVisible","animationProgress","sharedNodes","path","registerPotentialNode","addEventListener","name","handler","notifyListeners","args","_i","arguments","subscriptionManager","notify","apply","hasListeners","mount","SVGElement","tagName","visualElement","getInstance","delete","unblockTimeout_1","resizeUnblockUpdate_1","finishAnimation","registerSharedNode","_f","hasLayoutChanged","hasRelativeTargetChanged","newLayout","isTreeAnimationBlocked","relativeTarget","layoutTransition","defaultLayoutTransition","onLayoutAnimationComplete","getProps","targetChanged","targetLayout","hasOnlyRelativeTargetChanged","setAnimationOrigin","animationOptions","shouldReduceMotion","isLead","unmount","willUpdate","getStack","preRender","blockUpdate","unblockUpdate","isUpdateBlocked","startUpdate","resetRotation","shouldNotifyListeners","updateScroll","transformTemplate","prevTransformTemplateValue","updateSnapshot","didUpdate","clearMeasurements","size","mountNodeEarly","clear","resetTransformStyle","updateLayout","notifyLayoutUpdate","render","clearSnapshot","removeLeadSnapshots","scheduleUpdateProjection","scheduleCheckAfterUnmount","postRender","measured","measure","removeTransform","removeElementScroll","roundBox","alwaysMeasureLayout","prevLayout","actual","layoutCorrected","notifyLayoutMeasure","isResetRequested","hasProjection","transformTemplateValue","transformTemplateHasChanged","measureViewportBox","boxWithoutScroll","scroll_1","applyTransform","transformOnly","withTransforms","boxWithoutTransform","setTargetDelta","targetDelta","setOptions","relativeParent","getClosestProjectingParent","relativeTargetOrigin","targetWithTransforms","Boolean","attemptToResolveRelativeTarget","pendingAnimation","getLead","projectionDeltaWithTransform","prevTreeScaleX","prevTreeScaleY","prevProjectionTransform","projectionTransform","notifyAll","snapshotLatestValues","mixedValues","relativeLayout","isSharedLayoutAnimation","isOnlyMember","shouldCrossfadeOpacity","hasOpacityCrossfade","mixTargetDelta","mixAxisDelta","mixAxis","follow","opacityExit","borderLabel","followRadius","leadRadius","mixValues","isAnimating","completeAnimation","applyTransformsToTarget","initialPromotionConfig","shouldPreserveFollowOpacity","stack","getPrevLead","hasRotate","resetValues","getStaticValue","setStaticValue","syncRender","getProjectionStyles","styleProp","styles","visibility","pointerEvents","emptyStyles","valuesToRender","_g","transformOrigin","_h","correct","applyTo","corrected","num","resetTree","layout_1","measuredLayout","animationType","axisSnapshot","layoutDelta","visualDelta","parentSnapshot","parentLayout","relativeSnapshot","onBeforeLayoutMeasure","notifyBeforeLayoutMeasure","searchNode","element","document","querySelector","roundAxis","scaleCorrectors","addScaleCorrector","correctors","eachAxis","isIdentityScale","hasScale","hasTransform","hasTranslate","CAMEL_CASE_PATTERN","camelToDash","str","replace","toLowerCase","isCSSVariable","lowercaseSVGElements","isSVGComponent","Component","includes","getAnimatableNone","defaultValueType","defaultValueTypes","outlineColor","fill","stroke","borderColor","borderTopColor","borderRightColor","borderBottomColor","borderLeftColor","filter","WebkitFilter","getDefaultValueType","numberValueTypes","borderWidth","borderTopWidth","borderRightWidth","borderBottomWidth","borderLeftWidth","radius","borderTopLeftRadius","borderTopRightRadius","borderBottomRightRadius","borderBottomLeftRadius","width","maxWidth","height","maxHeight","top","right","bottom","left","padding","paddingTop","paddingRight","paddingBottom","paddingLeft","margin","marginTop","marginRight","marginBottom","marginLeft","scaleZ","skew","skewX","skewY","translateX","translateY","translateZ","perspective","transformPerspective","originZ","zIndex","fillOpacity","strokeOpacity","numOctaves","translateAlias","getValueAsType","buildHTMLStyles","vars","transformKeys","hasTransformOrigin","transformIsNone","valueType","number","valueAsType","transformIsDefault","enableHardwareAcceleration","allowTransformNone","transformString","transformHasZ","numTransformKeys","trim","buildTransform","buildTransformOrigin","renderHTML","projection","setProperty","scrapeMotionValuesFromProps","props","newValues","transformAxes","transformProps","sortTransformProps","operationKey","axesKey","transformPropSet","isTransformProp","transformOriginProps","isTransformOriginProp","calcOrigin","dashKeys","array","camelKeys","buildSVGAttrs","attrX","attrY","pathLength","pathSpacing","pathOffset","attrs","dimensions","pxOriginX","pxOriginY","calcSVGTransformOrigin","spacing","useDashCase","buildSVGPath","camelCaseAttributes","renderSVG","renderState","setAttribute","toUpperCase","isVariantLabels","isVariantLabel","resolveVariantFromProps","custom","currentValues","variants","resolveVariant","forEachValue","getCurrent","checkIfControllingVariants","initial","whileHover","whileDrag","whileTap","whileFocus","exit","checkIfVariantNode","addUniqueItem","arr","item","removeItem","index","isBrowser","isRefObject","ref","hasOwnProperty","isCustomValue","toValue","resolveFinalValueInKeyframes","SubscriptionManager","subscriptions","numSubscriptions","getSize","secondsToMilliseconds","seconds","useConstant","init","useRef","MotionValue","timeDelta","lastUpdated","updateSubscribers","velocityUpdateSubscribers","renderSubscribers","canTrackVelocity","updateAndNotify","timestamp","scheduleVelocityCheck","velocityCheck","hasAnimated","onChange","subscription","clearListeners","onRenderRequest","attach","passiveEffect","getPrevious","Promise","resolve","stopAnimation","then","clearAnimation","destroy","motionValue","isMotionValue","resolveMotionValue","unwrappedValue","defaultTimestep","getCurrentTime","performance","now","Date","onNextFrame","requestAnimationFrame","useDefaultElapsed","runNextFrame","isProcessing","stepsOrder","steps","reduce","acc","toRun","toRunNextFrame","numToRun","flushNextFrame","toKeepAlive","WeakSet","step","schedule","keepAlive","immediate","addToCurrentFrame","buffer","cancel","process","frameData","createRenderStep","sync","startLoop","cancelSync","flushSync","processStep","stepId","processFrame","getFrameData","reverseEasing","mirrorEasing","createBackIn","acos","backEasing","createAnticipate","p2","isPoint","isPoint3D","distance1D","xDelta","yDelta","zDelta","isNum","combineFunctions","transformers","toFromDifference","velocityPerSecond","frameDuration","r","substr","parseInt","alpha$1","clampRgbUnit","rgbUnit","isColorString","testProp","splitColor","aName","bName","cName","match","maxDefaults","applyDefaultFilter","slice","split","unit","defaultValue","functionRegex","functions","join","colorToken","numberToken","numColors","colors","numbers","tokenised","convertNumbersToZero","transformer","createUnitType","endsWith","degrees","percent","vh","vw","progressPercentage","sanitize","Number","toFixed","floatRegex","colorRegex","singleColorRegex","isString"],"sourceRoot":""}