{"version":3,"file":"4296-596bf7949b57790a191d.js","mappings":"uGACA,IAAIA,EAAQ,eACRC,EAAgB,IAAIC,OAAOF,EAAO,MAClCG,EAAe,IAAID,OAAO,IAAMF,EAAQ,KAAM,MAElD,SAASI,EAAiBC,EAAYC,GACrC,IAEC,OAAOC,mBAAmBF,EAAWG,KAAK,KACzC,MAAOC,IAIT,GAA0B,IAAtBJ,EAAWK,OACd,OAAOL,EAGRC,EAAQA,GAAS,EAGjB,IAAIK,EAAON,EAAWO,MAAM,EAAGN,GAC3BO,EAAQR,EAAWO,MAAMN,GAE7B,OAAOQ,MAAMC,UAAUC,OAAOC,KAAK,GAAIb,EAAiBO,GAAOP,EAAiBS,IAGjF,SAASK,EAAOC,GACf,IACC,OAAOZ,mBAAmBY,GACzB,MAAOV,GAGR,IAFA,IAAIW,EAASD,EAAME,MAAMpB,GAEhBqB,EAAI,EAAGA,EAAIF,EAAOV,OAAQY,IAGlCF,GAFAD,EAAQf,EAAiBgB,EAAQE,GAAGd,KAAK,KAE1Ba,MAAMpB,GAGtB,OAAOkB,GAyCTI,EAAOC,QAAU,SAAUC,GAC1B,GAA0B,iBAAfA,EACV,MAAM,IAAIC,UAAU,6DAA+DD,EAAa,KAGjG,IAIC,OAHAA,EAAaA,EAAWE,QAAQ,MAAO,KAGhCpB,mBAAmBkB,GACzB,MAAOhB,GAER,OAjDF,SAAkCU,GAQjC,IANA,IAAIS,EAAa,CAChB,SAAU,KACV,SAAU,MAGPP,EAAQlB,EAAa0B,KAAKV,GACvBE,GAAO,CACb,IAECO,EAAWP,EAAM,IAAMd,mBAAmBc,EAAM,IAC/C,MAAOZ,GACR,IAAIqB,EAASZ,EAAOG,EAAM,IAEtBS,IAAWT,EAAM,KACpBO,EAAWP,EAAM,IAAMS,GAIzBT,EAAQlB,EAAa0B,KAAKV,GAI3BS,EAAW,OAAS,IAIpB,IAFA,IAAIG,EAAUC,OAAOC,KAAKL,GAEjBN,EAAI,EAAGA,EAAIS,EAAQrB,OAAQY,IAAK,CAExC,IAAIY,EAAMH,EAAQT,GAClBH,EAAQA,EAAMQ,QAAQ,IAAIzB,OAAOgC,EAAK,KAAMN,EAAWM,IAGxD,OAAOf,EAeCgB,CAAyBV,M,UC1FlCF,EAAOC,QAAU,SAAUY,EAAKC,GAK/B,IAJA,IAAIC,EAAM,GACNL,EAAOD,OAAOC,KAAKG,GACnBG,EAAQzB,MAAM0B,QAAQH,GAEjBf,EAAI,EAAGA,EAAIW,EAAKvB,OAAQY,IAAK,CACrC,IAAIY,EAAMD,EAAKX,GACXmB,EAAML,EAAIF,IAEVK,GAAoC,IAA5BF,EAAUK,QAAQR,GAAcG,EAAUH,EAAKO,EAAKL,MAC/DE,EAAIJ,GAAOO,GAIb,OAAOH,I,gBCdR,MAAMK,EAAkB,EAAQ,OAC1BC,EAAkB,EAAQ,OAC1BC,EAAe,EAAQ,OACvBC,EAAe,EAAQ,OAIvBC,EAA2BC,OAAO,4BAgNxC,SAASC,EAA6BC,GACrC,GAAqB,iBAAVA,GAAuC,IAAjBA,EAAMxC,OACtC,MAAM,IAAIgB,UAAU,wDAItB,SAASyB,EAAOD,EAAOE,GACtB,OAAIA,EAAQD,OACJC,EAAQC,OAASV,EAAgBO,GAASI,mBAAmBJ,GAG9DA,EAGR,SAAShC,EAAOgC,EAAOE,GACtB,OAAIA,EAAQlC,OACJ0B,EAAgBM,GAGjBA,EAGR,SAASK,EAAWpC,GACnB,OAAIL,MAAM0B,QAAQrB,GACVA,EAAMqC,OAGO,iBAAVrC,EACHoC,EAAWvB,OAAOC,KAAKd,IAC5BqC,MAAK,CAACC,EAAGC,IAAMC,OAAOF,GAAKE,OAAOD,KAClCE,KAAI1B,GAAOf,EAAMe,KAGbf,EAGR,SAAS0C,EAAW1C,GACnB,MAAM2C,EAAY3C,EAAMuB,QAAQ,KAKhC,OAJmB,IAAfoB,IACH3C,EAAQA,EAAMP,MAAM,EAAGkD,IAGjB3C,EAaR,SAAS4C,EAAQ5C,GAEhB,MAAM6C,GADN7C,EAAQ0C,EAAW1C,IACMuB,QAAQ,KACjC,OAAoB,IAAhBsB,EACI,GAGD7C,EAAMP,MAAMoD,EAAa,GAGjC,SAASC,EAAWf,EAAOE,GAO1B,OANIA,EAAQc,eAAiBP,OAAOQ,MAAMR,OAAOT,KAA6B,iBAAVA,GAAuC,KAAjBA,EAAMkB,OAC/FlB,EAAQS,OAAOT,IACLE,EAAQiB,eAA2B,OAAVnB,GAA2C,SAAxBA,EAAMoB,eAAoD,UAAxBpB,EAAMoB,gBAC9FpB,EAAgC,SAAxBA,EAAMoB,eAGRpB,EAGR,SAASqB,EAAMC,EAAOpB,GAUrBH,GATAG,EAAUpB,OAAOyC,OAAO,CACvBvD,QAAQ,EACRsC,MAAM,EACNkB,YAAa,OACbC,qBAAsB,IACtBT,cAAc,EACdG,eAAe,GACbjB,IAEkCuB,sBAErC,MAAMC,EA7LP,SAA8BxB,GAC7B,IAAItB,EAEJ,OAAQsB,EAAQsB,aACf,IAAK,QACJ,MAAO,CAACxC,EAAKgB,EAAO2B,KACnB/C,EAAS,aAAaD,KAAKK,GAE3BA,EAAMA,EAAIP,QAAQ,WAAY,IAEzBG,QAKoBgD,IAArBD,EAAY3C,KACf2C,EAAY3C,GAAO,IAGpB2C,EAAY3C,GAAKJ,EAAO,IAAMoB,GAR7B2B,EAAY3C,GAAOgB,GAWtB,IAAK,UACJ,MAAO,CAAChB,EAAKgB,EAAO2B,KACnB/C,EAAS,UAAUD,KAAKK,GACxBA,EAAMA,EAAIP,QAAQ,QAAS,IAEtBG,OAKoBgD,IAArBD,EAAY3C,GAKhB2C,EAAY3C,GAAO,GAAGlB,OAAO6D,EAAY3C,GAAMgB,GAJ9C2B,EAAY3C,GAAO,CAACgB,GALpB2B,EAAY3C,GAAOgB,GAYtB,IAAK,uBACJ,MAAO,CAAChB,EAAKgB,EAAO2B,KACnB/C,EAAS,WAAWD,KAAKK,GACzBA,EAAMA,EAAIP,QAAQ,SAAU,IAEvBG,OAKoBgD,IAArBD,EAAY3C,GAKhB2C,EAAY3C,GAAO,GAAGlB,OAAO6D,EAAY3C,GAAMgB,GAJ9C2B,EAAY3C,GAAO,CAACgB,GALpB2B,EAAY3C,GAAOgB,GAYtB,IAAK,QACL,IAAK,YACJ,MAAO,CAAChB,EAAKgB,EAAO2B,KACnB,MAAMrC,EAA2B,iBAAVU,GAAsBA,EAAM6B,SAAS3B,EAAQuB,sBAC9DK,EAAmC,iBAAV9B,IAAuBV,GAAWtB,EAAOgC,EAAOE,GAAS2B,SAAS3B,EAAQuB,sBACzGzB,EAAQ8B,EAAiB9D,EAAOgC,EAAOE,GAAWF,EAClD,MAAM+B,EAAWzC,GAAWwC,EAAiB9B,EAAM5C,MAAM8C,EAAQuB,sBAAsBf,KAAIsB,GAAQhE,EAAOgE,EAAM9B,KAAsB,OAAVF,EAAiBA,EAAQhC,EAAOgC,EAAOE,GACnKyB,EAAY3C,GAAO+C,GAGrB,IAAK,oBACJ,MAAO,CAAC/C,EAAKgB,EAAO2B,KACnB,MAAMrC,EAAU,UAAU2C,KAAKjD,GAG/B,GAFAA,EAAMA,EAAIP,QAAQ,QAAS,KAEtBa,EAEJ,YADAqC,EAAY3C,GAAOgB,EAAQhC,EAAOgC,EAAOE,GAAWF,GAIrD,MAAMkC,EAAuB,OAAVlC,EAClB,GACAA,EAAM5C,MAAM8C,EAAQuB,sBAAsBf,KAAIsB,GAAQhE,EAAOgE,EAAM9B,UAE3C0B,IAArBD,EAAY3C,GAKhB2C,EAAY3C,GAAO,GAAGlB,OAAO6D,EAAY3C,GAAMkD,GAJ9CP,EAAY3C,GAAOkD,GAOtB,QACC,MAAO,CAAClD,EAAKgB,EAAO2B,UACMC,IAArBD,EAAY3C,GAKhB2C,EAAY3C,GAAO,GAAGlB,OAAO6D,EAAY3C,GAAMgB,GAJ9C2B,EAAY3C,GAAOgB,IAgGLmC,CAAqBjC,GAGjCd,EAAMN,OAAOsD,OAAO,MAE1B,GAAqB,iBAAVd,EACV,OAAOlC,EAKR,KAFAkC,EAAQA,EAAMJ,OAAOzC,QAAQ,SAAU,KAGtC,OAAOW,EAGR,IAAK,MAAMiD,KAASf,EAAMlE,MAAM,KAAM,CACrC,GAAc,KAAViF,EACH,SAGD,IAAKrD,EAAKgB,GAASL,EAAaO,EAAQlC,OAASqE,EAAM5D,QAAQ,MAAO,KAAO4D,EAAO,KAIpFrC,OAAkB4B,IAAV5B,EAAsB,KAAO,CAAC,QAAS,YAAa,qBAAqB6B,SAAS3B,EAAQsB,aAAexB,EAAQhC,EAAOgC,EAAOE,GACvIwB,EAAU1D,EAAOgB,EAAKkB,GAAUF,EAAOZ,GAGxC,IAAK,MAAMJ,KAAOF,OAAOC,KAAKK,GAAM,CACnC,MAAMY,EAAQZ,EAAIJ,GAClB,GAAqB,iBAAVgB,GAAgC,OAAVA,EAChC,IAAK,MAAMsC,KAAKxD,OAAOC,KAAKiB,GAC3BA,EAAMsC,GAAKvB,EAAWf,EAAMsC,GAAIpC,QAGjCd,EAAIJ,GAAO+B,EAAWf,EAAOE,GAI/B,OAAqB,IAAjBA,EAAQI,KACJlB,IAGiB,IAAjBc,EAAQI,KAAgBxB,OAAOC,KAAKK,GAAKkB,OAASxB,OAAOC,KAAKK,GAAKkB,KAAKJ,EAAQI,OAAOiC,QAAO,CAAC3D,EAAQI,KAC9G,MAAMgB,EAAQZ,EAAIJ,GAQlB,OAPIwD,QAAQxC,IAA2B,iBAAVA,IAAuBpC,MAAM0B,QAAQU,GAEjEpB,EAAOI,GAAOqB,EAAWL,GAEzBpB,EAAOI,GAAOgB,EAGRpB,IACLE,OAAOsD,OAAO,OAGlB9D,EAAQuC,QAAUA,EAClBvC,EAAQ+C,MAAQA,EAEhB/C,EAAQmE,UAAY,CAACC,EAAQxC,KAC5B,IAAKwC,EACJ,MAAO,GAUR3C,GAPAG,EAAUpB,OAAOyC,OAAO,CACvBtB,QAAQ,EACRE,QAAQ,EACRqB,YAAa,OACbC,qBAAsB,KACpBvB,IAEkCuB,sBAErC,MAAMkB,EAAe3D,GACnBkB,EAAQ0C,UAnXwB5C,MAmXM0C,EAAO1D,IAC7CkB,EAAQ2C,iBAAmC,KAAhBH,EAAO1D,GAG9B0C,EAnXP,SAA+BxB,GAC9B,OAAQA,EAAQsB,aACf,IAAK,QACJ,OAAOxC,GAAO,CAACJ,EAAQoB,KACtB,MAAM8C,EAAQlE,EAAOpB,OAErB,YACWoE,IAAV5B,GACCE,EAAQ0C,UAAsB,OAAV5C,GACpBE,EAAQ2C,iBAA6B,KAAV7C,EAErBpB,EAGM,OAAVoB,EACI,IAAIpB,EAAQ,CAACqB,EAAOjB,EAAKkB,GAAU,IAAK4C,EAAO,KAAKxF,KAAK,KAG1D,IACHsB,EACH,CAACqB,EAAOjB,EAAKkB,GAAU,IAAKD,EAAO6C,EAAO5C,GAAU,KAAMD,EAAOD,EAAOE,IAAU5C,KAAK,MAI1F,IAAK,UACJ,OAAO0B,GAAO,CAACJ,EAAQoB,SAEX4B,IAAV5B,GACCE,EAAQ0C,UAAsB,OAAV5C,GACpBE,EAAQ2C,iBAA6B,KAAV7C,EAErBpB,EAGM,OAAVoB,EACI,IAAIpB,EAAQ,CAACqB,EAAOjB,EAAKkB,GAAU,MAAM5C,KAAK,KAG/C,IAAIsB,EAAQ,CAACqB,EAAOjB,EAAKkB,GAAU,MAAOD,EAAOD,EAAOE,IAAU5C,KAAK,KAGhF,IAAK,uBACJ,OAAO0B,GAAO,CAACJ,EAAQoB,SAEX4B,IAAV5B,GACCE,EAAQ0C,UAAsB,OAAV5C,GACpBE,EAAQ2C,iBAA6B,KAAV7C,EAErBpB,EAGM,OAAVoB,EACI,IAAIpB,EAAQ,CAACqB,EAAOjB,EAAKkB,GAAU,UAAU5C,KAAK,KAGnD,IAAIsB,EAAQ,CAACqB,EAAOjB,EAAKkB,GAAU,SAAUD,EAAOD,EAAOE,IAAU5C,KAAK,KAGnF,IAAK,QACL,IAAK,YACL,IAAK,oBAAqB,CACzB,MAAMyF,EAAsC,sBAAxB7C,EAAQsB,YAC3B,MACA,IAED,OAAOxC,GAAO,CAACJ,EAAQoB,SAEX4B,IAAV5B,GACCE,EAAQ0C,UAAsB,OAAV5C,GACpBE,EAAQ2C,iBAA6B,KAAV7C,EAErBpB,GAIRoB,EAAkB,OAAVA,EAAiB,GAAKA,EAER,IAAlBpB,EAAOpB,OACH,CAAC,CAACyC,EAAOjB,EAAKkB,GAAU6C,EAAa9C,EAAOD,EAAOE,IAAU5C,KAAK,KAGnE,CAAC,CAACsB,EAAQqB,EAAOD,EAAOE,IAAU5C,KAAK4C,EAAQuB,wBAIxD,QACC,OAAOzC,GAAO,CAACJ,EAAQoB,SAEX4B,IAAV5B,GACCE,EAAQ0C,UAAsB,OAAV5C,GACpBE,EAAQ2C,iBAA6B,KAAV7C,EAErBpB,EAGM,OAAVoB,EACI,IAAIpB,EAAQqB,EAAOjB,EAAKkB,IAGzB,IAAItB,EAAQ,CAACqB,EAAOjB,EAAKkB,GAAU,IAAKD,EAAOD,EAAOE,IAAU5C,KAAK,MAgR7D0F,CAAsB9C,GAElC+C,EAAa,GAEnB,IAAK,MAAMjE,KAAOF,OAAOC,KAAK2D,GACxBC,EAAa3D,KACjBiE,EAAWjE,GAAO0D,EAAO1D,IAI3B,MAAMD,EAAOD,OAAOC,KAAKkE,GAMzB,OAJqB,IAAjB/C,EAAQI,MACXvB,EAAKuB,KAAKJ,EAAQI,MAGZvB,EAAK2B,KAAI1B,IACf,MAAMgB,EAAQ0C,EAAO1D,GAErB,YAAc4C,IAAV5B,EACI,GAGM,OAAVA,EACIC,EAAOjB,EAAKkB,GAGhBtC,MAAM0B,QAAQU,GACI,IAAjBA,EAAMxC,QAAwC,sBAAxB0C,EAAQsB,YAC1BvB,EAAOjB,EAAKkB,GAAW,KAGxBF,EACLuC,OAAOb,EAAU1C,GAAM,IACvB1B,KAAK,KAGD2C,EAAOjB,EAAKkB,GAAW,IAAMD,EAAOD,EAAOE,MAChDgD,QAAOC,GAAKA,EAAE3F,OAAS,IAAGF,KAAK,MAGnCgB,EAAQ8E,SAAW,CAACC,EAAKnD,KACxBA,EAAUpB,OAAOyC,OAAO,CACvBvD,QAAQ,GACNkC,GAEH,MAAOoD,EAAMC,GAAQ5D,EAAa0D,EAAK,KAEvC,OAAOvE,OAAOyC,OACb,CACC8B,IAAKC,EAAKlG,MAAM,KAAK,IAAM,GAC3BkE,MAAOD,EAAMR,EAAQwC,GAAMnD,IAE5BA,GAAWA,EAAQsD,yBAA2BD,EAAO,CAACE,mBAAoBzF,EAAOuF,EAAMrD,IAAY,KAIrG5B,EAAQoF,aAAe,CAAChB,EAAQxC,KAC/BA,EAAUpB,OAAOyC,OAAO,CACvBtB,QAAQ,EACRE,QAAQ,EACR,CAACN,IAA2B,GAC1BK,GAEH,MAAMmD,EAAM1C,EAAW+B,EAAOW,KAAKjG,MAAM,KAAK,IAAM,GAC9CuG,EAAerF,EAAQuC,QAAQ6B,EAAOW,KACtCO,EAAqBtF,EAAQ+C,MAAMsC,EAAc,CAACrD,MAAM,IAExDgB,EAAQxC,OAAOyC,OAAOqC,EAAoBlB,EAAOpB,OACvD,IAAIuC,EAAcvF,EAAQmE,UAAUnB,EAAOpB,GACvC2D,IACHA,EAAc,IAAIA,KAGnB,IAAIN,EAlML,SAAiBF,GAChB,IAAIE,EAAO,GACX,MAAM3C,EAAYyC,EAAI7D,QAAQ,KAK9B,OAJmB,IAAfoB,IACH2C,EAAOF,EAAI3F,MAAMkD,IAGX2C,EA2LIO,CAAQpB,EAAOW,KAK1B,OAJIX,EAAOe,qBACVF,EAAO,IAAIrD,EAAQL,GAA4BI,EAAOyC,EAAOe,mBAAoBvD,GAAWwC,EAAOe,sBAG7F,GAAGJ,IAAMQ,IAAcN,KAG/BjF,EAAQyF,KAAO,CAAC9F,EAAOiF,EAAQhD,KAC9BA,EAAUpB,OAAOyC,OAAO,CACvBiC,yBAAyB,EACzB,CAAC3D,IAA2B,GAC1BK,GAEH,MAAM,IAACmD,EAAG,MAAE/B,EAAK,mBAAEmC,GAAsBnF,EAAQ8E,SAASnF,EAAOiC,GACjE,OAAO5B,EAAQoF,aAAa,CAC3BL,MACA/B,MAAO1B,EAAa0B,EAAO4B,GAC3BO,sBACEvD,IAGJ5B,EAAQ0F,QAAU,CAAC/F,EAAOiF,EAAQhD,KACjC,MAAM+D,EAAkBrG,MAAM0B,QAAQ4D,GAAUlE,IAAQkE,EAAOrB,SAAS7C,GAAO,CAACA,EAAKgB,KAAWkD,EAAOlE,EAAKgB,GAE5G,OAAO1B,EAAQyF,KAAK9F,EAAOgG,EAAiB/D,K,UC9d7C7B,EAAOC,QAAU,CAAC4F,EAAQC,KACzB,GAAwB,iBAAXD,GAA4C,iBAAdC,EAC1C,MAAM,IAAI3F,UAAU,iDAGrB,GAAkB,KAAd2F,EACH,MAAO,CAACD,GAGT,MAAME,EAAiBF,EAAO1E,QAAQ2E,GAEtC,OAAwB,IAApBC,EACI,CAACF,GAGF,CACNA,EAAOxG,MAAM,EAAG0G,GAChBF,EAAOxG,MAAM0G,EAAiBD,EAAU3G,W,UClB1Ca,EAAOC,QAAU+F,GAAOjE,mBAAmBiE,GAAK5F,QAAQ,YAAY0E,GAAK,IAAIA,EAAEmB,WAAW,GAAGC,SAAS,IAAIC,mB,sEC8B1G,SAASC,EAAQC,EAAMC,EAAIC,QACJ,IAAfA,IAAyBA,EAAa,IAC1C,IAAI5E,GAAQ,IAAA5B,GAAcsG,GAAQA,GAAO,OAAYA,GAErD,OADA,QAAe,GAAI1E,EAAO2E,EAAIC,GACvB,CACHC,KAAM,WAAc,OAAO7E,EAAM6E,QACjCC,YAAa,WAAc,OAAO9E,EAAM8E,kB,6HCrChD,MAAMC,EAAWC,GAAUA,EAAMC,eAAe,MAAQD,EAAMC,eAAe,KCEvEC,EAAaF,GAAUD,EAAQC,IAAUA,EAAMC,eAAe,K,eCEpE,MAAME,EAAa,CAAC5E,EAAGC,IAAM4E,KAAKC,IAAI9E,EAAIC,GAC1C,SAAS8E,EAAS/E,EAAGC,GACjB,IAAI,OAAMD,KAAM,OAAMC,GAClB,OAAO2E,EAAW5E,EAAGC,GAEpB,GAAIuE,EAAQxE,IAAMwE,EAAQvE,GAAI,CAC/B,MAAM+E,EAASJ,EAAW5E,EAAE4C,EAAG3C,EAAE2C,GAC3BqC,EAASL,EAAW5E,EAAEkF,EAAGjF,EAAEiF,GAC3BC,EAASR,EAAU3E,IAAM2E,EAAU1E,GAAK2E,EAAW5E,EAAEoF,EAAGnF,EAAEmF,GAAK,EACrE,OAAOP,KAAKQ,KAAKR,KAAKS,IAAIN,EAAQ,GAAKH,KAAKS,IAAIL,EAAQ,GAAKJ,KAAKS,IAAIH,EAAQ,K,cCFlFI,EAA4B,WAC5B,SAASA,EAAWC,EAAOC,EAAUC,GACjC,IAAIC,EAAQC,KACsBC,QAAlB,IAAPH,EAAgB,GAAKA,GAA4BG,mBA2D1D,GAvDAD,KAAKE,WAAa,KAIlBF,KAAKG,cAAgB,KAIrBH,KAAKI,kBAAoB,KAIzBJ,KAAKH,SAAW,GAChBG,KAAKK,YAAc,WACf,GAAMN,EAAMI,eAAiBJ,EAAMK,kBAAnC,CAEA,IAAIE,EAAOC,EAAWR,EAAMK,kBAAmBL,EAAMS,SACjDC,EAAoC,OAArBV,EAAMG,WAIrBQ,EAA0BvB,EAASmB,EAAKK,OAAQ,CAAE3D,EAAG,EAAGsC,EAAG,KAAQ,EACvE,GAAKmB,GAAiBC,EAAtB,CAEA,IAAI7B,EAAQyB,EAAKzB,MACb+B,GAAY,UAAeA,UAC/Bb,EAAMS,QAAQK,MAAK,SAAS,QAAS,GAAIhC,GAAQ,CAAE+B,UAAWA,KAC9D,IAAId,EAAKC,EAAMF,SAAUiB,EAAUhB,EAAGgB,QAASC,EAASjB,EAAGiB,OACtDN,IACDK,GAAWA,EAAQf,EAAMI,cAAeG,GACxCP,EAAMG,WAAaH,EAAMI,eAE7BY,GAAUA,EAAOhB,EAAMI,cAAeG,MAE1CN,KAAKgB,kBAAoB,SAAUpB,EAAOU,GACtCP,EAAMI,cAAgBP,EACtBG,EAAMK,kBAAoBa,EAAeX,EAAMP,EAAME,qBAEjD,OAAaL,IAA4B,IAAlBA,EAAMsB,QAC7BnB,EAAMoB,gBAAgBvB,EAAOU,GAIjC,YAAYP,EAAMM,aAAa,IAEnCL,KAAKmB,gBAAkB,SAAUvB,EAAOU,GACpCP,EAAMqB,MACN,IAAItB,EAAKC,EAAMF,SAAUwB,EAAQvB,EAAGuB,MAAOC,EAAexB,EAAGwB,aACzDC,EAAUhB,EAAWU,EAAeX,EAAMP,EAAME,oBAAqBF,EAAMS,SAC3ET,EAAMG,YAAcmB,GACpBA,EAAMzB,EAAO2B,GAEjBD,GAAgBA,EAAa1B,EAAO2B,OAGpC,OAAa3B,IAAUA,EAAM4B,QAAQnK,OAAS,GAAlD,CAEA2I,KAAKH,SAAWA,EAChBG,KAAKC,mBAAqBA,EAC1B,IACIwB,EAAcR,GADP,OAAiBrB,GACWI,KAAKC,oBACxCpB,EAAQ4C,EAAY5C,MACpB+B,GAAY,UAAeA,UAC/BZ,KAAKQ,QAAU,EAAC,SAAS,QAAS,GAAI3B,GAAQ,CAAE+B,UAAWA,KAC3D,IAAIc,EAAiB7B,EAAS6B,eAC9BA,GACIA,EAAe9B,EAAOW,EAAWkB,EAAazB,KAAKQ,UACvDR,KAAK2B,iBAAkB,EAAAC,EAAA,IAAK,IAAAxH,GAAgByH,OAAQ,cAAe7B,KAAKgB,oBAAoB,IAAA5G,GAAgByH,OAAQ,YAAa7B,KAAKmB,kBAAkB,IAAA/G,GAAgByH,OAAQ,gBAAiB7B,KAAKmB,mBAS1M,OAPAxB,EAAWjI,UAAUoK,eAAiB,SAAUjC,GAC5CG,KAAKH,SAAWA,GAEpBF,EAAWjI,UAAU0J,IAAM,WACvBpB,KAAK2B,iBAAmB3B,KAAK2B,kBAC7B,YAAkB3B,KAAKK,cAEpBV,EAnFoB,GAqF/B,SAASsB,EAAeX,EAAML,GAC1B,OAAOA,EAAqB,CAAEpB,MAAOoB,EAAmBK,EAAKzB,QAAWyB,EAE5E,SAASyB,EAAc3H,EAAGC,GACtB,MAAO,CAAE2C,EAAG5C,EAAE4C,EAAI3C,EAAE2C,EAAGsC,EAAGlF,EAAEkF,EAAIjF,EAAEiF,GAEtC,SAASiB,EAAWT,EAAIU,GACpB,IAAI3B,EAAQiB,EAAGjB,MACf,MAAO,CACHA,MAAOA,EACPmD,MAAOD,EAAclD,EAAOoD,EAAgBzB,IAC5CG,OAAQoB,EAAclD,EAAOqD,EAAiB1B,IAC9C2B,SAAUC,EAAY5B,EAAS,KAGvC,SAAS0B,EAAiB1B,GACtB,OAAOA,EAAQ,GAEnB,SAASyB,EAAgBzB,GACrB,OAAOA,EAAQA,EAAQnJ,OAAS,GAEpC,SAAS+K,EAAY5B,EAAS6B,GAC1B,GAAI7B,EAAQnJ,OAAS,EACjB,MAAO,CAAE2F,EAAG,EAAGsC,EAAG,GAKtB,IAHA,IAAIrH,EAAIuI,EAAQnJ,OAAS,EACrBiL,EAAmB,KACnBC,EAAYN,EAAgBzB,GACzBvI,GAAK,IACRqK,EAAmB9B,EAAQvI,KACvBsK,EAAU3B,UAAY0B,EAAiB1B,WACvC,OAAsByB,MAG1BpK,IAEJ,IAAKqK,EACD,MAAO,CAAEtF,EAAG,EAAGsC,EAAG,GAEtB,IAAIkD,GAAQD,EAAU3B,UAAY0B,EAAiB1B,WAAa,IAChE,GAAa,IAAT4B,EACA,MAAO,CAAExF,EAAG,EAAGsC,EAAG,GAEtB,IAAImD,EAAkB,CAClBzF,GAAIuF,EAAUvF,EAAIsF,EAAiBtF,GAAKwF,EACxClD,GAAIiD,EAAUjD,EAAIgD,EAAiBhD,GAAKkD,GAQ5C,OANIC,EAAgBzF,IAAM0F,MACtBD,EAAgBzF,EAAI,GAEpByF,EAAgBnD,IAAMoD,MACtBD,EAAgBnD,EAAI,GAEjBmD,E,yDCnJX,SAASE,EAAWC,GAChB,OAAOA,EAAKC,IAAMD,EAAKE,IAE3B,SAASC,EAAOlJ,EAAOmJ,EAAQC,GAG3B,YAFe,IAAXD,IAAqBA,EAAS,QACd,IAAhBC,IAA0BA,EAAc,KACrC9D,EAAStF,EAAOmJ,GAAUC,EAErC,SAASC,EAAclB,EAAOmB,EAAQH,EAAQI,QAC3B,IAAXA,IAAqBA,EAAS,IAClCpB,EAAMoB,OAASA,EACfpB,EAAMqB,aAAc,EAAAC,EAAA,GAAIH,EAAOL,IAAKK,EAAON,IAAKb,EAAMoB,QACtDpB,EAAMuB,MAAQZ,EAAWK,GAAUL,EAAWQ,IAC1CJ,EAAOf,EAAMuB,MAAO,EAAG,OAAWzI,MAAMkH,EAAMuB,UAC9CvB,EAAMuB,MAAQ,GAClBvB,EAAMwB,WACF,EAAAF,EAAA,GAAIN,EAAOF,IAAKE,EAAOH,IAAKb,EAAMoB,QAAUpB,EAAMqB,aAClDN,EAAOf,EAAMwB,YAAc1I,MAAMkH,EAAMwB,cACvCxB,EAAMwB,UAAY,GAE1B,SAASC,EAAazB,EAAOmB,EAAQH,EAAQI,GACzCF,EAAclB,EAAMhF,EAAGmG,EAAOnG,EAAGgG,EAAOhG,EAAGoG,aAAuC,EAASA,EAAOM,SAClGR,EAAclB,EAAM1C,EAAG6D,EAAO7D,EAAG0D,EAAO1D,EAAG8D,aAAuC,EAASA,EAAOO,SAEtG,SAASC,EAAiBZ,EAAQa,EAAUC,GACxCd,EAAOF,IAAMgB,EAAOhB,IAAMe,EAASf,IACnCE,EAAOH,IAAMG,EAAOF,IAAMH,EAAWkB,GAMzC,SAASE,EAAyBf,EAAQgB,EAAQF,GAC9Cd,EAAOF,IAAMkB,EAAOlB,IAAMgB,EAAOhB,IACjCE,EAAOH,IAAMG,EAAOF,IAAMH,EAAWqB,GAEzC,SAASC,EAAqBjB,EAAQgB,EAAQF,GAC1CC,EAAyBf,EAAOhG,EAAGgH,EAAOhH,EAAG8G,EAAO9G,GACpD+G,EAAyBf,EAAO1D,EAAG0E,EAAO1E,EAAGwE,EAAOxE,GCdxD,SAAS4E,EAA4BtB,EAAME,EAAKD,GAC5C,MAAO,CACHC,SAAarH,IAARqH,EAAoBF,EAAKE,IAAMA,OAAMrH,EAC1CoH,SAAapH,IAARoH,EACCD,EAAKC,IAAMA,GAAOD,EAAKC,IAAMD,EAAKE,UAClCrH,GAiBd,SAAS0I,EAA4BC,EAAYC,GAC7C,IAAIvE,EACAgD,EAAMuB,EAAgBvB,IAAMsB,EAAWtB,IACvCD,EAAMwB,EAAgBxB,IAAMuB,EAAWvB,IAO3C,OAJIwB,EAAgBxB,IAAMwB,EAAgBvB,IACtCsB,EAAWvB,IAAMuB,EAAWtB,MACAA,GAA5BhD,GAAK,QAAO,CAAC+C,EAAKC,GAAM,IAAa,GAAID,EAAM/C,EAAG,IAE/C,CAAEgD,IAAKA,EAAKD,IAAKA,GAwC5B,IAAIyB,EAAiB,IAiBrB,SAASC,EAAmBC,EAAaC,EAAUC,GAC/C,MAAO,CACH5B,IAAK6B,EAAoBH,EAAaC,GACtC5B,IAAK8B,EAAoBH,EAAaE,IAG9C,SAASC,EAAoBH,EAAaI,GACtC,IAAI9E,EACJ,MAA8B,iBAAhB0E,EACRA,EAC8B,QAA7B1E,EAAK0E,EAAYI,UAA2B,IAAP9E,EAAgBA,EAAK,E,cC7HrE,SAAS+E,EAASC,GACd,MAAO,CAACA,EAAS,KAAMA,EAAS,M,0DCkBhCC,EAAsB,IAAIC,QAK1BC,EAA2C,WAC3C,SAASA,EAA0BC,GAI/BlF,KAAKmF,eAAiB,KACtBnF,KAAKoF,YAAa,EAClBpF,KAAKqF,iBAAmB,KACxBrF,KAAKqD,YAAc,CAAErG,EAAG,EAAGsC,EAAG,GAI9BU,KAAKsF,aAAc,EACnBtF,KAAKuF,uBAAwB,EAI7BvF,KAAKwF,QC9BwB,CACjCxI,EAFkC,CAAG8F,IAAK,EAAGD,IAAK,GAGlDvD,EAHkC,CAAGwD,IAAK,EAAGD,IAAK,IDgC9C7C,KAAKkF,cAAgBA,EA0XzB,OAxXAD,EAA0BvN,UAAU+N,MAAQ,SAAUC,EAAa5F,GAC/D,IAAIC,EAAQC,KACsB2F,QAAlB,IAAP7F,EAAgB,GAAKA,GAAY8F,aAAcA,OAAsB,IAAPD,GAAwBA,GAI1D,IAAjC3F,KAAKkF,cAAcW,YAsFvB7F,KAAK8F,WAAa,IAAInG,EAAW+F,EAAa,CAC1ChE,eArFiB,SAAU9B,GAG3BG,EAAMgG,gBACFH,GACA7F,EAAM6F,cAAa,OAAiBhG,EAAO,QAAQf,QAiFvDiC,QA9EU,SAAUlB,EAAOU,GAC3B,IAAIR,EAEAkG,EAAKjG,EAAMkG,WAAYC,EAAOF,EAAGE,KAAMC,EAAkBH,EAAGG,gBAAiBC,EAAcJ,EAAGI,cAC9FF,GAASC,IACLpG,EAAMoF,gBACNpF,EAAMoF,iBACVpF,EAAMoF,gBAAiB,QAAce,GAEhCnG,EAAMoF,mBAGfpF,EAAMqF,YAAa,EACnBrF,EAAMsF,iBAAmB,KACzBtF,EAAMsG,qBACFtG,EAAMmF,cAAcoB,aACpBvG,EAAMmF,cAAcoB,WAAWC,oBAAqB,EACpDxG,EAAMmF,cAAcoB,WAAWtD,YAASvH,GAK5CoJ,GAAS,SAAUjC,GACf,IAAI9C,EAAIkG,EACJQ,EAAUzG,EAAM0G,mBAAmB7D,GAAM8D,OAAS,EAItD,GAAI,UAAaF,GAAU,CACvB,IAAIG,EAA+G,QAA/FX,EAA+C,QAAzClG,EAAKC,EAAMmF,cAAcoB,kBAA+B,IAAPxG,OAAgB,EAASA,EAAGkE,cAA2B,IAAPgC,OAAgB,EAASA,EAAGY,OAAOhE,GAC1J+D,IAEAH,EADe7D,EAAWgE,IACJE,WAAWL,GAAW,MAGpDzG,EAAMsD,YAAYT,GAAQ4D,KAG9BJ,SAA0DA,EAAYxG,EAAOU,GAC/B,QAA7CR,EAAKC,EAAMmF,cAAc4B,sBAAmC,IAAPhH,GAAyBA,EAAGiH,UAAU,UAAoB,KAwChHhG,OAtCS,SAAUnB,EAAOU,GAE1B,IAAIR,EAAKC,EAAMkG,WAAYE,EAAkBrG,EAAGqG,gBAAiBa,EAAoBlH,EAAGkH,kBAAmBC,EAAkBnH,EAAGmH,gBAAiBC,EAASpH,EAAGoH,OAE7J,GAAKf,GAAoBpG,EAAMoF,eAA/B,CAEA,IAAIxE,EAASL,EAAKK,OAElB,GAAIqG,GAAgD,OAA3BjH,EAAMsF,iBAM3B,OALAtF,EAAMsF,iBAmUtB,SAA6B1E,EAAQwG,QACX,IAAlBA,IAA4BA,EAAgB,IAChD,IAAIC,EAAY,KAOhB,OANInI,KAAKC,IAAIyB,EAAOrB,GAAK6H,EACrBC,EAAY,IAEPnI,KAAKC,IAAIyB,EAAO3D,GAAKmK,IAC1BC,EAAY,KAETA,EA5U8BC,CAAoB1G,QAEd,OAA3BZ,EAAMsF,mBACN4B,SAAkEA,EAAgBlH,EAAMsF,oBAKhGtF,EAAMuH,WAAW,IAAKhH,EAAKzB,MAAO8B,GAClCZ,EAAMuH,WAAW,IAAKhH,EAAKzB,MAAO8B,GAOlCZ,EAAMmF,cAAcqC,aAKpBL,SAAgDA,EAAOtH,EAAOU,KAS9DgB,aAPe,SAAU1B,EAAOU,GAChC,OAAOP,EAAMrB,KAAKkB,EAAOU,KAO1B,CAAEL,mBAAoBD,KAAKkF,cAAcsC,4BAEhDvC,EAA0BvN,UAAUgH,KAAO,SAAUkB,EAAOU,GACxD,IAAI8E,EAAapF,KAAKoF,WAEtB,GADApF,KAAKyH,SACArC,EAAL,CAEA,IAAIjD,EAAW7B,EAAK6B,SACpBnC,KAAK0H,eAAevF,GACpB,IAAIwF,EAAY3H,KAAKiG,WAAW0B,UAChCA,SAAsDA,EAAU/H,EAAOU,KAE3E2E,EAA0BvN,UAAU+P,OAAS,WACzC,IAAI3H,EAAIkG,EACRhG,KAAKoF,YAAa,EACdpF,KAAKkF,cAAcoB,aACnBtG,KAAKkF,cAAcoB,WAAWC,oBAAqB,GAE5B,QAA1BzG,EAAKE,KAAK8F,kBAA+B,IAAPhG,GAAyBA,EAAGsB,MAC/DpB,KAAK8F,gBAAarK,GACIuE,KAAKiG,WAAWE,iBACdnG,KAAKmF,iBACzBnF,KAAKmF,iBACLnF,KAAKmF,eAAiB,MAEmB,QAA5Ca,EAAKhG,KAAKkF,cAAc4B,sBAAmC,IAAPd,GAAyBA,EAAGe,UAAU,UAAoB,IAEnH9B,EAA0BvN,UAAU4P,WAAa,SAAU1E,EAAMgF,EAAQjH,GACrE,IAAIuF,EAAOlG,KAAKiG,WAAWC,KAE3B,GAAKvF,GAAWkH,EAAWjF,EAAMsD,EAAMlG,KAAKqF,kBAA5C,CAEA,IFpKkBxG,EAAOiB,EAAI0F,EAC7B1C,EAAcD,EEmKViF,EAAY9H,KAAKyG,mBAAmB7D,GACpCmF,EAAO/H,KAAKqD,YAAYT,GAAQjC,EAAOiC,GAEvC5C,KAAKsF,aAAetF,KAAKsF,YAAY1C,KFvKvB/D,EEwKUkJ,EFxKHjI,EEwKSE,KAAKsF,YAAY1C,GFxKtB4C,EEwK6BxF,KAAKwF,QAAQ5C,GFvKvEE,EAAMhD,EAAGgD,IAAKD,EAAM/C,EAAG+C,SACfpH,IAARqH,GAAqBjE,EAAQiE,EAE7BjE,EAAQ2G,GAAU,EAAAlC,EAAA,GAAIR,EAAKjE,EAAO2G,EAAQ1C,KAAO7D,KAAK4D,IAAIhE,EAAOiE,QAEpDrH,IAARoH,GAAqBhE,EAAQgE,IAElChE,EAAQ2G,GAAU,EAAAlC,EAAA,GAAIT,EAAKhE,EAAO2G,EAAQ3C,KAAO5D,KAAK6D,IAAIjE,EAAOgE,IEgK7DkF,EF9JDlJ,GEgKHiJ,EAAUE,IAAID,KAElB9C,EAA0BvN,UAAU2O,mBAAqB,WACrD,IAAItG,EAAQC,KACRF,EAAKE,KAAKiG,WAAYgC,EAAkBnI,EAAGmI,gBAAiBzD,EAAc1E,EAAG0E,YAC7ER,GAAUhE,KAAKkF,cAAcoB,YAAc,IAAItC,OAC/CkE,EAAkBlI,KAAKsF,YACvB2C,IAAmB,OAAYA,GAC1BjI,KAAKsF,cACNtF,KAAKsF,YAActF,KAAKmI,yBAKxBnI,KAAKsF,eADL2C,IAAmBjE,IF1JnC,SAAiCoE,EAAWtI,GACxC,IAAIuI,EAAMvI,EAAGuI,IAAK/Q,EAAOwI,EAAGxI,KAAMgR,EAASxI,EAAGwI,OAAQ9Q,EAAQsI,EAAGtI,MACjE,MAAO,CACHwF,EAAGkH,EAA4BkE,EAAUpL,EAAG1F,EAAME,GAClD8H,EAAG4E,EAA4BkE,EAAU9I,EAAG+I,EAAKC,IEuJtBC,CAAwBvE,EAAO4C,OAAQqB,GAMlEjI,KAAKwF,QFjGb,SAA4BhB,GAQxB,YAPoB,IAAhBA,IAA0BA,EAAcF,IACxB,IAAhBE,EACAA,EAAc,GAEO,IAAhBA,IACLA,EAAcF,GAEX,CACHtH,EAAGuH,EAAmBC,EAAa,OAAQ,SAC3ClF,EAAGiF,EAAmBC,EAAa,MAAO,WEuF3BgE,CAAmBhE,GAK9B0D,IAAoBlI,KAAKsF,aACzBtB,GACAhE,KAAKsF,cACJtF,KAAKuF,uBACNV,GAAS,SAAUjC,GACX7C,EAAM0G,mBAAmB7D,KACzB7C,EAAMuF,YAAY1C,GF1HtC,SAA+BoB,EAAQsB,GACnC,IAAImD,EAAsB,GAO1B,YANwBhN,IAApB6J,EAAYxC,MACZ2F,EAAoB3F,IAAMwC,EAAYxC,IAAMkB,EAAOlB,UAE/BrH,IAApB6J,EAAYzC,MACZ4F,EAAoB5F,IAAMyC,EAAYzC,IAAMmB,EAAOlB,KAEhD2F,EEkHmCC,CAAsB1E,EAAO4C,OAAOhE,GAAO7C,EAAMuF,YAAY1C,SAKvGqC,EAA0BvN,UAAUyQ,sBAAwB,WACxD,IAAIrI,EAAKE,KAAKiG,WAAYX,EAAcxF,EAAGmI,gBAAiBU,EAA2B7I,EAAG6I,yBAC1F,IAAKrD,KAAgB,OAAYA,GAC7B,OAAO,EACX,IAAIsD,EAAqBtD,EAAYkB,SACrC,OAAiC,OAAvBoC,EAA6B,0GACvC,IAAItC,EAAatG,KAAKkF,cAAcoB,WAEpC,IAAKA,IAAeA,EAAWtC,OAC3B,OAAO,EACX,IAAI6E,GAAiB,EAAAC,EAAA,GAAeF,EAAoBtC,EAAWyC,KAAM/I,KAAKkF,cAAcsC,yBACxFwB,EFnKZ,SAAiCZ,EAAWS,GACxC,MAAO,CACH7L,EAAGmH,EAA4BiE,EAAUpL,EAAG6L,EAAe7L,GAC3DsC,EAAG6E,EAA4BiE,EAAU9I,EAAGuJ,EAAevJ,IEgKjC2J,CAAwB3C,EAAWtC,OAAO4C,OAAQiC,GAK5E,GAAIF,EAA0B,CAC1B,IAAIO,EAAkBP,GAAyB,QAAwBK,IACvEhJ,KAAKuF,wBAA0B2D,EAC3BA,IACAF,GAAsB,QAAwBE,IAGtD,OAAOF,GAEX/D,EAA0BvN,UAAUgQ,eAAiB,SAAUvF,GAC3D,IAAIpC,EAAQC,KACRF,EAAKE,KAAKiG,WAAYC,EAAOpG,EAAGoG,KAAMiD,EAAerJ,EAAGqJ,aAAc3E,EAAc1E,EAAG0E,YAAa4E,EAAiBtJ,EAAGsJ,eAAgBC,EAAmBvJ,EAAGuJ,iBAAkBC,EAAsBxJ,EAAGwJ,oBACzMhE,EAActF,KAAKsF,aAAe,GAClCiE,EAAqB1E,GAAS,SAAUjC,GACxC,IAAI9C,EACJ,GAAK+H,EAAWjF,EAAMsD,EAAMnG,EAAMsF,kBAAlC,CAGA,IAAI5G,EAAoG,QAAtFqB,EAAKwF,aAAiD,EAASA,EAAY1C,UAA0B,IAAP9C,EAAgBA,EAAK,GACjIuJ,IACA5K,EAAa,CAAEqE,IAAK,EAAGD,IAAK,IAOhC,IAAI2G,EAAkBhF,EAAc,IAAM,IACtCiF,EAAgBjF,EAAc,GAAK,IACnCkF,GAAU,SAAS,QAAS,CAAEC,KAAM,UAAWxH,SAAUgH,EAAehH,EAASS,GAAQ,EAAG4G,gBAAiBA,EAAiBC,cAAeA,EAAeG,aAAc,IAAKC,UAAW,EAAGC,UAAW,IAAMV,GAAiB3K,GAInO,OAAOsB,EAAMgK,wBAAwBnH,EAAM8G,OAG/C,OAAOM,QAAQC,IAAIV,GAAoBW,KAAKZ,IAEhDrE,EAA0BvN,UAAUqS,wBAA0B,SAAUnH,EAAMnE,GAC1E,IAAIqJ,EAAY9H,KAAKyG,mBAAmB7D,GACxC,OAAO,QAAeA,EAAMkF,EAAW,EAAGrJ,IAE9CwG,EAA0BvN,UAAUqO,cAAgB,WAChD,IAAIhG,EAAQC,KACZ6E,GAAS,SAAUjC,GAAQ,OAAO7C,EAAM0G,mBAAmB7D,GAAMlE,WAQrEuG,EAA0BvN,UAAU+O,mBAAqB,SAAU7D,GAC/D,IAAI9C,EAAIkG,EACJmE,EAAU,QAAUvH,EAAKvE,cAE7B,OAD0B2B,KAAKkF,cAAce,WAAWkE,IAGlDnK,KAAKkF,cAAckF,SAASxH,EAA4G,QAArGoD,EAAsD,QAAhDlG,EAAKE,KAAKkF,cAAce,WAAWoE,eAA4B,IAAPvK,OAAgB,EAASA,EAAG8C,UAA0B,IAAPoD,EAAgBA,EAAK,IAE/Kf,EAA0BvN,UAAUkO,aAAe,SAAU/G,GACzD,IAAIkB,EAAQC,KACZ6E,GAAS,SAAUjC,GAGf,GAAKiF,EAAWjF,EAFL7C,EAAMkG,WAAWC,KAEAnG,EAAMsF,kBAAlC,CAEA,IAAIiB,EAAavG,EAAMmF,cAAcoB,WACjCwB,EAAY/H,EAAM0G,mBAAmB7D,GACzC,GAAI0D,GAAcA,EAAWtC,OAAQ,CACjC,IAAIlE,EAAKwG,EAAWtC,OAAO4C,OAAOhE,GAAOE,EAAMhD,EAAGgD,IAAKD,EAAM/C,EAAG+C,IAChEiF,EAAUE,IAAInJ,EAAM+D,IAAQ,EAAAU,EAAA,GAAIR,EAAKD,EAAK,WAStDoC,EAA0BvN,UAAU4S,+BAAiC,WACjE,IACIxK,EADAC,EAAQC,KAERgG,EAAKhG,KAAKiG,WAAYC,EAAOF,EAAGE,KAAM+B,EAAkBjC,EAAGiC,gBAC3D3B,EAAatG,KAAKkF,cAAcoB,WACpC,IAAK,OAAY2B,IAAqB3B,GAAetG,KAAKsF,YAA1D,CAMAtF,KAAK+F,gBAKL,IAAIwE,EAAc,CAAEvN,EAAG,EAAGsC,EAAG,GAC7BuF,GAAS,SAAUjC,GACf,IFhQQO,EAAQH,EACpBI,EACAoH,EACAC,EE6PQ3C,EAAY/H,EAAM0G,mBAAmB7D,GACzC,GAAIkF,EAAW,CACX,IAAI4C,EAAS5C,EAAUpB,MACvB6D,EAAY3H,IFnQRO,EEmQ2B,CAAEL,IAAK4H,EAAQ7H,IAAK6H,GFnQvC1H,EEmQiDjD,EAAMuF,YAAY1C,GFlQvFQ,EAAS,GACToH,EAAe7H,EAAWQ,IAC1BsH,EAAe9H,EAAWK,IACXwH,EACfpH,GAAS,EAAAuH,EAAA,GAAS3H,EAAOF,IAAKE,EAAOH,IAAM2H,EAAcrH,EAAOL,KAE3D0H,EAAeC,IACpBrH,GAAS,EAAAuH,EAAA,GAASxH,EAAOL,IAAKK,EAAON,IAAM4H,EAAczH,EAAOF,OAE7D,EAAA8H,EAAA,GAAM,EAAG,EAAGxH,QE+Pf,IAAIyH,EAAoB7K,KAAKkF,cAAce,WAAW4E,kBACtD7K,KAAKkF,cAAc4F,cAAcC,MAAMC,UAAYH,EAC7CA,EAAkB,GAAI,IACtB,OACqB,QAA1B/K,EAAKwG,EAAWyC,YAAyB,IAAPjJ,GAAyBA,EAAGmL,eAC/D3E,EAAW4E,eACXlL,KAAKqG,qBAKLxB,GAAS,SAAUjC,GACf,GAAKiF,EAAWjF,EAAMsD,EAAM,MAA5B,CAKA,IAAI4B,EAAY/H,EAAM0G,mBAAmB7D,GACrC9C,EAAKC,EAAMuF,YAAY1C,GAAOE,EAAMhD,EAAGgD,IAAKD,EAAM/C,EAAG+C,IACzDiF,EAAUE,KAAI,EAAA1E,EAAA,GAAIR,EAAKD,EAAK0H,EAAY3H,WAGhDqC,EAA0BvN,UAAUyT,aAAe,WAC/C,IACIrL,EADAC,EAAQC,KAEZ+E,EAAoBiD,IAAIhI,KAAKkF,cAAelF,MAC5C,IAAIoL,EAAUpL,KAAKkF,cAAc4F,cAI7BO,GAAsB,IAAAjR,GAAgBgR,EAAS,eAAe,SAAUxL,GACxE,IAAIE,EAAKC,EAAMkG,WAAYC,EAAOpG,EAAGoG,KAAMF,EAAKlG,EAAGwL,aACnDpF,SADuF,IAAPF,GAAuBA,IAC/EjG,EAAM0F,MAAM7F,MAEpC2L,EAAyB,WACzB,IAAItD,EAAkBlI,EAAMkG,WAAWgC,iBACnC,OAAYA,KACZlI,EAAMuF,YAAcvF,EAAMoI,0BAG9B7B,EAAatG,KAAKkF,cAAcoB,WAChCkF,EAA4BlF,EAAWmF,iBAAiB,UAAWF,GACnEjF,IAAeA,EAAWtC,SACC,QAA1BlE,EAAKwG,EAAWyC,YAAyB,IAAPjJ,GAAyBA,EAAGmL,eAC/D3E,EAAW4E,gBAEfK,IAKA,IAAIG,GAAqB,OAAY7J,OAAQ,UAAU,WACnD,OAAO9B,EAAMuK,oCAmBjB,OAbAhE,EAAWmF,iBAAiB,aAAa,SAAW3L,GAChD,IAAIkC,EAAQlC,EAAGkC,MAAO2J,EAAmB7L,EAAG6L,iBACxC5L,EAAMqF,YAAcuG,IACpB9G,GAAS,SAAUjC,GACf,IAAIgJ,EAAc7L,EAAM0G,mBAAmB7D,GACtCgJ,IAEL7L,EAAMsD,YAAYT,IAASZ,EAAMY,GAAMY,UACvCoI,EAAY5D,IAAI4D,EAAYlF,MAAQ1E,EAAMY,GAAMY,eAEpDzD,EAAMmF,cAAcqC,iBAGrB,WACHmE,IACAL,IACAG,MAGRvG,EAA0BvN,UAAUuO,SAAW,WAC3C,IAAI4F,EAAQ7L,KAAKkF,cAAce,WAC3BnG,EAAK+L,EAAM3F,KAAMA,OAAc,IAAPpG,GAAwBA,EAAIkG,EAAK6F,EAAM7E,kBAAmBA,OAA2B,IAAPhB,GAAwBA,EAAIL,EAAKkG,EAAM1F,gBAAiBA,OAAyB,IAAPR,GAAwBA,EAAImG,EAAKD,EAAM5D,gBAAiBA,OAAyB,IAAP6D,GAAwBA,EAAIC,EAAKF,EAAMrH,YAAaA,OAAqB,IAAPuH,EAAgBzH,EAAiByH,EAAIC,EAAKH,EAAM1C,aAAcA,OAAsB,IAAP6C,GAAuBA,EACpa,OAAO,SAAS,QAAS,GAAIH,GAAQ,CAAE3F,KAAMA,EAAMc,kBAAmBA,EAAmBb,gBAAiBA,EAAiB8B,gBAAiBA,EAAiBzD,YAAaA,EAAa2E,aAAcA,KAElMlE,EA5YmC,GA8Y9C,SAAS4C,EAAWT,EAAWlB,EAAMb,GACjC,SAAkB,IAATa,GAAiBA,IAASkB,GACT,OAArB/B,GAA6BA,IAAqB+B,G,gDEpavDlB,GAAO,CACP+F,KAAK,SCaT,SAAuBnM,GACnB,IAAIoM,EAAQpM,EAAGoM,MAAOC,EAAarM,EAAGqM,WAAYC,EAAWtM,EAAGsM,SAAUC,EAAoBvM,EAAGuM,kBAAmBnH,EAAgBpF,EAAGoF,cACnIoH,EAAeJ,GAASC,GAAcC,GAAYC,EAClDvG,GAAa,IAAAyG,QAAO,MACpBtM,GAAqB,IAAAuM,YAAWC,EAAA,GAAqBxM,mBACrDJ,EAAW,CACX6B,eAAgB2K,EAChBvL,QAASqL,EACTpL,OAAQmL,EACR7K,MAAO,SAAUzB,EAAOU,GACpBwF,EAAWU,QAAU,KACrB4F,GAAYA,EAASxM,EAAOU,MAGpC,IAAAoM,YAAU,WACqB,OAAvB5G,EAAWU,SACXV,EAAWU,QAAQ1E,eAAejC,OAQ1C,OAAgBqF,EAAe,cAAeoH,GAL9C,SAAuB1M,GACnBkG,EAAWU,QAAU,IAAI7G,EAAWC,EAAOC,EAAU,CACjDI,mBAAoBA,OAI5B,QAAiB,WAAc,OAAO6F,EAAWU,SAAWV,EAAWU,QAAQpF,YDrC/E8E,MAAM,SEGV,SAAiB2F,GACb,IAAIc,EAAoBd,EAAMe,aAAc1H,EAAgB2G,EAAM3G,cAC9D0H,GAAe,QAAY,WAAc,OAAO,IAAI3H,EAA0BC,OAGlF,IAAAwH,YAAU,WAAc,OAAOC,GAAqBA,EAAkBE,UAAUD,KAAkB,CAACA,EAAcD,KAEjH,IAAAD,YAAU,WAAc,OAAOE,EAAazB,iBAAmB,CAACyB,Q,gDCdpE,SAASE,GAAgBC,EAAQnK,GAC7B,OAAIA,EAAKC,MAAQD,EAAKE,IACX,EACHiK,GAAUnK,EAAKC,IAAMD,EAAKE,KAAQ,IAS9C,IAAIkK,GAAsB,CACtBC,QAAS,SAAUvC,EAAQwC,GACvB,IAAKA,EAAKlK,OACN,OAAO0H,EAKX,GAAsB,iBAAXA,EAAqB,CAC5B,IAAI,EAAAyC,GAAA,KAAQzC,GAIR,OAAOA,EAHPA,EAAS7D,WAAW6D,GAU5B,IAAI1N,EAAI8P,GAAgBpC,EAAQwC,EAAKlK,OAAOhG,GACxCsC,EAAIwN,GAAgBpC,EAAQwC,EAAKlK,OAAO1D,GAC5C,MAAO,GAAG3H,OAAOqF,EAAG,MAAMrF,OAAO2H,EAAG,O,wBChCxC8N,GAAW,QACXC,GAAmB,CACnBJ,QAAS,SAAUvC,EAAQ5K,GACvB,IAAIwN,EAAYxN,EAAGwN,UAAWC,EAAkBzN,EAAGyN,gBAC/CC,EAAW9C,EAIX+C,EAAuB/C,EAAOhP,SAAS,QACvCgS,EAAe,GACfD,IACA/C,EAASA,EAAOpS,QAAQ,OAAkB,SAAUN,GAEhD,OADA0V,EAAa7M,KAAK7I,GACXoV,OAGf,IAAIO,EAASC,GAAA,QAAclD,GAE3B,GAAIiD,EAAOtW,OAAS,EAChB,OAAOmW,EACX,IAAIK,EAAWD,GAAA,oBAA0BlD,GACrC/J,EAA8B,iBAAdgN,EAAO,GAAkB,EAAI,EAE7CG,EAASP,EAAgBvQ,EAAEuG,MAAQ+J,EAAUtQ,EAC7C+Q,EAASR,EAAgBjO,EAAEiE,MAAQ+J,EAAUhO,EACjDqO,EAAO,EAAIhN,IAAWmN,EACtBH,EAAO,EAAIhN,IAAWoN,EAOtB,IAAIC,GAAe,EAAA1K,EAAA,GAAIwK,EAAQC,EAAQ,IAEL,iBAAvBJ,EAAO,EAAIhN,KAClBgN,EAAO,EAAIhN,IAAWqN,GAEQ,iBAAvBL,EAAO,EAAIhN,KAClBgN,EAAO,EAAIhN,IAAWqN,GAC1B,IAAIC,EAASJ,EAASF,GACtB,GAAIF,EAAsB,CACtB,IAAIS,EAAM,EACVD,EAASA,EAAO3V,QAAQ8U,IAAU,WAC9B,IAAIe,EAAcT,EAAaQ,GAE/B,OADAA,IACOC,KAGf,OAAOF,I,YC1CXG,GAA0C,SAAUC,GAEpD,SAASD,IACL,OAAkB,OAAXC,GAAmBA,EAAOC,MAAMtO,KAAMuO,YAAcvO,KA+F/D,OAjGA,QAAUoO,EAA0BC,GASpCD,EAAyB1W,UAAU8W,kBAAoB,WACnD,IAAIzO,EAAQC,KACRF,EAAKE,KAAK6L,MAAO3G,EAAgBpF,EAAGoF,cAAeuJ,EAAc3O,EAAG2O,YAAaC,EAAoB5O,EAAG4O,kBAAmBC,EAAW7O,EAAG6O,SACzIrI,EAAapB,EAAcoB,YAC/B,QAAkBsI,IACdtI,KACImI,aAAiD,EAASA,EAAYI,QACtEJ,EAAYI,MAAMC,IAAIxI,IACrBoI,aAA6D,EAASA,EAAkBK,WAAaJ,GACtGD,EAAkBK,SAASzI,GAE/BA,EAAWyC,KAAKiG,YAChB1I,EAAWmF,iBAAiB,qBAAqB,WAC7C1L,EAAMkP,kBAEV3I,EAAW4I,YAAW,SAAS,QAAS,GAAI5I,EAAWvM,SAAU,CAAEoV,eAAgB,WAAc,OAAOpP,EAAMkP,oBAElH,qBAAuC,GAE3Cb,EAAyB1W,UAAU0X,wBAA0B,SAAUC,GACnE,IAAItP,EAAQC,KACRF,EAAKE,KAAK6L,MAAOyD,EAAmBxP,EAAGwP,iBAAkBpK,EAAgBpF,EAAGoF,cAAegB,EAAOpG,EAAGoG,KAAML,EAAY/F,EAAG+F,UAC1HS,EAAapB,EAAcoB,WAC/B,OAAKA,GASLA,EAAWT,UAAYA,EACnBK,GACAmJ,EAAUC,mBAAqBA,QACV7T,IAArB6T,EACAhJ,EAAWiJ,aAGXvP,KAAKiP,eAELI,EAAUxJ,YAAcA,IACpBA,EACAS,EAAWkJ,UAELlJ,EAAWmJ,YAMjB,iBAAgB,WACZ,IAAI3P,GACmC,QAAhCA,EAAKwG,EAAWoJ,kBAA+B,IAAP5P,OAAgB,EAASA,EAAG6P,QAAQtY,SAC/E0I,EAAMkP,mBAKf,MAnCI,MAqCfb,EAAyB1W,UAAUkY,mBAAqB,WACpD,IAAItJ,EAAatG,KAAK6L,MAAM3G,cAAcoB,WACtCA,IACAA,EAAWyC,KAAKiG,aACX1I,EAAWuJ,kBAAoBvJ,EAAWwJ,UAC3C9P,KAAKiP,iBAIjBb,EAAyB1W,UAAUqY,qBAAuB,WACtD,IAAIjQ,EAAKE,KAAK6L,MAAO3G,EAAgBpF,EAAGoF,cAAeuJ,EAAc3O,EAAG2O,YAAauB,EAAiBlQ,EAAG4O,kBACrGpI,EAAapB,EAAcoB,WAC3BA,IACAA,EAAW2J,6BACPxB,aAAiD,EAASA,EAAYI,QACtEJ,EAAYI,MAAMqB,OAAO5J,IACzB0J,aAAuD,EAASA,EAAeG,aAC/EH,EAAeG,WAAW7J,KAGtC8H,EAAyB1W,UAAUuX,aAAe,WAC9C,IAAIA,EAAejP,KAAK6L,MAAMoD,aAC9BA,SAA4DA,KAEhEb,EAAyB1W,UAAU0Y,OAAS,WACxC,OAAO,MAEJhC,EAlGkC,CAmG3C,aAMEQ,GAAyB,CACzByB,cAAc,SAAS,QAAS,GAAIrD,IAAsB,CAAEsD,QAAS,CAC7D,sBACA,uBACA,yBACA,6BAERC,oBAAqBvD,GACrBwD,qBAAsBxD,GACtByD,uBAAwBzD,GACxB0D,wBAAyB1D,GACzB2D,UAAWtD,IC7HXuD,GAAiB,CACjBC,cD4GJ,SAAuBhF,GACnB,IAAI/L,GAAK,SAAO,WAAe,GAAI+F,EAAY/F,EAAG,GAAImP,EAAenP,EAAG,GACpE2O,GAAc,IAAAjC,YAAWsE,GAAA,GAC7B,OAAQ,gBAA6B1C,IAA0B,QAAS,GAAIvC,EAAO,CAAE4C,YAAaA,EAAaC,mBAAmB,IAAAlC,YAAWuE,GAAA,GAA2BlL,UAAWA,EAAWoJ,aAAcA,O,8CE/G5M+B,GAAU,CAAC,UAAW,WAAY,aAAc,eAChDC,GAAaD,GAAQ3Z,OACrB6Z,GAAW,SAAUrX,GACrB,MAAwB,iBAAVA,EAAqBgN,WAAWhN,GAASA,GAEvDsX,GAAO,SAAUtX,GACjB,MAAwB,iBAAVA,GAAsB,EAAAsT,GAAA,KAAQtT,IA6ChD,SAASuX,GAAUC,EAAQC,GACvB,IAAIxR,EACJ,OAAqC,QAA7BA,EAAKuR,EAAOC,UAAgC,IAAPxR,EAAgBA,EAAKuR,EAAOhB,aAyB7E,IAAIkB,GAAkBC,GAAS,EAAG,GAAK,OACnCC,GAAmBD,GAAS,GAAK,IAAM,OAC3C,SAASA,GAAS1O,EAAKD,EAAK6O,GACxB,OAAO,SAAUC,GAEb,OAAIA,EAAI7O,EACG,EACP6O,EAAI9O,EACG,EACJ6O,GAAO,EAAA/G,EAAA,GAAS7H,EAAKD,EAAK8O,KCrFzC,SAASC,GAAahP,EAAMiP,GACxBjP,EAAKE,IAAM+O,EAAW/O,IACtBF,EAAKC,IAAMgP,EAAWhP,IAO1B,SAASiP,GAAYC,EAAKC,GACtBJ,GAAaG,EAAI/U,EAAGgV,EAAUhV,GAC9B4U,GAAaG,EAAIzS,EAAG0S,EAAU1S,G,eCRlC,SAAS2S,GAAiBpT,EAAO2E,EAAWD,EAAOF,EAAa6O,GAM5D,OALArT,GAAS2E,EACT3E,GAAQ,SAAWA,EAAO,EAAI0E,EAAOF,QACpB5H,IAAbyW,IACArT,GAAQ,SAAWA,EAAO,EAAIqT,EAAU7O,IAErCxE,EA4BX,SAASsT,GAAqBvP,EAAMwP,EAAYtS,EAAIsD,EAAQiP,GACxD,IAAIrM,GAAK,QAAOlG,EAAI,GAAIjH,EAAMmN,EAAG,GAAIsM,EAAWtM,EAAG,GAAIuM,EAAYvM,EAAG,IAxB1E,SAAyBpD,EAAMY,EAAWD,EAAOH,EAAQ8O,EAAUL,EAAYQ,GAW3E,QAVkB,IAAd7O,IAAwBA,EAAY,QAC1B,IAAVD,IAAoBA,EAAQ,QACjB,IAAXH,IAAqBA,EAAS,SACf,IAAfyO,IAAyBA,EAAajP,QACvB,IAAfyP,IAAyBA,EAAazP,GACtC,UAAaY,KACbA,EAAYqD,WAAWrD,GAEvBA,GADuB,EAAAF,EAAA,GAAI+O,EAAWvP,IAAKuP,EAAWxP,IAAKW,EAAY,KACxC6O,EAAWvP,KAErB,iBAAdU,EAAX,CAEA,IAAIH,GAAc,EAAAC,EAAA,GAAIuO,EAAW/O,IAAK+O,EAAWhP,IAAKO,GAClDR,IAASiP,IACTxO,GAAeG,GACnBZ,EAAKE,IAAMmP,GAAiBrP,EAAKE,IAAKU,EAAWD,EAAOF,EAAa6O,GACrEtP,EAAKC,IAAMoP,GAAiBrP,EAAKC,IAAKW,EAAWD,EAAOF,EAAa6O,IAQrEM,CAAgB5P,EAAMwP,EAAWvZ,GAAMuZ,EAAWE,GAAWF,EAAWG,GAAYH,EAAW7O,MAAOH,EAAQiP,GAKlH,IAAII,GAAQ,CAAC,IAAK,SAAU,WACxBC,GAAQ,CAAC,IAAK,SAAU,WAK5B,SAASC,GAAoBZ,EAAKK,EAAYJ,EAAWY,GACrDT,GAAqBJ,EAAI/U,EAAGoV,EAAYK,GAAOT,aAA6C,EAASA,EAAUhV,EAAG4V,aAA6C,EAASA,EAAU5V,GAClLmV,GAAqBJ,EAAIzS,EAAG8S,EAAYM,GAAOV,aAA6C,EAASA,EAAU1S,EAAGsT,aAA6C,EAASA,EAAUtT,GCzDtL,SAASuT,GAAgB7Q,GACrB,OAA2B,IAApBA,EAAMwB,WAAmC,IAAhBxB,EAAMuB,MAE1C,SAASuP,GAAY9Q,GACjB,OAAO6Q,GAAgB7Q,EAAMhF,IAAM6V,GAAgB7Q,EAAM1C,GAE7D,SAASyT,GAAU3Y,EAAGC,GAClB,OAAQD,EAAE4C,EAAE8F,MAAQzI,EAAE2C,EAAE8F,KACpB1I,EAAE4C,EAAE6F,MAAQxI,EAAE2C,EAAE6F,KAChBzI,EAAEkF,EAAEwD,MAAQzI,EAAEiF,EAAEwD,KAChB1I,EAAEkF,EAAEuD,MAAQxI,EAAEiF,EAAEuD,I,gBCRpBmQ,GAA2B,WAC3B,SAASA,IACLhT,KAAK2P,QAAU,GAwGnB,OAtGAqD,EAAUtb,UAAUoX,IAAM,SAAU5B,IAChC,SAAclN,KAAK2P,QAASzC,GAC5BA,EAAK+F,kBAETD,EAAUtb,UAAUwY,OAAS,SAAUhD,GAKnC,IAJA,SAAWlN,KAAK2P,QAASzC,GACrBA,IAASlN,KAAKkT,WACdlT,KAAKkT,cAAWzX,GAEhByR,IAASlN,KAAKmT,KAAM,CACpB,IAAID,EAAWlT,KAAK2P,QAAQ3P,KAAK2P,QAAQtY,OAAS,GAC9C6b,GACAlT,KAAKwP,QAAQ0D,KAIzBF,EAAUtb,UAAU+X,SAAW,SAAUvC,GACrC,IAMIgG,EANAE,EAAcpT,KAAK2P,QAAQ0D,WAAU,SAAUC,GAAU,OAAOpG,IAASoG,KAC7E,GAAoB,IAAhBF,EACA,OAAO,EAKX,IAAK,IAAInb,EAAImb,EAAanb,GAAK,EAAGA,IAAK,CACnC,IAAIqb,EAAStT,KAAK2P,QAAQ1X,GAC1B,IAAyB,IAArBqb,EAAOzN,UAAqB,CAC5BqN,EAAWI,EACX,OAGR,QAAIJ,IACAlT,KAAKwP,QAAQ0D,IACN,IAMfF,EAAUtb,UAAU8X,QAAU,SAAUtC,EAAMqG,GAC1C,IAAIzT,EACAoT,EAAWlT,KAAKmT,KAChBjG,IAASgG,IAEblT,KAAKkT,SAAWA,EAChBlT,KAAKmT,KAAOjG,EACZA,EAAKsG,OACDN,IACAA,EAASO,UAAYP,EAASD,iBAC9B/F,EAAK+F,iBACL/F,EAAKwG,WAAaR,EACdK,IACArG,EAAKwG,WAAWC,iBAAkB,GAElCT,EAASU,WACT1G,EAAK0G,SAAWV,EAASU,SACzB1G,EAAK0G,SAASC,aACVX,EAASY,iBAAmBZ,EAASW,aACzC3G,EAAK0G,SAASG,UAAW,IAEJ,QAApBjU,EAAKoN,EAAKnE,YAAyB,IAAPjJ,OAAgB,EAASA,EAAGkU,cACzD9G,EAAK+G,eAAgB,IAGP,IADF/G,EAAKnT,QAAQma,WAEzBhB,EAASiB,UAgBrBnB,EAAUtb,UAAU0c,sBAAwB,WACxCpU,KAAK2P,QAAQ0E,SAAQ,SAAUnH,GAC3B,IAAIpN,EAAIkG,EAAIL,EAAImG,EAAIC,EAC0B,QAA7C/F,GAAMlG,EAAKoN,EAAKnT,SAASoV,sBAAmC,IAAPnJ,GAAyBA,EAAGpO,KAAKkI,GACmB,QAAzGiM,EAAkC,QAA5BpG,EAAKuH,EAAKoH,oBAAiC,IAAP3O,OAAgB,GAAUmG,EAAKnG,EAAG5L,SAASoV,sBAAmC,IAAPpD,GAAyBA,EAAGnU,KAAKkU,OAG3JkH,EAAUtb,UAAUub,eAAiB,WACjCjT,KAAK2P,QAAQ0E,SAAQ,SAAUnH,GAC3BA,EAAKuG,UAAYvG,EAAK+F,gBAAe,OAO7CD,EAAUtb,UAAU6c,mBAAqB,WACjCvU,KAAKmT,MAAQnT,KAAKmT,KAAKS,WACvB5T,KAAKmT,KAAKS,cAAWnY,IAGtBuX,EA1GmB,GCD9B,SAASwB,GAAyBxS,EAAOsL,EAAWmH,GAOhD,IAAIC,EAAa1S,EAAMhF,EAAEwG,UAAY8J,EAAUtQ,EAC3C2X,EAAa3S,EAAM1C,EAAEkE,UAAY8J,EAAUhO,EAC3C0L,EAAY,eAAerT,OAAO+c,EAAY,QAAQ/c,OAAOgd,EAAY,WAM7E,GADA3J,GAAa,SAASrT,OAAO,EAAI2V,EAAUtQ,EAAG,MAAMrF,OAAO,EAAI2V,EAAUhO,EAAG,MACxEmV,EAAiB,CACjB,IAAIG,EAASH,EAAgBG,OAAQC,EAAUJ,EAAgBI,QAASC,EAAUL,EAAgBK,QAC9FF,IACA5J,GAAa,UAAUrT,OAAOid,EAAQ,UACtCC,IACA7J,GAAa,WAAWrT,OAAOkd,EAAS,UACxCC,IACA9J,GAAa,WAAWrT,OAAOmd,EAAS,UAMhD,IAAIC,EAAgB/S,EAAMhF,EAAEuG,MAAQ+J,EAAUtQ,EAC1CgY,EAAgBhT,EAAM1C,EAAEiE,MAAQ+J,EAAUhO,EAE9C,MAhCqB,sDA+BrB0L,GAAa,SAASrT,OAAOod,EAAe,MAAMpd,OAAOqd,EAAe,MAC9B,OAAShK,E,4BChCnDiK,GAAiB,SAAU7a,EAAGC,GAC9B,OAAOD,EAAE8a,MAAQ7a,EAAE6a,OCEnBC,GAA0B,WAC1B,SAASA,IACLnV,KAAKoV,SAAW,GAChBpV,KAAKqV,SAAU,EAenB,OAbAF,EAASzd,UAAUoX,IAAM,SAAUwG,IAC/B,SAActV,KAAKoV,SAAUE,GAC7BtV,KAAKqV,SAAU,GAEnBF,EAASzd,UAAUwY,OAAS,SAAUoF,IAClC,SAAWtV,KAAKoV,SAAUE,GAC1BtV,KAAKqV,SAAU,GAEnBF,EAASzd,UAAU2c,QAAU,SAAUvP,GACnC9E,KAAKqV,SAAWrV,KAAKoV,SAASjb,KAAK8a,IACnCjV,KAAKqV,SAAU,EACfrV,KAAKoV,SAASf,QAAQvP,IAEnBqQ,EAlBkB,G,YCyB7B,SAASI,GAAqBzV,GAC1B,IAAI0V,EAAuB1V,EAAG0V,qBAAsBC,EAAgB3V,EAAG2V,cAAeC,EAAgB5V,EAAG4V,cAAeC,EAAoB7V,EAAG6V,kBAAmBC,EAAiB9V,EAAG8V,eACtL,OAAsB,WAClB,SAASC,EAAeC,EAAIjC,EAAc/P,GACtC,IAAI/D,EAAQC,UACS,IAAjB6T,IAA2BA,EAAe,SAC/B,IAAX/P,IAAqBA,EAAS2R,aAAqD,EAASA,KAOhGzV,KAAKoV,SAAW,IAAIW,IAKpB/V,KAAKjG,QAAU,GAMfiG,KAAKgW,iBAAkB,EACvBhW,KAAKuG,oBAAqB,EAO1BvG,KAAKiU,eAAgB,EAIrBjU,KAAKiW,uBAAwB,EAC7BjW,KAAKkW,uBAAwB,EAK7BlW,KAAKgU,YAAa,EAIlBhU,KAAKmW,OAAQ,EAKbnW,KAAKoW,YAAa,EAIlBpW,KAAKqW,sBAAuB,EAS5BrW,KAAKsN,UAAY,CAAEtQ,EAAG,EAAGsC,EAAG,GAI5BU,KAAKsW,cAAgB,IAAIC,IAEzBvW,KAAKwW,eAAiB,IAAID,IAC1BvW,KAAKyW,kBAAoB,WACjB1W,EAAMiU,aACNjU,EAAMiU,YAAa,EACnBjU,EAAM2W,sBAGd1W,KAAK2W,iBAAmB,WACpB5W,EAAM6W,MAAMvC,QAAQwC,IACpB9W,EAAM6W,MAAMvC,QAAQyC,KAExB9W,KAAK+W,cAAe,EACpB/W,KAAKgX,WAAY,EACjBhX,KAAKiX,kBAAoB,EAKzBjX,KAAKkX,YAAc,IAAIX,IACvBvW,KAAK8V,GAAKA,EACV9V,KAAK6T,aAAeA,EACpB7T,KAAK+I,KAAOjF,EAASA,EAAOiF,MAAQjF,EAAS9D,KAC7CA,KAAKmX,KAAOrT,GAAS,SAAc,QAAc,IAAI,QAAOA,EAAOqT,OAAO,GAAQ,CAACrT,IAAS,GAAS,GACrG9D,KAAK8D,OAASA,EACd9D,KAAKkV,MAAQpR,EAASA,EAAOoR,MAAQ,EAAI,EACzCY,GAAM9V,KAAK+I,KAAKqO,sBAAsBtB,EAAI9V,MAC1C,IAAK,IAAI/H,EAAI,EAAGA,EAAI+H,KAAKmX,KAAK9f,OAAQY,IAClC+H,KAAKmX,KAAKlf,GAAGoe,sBAAuB,EAEpCrW,KAAK+I,OAAS/I,OACdA,KAAK4W,MAAQ,IAAIzB,IAs5BzB,OAp5BAU,EAAene,UAAU+T,iBAAmB,SAAU4L,EAAMC,GAIxD,OAHKtX,KAAKsW,cAAciB,IAAIF,IACxBrX,KAAKsW,cAActO,IAAIqP,EAAM,IAAI,MAE9BrX,KAAKsW,cAAc5P,IAAI2Q,GAAMvI,IAAIwI,IAE5CzB,EAAene,UAAU8f,gBAAkB,SAAUH,GAEjD,IADA,IAAII,EAAO,GACFC,EAAK,EAAGA,EAAKnJ,UAAUlX,OAAQqgB,IACpCD,EAAKC,EAAK,GAAKnJ,UAAUmJ,GAE7B,IAAIC,EAAsB3X,KAAKsW,cAAc5P,IAAI2Q,GACjDM,SAA0EA,EAAoBC,OAAOtJ,MAAMqJ,GAAqB,QAAc,IAAI,QAAOF,IAAO,KAEpK5B,EAAene,UAAUmgB,aAAe,SAAUR,GAC9C,OAAOrX,KAAKsW,cAAciB,IAAIF,IAElCxB,EAAene,UAAU0f,sBAAwB,SAAUtB,EAAI5I,GAC3DlN,KAAKwW,eAAexO,IAAI8N,EAAI5I,IAKhC2I,EAAene,UAAUogB,MAAQ,SAAUrE,EAAUQ,GACjD,IACInU,EADAC,EAAQC,KAGZ,QADsB,IAAlBiU,IAA4BA,GAAgB,IAC5CjU,KAAKyT,SAAT,CAEAzT,KAAKmW,MACD1C,aAAoBsE,YAAmC,QAArBtE,EAASuE,QAC/ChY,KAAKyT,SAAWA,EAChB,IAAIzN,EAAKhG,KAAKjG,QAAS4U,EAAW3I,EAAG2I,SAAU3K,EAASgC,EAAGhC,OAAQkB,EAAgBc,EAAGd,cAUtF,GATIA,IAAkBA,EAAc4F,eAChC5F,EAAc4S,MAAMrE,GAExBzT,KAAK+I,KAAK6N,MAAM9H,IAAI9O,MACG,QAAtBF,EAAKE,KAAK8D,cAA2B,IAAPhE,GAAyBA,EAAGsV,SAAStG,IAAI9O,MACxEA,KAAK8V,IAAM9V,KAAK+I,KAAKyN,eAAeyB,OAAOjY,KAAK8V,IAC5C7B,IAAkBjQ,GAAU2K,KAC5B3O,KAAKiU,eAAgB,GAErBuB,EAAsB,CACtB,IAAI0C,EACAC,EAAwB,WACxB,OAAQpY,EAAMgJ,KAAKmN,uBAAwB,GAE/CV,EAAqB/B,GAAU,WAC3B1T,EAAMgJ,KAAKmN,uBAAwB,EACnCkC,aAAaF,GACbA,EAAmBrW,OAAOwW,WAAWF,EAAuB,KACxD,8BACA,6BAA+C,EAC/CpY,EAAM6W,MAAMvC,QAAQiE,QAI5B3J,GACA3O,KAAK+I,KAAKwP,mBAAmB5J,EAAU3O,OAGd,IAAzBA,KAAKjG,QAAQuE,SACb4G,IACCyJ,GAAY3K,IACbhE,KAAKyL,iBAAiB,aAAa,SAAU3L,GACzC,IAAIkG,EAAIL,EAAImG,EAAIC,EAAIC,EAChBhK,EAAQlC,EAAGkC,MAAO2J,EAAmB7L,EAAG6L,iBAAkB6M,EAA2B1Y,EAAG0Y,yBAA0BC,EAAY3Y,EAAGkE,OACrI,GAAIjE,EAAM2Y,yBAGN,OAFA3Y,EAAMiD,YAASvH,OACfsE,EAAM4Y,oBAAiBld,GAI3B,IAAImd,EAAoI,QAAhHjT,EAAyC,QAAnCK,EAAKjG,EAAMhG,QAAQ0E,kBAA+B,IAAPuH,EAAgBA,EAAKd,EAAc2T,8BAA2C,IAAPlT,EAAgBA,EAAKmT,GACjKC,EAAK7T,EAAce,WAAY+S,EAAyBD,EAAGC,uBAAwBC,EAA4BF,EAAGE,0BAKlHC,GAAiBnZ,EAAMoZ,eACtBpG,GAAUhT,EAAMoZ,aAAcV,IAC/BD,EAMAY,GAAgCzN,GAAoB6M,EACxD,IAAiC,QAA3B1M,EAAK/L,EAAM2T,kBAA+B,IAAP5H,OAAgB,EAASA,EAAG2H,WACjE2F,GACCzN,IACIuN,IAAkBnZ,EAAM8P,kBAAoB,CAC7C9P,EAAM2T,aACN3T,EAAMuU,aAAevU,EAAM2T,WAC3B3T,EAAMuU,aAAaA,kBAAe7Y,GAEtCsE,EAAMsZ,mBAAmBrX,EAAOoX,GAChC,IAAIE,GAAmB,SAAS,QAAS,IAAI,QAAmBV,EAAkB,WAAY,CAAEW,OAAQP,EAAwBQ,WAAYP,IACxI/T,EAAcuU,qBACdH,EAAiBI,MAAQ,EACzBJ,EAAiB3P,MAAO,GAE5B5J,EAAM2H,eAAe4R,QAQhB3N,GAC2B,IAA5B5L,EAAMkX,mBACNlX,EAAMuY,kBAEVvY,EAAM+P,WAA4D,QAA9C9D,GAAMD,EAAKhM,EAAMhG,SAASoV,sBAAmC,IAAPnD,GAAyBA,EAAGpU,KAAKmU,IAE/GhM,EAAMoZ,aAAeV,OAIjC5C,EAAene,UAAUiiB,QAAU,WAC/B,IAAI7Z,EAAIkG,EACRhG,KAAKjG,QAAQ4U,UAAY3O,KAAKuP,aAC9BvP,KAAK+I,KAAK6N,MAAM1G,OAAOlQ,MACI,QAA1BF,EAAKE,KAAK0P,kBAA+B,IAAP5P,GAAyBA,EAAGoQ,OAAOlQ,MAC/C,QAAtBgG,EAAKhG,KAAK8D,cAA2B,IAAPkC,GAAyBA,EAAGoP,SAAS6C,OAAOjY,MAC3EA,KAAKyT,cAAWhY,EAChB,eAAqBuE,KAAK2W,mBAG9Bd,EAAene,UAAUkiB,YAAc,WACnC5Z,KAAKiW,uBAAwB,GAEjCJ,EAAene,UAAUmiB,cAAgB,WACrC7Z,KAAKiW,uBAAwB,GAEjCJ,EAAene,UAAUoiB,gBAAkB,WACvC,OAAO9Z,KAAKiW,uBAAyBjW,KAAKkW,uBAE9CL,EAAene,UAAUghB,uBAAyB,WAC9C,IAAI5Y,EACJ,OAAQE,KAAKuG,qBACe,QAAtBzG,EAAKE,KAAK8D,cAA2B,IAAPhE,OAAgB,EAASA,EAAG4Y,4BAC5D,GAGR7C,EAAene,UAAUqiB,YAAc,WACnC,IAAIja,EACAE,KAAK8Z,oBAET9Z,KAAKgU,YAAa,EACI,QAArBlU,EAAKE,KAAK4W,aAA0B,IAAP9W,GAAyBA,EAAGuU,QAAQ2F,MAEtEnE,EAAene,UAAU6X,WAAa,SAAU0K,GAC5C,IAAIna,EAAIkG,EAAIL,EAEZ,QAD8B,IAA1BsU,IAAoCA,GAAwB,GAC5Dja,KAAK+I,KAAK+Q,kBACoC,QAA7C9T,GAAMlG,EAAKE,KAAKjG,SAASoV,sBAAmC,IAAPnJ,GAAyBA,EAAGpO,KAAKkI,QAI3F,IADCE,KAAK+I,KAAKiL,YAAchU,KAAK+I,KAAKgR,eAC/B/Z,KAAKiU,cAAT,CAEAjU,KAAKiU,eAAgB,EACrB,IAAK,IAAIhc,EAAI,EAAGA,EAAI+H,KAAKmX,KAAK9f,OAAQY,IAAK,CACvC,IAAIiV,EAAOlN,KAAKmX,KAAKlf,GACrBiV,EAAKmJ,sBAAuB,EAK5BnJ,EAAKjC,eAET,IAAIa,EAAK9L,KAAKjG,QAAS4U,EAAW7C,EAAG6C,SAAU3K,EAAS8H,EAAG9H,OAC3D,QAAiBvI,IAAbkT,GAA2B3K,EAA/B,CAEA,IAAI6G,EAA0D,QAArClF,EAAK3F,KAAKjG,QAAQmL,qBAAkC,IAAPS,OAAgB,EAASA,EAAGM,WAAW4E,kBAC7G7K,KAAKka,2BAA6BrP,aAA6D,EAASA,EAAkB7K,KAAK6T,aAAc,IAC7I7T,KAAKma,iBACLF,GAAyBja,KAAKwX,gBAAgB,iBAGlD3B,EAAene,UAAUsX,UAAY,WAKjC,GAJuBhP,KAAK8Z,kBAQxB,OAHA9Z,KAAK6Z,gBACL7Z,KAAK0W,yBACL1W,KAAK4W,MAAMvC,QAAQ+F,IAGlBpa,KAAKgU,aAEVhU,KAAKgU,YAAa,EAOdhU,KAAKwW,eAAe6D,OACpBra,KAAKwW,eAAenC,QAAQiG,IAC5Bta,KAAKwW,eAAe+D,SAKxBva,KAAK4W,MAAMvC,QAAQmG,IAKnBxa,KAAK4W,MAAMvC,QAAQnJ,IAKnBlL,KAAK4W,MAAMvC,QAAQoG,IACnBza,KAAK0W,oBAEL,cACA,iBACA,gBAEJb,EAAene,UAAUgf,kBAAoB,WACzC1W,KAAK4W,MAAMvC,QAAQqG,IACnB1a,KAAKkX,YAAY7C,QAAQsG,KAE7B9E,EAAene,UAAUkjB,yBAA2B,WAChD,eAAe5a,KAAK2W,kBAAkB,GAAO,IAEjDd,EAAene,UAAUuY,0BAA4B,WACjD,IAAIlQ,EAAQC,KAMZ,iBAAgB,WACRD,EAAMkU,cACNlU,EAAMgJ,KAAKiG,YAGXjP,EAAMgJ,KAAK0N,wBAOvBZ,EAAene,UAAUyiB,eAAiB,WACtC,IAAIna,KAAK4T,UAAa5T,KAAKyT,SAA3B,CAEA,IAAIoH,EAAW7a,KAAK8I,UAChB9E,EAAShE,KAAK8a,gBAAgB9a,KAAK+a,oBAAoBF,IAC3DG,GAAShX,GACThE,KAAK4T,SAAW,CACZiH,SAAUA,EACV7W,OAAQA,EACR6P,aAAc,MAGtBgC,EAAene,UAAUwT,aAAe,WACpC,IAAIpL,EACJ,GAAKE,KAAKyT,WAGVzT,KAAKiL,eACCjL,KAAKjG,QAAQkhB,qBAAuBjb,KAAK8P,UAC1C9P,KAAKiU,eADV,CAWA,GAAIjU,KAAK0T,aAAe1T,KAAK0T,WAAWD,SACpC,IAAK,IAAIxb,EAAI,EAAGA,EAAI+H,KAAKmX,KAAK9f,OAAQY,IACvB+H,KAAKmX,KAAKlf,GAChBgT,eAGb,IAAI4P,EAAW7a,KAAK8I,UACpBkS,GAASH,GACT,IAAIK,EAAalb,KAAKgE,OACtBhE,KAAKgE,OAAS,CACV6W,SAAUA,EACVjU,OAAQ5G,KAAK+a,oBAAoBF,IAErC7a,KAAKmb,gBhB7ZoB,CACjCne,EAFkC,CAAG8F,IAAK,EAAGD,IAAK,GAGlDvD,EAHkC,CAAGwD,IAAK,EAAGD,IAAK,IgB+Z1C7C,KAAKiU,eAAgB,EACrBjU,KAAKuN,qBAAkB9R,EACvBuE,KAAKwX,gBAAgB,UAAWxX,KAAKgE,OAAO4C,QACN,QAArC9G,EAAKE,KAAKjG,QAAQmL,qBAAkC,IAAPpF,GAAyBA,EAAGsb,oBAAoBpb,KAAKgE,OAAO4C,OAAQsU,aAA+C,EAASA,EAAWtU,UAEzLiP,EAAene,UAAUuT,aAAe,WAChCjL,KAAKjG,QAAQshB,cAAgBrb,KAAKyT,WAClCzT,KAAKsb,aAAe3F,EAAkB3V,KAAKyT,UAC3CzT,KAAKub,OAAS7F,EAAc1V,KAAKyT,YAGzCoC,EAAene,UAAUke,eAAiB,WACtC,IAAI9V,EACJ,GAAK8V,EAAL,CAEA,IAAI4F,EAAmBxb,KAAKiU,eAAiBjU,KAAKqW,qBAC9CoF,EAAgBzb,KAAKuN,kBAAoBuF,GAAY9S,KAAKuN,iBAC1D1C,EAA0D,QAArC/K,EAAKE,KAAKjG,QAAQmL,qBAAkC,IAAPpF,OAAgB,EAASA,EAAGmG,WAAW4E,kBACzG6Q,EAAyB7Q,aAA6D,EAASA,EAAkB7K,KAAK6T,aAAc,IACpI8H,EAA8BD,IAA2B1b,KAAKka,2BAC9DsB,IACCC,IACG,QAAazb,KAAK6T,eAClB8H,KACJ/F,EAAe5V,KAAKyT,SAAUiI,GAC9B1b,KAAKqW,sBAAuB,EAC5BrW,KAAKiT,oBAGb4C,EAAene,UAAUoR,QAAU,WAC/B,IAAI5D,EAAgBlF,KAAKjG,QAAQmL,cACjC,IAAKA,EACD,MhB9bqB,CACjClI,EAFkC,CAAG8F,IAAK,EAAGD,IAAK,GAGlDvD,EAHkC,CAAGwD,IAAK,EAAGD,IAAK,IgBgc1C,IAAIkP,EAAM7M,EAAc0W,qBAEpBL,EAASvb,KAAK+I,KAAKwS,OAKvB,OAJIA,KACA,SAAcxJ,EAAI/U,EAAGue,EAAOve,IAC5B,SAAc+U,EAAIzS,EAAGic,EAAOjc,IAEzByS,GAEX8D,EAAene,UAAUqjB,oBAAsB,SAAUhJ,GACrD,IAAI8J,EhBzcqB,CACjC7e,EAFkC,CAAG8F,IAAK,EAAGD,IAAK,GAGlDvD,EAHkC,CAAGwD,IAAK,EAAGD,IAAK,IgB2c1CiP,GAAY+J,EAAkB9J,GAK9B,IAAK,IAAI9Z,EAAI,EAAGA,EAAI+H,KAAKmX,KAAK9f,OAAQY,IAAK,CACvC,IAAIiV,EAAOlN,KAAKmX,KAAKlf,GACjB6jB,EAAW5O,EAAKqO,OAAQxhB,EAAUmT,EAAKnT,QAASuhB,EAAepO,EAAKoO,aACxE,GAAIpO,IAASlN,KAAK+I,MAAQ+S,GAAY/hB,EAAQshB,aAAc,CAKxD,GAAIC,EAAc,CACdxJ,GAAY+J,EAAkB9J,GAC9B,IAAIgK,EAAa/b,KAAK+I,KAAKwS,OAKvBQ,KACA,SAAcF,EAAiB7e,GAAI+e,EAAW/e,IAC9C,SAAc6e,EAAiBvc,GAAIyc,EAAWzc,KAGtD,SAAcuc,EAAiB7e,EAAG8e,EAAS9e,IAC3C,SAAc6e,EAAiBvc,EAAGwc,EAASxc,IAGnD,OAAOuc,GAEXhG,EAAene,UAAUskB,eAAiB,SAAUjK,EAAKkK,QAC/B,IAAlBA,IAA4BA,GAAgB,GAChD,IAAIC,EhB3eqB,CACjClf,EAFkC,CAAG8F,IAAK,EAAGD,IAAK,GAGlDvD,EAHkC,CAAGwD,IAAK,EAAGD,IAAK,IgB6e1CiP,GAAYoK,EAAgBnK,GAC5B,IAAK,IAAI9Z,EAAI,EAAGA,EAAI+H,KAAKmX,KAAK9f,OAAQY,IAAK,CACvC,IAAIiV,EAAOlN,KAAKmX,KAAKlf,IAChBgkB,GACD/O,EAAKnT,QAAQshB,cACbnO,EAAKqO,QACLrO,IAASA,EAAKnE,OACd,SAAamT,EAAgB,CACzBlf,GAAIkQ,EAAKqO,OAAOve,EAChBsC,GAAI4N,EAAKqO,OAAOjc,KAGnB,QAAa4N,EAAK2G,gBAEvB,SAAaqI,EAAgBhP,EAAK2G,cAKtC,OAHI,QAAa7T,KAAK6T,gBAClB,SAAaqI,EAAgBlc,KAAK6T,cAE/BqI,GAEXrG,EAAene,UAAUojB,gBAAkB,SAAU/I,GACjD,IAAIjS,EACAqc,EhBngBqB,CACjCnf,EAFkC,CAAG8F,IAAK,EAAGD,IAAK,GAGlDvD,EAHkC,CAAGwD,IAAK,EAAGD,IAAK,IgBqgB1CiP,GAAYqK,EAAqBpK,GACjC,IAAK,IAAI9Z,EAAI,EAAGA,EAAI+H,KAAKmX,KAAK9f,OAAQY,IAAK,CACvC,IAAIiV,EAAOlN,KAAKmX,KAAKlf,GACrB,GAAKiV,EAAKuG,WAEL,QAAavG,EAAK2G,cAAvB,EAEA,QAAS3G,EAAK2G,eAAiB3G,EAAKiN,iBACpC,IAAIvH,EhB5gBiB,CACjC5V,EAFkC,CAAG8F,IAAK,EAAGD,IAAK,GAGlDvD,EAHkC,CAAGwD,IAAK,EAAGD,IAAK,IgB+gBtCiP,GAAYc,EADE1F,EAAKpE,WAEnB6J,GAAoBwJ,EAAqBjP,EAAK2G,aAAuC,QAAxB/T,EAAKoN,EAAK0G,gBAA6B,IAAP9T,OAAgB,EAASA,EAAGkE,OAAQ4O,IAKrI,OAHI,QAAa5S,KAAK6T,eAClBlB,GAAoBwJ,EAAqBnc,KAAK6T,cAE3CsI,GAKXtG,EAAene,UAAU0kB,eAAiB,SAAUpa,GAChDhC,KAAKqc,YAAcra,EACnBhC,KAAK+I,KAAK6R,4BAEd/E,EAAene,UAAUwX,WAAa,SAAUnV,GAC5C,IAAI+F,EACJE,KAAKjG,SAAU,SAAS,SAAS,QAAS,GAAIiG,KAAKjG,SAAUA,GAAU,CAAEma,UAAwC,QAA5BpU,EAAK/F,EAAQma,iBAA8B,IAAPpU,GAAgBA,KAE7I+V,EAAene,UAAU0iB,kBAAoB,WACzCpa,KAAKub,YAAS9f,EACduE,KAAKgE,YAASvI,EACduE,KAAK4T,cAAWnY,EAChBuE,KAAKka,gCAA6Bze,EAClCuE,KAAKqc,iBAAc5gB,EACnBuE,KAAKgD,YAASvH,EACduE,KAAKiU,eAAgB,GAKzB4B,EAAene,UAAUmf,mBAAqB,WAC1C,IAAI/W,EpB3hBSkD,EAAQa,EAAUC,EoB4hB3BkC,EAAKhG,KAAKjG,QAASiK,EAASgC,EAAGhC,OAAQ2K,EAAW3I,EAAG2I,SAIpD3O,KAAKgE,SAAYA,GAAU2K,KAQ3B3O,KAAKqc,aAAgBrc,KAAK2Y,iBAE3B3Y,KAAKsc,eAAiBtc,KAAKuc,6BACvBvc,KAAKsc,gBAAkBtc,KAAKsc,eAAetY,SAC3ChE,KAAK2Y,ehB/jBY,CACjC3b,EAFkC,CAAG8F,IAAK,EAAGD,IAAK,GAGlDvD,EAHkC,CAAGwD,IAAK,EAAGD,IAAK,IgBikBlC7C,KAAKwc,qBhBhkBY,CACjCxf,EAFkC,CAAG8F,IAAK,EAAGD,IAAK,GAGlDvD,EAHkC,CAAGwD,IAAK,EAAGD,IAAK,IgBkkBlCoB,EAAqBjE,KAAKwc,qBAAsBxc,KAAKgE,OAAO4C,OAAQ5G,KAAKsc,eAAetY,OAAO4C,QAC/FkL,GAAY9R,KAAK2Y,eAAgB3Y,KAAKwc,yBAOzCxc,KAAK2Y,gBAAmB3Y,KAAKqc,eAK7Brc,KAAKgD,SACNhD,KAAKgD,OhB/kBgB,CACjChG,EAFkC,CAAG8F,IAAK,EAAGD,IAAK,GAGlDvD,EAHkC,CAAGwD,IAAK,EAAGD,IAAK,IgBilBtC7C,KAAKyc,qBhBhlBgB,CACjCzf,EAFkC,CAAG8F,IAAK,EAAGD,IAAK,GAGlDvD,EAHkC,CAAGwD,IAAK,EAAGD,IAAK,KgBslBtC7C,KAAK2Y,gBACL3Y,KAAKwc,uBAC2B,QAA9B1c,EAAKE,KAAKsc,sBAAmC,IAAPxc,OAAgB,EAASA,EAAGkD,SpBpkB3DA,EoBqkBOhD,KAAKgD,OpBrkBJa,EoBqkBY7D,KAAK2Y,epBrkBP7U,EoBqkBuB9D,KAAKsc,eAAetZ,OpBpkBlFY,EAAiBZ,EAAOhG,EAAG6G,EAAS7G,EAAG8G,EAAO9G,GAC9C4G,EAAiBZ,EAAO1D,EAAGuE,EAASvE,EAAGwE,EAAOxE,IoBwkB7BU,KAAKqc,aACNhgB,QAAQ2D,KAAKsU,cAEbtU,KAAKgD,OAAShD,KAAKgc,eAAehc,KAAKgE,OAAO4C,QAG9CkL,GAAY9R,KAAKgD,OAAQhD,KAAKgE,OAAO4C,SAEzC,SAAc5G,KAAKgD,OAAQhD,KAAKqc,cAMhCvK,GAAY9R,KAAKgD,OAAQhD,KAAKgE,OAAO4C,QAKrC5G,KAAK0c,iCACL1c,KAAK0c,gCAAiC,EACtC1c,KAAKsc,eAAiBtc,KAAKuc,6BACvBvc,KAAKsc,gBACLjgB,QAAQ2D,KAAKsc,eAAehI,gBACxBjY,QAAQ2D,KAAKsU,gBAChBtU,KAAKsc,eAAeviB,QAAQshB,cAC7Brb,KAAKsc,eAAetZ,SACpBhD,KAAK2Y,ehBxnBY,CACjC3b,EAFkC,CAAG8F,IAAK,EAAGD,IAAK,GAGlDvD,EAHkC,CAAGwD,IAAK,EAAGD,IAAK,IgB0nBlC7C,KAAKwc,qBhBznBY,CACjCxf,EAFkC,CAAG8F,IAAK,EAAGD,IAAK,GAGlDvD,EAHkC,CAAGwD,IAAK,EAAGD,IAAK,IgB2nBlCoB,EAAqBjE,KAAKwc,qBAAsBxc,KAAKgD,OAAQhD,KAAKsc,eAAetZ,QACjF8O,GAAY9R,KAAK2Y,eAAgB3Y,KAAKwc,2BAIlD3G,EAAene,UAAU6kB,2BAA6B,WAClD,GAAKvc,KAAK8D,UAAU,QAAa9D,KAAK8D,OAAO+P,cAE7C,OAAK7T,KAAK8D,OAAO6U,gBAAkB3Y,KAAK8D,OAAOuY,cAC3Crc,KAAK8D,OAAOE,OACLhE,KAAK8D,OAGL9D,KAAK8D,OAAOyY,8BAG3B1G,EAAene,UAAUof,eAAiB,WACtC,IAAIhX,EACAkG,EAAKhG,KAAKjG,QAASiK,EAASgC,EAAGhC,OAAQ2K,EAAW3I,EAAG2I,SAWzD,GANA3O,KAAKgW,gBAAkB3Z,SAAgC,QAAtByD,EAAKE,KAAK8D,cAA2B,IAAPhE,OAAgB,EAASA,EAAGkW,kBACvFhW,KAAK6P,kBACL7P,KAAK2c,kBACJ3c,KAAKgW,kBACNhW,KAAKqc,YAAcrc,KAAK2Y,oBAAiBld,GAExCuE,KAAKgE,SAAYA,GAAU2K,GAAhC,CAEA,IAAIwE,EAAOnT,KAAK4c,UAKhB9K,GAAY9R,KAAKmb,gBAAiBnb,KAAKgE,OAAO4C,SAK9C,SAAgB5G,KAAKmb,gBAAiBnb,KAAKsN,UAAWtN,KAAKmX,KAAM9a,QAAQ2D,KAAKsU,eAAiBtU,OAASmT,GACxG,IAAInQ,EAASmQ,EAAKnQ,OAClB,GAAKA,EAAL,CAEKhD,KAAKuN,kBACNvN,KAAKuN,gBhB7qBkB,CACnCvQ,EAPuC,CACvCwG,UAAW,EACXD,MAAO,EACPH,OAAQ,EACRC,YAAa,GAIb/D,EARuC,CACvCkE,UAAW,EACXD,MAAO,EACPH,OAAQ,EACRC,YAAa,IgBgrBDrD,KAAK6c,6BhB9qBkB,CACnC7f,EAPuC,CACvCwG,UAAW,EACXD,MAAO,EACPH,OAAQ,EACRC,YAAa,GAIb/D,EARuC,CACvCkE,UAAW,EACXD,MAAO,EACPH,OAAQ,EACRC,YAAa,KgBkrBL,IAAIyZ,EAAiB9c,KAAKsN,UAAUtQ,EAChC+f,EAAiB/c,KAAKsN,UAAUhO,EAChC0d,EAA0Bhd,KAAKid,oBAUnCxZ,EAAazD,KAAKuN,gBAAiBvN,KAAKmb,gBAAiBnY,EAAQhD,KAAK6T,cACtE7T,KAAKid,oBAAsBzI,GAAyBxU,KAAKuN,gBAAiBvN,KAAKsN,WAC3EtN,KAAKid,sBAAwBD,GAC7Bhd,KAAKsN,UAAUtQ,IAAM8f,GACrB9c,KAAKsN,UAAUhO,IAAMyd,IACrB/c,KAAK+W,cAAe,EACpB/W,KAAKiT,iBACLjT,KAAKwX,gBAAgB,mBAAoBxU,OAGjD6S,EAAene,UAAUyc,KAAO,WAC5BnU,KAAKgX,WAAY,GAGrBnB,EAAene,UAAU8b,KAAO,WAC5BxT,KAAKgX,WAAY,GAGrBnB,EAAene,UAAUub,eAAiB,SAAUiK,GAChD,IAAIpd,EAAIkG,EAAIL,OACM,IAAduX,IAAwBA,GAAY,GACM,QAA7ClX,GAAMlG,EAAKE,KAAKjG,SAASkZ,sBAAmC,IAAPjN,GAAyBA,EAAGpO,KAAKkI,GACvFod,IAAyC,QAA1BvX,EAAK3F,KAAK0P,kBAA+B,IAAP/J,GAAyBA,EAAGsN,kBACzEjT,KAAKsU,eAAiBtU,KAAKsU,aAAab,WACxCzT,KAAKsU,kBAAe7Y,IAG5Boa,EAAene,UAAU2hB,mBAAqB,SAAUrX,EAAOoX,GAC3D,IACItZ,EADAC,EAAQC,UAEyB,IAAjCoZ,IAA2CA,GAA+B,GAC9E,IAAIxF,EAAW5T,KAAK4T,SAChBuJ,GAAwBvJ,aAA2C,EAASA,EAASC,eAAiB,GACtGuJ,GAAc,QAAS,GAAIpd,KAAK6T,cAChCwI,EhB9tBuB,CACnCrf,EAPuC,CACvCwG,UAAW,EACXD,MAAO,EACPH,OAAQ,EACRC,YAAa,GAIb/D,EARuC,CACvCkE,UAAW,EACXD,MAAO,EACPH,OAAQ,EACRC,YAAa,IgBiuBLrD,KAAK2Y,eAAiB3Y,KAAKwc,0BAAuB/gB,EAClDuE,KAAK0c,gCAAkCtD,EACvC,IAAIiE,EhB5tBqB,CACjCrgB,EAFkC,CAAG8F,IAAK,EAAGD,IAAK,GAGlDvD,EAHkC,CAAGwD,IAAK,EAAGD,IAAK,IgB8tBtCya,EAA0B1J,aAA2C,EAASA,EAASG,SACvFwJ,IAA4C,QAA1Bzd,EAAKE,KAAK0P,kBAA+B,IAAP5P,OAAgB,EAASA,EAAG6P,QAAQtY,SAAW,IAAM,EACzGmmB,EAAyBnhB,QAAQihB,IAChCC,IAC0B,IAA3Bvd,KAAKjG,QAAQma,YACZlU,KAAKmX,KAAKsG,KAAKC,KACpB1d,KAAKiX,kBAAoB,EACzBjX,KAAK2d,eAAiB,SAAUjT,GAC5B,IAAI5K,EAiaJmO,EAAQ1P,EAAMC,EAAImT,EAhadhH,EAAWD,EAAS,IACxBkT,GAAavB,EAAYrf,EAAGgF,EAAMhF,EAAG2N,GACrCiT,GAAavB,EAAY/c,EAAG0C,EAAM1C,EAAGqL,GACrC5K,EAAMqc,eAAeC,GACjBtc,EAAM4Y,gBACN5Y,EAAMyc,sBACNzc,EAAMiE,SAC2B,QAA/BlE,EAAKC,EAAMuc,sBAAmC,IAAPxc,OAAgB,EAASA,EAAGkE,UACrEC,EAAqBoZ,EAAgBtd,EAAMiE,OAAO4C,OAAQ7G,EAAMuc,eAAetY,OAAO4C,QAwZ1FqH,EAvZWlO,EAAM4Y,eAuZTpa,EAvZyBwB,EAAMyc,qBAuZzBhe,EAvZ+C6e,EAuZ3C1L,EAvZ2DhH,EAwZzFkT,GAAQ5P,EAAOjR,EAAGuB,EAAKvB,EAAGwB,EAAGxB,EAAG2U,GAChCkM,GAAQ5P,EAAO3O,EAAGf,EAAKe,EAAGd,EAAGc,EAAGqS,IAvZhB2L,IACAvd,EAAM+T,gBAAkBsJ,ERlvB5C,SAAmBpa,EAAQ8a,EAAQ3K,EAAMxI,EAAU6S,EAAwBD,GACvE,IAAIzd,EAAIkG,EAAIL,EAAImG,EACZ0R,GACAxa,EAAO+a,SAAU,EAAAza,EAAA,GAAI,EAGG,QAAvBxD,EAAKqT,EAAK4K,eAA4B,IAAPje,EAAgBA,EAAK,EAAGyR,GAAgB5G,IACxE3H,EAAOgb,aAAc,EAAA1a,EAAA,GAA8B,QAAzB0C,EAAK8X,EAAOC,eAA4B,IAAP/X,EAAgBA,EAAK,EAAG,EAAGyL,GAAiB9G,KAElG4S,IACLva,EAAO+a,SAAU,EAAAza,EAAA,GAA8B,QAAzBqC,EAAKmY,EAAOC,eAA4B,IAAPpY,EAAgBA,EAAK,EAA2B,QAAvBmG,EAAKqH,EAAK4K,eAA4B,IAAPjS,EAAgBA,EAAK,EAAGnB,IAK3I,IAAK,IAAI1S,EAAI,EAAGA,EAAIgZ,GAAYhZ,IAAK,CACjC,IAAIgmB,EAAc,SAAStmB,OAAOqZ,GAAQ/Y,GAAI,UAC1CimB,EAAe9M,GAAU0M,EAAQG,GACjCE,EAAa/M,GAAU+B,EAAM8K,QACZxiB,IAAjByiB,QAA6CziB,IAAf0iB,IAElCD,IAAiBA,EAAe,GAChCC,IAAeA,EAAa,GACE,IAAjBD,GACM,IAAfC,GACAhN,GAAK+M,KAAkB/M,GAAKgN,IAE5Bnb,EAAOib,GAAehf,KAAK4D,KAAI,EAAAS,EAAA,GAAI4N,GAASgN,GAAehN,GAASiN,GAAaxT,GAAW,IACxF,UAAawT,IAAe,UAAaD,MACzClb,EAAOib,IAAgB,MAI3Bjb,EAAOib,GAAeE,IAM1BL,EAAOlJ,QAAUzB,EAAKyB,UACtB5R,EAAO4R,QAAS,EAAAtR,EAAA,GAAIwa,EAAOlJ,QAAU,EAAGzB,EAAKyB,QAAU,EAAGjK,IQ2sB9CyT,CAAUhB,EAAaD,EAAsBpd,EAAM8T,aAAclJ,EAAU6S,EAAwBD,IAEvGxd,EAAMgJ,KAAK6R,2BACX7a,EAAMkT,iBACNlT,EAAMkX,kBAAoBtM,GAE9B3K,KAAK2d,eAAe,IAExB9H,EAAene,UAAUgQ,eAAiB,SAAU3N,GAChD,IACI+F,EAAIkG,EADJjG,EAAQC,KAEZA,KAAKwX,gBAAgB,kBACY,QAAhC1X,EAAKE,KAAK6P,wBAAqC,IAAP/P,GAAyBA,EAAGpB,OACjEsB,KAAKsU,eACyC,QAA7CtO,EAAKhG,KAAKsU,aAAazE,wBAAqC,IAAP7J,GAAyBA,EAAGtH,QAElFsB,KAAK2c,mBACL,YAAkB3c,KAAK2c,kBACvB3c,KAAK2c,sBAAmBlhB,GAO5BuE,KAAK2c,iBAAmB,aAAY,WAChC,6BAA+C,EAC/C5c,EAAM8P,kBAAmB,EAAAvR,GAAA,GAAQ,EA9vB3B,KA8vB+C,SAAS,QAAS,GAAIvE,GAAU,CAAEskB,SAAU,SAAU3T,GACnG,IAAI5K,EACJC,EAAM4d,eAAejT,GACO,QAA3B5K,EAAK/F,EAAQskB,gBAA6B,IAAPve,GAAyBA,EAAGlI,KAAKmC,EAAS2Q,IAC/E8O,WAAY,WACX,IAAI1Z,EAC0B,QAA7BA,EAAK/F,EAAQyf,kBAA+B,IAAP1Z,GAAyBA,EAAGlI,KAAKmC,GACvEgG,EAAMue,wBAEVve,EAAMuU,eACNvU,EAAMuU,aAAazE,iBAAmB9P,EAAM8P,kBAEhD9P,EAAM4c,sBAAmBlhB,MAGjCoa,EAAene,UAAU4mB,kBAAoB,WACzC,IAAIxe,EACAE,KAAKsU,eACLtU,KAAKsU,aAAazE,sBAAmBpU,EACrCuE,KAAKsU,aAAaX,qBAAkBlY,GAEb,QAA1BqE,EAAKE,KAAK0P,kBAA+B,IAAP5P,GAAyBA,EAAGsU,wBAC/DpU,KAAKsU,aACDtU,KAAK6P,iBACD7P,KAAK8T,qBACDrY,EACZuE,KAAKwX,gBAAgB,sBAEzB3B,EAAene,UAAU4gB,gBAAkB,WACvC,IAAIxY,EACAE,KAAK6P,mBAC0B,QAA9B/P,EAAKE,KAAK2d,sBAAmC,IAAP7d,GAAyBA,EAAGlI,KAAKoI,KA7xBlE,KA8xBNA,KAAK6P,iBAAiBnR,QAE1BsB,KAAKse,qBAETzI,EAAene,UAAU6mB,wBAA0B,WAC/C,IAAIze,EAAKE,KAAK4c,UAAWH,EAAuB3c,EAAG2c,qBAAsBzZ,EAASlD,EAAGkD,OAAQgB,EAASlE,EAAGkE,OAAQ6P,EAAe/T,EAAG+T,aAC9H4I,GAAyBzZ,GAAWgB,IAEzC8N,GAAY2K,EAAsBzZ,IAMlC,SAAayZ,EAAsB5I,GAOnCpQ,EAAazD,KAAK6c,6BAA8B7c,KAAKmb,gBAAiBsB,EAAsB5I,KAEhGgC,EAAene,UAAU6gB,mBAAqB,SAAU5J,EAAUzB,GAC9D,IAAIpN,EAAIkG,EAAIL,EACP3F,KAAKkX,YAAYK,IAAI5I,IACtB3O,KAAKkX,YAAYlP,IAAI2G,EAAU,IAAIqE,IAE3BhT,KAAKkX,YAAYxQ,IAAIiI,GAC3BG,IAAI5B,GACVA,EAAKsC,QAAQ,CACT/Q,WAA2D,QAA9CqB,EAAKoN,EAAKnT,QAAQykB,8BAA2C,IAAP1e,OAAgB,EAASA,EAAGrB,WAC/F8U,sBAAiJ,QAAzH5N,EAAoD,QAA9CK,EAAKkH,EAAKnT,QAAQykB,8BAA2C,IAAPxY,OAAgB,EAASA,EAAGyY,mCAAgD,IAAP9Y,OAAgB,EAASA,EAAG/N,KAAKoO,EAAIkH,MAGtM2I,EAAene,UAAUoY,OAAS,WAC9B,IAAI4O,EAAQ1e,KAAK0P,WACjB,OAAOgP,GAAQA,EAAMvL,OAASnT,MAElC6V,EAAene,UAAUklB,QAAU,WAC/B,IAAI9c,EAEJ,OADeE,KAAKjG,QAAQ4U,WACkB,QAA1B7O,EAAKE,KAAK0P,kBAA+B,IAAP5P,OAAgB,EAASA,EAAGqT,OAAgBnT,MAEtG6V,EAAene,UAAUinB,YAAc,WACnC,IAAI7e,EAEJ,OADeE,KAAKjG,QAAQ4U,SACiB,QAA1B7O,EAAKE,KAAK0P,kBAA+B,IAAP5P,OAAgB,EAASA,EAAGoT,cAAWzX,GAEhGoa,EAAene,UAAUgY,SAAW,WAChC,IAAIf,EAAW3O,KAAKjG,QAAQ4U,SAC5B,GAAIA,EACA,OAAO3O,KAAK+I,KAAKmO,YAAYxQ,IAAIiI,IAEzCkH,EAAene,UAAU8X,QAAU,SAAU1P,GACzC,IAAIkG,OAAY,IAAPlG,EAAgB,GAAKA,EAAIsW,EAAapQ,EAAGoQ,WAAY3X,EAAauH,EAAGvH,WAAY8U,EAAwBvN,EAAGuN,sBACjHmL,EAAQ1e,KAAK0P,WACbgP,GACAA,EAAMlP,QAAQxP,KAAMuT,GACpB6C,IACApW,KAAKuN,qBAAkB9R,EACvBuE,KAAKoW,YAAa,GAElB3X,GACAuB,KAAKkP,WAAW,CAAEzQ,WAAYA,KAEtCoX,EAAene,UAAU+X,SAAW,WAChC,IAAIiP,EAAQ1e,KAAK0P,WACjB,QAAIgP,GACOA,EAAMjP,SAASzP,OAM9B6V,EAAene,UAAUsiB,cAAgB,WACrC,IAAI9U,EAAgBlF,KAAKjG,QAAQmL,cACjC,GAAKA,EAAL,CAOA,IAJA,IAAI0Z,GAAY,EAEZC,EAAc,GAET5mB,EAAI,EAAGA,EAAI+S,GAAA,UAAsB/S,IAAK,CAC3C,IACIY,EAAM,SADCmS,GAAA,GAAc/S,GAIpBiN,EAAc4Z,eAAejmB,KAGlC+lB,GAAY,EAEZC,EAAYhmB,GAAOqM,EAAc4Z,eAAejmB,GAChDqM,EAAc6Z,eAAelmB,EAAK,IAGtC,GAAK+lB,EAAL,CAMA,IAAK,IAAI/lB,KAFTqM,SAA8DA,EAAcqC,aAE5DsX,EACZ3Z,EAAc6Z,eAAelmB,EAAKgmB,EAAYhmB,IAIlDqM,EAAc+N,oBAElB4C,EAAene,UAAUsnB,oBAAsB,SAAUC,GACrD,IAAInf,EAAIkG,EAAIL,EAAImG,EAAIC,EAAIC,OACN,IAAdiT,IAAwBA,EAAY,IAExC,IAAIC,EAAS,GACb,IAAKlf,KAAKyT,UAAYzT,KAAKmW,MACvB,OAAO+I,EACX,IAAKlf,KAAKgX,UACN,MAAO,CAAEmI,WAAY,UAGrBD,EAAOC,WAAa,GAExB,IAAItU,EAA0D,QAArC/K,EAAKE,KAAKjG,QAAQmL,qBAAkC,IAAPpF,OAAgB,EAASA,EAAGmG,WAAW4E,kBAC7G,GAAI7K,KAAKoW,WAQL,OAPApW,KAAKoW,YAAa,EAClB8I,EAAOnB,QAAU,GACjBmB,EAAOE,eACH,QAAmBH,EAAUG,gBAAkB,GACnDF,EAAOlU,UAAYH,EACbA,EAAkB7K,KAAK6T,aAAc,IACrC,OACCqL,EAEX,IAAI/L,EAAOnT,KAAK4c,UAChB,IAAK5c,KAAKuN,kBAAoBvN,KAAKgE,SAAWmP,EAAKnQ,OAAQ,CACvD,IAAIqc,EAAc,GAYlB,OAXIrf,KAAKjG,QAAQ4U,WACb0Q,EAAYtB,QAA+C,QAApC/X,EAAKhG,KAAK6T,aAAakK,eAA4B,IAAP/X,EAAgBA,EAAK,EACxFqZ,EAAYD,eACR,QAAmBH,EAAUG,gBAAkB,IAEnDpf,KAAK+W,gBAAiB,QAAa/W,KAAK6T,gBACxCwL,EAAYrU,UAAYH,EAClBA,EAAkB,GAAI,IACtB,OACN7K,KAAK+W,cAAe,GAEjBsI,EAEX,IAAIC,EAAiBnM,EAAKW,iBAAmBX,EAAKU,aAClD7T,KAAKue,0BACLW,EAAOlU,UAAYwJ,GAAyBxU,KAAK6c,6BAA8B7c,KAAKsN,UAAWgS,GAC3FzU,IACAqU,EAAOlU,UAAYH,EAAkByU,EAAgBJ,EAAOlU,YAEhE,IAAI+N,EAAK/Y,KAAKuN,gBAAiBvQ,EAAI+b,EAAG/b,EAAGsC,EAAIyZ,EAAGzZ,EA2BhD,IAAK,IAAIzG,KA1BTqmB,EAAOK,gBAAkB,GAAG5nB,OAAkB,IAAXqF,EAAEoG,OAAc,MAAMzL,OAAkB,IAAX2H,EAAE8D,OAAc,OAC5E+P,EAAKW,gBAKLoL,EAAOnB,QACH5K,IAASnT,KACiG,QAAnG8L,EAAuC,QAAjCnG,EAAK2Z,EAAevB,eAA4B,IAAPpY,EAAgBA,EAAK3F,KAAK6T,aAAakK,eAA4B,IAAPjS,EAAgBA,EAAK,EACjI9L,KAAK2T,gBACD3T,KAAK6T,aAAakK,QAClBuB,EAAetB,YAO7BkB,EAAOnB,QACH5K,IAASnT,KAC+B,QAAjC+L,EAAKuT,EAAevB,eAA4B,IAAPhS,EAAgBA,EAAK,GACzB,QAArCC,EAAKsT,EAAetB,mBAAgC,IAAPhS,EAAgBA,EAAK,EAKjE,KACZ,QAA4BvQ,IAAxB6jB,EAAezmB,GAAnB,CAEA,IAAI2mB,EAAK,KAAgB3mB,GAAMoU,EAAUuS,EAAGvS,QAASqD,EAAUkP,EAAGlP,QAC9DmP,EAAYxS,EAAQqS,EAAezmB,GAAMsa,GAC7C,GAAI7C,EAEA,IADA,IAAIoP,EAAMpP,EAAQjZ,OACTY,EAAI,EAAGA,EAAIynB,EAAKznB,IACrBinB,EAAO5O,EAAQrY,IAAMwnB,OAIzBP,EAAOrmB,GAAO4mB,EActB,OANIzf,KAAKjG,QAAQ4U,WACbuQ,EAAOE,cACHjM,IAASnT,MACH,QAAmBif,EAAUG,gBAAkB,GAC/C,QAEPF,GAEXrJ,EAAene,UAAUgjB,cAAgB,WACrC1a,KAAK0T,WAAa1T,KAAK4T,cAAWnY,GAGtCoa,EAAene,UAAUioB,UAAY,WACjC3f,KAAK+I,KAAK6N,MAAMvC,SAAQ,SAAUnH,GAAQ,IAAIpN,EAAI,OAAwC,QAAhCA,EAAKoN,EAAK2C,wBAAqC,IAAP/P,OAAgB,EAASA,EAAGpB,UAC9HsB,KAAK+I,KAAK6N,MAAMvC,QAAQ+F,IACxBpa,KAAK+I,KAAKmO,YAAYqD,SAEnB1E,EAx/BU,GA2/BzB,SAAS3K,GAAagC,GAClBA,EAAKhC,eAET,SAASuP,GAAmBvN,GACxB,IAAIpN,EAAIkG,EAAIL,EAAImG,EACZ8H,EAA8F,QAAlF5N,EAAgC,QAA1BlG,EAAKoN,EAAKwG,kBAA+B,IAAP5T,OAAgB,EAASA,EAAG8T,gBAA6B,IAAP5N,EAAgBA,EAAKkH,EAAK0G,SACpI,GAAI1G,EAAK4C,UACL5C,EAAKlJ,QACL4P,GACA1G,EAAK2K,aAAa,aAAc,CAChC,IAAI9L,EAAKmB,EAAKlJ,OAAQ4b,EAAW7T,EAAGnF,OAAQiZ,EAAiB9T,EAAG8O,SAG7B,SAA/B3N,EAAKnT,QAAQ+lB,cACbjb,GAAS,SAAUjC,GACf,IAAImd,EAAenM,EAASG,SACtBH,EAASiH,SAASjY,GAClBgR,EAAS5P,OAAOpB,GAClBvL,EAASsL,EAAWod,GACxBA,EAAajd,IAAM8c,EAAShd,GAAME,IAClCid,EAAald,IAAMkd,EAAajd,IAAMzL,KAGN,aAA/B6V,EAAKnT,QAAQ+lB,eAClBjb,GAAS,SAAUjC,GACf,IAAImd,EAAenM,EAASG,SACtBH,EAASiH,SAASjY,GAClBgR,EAAS5P,OAAOpB,GAClBvL,EAASsL,EAAWid,EAAShd,IACjCmd,EAAald,IAAMkd,EAAajd,IAAMzL,KAG9C,IAAI2oB,EhBnjC2B,CACnChjB,EAPuC,CACvCwG,UAAW,EACXD,MAAO,EACPH,OAAQ,EACRC,YAAa,GAIb/D,EARuC,CACvCkE,UAAW,EACXD,MAAO,EACPH,OAAQ,EACRC,YAAa,IgBsjCTI,EAAauc,EAAaJ,EAAUhM,EAAS5P,QAC7C,IAAIic,EhBrjC2B,CACnCjjB,EAPuC,CACvCwG,UAAW,EACXD,MAAO,EACPH,OAAQ,EACRC,YAAa,GAIb/D,EARuC,CACvCkE,UAAW,EACXD,MAAO,EACPH,OAAQ,EACRC,YAAa,IgBwjCLuQ,EAASG,SACTtQ,EAAawc,EAAa/S,EAAK8O,eAAe6D,GAAgB,GAAOjM,EAASiH,UAG9EpX,EAAawc,EAAaL,EAAUhM,EAAS5P,QAEjD,IAAI2H,GAAoBmH,GAAYkN,GAChCxH,GAA2B,EAC/B,IAAKtL,EAAKwG,aACNxG,EAAKoP,eAAiBpP,EAAKqP,6BAKvBrP,EAAKoP,iBAAmBpP,EAAKoP,eAAe5I,YAAY,CACxD,IAAI1H,EAAKkB,EAAKoP,eAAgB4D,EAAiBlU,EAAG4H,SAAUuM,EAAenU,EAAGhI,OAC9E,GAAIkc,GAAkBC,EAAc,CAChC,IAAIC,EhBlkCa,CACjCpjB,EAFkC,CAAG8F,IAAK,EAAGD,IAAK,GAGlDvD,EAHkC,CAAGwD,IAAK,EAAGD,IAAK,IgBokClCoB,EAAqBmc,EAAkBxM,EAAS5P,OAAQkc,EAAelc,QACvE,IAAIqZ,EhBpkCa,CACjCrgB,EAFkC,CAAG8F,IAAK,EAAGD,IAAK,GAGlDvD,EAHkC,CAAGwD,IAAK,EAAGD,IAAK,IgBskClCoB,EAAqBoZ,EAAgBuC,EAAUO,EAAavZ,QACvDmM,GAAUqN,EAAkB/C,KAC7B7E,GAA2B,IAK3CtL,EAAKsK,gBAAgB,YAAa,CAC9BxT,OAAQ4b,EACRhM,SAAUA,EACV5R,MAAOie,EACPD,YAAaA,EACbrU,iBAAkBA,EAClB6M,yBAA0BA,SAGzBtL,EAAK4C,WACoC,QAA7ChE,GAAMnG,EAAKuH,EAAKnT,SAASoV,sBAAmC,IAAPrD,GAAyBA,EAAGlU,KAAK+N,IAO3FuH,EAAKnT,QAAQ0E,gBAAahD,EAE9B,SAASif,GAAcxN,GACnBA,EAAKwN,gBAET,SAASN,GAAkBlN,GACvBA,EAAKkN,oBAET,SAASI,GAAoBtN,GACzB,IAAIhI,EAAgBgI,EAAKnT,QAAQmL,eAC7BA,aAAqD,EAASA,EAAce,WAAWoa,wBACvFnb,EAAcob,4BAElBpT,EAAK0I,iBAET,SAAS0C,GAAgBpL,GACrBA,EAAKoL,kBACLpL,EAAKmP,YAAcnP,EAAKyL,eAAiBzL,EAAKlK,YAASvH,EAE3D,SAASob,GAAmB3J,GACxBA,EAAK2J,qBAET,SAASC,GAAe5J,GACpBA,EAAK4J,iBAET,SAASkD,GAAc9M,GACnBA,EAAK8M,gBAET,SAASW,GAAoB+D,GACzBA,EAAMnK,qBAEV,SAASqJ,GAAa3P,EAAQjM,EAAO2P,GACjC1D,EAAOzK,WAAY,EAAAF,EAAA,GAAItB,EAAMwB,UAAW,EAAGmO,GAC3C1D,EAAO1K,OAAQ,EAAAD,EAAA,GAAItB,EAAMuB,MAAO,EAAGoO,GACnC1D,EAAO7K,OAASpB,EAAMoB,OACtB6K,EAAO5K,YAAcrB,EAAMqB,YAE/B,SAASwa,GAAQ5P,EAAQ1P,EAAMC,EAAImT,GAC/B1D,EAAOnL,KAAM,EAAAQ,EAAA,GAAI/E,EAAKuE,IAAKtE,EAAGsE,IAAK6O,GACnC1D,EAAOpL,KAAM,EAAAS,EAAA,GAAI/E,EAAKsE,IAAKrE,EAAGqE,IAAK8O,GAMvC,SAAS+L,GAAoBxQ,GACzB,OAAQA,EAAK4G,sBAAwDrY,IAArCyR,EAAK4G,gBAAgBkK,YAEzD,IAAIlF,GAA0B,CAC1ByH,SAAU,IACVC,KAAM,CAAC,GAAK,EAAG,GAAK,IAExB,SAASlG,GAAepN,EAAM4I,GAM1B,IADA,IAAI2K,EAAavT,EAAKnE,KACb9Q,EAAIiV,EAAKiK,KAAK9f,OAAS,EAAGY,GAAK,EAAGA,IACvC,GAAIoE,QAAQ6Q,EAAKiK,KAAKlf,GAAGwb,UAAW,CAChCgN,EAAavT,EAAKiK,KAAKlf,GACvB,MAGR,IACImT,GADgBqV,GAAcA,IAAevT,EAAKnE,KAAO0X,EAAWhN,SAAWiN,UACvDC,cAAc,wBAAyBhpB,OAAOme,EAAI,OAC1E1K,GACA8B,EAAK4K,MAAM1M,GAAS,GAE5B,SAASwV,GAAUhe,GACfA,EAAKE,IAAM7D,KAAK4hB,MAAMje,EAAKE,KAC3BF,EAAKC,IAAM5D,KAAK4hB,MAAMje,EAAKC,KAE/B,SAASmY,GAASjJ,GACd6O,GAAU7O,EAAI/U,GACd4jB,GAAU7O,EAAIzS,GChrClB,IAAIwhB,GAAyBvL,GAAqB,CAC9CC,qBAAsB,SAAUuL,EAAKnJ,GAAU,OAAO,OAAYmJ,EAAK,SAAUnJ,IACjFlC,cAAe,WAAc,MAAO,CAChC1Y,EAAG0jB,SAASM,gBAAgBC,YAAcP,SAASQ,KAAKD,WACxD3hB,EAAGohB,SAASM,gBAAgBG,WAAaT,SAASQ,KAAKC,YAE3DxL,kBAAmB,WAAc,OAAO,KCNxCyL,GAAqB,CACrB5a,aAAS/K,GAET4lB,GAAqB9L,GAAqB,CAC1CG,cAAe,SAAUjC,GAAY,MAAO,CACxCzW,EAAGyW,EAASwN,WACZ3hB,EAAGmU,EAAS0N,YAEhB1L,cAAe,WACX,IAAK2L,GAAmB5a,QAAS,CAC7B,IAAI8a,EAAe,IAAIR,GAAuB,EAAG,IACjDQ,EAAaxJ,MAAMjW,QACnByf,EAAapS,WAAW,CAAEmM,cAAc,IACxC+F,GAAmB5a,QAAU8a,EAEjC,OAAOF,GAAmB5a,SAE9BoP,eAAgB,SAAUnC,EAAU5Z,GAChC4Z,EAAS1I,MAAMC,UAAYnR,QAAqCA,EAAQ,QAE5E8b,kBAAmB,SAAUlC,GACzB,OAAOpX,QAAuD,UAA/CwF,OAAO0f,iBAAiB9N,GAAU+N,aCfrDC,IAAS,SAAS,SAAS,SAAS,QAAS,GAAI,MAAevb,IAAO0K,IAAiB,CAAE8Q,0BAA2BL","sources":["webpack://james-fisher/./node_modules/decode-uri-component/index.js","webpack://james-fisher/./node_modules/filter-obj/index.js","webpack://james-fisher/./node_modules/query-string/index.js","webpack://james-fisher/./node_modules/split-on-first/index.js","webpack://james-fisher/./node_modules/strict-uri-encode/index.js","webpack://james-fisher/./node_modules/framer-motion/dist/es/animation/animate.mjs","webpack://james-fisher/./node_modules/popmotion/dist/es/utils/is-point.mjs","webpack://james-fisher/./node_modules/popmotion/dist/es/utils/is-point-3d.mjs","webpack://james-fisher/./node_modules/popmotion/dist/es/utils/distance.mjs","webpack://james-fisher/./node_modules/framer-motion/dist/es/gestures/PanSession.mjs","webpack://james-fisher/./node_modules/framer-motion/dist/es/projection/geometry/delta-calc.mjs","webpack://james-fisher/./node_modules/framer-motion/dist/es/gestures/drag/utils/constraints.mjs","webpack://james-fisher/./node_modules/framer-motion/dist/es/projection/utils/each-axis.mjs","webpack://james-fisher/./node_modules/framer-motion/dist/es/gestures/drag/VisualElementDragControls.mjs","webpack://james-fisher/./node_modules/framer-motion/dist/es/projection/geometry/models.mjs","webpack://james-fisher/./node_modules/framer-motion/dist/es/motion/features/drag.mjs","webpack://james-fisher/./node_modules/framer-motion/dist/es/gestures/use-pan-gesture.mjs","webpack://james-fisher/./node_modules/framer-motion/dist/es/gestures/drag/use-drag.mjs","webpack://james-fisher/./node_modules/framer-motion/dist/es/projection/styles/scale-border-radius.mjs","webpack://james-fisher/./node_modules/framer-motion/dist/es/projection/styles/scale-box-shadow.mjs","webpack://james-fisher/./node_modules/framer-motion/dist/es/motion/features/layout/MeasureLayout.mjs","webpack://james-fisher/./node_modules/framer-motion/dist/es/motion/features/layout/index.mjs","webpack://james-fisher/./node_modules/framer-motion/dist/es/projection/animation/mix-values.mjs","webpack://james-fisher/./node_modules/framer-motion/dist/es/projection/geometry/copy.mjs","webpack://james-fisher/./node_modules/framer-motion/dist/es/projection/geometry/delta-remove.mjs","webpack://james-fisher/./node_modules/framer-motion/dist/es/projection/geometry/utils.mjs","webpack://james-fisher/./node_modules/framer-motion/dist/es/projection/shared/stack.mjs","webpack://james-fisher/./node_modules/framer-motion/dist/es/projection/styles/transform.mjs","webpack://james-fisher/./node_modules/framer-motion/dist/es/render/utils/compare-by-depth.mjs","webpack://james-fisher/./node_modules/framer-motion/dist/es/render/utils/flat-tree.mjs","webpack://james-fisher/./node_modules/framer-motion/dist/es/projection/node/create-projection-node.mjs","webpack://james-fisher/./node_modules/framer-motion/dist/es/projection/node/DocumentProjectionNode.mjs","webpack://james-fisher/./node_modules/framer-motion/dist/es/projection/node/HTMLProjectionNode.mjs","webpack://james-fisher/./node_modules/framer-motion/dist/es/render/dom/features-max.mjs"],"sourcesContent":["'use strict';\nvar token = '%[a-f0-9]{2}';\nvar singleMatcher = new RegExp(token, 'gi');\nvar multiMatcher = new RegExp('(' + token + ')+', 'gi');\n\nfunction decodeComponents(components, split) {\n\ttry {\n\t\t// Try to decode the entire string first\n\t\treturn decodeURIComponent(components.join(''));\n\t} catch (err) {\n\t\t// Do nothing\n\t}\n\n\tif (components.length === 1) {\n\t\treturn components;\n\t}\n\n\tsplit = split || 1;\n\n\t// Split the array in 2 parts\n\tvar left = components.slice(0, split);\n\tvar right = components.slice(split);\n\n\treturn Array.prototype.concat.call([], decodeComponents(left), decodeComponents(right));\n}\n\nfunction decode(input) {\n\ttry {\n\t\treturn decodeURIComponent(input);\n\t} catch (err) {\n\t\tvar tokens = input.match(singleMatcher);\n\n\t\tfor (var i = 1; i < tokens.length; i++) {\n\t\t\tinput = decodeComponents(tokens, i).join('');\n\n\t\t\ttokens = input.match(singleMatcher);\n\t\t}\n\n\t\treturn input;\n\t}\n}\n\nfunction customDecodeURIComponent(input) {\n\t// Keep track of all the replacements and prefill the map with the `BOM`\n\tvar replaceMap = {\n\t\t'%FE%FF': '\\uFFFD\\uFFFD',\n\t\t'%FF%FE': '\\uFFFD\\uFFFD'\n\t};\n\n\tvar match = multiMatcher.exec(input);\n\twhile (match) {\n\t\ttry {\n\t\t\t// Decode as big chunks as possible\n\t\t\treplaceMap[match[0]] = decodeURIComponent(match[0]);\n\t\t} catch (err) {\n\t\t\tvar result = decode(match[0]);\n\n\t\t\tif (result !== match[0]) {\n\t\t\t\treplaceMap[match[0]] = result;\n\t\t\t}\n\t\t}\n\n\t\tmatch = multiMatcher.exec(input);\n\t}\n\n\t// Add `%C2` at the end of the map to make sure it does not replace the combinator before everything else\n\treplaceMap['%C2'] = '\\uFFFD';\n\n\tvar entries = Object.keys(replaceMap);\n\n\tfor (var i = 0; i < entries.length; i++) {\n\t\t// Replace all decoded components\n\t\tvar key = entries[i];\n\t\tinput = input.replace(new RegExp(key, 'g'), replaceMap[key]);\n\t}\n\n\treturn input;\n}\n\nmodule.exports = function (encodedURI) {\n\tif (typeof encodedURI !== 'string') {\n\t\tthrow new TypeError('Expected `encodedURI` to be of type `string`, got `' + typeof encodedURI + '`');\n\t}\n\n\ttry {\n\t\tencodedURI = encodedURI.replace(/\\+/g, ' ');\n\n\t\t// Try the built in decoder first\n\t\treturn decodeURIComponent(encodedURI);\n\t} catch (err) {\n\t\t// Fallback to a more advanced decoder\n\t\treturn customDecodeURIComponent(encodedURI);\n\t}\n};\n","'use strict';\nmodule.exports = function (obj, predicate) {\n\tvar ret = {};\n\tvar keys = Object.keys(obj);\n\tvar isArr = Array.isArray(predicate);\n\n\tfor (var i = 0; i < keys.length; i++) {\n\t\tvar key = keys[i];\n\t\tvar val = obj[key];\n\n\t\tif (isArr ? predicate.indexOf(key) !== -1 : predicate(key, val, obj)) {\n\t\t\tret[key] = val;\n\t\t}\n\t}\n\n\treturn ret;\n};\n","'use strict';\nconst strictUriEncode = require('strict-uri-encode');\nconst decodeComponent = require('decode-uri-component');\nconst splitOnFirst = require('split-on-first');\nconst filterObject = require('filter-obj');\n\nconst isNullOrUndefined = value => value === null || value === undefined;\n\nconst encodeFragmentIdentifier = Symbol('encodeFragmentIdentifier');\n\nfunction encoderForArrayFormat(options) {\n\tswitch (options.arrayFormat) {\n\t\tcase 'index':\n\t\t\treturn key => (result, value) => {\n\t\t\t\tconst index = result.length;\n\n\t\t\t\tif (\n\t\t\t\t\tvalue === undefined ||\n\t\t\t\t\t(options.skipNull && value === null) ||\n\t\t\t\t\t(options.skipEmptyString && value === '')\n\t\t\t\t) {\n\t\t\t\t\treturn result;\n\t\t\t\t}\n\n\t\t\t\tif (value === null) {\n\t\t\t\t\treturn [...result, [encode(key, options), '[', index, ']'].join('')];\n\t\t\t\t}\n\n\t\t\t\treturn [\n\t\t\t\t\t...result,\n\t\t\t\t\t[encode(key, options), '[', encode(index, options), ']=', encode(value, options)].join('')\n\t\t\t\t];\n\t\t\t};\n\n\t\tcase 'bracket':\n\t\t\treturn key => (result, value) => {\n\t\t\t\tif (\n\t\t\t\t\tvalue === undefined ||\n\t\t\t\t\t(options.skipNull && value === null) ||\n\t\t\t\t\t(options.skipEmptyString && value === '')\n\t\t\t\t) {\n\t\t\t\t\treturn result;\n\t\t\t\t}\n\n\t\t\t\tif (value === null) {\n\t\t\t\t\treturn [...result, [encode(key, options), '[]'].join('')];\n\t\t\t\t}\n\n\t\t\t\treturn [...result, [encode(key, options), '[]=', encode(value, options)].join('')];\n\t\t\t};\n\n\t\tcase 'colon-list-separator':\n\t\t\treturn key => (result, value) => {\n\t\t\t\tif (\n\t\t\t\t\tvalue === undefined ||\n\t\t\t\t\t(options.skipNull && value === null) ||\n\t\t\t\t\t(options.skipEmptyString && value === '')\n\t\t\t\t) {\n\t\t\t\t\treturn result;\n\t\t\t\t}\n\n\t\t\t\tif (value === null) {\n\t\t\t\t\treturn [...result, [encode(key, options), ':list='].join('')];\n\t\t\t\t}\n\n\t\t\t\treturn [...result, [encode(key, options), ':list=', encode(value, options)].join('')];\n\t\t\t};\n\n\t\tcase 'comma':\n\t\tcase 'separator':\n\t\tcase 'bracket-separator': {\n\t\t\tconst keyValueSep = options.arrayFormat === 'bracket-separator' ?\n\t\t\t\t'[]=' :\n\t\t\t\t'=';\n\n\t\t\treturn key => (result, value) => {\n\t\t\t\tif (\n\t\t\t\t\tvalue === undefined ||\n\t\t\t\t\t(options.skipNull && value === null) ||\n\t\t\t\t\t(options.skipEmptyString && value === '')\n\t\t\t\t) {\n\t\t\t\t\treturn result;\n\t\t\t\t}\n\n\t\t\t\t// Translate null to an empty string so that it doesn't serialize as 'null'\n\t\t\t\tvalue = value === null ? '' : value;\n\n\t\t\t\tif (result.length === 0) {\n\t\t\t\t\treturn [[encode(key, options), keyValueSep, encode(value, options)].join('')];\n\t\t\t\t}\n\n\t\t\t\treturn [[result, encode(value, options)].join(options.arrayFormatSeparator)];\n\t\t\t};\n\t\t}\n\n\t\tdefault:\n\t\t\treturn key => (result, value) => {\n\t\t\t\tif (\n\t\t\t\t\tvalue === undefined ||\n\t\t\t\t\t(options.skipNull && value === null) ||\n\t\t\t\t\t(options.skipEmptyString && value === '')\n\t\t\t\t) {\n\t\t\t\t\treturn result;\n\t\t\t\t}\n\n\t\t\t\tif (value === null) {\n\t\t\t\t\treturn [...result, encode(key, options)];\n\t\t\t\t}\n\n\t\t\t\treturn [...result, [encode(key, options), '=', encode(value, options)].join('')];\n\t\t\t};\n\t}\n}\n\nfunction parserForArrayFormat(options) {\n\tlet result;\n\n\tswitch (options.arrayFormat) {\n\t\tcase 'index':\n\t\t\treturn (key, value, accumulator) => {\n\t\t\t\tresult = /\\[(\\d*)\\]$/.exec(key);\n\n\t\t\t\tkey = key.replace(/\\[\\d*\\]$/, '');\n\n\t\t\t\tif (!result) {\n\t\t\t\t\taccumulator[key] = value;\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tif (accumulator[key] === undefined) {\n\t\t\t\t\taccumulator[key] = {};\n\t\t\t\t}\n\n\t\t\t\taccumulator[key][result[1]] = value;\n\t\t\t};\n\n\t\tcase 'bracket':\n\t\t\treturn (key, value, accumulator) => {\n\t\t\t\tresult = /(\\[\\])$/.exec(key);\n\t\t\t\tkey = key.replace(/\\[\\]$/, '');\n\n\t\t\t\tif (!result) {\n\t\t\t\t\taccumulator[key] = value;\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tif (accumulator[key] === undefined) {\n\t\t\t\t\taccumulator[key] = [value];\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\taccumulator[key] = [].concat(accumulator[key], value);\n\t\t\t};\n\n\t\tcase 'colon-list-separator':\n\t\t\treturn (key, value, accumulator) => {\n\t\t\t\tresult = /(:list)$/.exec(key);\n\t\t\t\tkey = key.replace(/:list$/, '');\n\n\t\t\t\tif (!result) {\n\t\t\t\t\taccumulator[key] = value;\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tif (accumulator[key] === undefined) {\n\t\t\t\t\taccumulator[key] = [value];\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\taccumulator[key] = [].concat(accumulator[key], value);\n\t\t\t};\n\n\t\tcase 'comma':\n\t\tcase 'separator':\n\t\t\treturn (key, value, accumulator) => {\n\t\t\t\tconst isArray = typeof value === 'string' && value.includes(options.arrayFormatSeparator);\n\t\t\t\tconst isEncodedArray = (typeof value === 'string' && !isArray && decode(value, options).includes(options.arrayFormatSeparator));\n\t\t\t\tvalue = isEncodedArray ? decode(value, options) : value;\n\t\t\t\tconst newValue = isArray || isEncodedArray ? value.split(options.arrayFormatSeparator).map(item => decode(item, options)) : value === null ? value : decode(value, options);\n\t\t\t\taccumulator[key] = newValue;\n\t\t\t};\n\n\t\tcase 'bracket-separator':\n\t\t\treturn (key, value, accumulator) => {\n\t\t\t\tconst isArray = /(\\[\\])$/.test(key);\n\t\t\t\tkey = key.replace(/\\[\\]$/, '');\n\n\t\t\t\tif (!isArray) {\n\t\t\t\t\taccumulator[key] = value ? decode(value, options) : value;\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tconst arrayValue = value === null ?\n\t\t\t\t\t[] :\n\t\t\t\t\tvalue.split(options.arrayFormatSeparator).map(item => decode(item, options));\n\n\t\t\t\tif (accumulator[key] === undefined) {\n\t\t\t\t\taccumulator[key] = arrayValue;\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\taccumulator[key] = [].concat(accumulator[key], arrayValue);\n\t\t\t};\n\n\t\tdefault:\n\t\t\treturn (key, value, accumulator) => {\n\t\t\t\tif (accumulator[key] === undefined) {\n\t\t\t\t\taccumulator[key] = value;\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\taccumulator[key] = [].concat(accumulator[key], value);\n\t\t\t};\n\t}\n}\n\nfunction validateArrayFormatSeparator(value) {\n\tif (typeof value !== 'string' || value.length !== 1) {\n\t\tthrow new TypeError('arrayFormatSeparator must be single character string');\n\t}\n}\n\nfunction encode(value, options) {\n\tif (options.encode) {\n\t\treturn options.strict ? strictUriEncode(value) : encodeURIComponent(value);\n\t}\n\n\treturn value;\n}\n\nfunction decode(value, options) {\n\tif (options.decode) {\n\t\treturn decodeComponent(value);\n\t}\n\n\treturn value;\n}\n\nfunction keysSorter(input) {\n\tif (Array.isArray(input)) {\n\t\treturn input.sort();\n\t}\n\n\tif (typeof input === 'object') {\n\t\treturn keysSorter(Object.keys(input))\n\t\t\t.sort((a, b) => Number(a) - Number(b))\n\t\t\t.map(key => input[key]);\n\t}\n\n\treturn input;\n}\n\nfunction removeHash(input) {\n\tconst hashStart = input.indexOf('#');\n\tif (hashStart !== -1) {\n\t\tinput = input.slice(0, hashStart);\n\t}\n\n\treturn input;\n}\n\nfunction getHash(url) {\n\tlet hash = '';\n\tconst hashStart = url.indexOf('#');\n\tif (hashStart !== -1) {\n\t\thash = url.slice(hashStart);\n\t}\n\n\treturn hash;\n}\n\nfunction extract(input) {\n\tinput = removeHash(input);\n\tconst queryStart = input.indexOf('?');\n\tif (queryStart === -1) {\n\t\treturn '';\n\t}\n\n\treturn input.slice(queryStart + 1);\n}\n\nfunction parseValue(value, options) {\n\tif (options.parseNumbers && !Number.isNaN(Number(value)) && (typeof value === 'string' && value.trim() !== '')) {\n\t\tvalue = Number(value);\n\t} else if (options.parseBooleans && value !== null && (value.toLowerCase() === 'true' || value.toLowerCase() === 'false')) {\n\t\tvalue = value.toLowerCase() === 'true';\n\t}\n\n\treturn value;\n}\n\nfunction parse(query, options) {\n\toptions = Object.assign({\n\t\tdecode: true,\n\t\tsort: true,\n\t\tarrayFormat: 'none',\n\t\tarrayFormatSeparator: ',',\n\t\tparseNumbers: false,\n\t\tparseBooleans: false\n\t}, options);\n\n\tvalidateArrayFormatSeparator(options.arrayFormatSeparator);\n\n\tconst formatter = parserForArrayFormat(options);\n\n\t// Create an object with no prototype\n\tconst ret = Object.create(null);\n\n\tif (typeof query !== 'string') {\n\t\treturn ret;\n\t}\n\n\tquery = query.trim().replace(/^[?#&]/, '');\n\n\tif (!query) {\n\t\treturn ret;\n\t}\n\n\tfor (const param of query.split('&')) {\n\t\tif (param === '') {\n\t\t\tcontinue;\n\t\t}\n\n\t\tlet [key, value] = splitOnFirst(options.decode ? param.replace(/\\+/g, ' ') : param, '=');\n\n\t\t// Missing `=` should be `null`:\n\t\t// http://w3.org/TR/2012/WD-url-20120524/#collect-url-parameters\n\t\tvalue = value === undefined ? null : ['comma', 'separator', 'bracket-separator'].includes(options.arrayFormat) ? value : decode(value, options);\n\t\tformatter(decode(key, options), value, ret);\n\t}\n\n\tfor (const key of Object.keys(ret)) {\n\t\tconst value = ret[key];\n\t\tif (typeof value === 'object' && value !== null) {\n\t\t\tfor (const k of Object.keys(value)) {\n\t\t\t\tvalue[k] = parseValue(value[k], options);\n\t\t\t}\n\t\t} else {\n\t\t\tret[key] = parseValue(value, options);\n\t\t}\n\t}\n\n\tif (options.sort === false) {\n\t\treturn ret;\n\t}\n\n\treturn (options.sort === true ? Object.keys(ret).sort() : Object.keys(ret).sort(options.sort)).reduce((result, key) => {\n\t\tconst value = ret[key];\n\t\tif (Boolean(value) && typeof value === 'object' && !Array.isArray(value)) {\n\t\t\t// Sort object keys, not values\n\t\t\tresult[key] = keysSorter(value);\n\t\t} else {\n\t\t\tresult[key] = value;\n\t\t}\n\n\t\treturn result;\n\t}, Object.create(null));\n}\n\nexports.extract = extract;\nexports.parse = parse;\n\nexports.stringify = (object, options) => {\n\tif (!object) {\n\t\treturn '';\n\t}\n\n\toptions = Object.assign({\n\t\tencode: true,\n\t\tstrict: true,\n\t\tarrayFormat: 'none',\n\t\tarrayFormatSeparator: ','\n\t}, options);\n\n\tvalidateArrayFormatSeparator(options.arrayFormatSeparator);\n\n\tconst shouldFilter = key => (\n\t\t(options.skipNull && isNullOrUndefined(object[key])) ||\n\t\t(options.skipEmptyString && object[key] === '')\n\t);\n\n\tconst formatter = encoderForArrayFormat(options);\n\n\tconst objectCopy = {};\n\n\tfor (const key of Object.keys(object)) {\n\t\tif (!shouldFilter(key)) {\n\t\t\tobjectCopy[key] = object[key];\n\t\t}\n\t}\n\n\tconst keys = Object.keys(objectCopy);\n\n\tif (options.sort !== false) {\n\t\tkeys.sort(options.sort);\n\t}\n\n\treturn keys.map(key => {\n\t\tconst value = object[key];\n\n\t\tif (value === undefined) {\n\t\t\treturn '';\n\t\t}\n\n\t\tif (value === null) {\n\t\t\treturn encode(key, options);\n\t\t}\n\n\t\tif (Array.isArray(value)) {\n\t\t\tif (value.length === 0 && options.arrayFormat === 'bracket-separator') {\n\t\t\t\treturn encode(key, options) + '[]';\n\t\t\t}\n\n\t\t\treturn value\n\t\t\t\t.reduce(formatter(key), [])\n\t\t\t\t.join('&');\n\t\t}\n\n\t\treturn encode(key, options) + '=' + encode(value, options);\n\t}).filter(x => x.length > 0).join('&');\n};\n\nexports.parseUrl = (url, options) => {\n\toptions = Object.assign({\n\t\tdecode: true\n\t}, options);\n\n\tconst [url_, hash] = splitOnFirst(url, '#');\n\n\treturn Object.assign(\n\t\t{\n\t\t\turl: url_.split('?')[0] || '',\n\t\t\tquery: parse(extract(url), options)\n\t\t},\n\t\toptions && options.parseFragmentIdentifier && hash ? {fragmentIdentifier: decode(hash, options)} : {}\n\t);\n};\n\nexports.stringifyUrl = (object, options) => {\n\toptions = Object.assign({\n\t\tencode: true,\n\t\tstrict: true,\n\t\t[encodeFragmentIdentifier]: true\n\t}, options);\n\n\tconst url = removeHash(object.url).split('?')[0] || '';\n\tconst queryFromUrl = exports.extract(object.url);\n\tconst parsedQueryFromUrl = exports.parse(queryFromUrl, {sort: false});\n\n\tconst query = Object.assign(parsedQueryFromUrl, object.query);\n\tlet queryString = exports.stringify(query, options);\n\tif (queryString) {\n\t\tqueryString = `?${queryString}`;\n\t}\n\n\tlet hash = getHash(object.url);\n\tif (object.fragmentIdentifier) {\n\t\thash = `#${options[encodeFragmentIdentifier] ? encode(object.fragmentIdentifier, options) : object.fragmentIdentifier}`;\n\t}\n\n\treturn `${url}${queryString}${hash}`;\n};\n\nexports.pick = (input, filter, options) => {\n\toptions = Object.assign({\n\t\tparseFragmentIdentifier: true,\n\t\t[encodeFragmentIdentifier]: false\n\t}, options);\n\n\tconst {url, query, fragmentIdentifier} = exports.parseUrl(input, options);\n\treturn exports.stringifyUrl({\n\t\turl,\n\t\tquery: filterObject(query, filter),\n\t\tfragmentIdentifier\n\t}, options);\n};\n\nexports.exclude = (input, filter, options) => {\n\tconst exclusionFilter = Array.isArray(filter) ? key => !filter.includes(key) : (key, value) => !filter(key, value);\n\n\treturn exports.pick(input, exclusionFilter, options);\n};\n","'use strict';\n\nmodule.exports = (string, separator) => {\n\tif (!(typeof string === 'string' && typeof separator === 'string')) {\n\t\tthrow new TypeError('Expected the arguments to be of type `string`');\n\t}\n\n\tif (separator === '') {\n\t\treturn [string];\n\t}\n\n\tconst separatorIndex = string.indexOf(separator);\n\n\tif (separatorIndex === -1) {\n\t\treturn [string];\n\t}\n\n\treturn [\n\t\tstring.slice(0, separatorIndex),\n\t\tstring.slice(separatorIndex + separator.length)\n\t];\n};\n","'use strict';\nmodule.exports = str => encodeURIComponent(str).replace(/[!'()*]/g, x => `%${x.charCodeAt(0).toString(16).toUpperCase()}`);\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","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","import { __assign } from 'tslib';\nimport { isMouseEvent, isTouchEvent } from './utils/event-type.mjs';\nimport { extractEventInfo } from '../events/event-info.mjs';\nimport sync, { getFrameData, cancelSync } from 'framesync';\nimport { secondsToMilliseconds } from '../utils/time-conversion.mjs';\nimport { addPointerEvent } from '../events/use-pointer-event.mjs';\nimport { distance, pipe } from 'popmotion';\n\n/**\n * @internal\n */\nvar PanSession = /** @class */ (function () {\n    function PanSession(event, handlers, _a) {\n        var _this = this;\n        var _b = _a === void 0 ? {} : _a, transformPagePoint = _b.transformPagePoint;\n        /**\n         * @internal\n         */\n        this.startEvent = null;\n        /**\n         * @internal\n         */\n        this.lastMoveEvent = null;\n        /**\n         * @internal\n         */\n        this.lastMoveEventInfo = null;\n        /**\n         * @internal\n         */\n        this.handlers = {};\n        this.updatePoint = function () {\n            if (!(_this.lastMoveEvent && _this.lastMoveEventInfo))\n                return;\n            var info = getPanInfo(_this.lastMoveEventInfo, _this.history);\n            var isPanStarted = _this.startEvent !== null;\n            // Only start panning if the offset is larger than 3 pixels. If we make it\n            // any larger than this we'll want to reset the pointer history\n            // on the first update to avoid visual snapping to the cursoe.\n            var isDistancePastThreshold = distance(info.offset, { x: 0, y: 0 }) >= 3;\n            if (!isPanStarted && !isDistancePastThreshold)\n                return;\n            var point = info.point;\n            var timestamp = getFrameData().timestamp;\n            _this.history.push(__assign(__assign({}, point), { timestamp: timestamp }));\n            var _a = _this.handlers, onStart = _a.onStart, onMove = _a.onMove;\n            if (!isPanStarted) {\n                onStart && onStart(_this.lastMoveEvent, info);\n                _this.startEvent = _this.lastMoveEvent;\n            }\n            onMove && onMove(_this.lastMoveEvent, info);\n        };\n        this.handlePointerMove = function (event, info) {\n            _this.lastMoveEvent = event;\n            _this.lastMoveEventInfo = transformPoint(info, _this.transformPagePoint);\n            // Because Safari doesn't trigger mouseup events when it's above a `<select>`\n            if (isMouseEvent(event) && event.buttons === 0) {\n                _this.handlePointerUp(event, info);\n                return;\n            }\n            // Throttle mouse move event to once per frame\n            sync.update(_this.updatePoint, true);\n        };\n        this.handlePointerUp = function (event, info) {\n            _this.end();\n            var _a = _this.handlers, onEnd = _a.onEnd, onSessionEnd = _a.onSessionEnd;\n            var panInfo = getPanInfo(transformPoint(info, _this.transformPagePoint), _this.history);\n            if (_this.startEvent && onEnd) {\n                onEnd(event, panInfo);\n            }\n            onSessionEnd && onSessionEnd(event, panInfo);\n        };\n        // If we have more than one touch, don't start detecting this gesture\n        if (isTouchEvent(event) && event.touches.length > 1)\n            return;\n        this.handlers = handlers;\n        this.transformPagePoint = transformPagePoint;\n        var info = extractEventInfo(event);\n        var initialInfo = transformPoint(info, this.transformPagePoint);\n        var point = initialInfo.point;\n        var timestamp = getFrameData().timestamp;\n        this.history = [__assign(__assign({}, point), { timestamp: timestamp })];\n        var onSessionStart = handlers.onSessionStart;\n        onSessionStart &&\n            onSessionStart(event, getPanInfo(initialInfo, this.history));\n        this.removeListeners = pipe(addPointerEvent(window, \"pointermove\", this.handlePointerMove), addPointerEvent(window, \"pointerup\", this.handlePointerUp), addPointerEvent(window, \"pointercancel\", this.handlePointerUp));\n    }\n    PanSession.prototype.updateHandlers = function (handlers) {\n        this.handlers = handlers;\n    };\n    PanSession.prototype.end = function () {\n        this.removeListeners && this.removeListeners();\n        cancelSync.update(this.updatePoint);\n    };\n    return PanSession;\n}());\nfunction transformPoint(info, transformPagePoint) {\n    return transformPagePoint ? { point: transformPagePoint(info.point) } : info;\n}\nfunction subtractPoint(a, b) {\n    return { x: a.x - b.x, y: a.y - b.y };\n}\nfunction getPanInfo(_a, history) {\n    var point = _a.point;\n    return {\n        point: point,\n        delta: subtractPoint(point, lastDevicePoint(history)),\n        offset: subtractPoint(point, startDevicePoint(history)),\n        velocity: getVelocity(history, 0.1),\n    };\n}\nfunction startDevicePoint(history) {\n    return history[0];\n}\nfunction lastDevicePoint(history) {\n    return history[history.length - 1];\n}\nfunction getVelocity(history, timeDelta) {\n    if (history.length < 2) {\n        return { x: 0, y: 0 };\n    }\n    var i = history.length - 1;\n    var timestampedPoint = null;\n    var lastPoint = lastDevicePoint(history);\n    while (i >= 0) {\n        timestampedPoint = history[i];\n        if (lastPoint.timestamp - timestampedPoint.timestamp >\n            secondsToMilliseconds(timeDelta)) {\n            break;\n        }\n        i--;\n    }\n    if (!timestampedPoint) {\n        return { x: 0, y: 0 };\n    }\n    var time = (lastPoint.timestamp - timestampedPoint.timestamp) / 1000;\n    if (time === 0) {\n        return { x: 0, y: 0 };\n    }\n    var currentVelocity = {\n        x: (lastPoint.x - timestampedPoint.x) / time,\n        y: (lastPoint.y - timestampedPoint.y) / time,\n    };\n    if (currentVelocity.x === Infinity) {\n        currentVelocity.x = 0;\n    }\n    if (currentVelocity.y === Infinity) {\n        currentVelocity.y = 0;\n    }\n    return currentVelocity;\n}\n\nexport { PanSession };\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","import { __read } from 'tslib';\nimport { clamp, mix, progress } from 'popmotion';\nimport { calcLength } from '../../../projection/geometry/delta-calc.mjs';\n\n/**\n * Apply constraints to a point. These constraints are both physical along an\n * axis, and an elastic factor that determines how much to constrain the point\n * by if it does lie outside the defined parameters.\n */\nfunction applyConstraints(point, _a, elastic) {\n    var min = _a.min, max = _a.max;\n    if (min !== undefined && point < min) {\n        // If we have a min point defined, and this is outside of that, constrain\n        point = elastic ? mix(min, point, elastic.min) : Math.max(point, min);\n    }\n    else if (max !== undefined && point > max) {\n        // If we have a max point defined, and this is outside of that, constrain\n        point = elastic ? mix(max, point, elastic.max) : Math.min(point, max);\n    }\n    return point;\n}\n/**\n * Calculate constraints in terms of the viewport when defined relatively to the\n * measured axis. This is measured from the nearest edge, so a max constraint of 200\n * on an axis with a max value of 300 would return a constraint of 500 - axis length\n */\nfunction calcRelativeAxisConstraints(axis, min, max) {\n    return {\n        min: min !== undefined ? axis.min + min : undefined,\n        max: max !== undefined\n            ? axis.max + max - (axis.max - axis.min)\n            : undefined,\n    };\n}\n/**\n * Calculate constraints in terms of the viewport when\n * defined relatively to the measured bounding box.\n */\nfunction calcRelativeConstraints(layoutBox, _a) {\n    var top = _a.top, left = _a.left, bottom = _a.bottom, right = _a.right;\n    return {\n        x: calcRelativeAxisConstraints(layoutBox.x, left, right),\n        y: calcRelativeAxisConstraints(layoutBox.y, top, bottom),\n    };\n}\n/**\n * Calculate viewport constraints when defined as another viewport-relative axis\n */\nfunction calcViewportAxisConstraints(layoutAxis, constraintsAxis) {\n    var _a;\n    var min = constraintsAxis.min - layoutAxis.min;\n    var max = constraintsAxis.max - layoutAxis.max;\n    // If the constraints axis is actually smaller than the layout axis then we can\n    // flip the constraints\n    if (constraintsAxis.max - constraintsAxis.min <\n        layoutAxis.max - layoutAxis.min) {\n        _a = __read([max, min], 2), min = _a[0], max = _a[1];\n    }\n    return { min: min, max: max };\n}\n/**\n * Calculate viewport constraints when defined as another viewport-relative box\n */\nfunction calcViewportConstraints(layoutBox, constraintsBox) {\n    return {\n        x: calcViewportAxisConstraints(layoutBox.x, constraintsBox.x),\n        y: calcViewportAxisConstraints(layoutBox.y, constraintsBox.y),\n    };\n}\n/**\n * Calculate a transform origin relative to the source axis, between 0-1, that results\n * in an asthetically pleasing scale/transform needed to project from source to target.\n */\nfunction calcOrigin(source, target) {\n    var origin = 0.5;\n    var sourceLength = calcLength(source);\n    var targetLength = calcLength(target);\n    if (targetLength > sourceLength) {\n        origin = progress(target.min, target.max - sourceLength, source.min);\n    }\n    else if (sourceLength > targetLength) {\n        origin = progress(source.min, source.max - targetLength, target.min);\n    }\n    return clamp(0, 1, origin);\n}\n/**\n * Rebase the calculated viewport constraints relative to the layout.min point.\n */\nfunction rebaseAxisConstraints(layout, constraints) {\n    var relativeConstraints = {};\n    if (constraints.min !== undefined) {\n        relativeConstraints.min = constraints.min - layout.min;\n    }\n    if (constraints.max !== undefined) {\n        relativeConstraints.max = constraints.max - layout.min;\n    }\n    return relativeConstraints;\n}\nvar defaultElastic = 0.35;\n/**\n * Accepts a dragElastic prop and returns resolved elastic values for each axis.\n */\nfunction resolveDragElastic(dragElastic) {\n    if (dragElastic === void 0) { dragElastic = defaultElastic; }\n    if (dragElastic === false) {\n        dragElastic = 0;\n    }\n    else if (dragElastic === true) {\n        dragElastic = defaultElastic;\n    }\n    return {\n        x: resolveAxisElastic(dragElastic, \"left\", \"right\"),\n        y: resolveAxisElastic(dragElastic, \"top\", \"bottom\"),\n    };\n}\nfunction resolveAxisElastic(dragElastic, minLabel, maxLabel) {\n    return {\n        min: resolvePointElastic(dragElastic, minLabel),\n        max: resolvePointElastic(dragElastic, maxLabel),\n    };\n}\nfunction resolvePointElastic(dragElastic, label) {\n    var _a;\n    return typeof dragElastic === \"number\"\n        ? dragElastic\n        : (_a = dragElastic[label]) !== null && _a !== void 0 ? _a : 0;\n}\n\nexport { applyConstraints, calcOrigin, calcRelativeAxisConstraints, calcRelativeConstraints, calcViewportAxisConstraints, calcViewportConstraints, defaultElastic, rebaseAxisConstraints, resolveAxisElastic, resolveDragElastic, resolvePointElastic };\n","function eachAxis(callback) {\n    return [callback(\"x\"), callback(\"y\")];\n}\n\nexport { eachAxis };\n","import { __assign } from 'tslib';\nimport { invariant } from 'hey-listen';\nimport { PanSession } from '../PanSession.mjs';\nimport { getGlobalLock } from './utils/lock.mjs';\nimport { isRefObject } from '../../utils/is-ref-object.mjs';\nimport { addPointerEvent } from '../../events/use-pointer-event.mjs';\nimport { applyConstraints, calcRelativeConstraints, resolveDragElastic, rebaseAxisConstraints, calcViewportConstraints, calcOrigin, defaultElastic } from './utils/constraints.mjs';\nimport { AnimationType } from '../../render/utils/types.mjs';\nimport { createBox } from '../../projection/geometry/models.mjs';\nimport { eachAxis } from '../../projection/utils/each-axis.mjs';\nimport { measurePageBox } from '../../projection/utils/measure.mjs';\nimport { extractEventInfo } from '../../events/event-info.mjs';\nimport { startAnimation } from '../../animation/utils/transitions.mjs';\nimport { convertBoxToBoundingBox, convertBoundingBoxToBox } from '../../projection/geometry/conversion.mjs';\nimport { addDomEvent } from '../../events/use-dom-event.mjs';\nimport { mix } from 'popmotion';\nimport { percent } from 'style-value-types';\nimport { calcLength } from '../../projection/geometry/delta-calc.mjs';\n\nvar elementDragControls = new WeakMap();\n/**\n *\n */\n// let latestPointerEvent: AnyPointerEvent\nvar VisualElementDragControls = /** @class */ (function () {\n    function VisualElementDragControls(visualElement) {\n        // This is a reference to the global drag gesture lock, ensuring only one component\n        // can \"capture\" the drag of one or both axes.\n        // TODO: Look into moving this into pansession?\n        this.openGlobalLock = null;\n        this.isDragging = false;\n        this.currentDirection = null;\n        this.originPoint = { x: 0, y: 0 };\n        /**\n         * The permitted boundaries of travel, in pixels.\n         */\n        this.constraints = false;\n        this.hasMutatedConstraints = false;\n        /**\n         * The per-axis resolved elastic values.\n         */\n        this.elastic = createBox();\n        this.visualElement = visualElement;\n    }\n    VisualElementDragControls.prototype.start = function (originEvent, _a) {\n        var _this = this;\n        var _b = _a === void 0 ? {} : _a, _c = _b.snapToCursor, snapToCursor = _c === void 0 ? false : _c;\n        /**\n         * Don't start dragging if this component is exiting\n         */\n        if (this.visualElement.isPresent === false)\n            return;\n        var onSessionStart = function (event) {\n            // Stop any animations on both axis values immediately. This allows the user to throw and catch\n            // the component.\n            _this.stopAnimation();\n            if (snapToCursor) {\n                _this.snapToCursor(extractEventInfo(event, \"page\").point);\n            }\n        };\n        var onStart = function (event, info) {\n            var _a;\n            // Attempt to grab the global drag gesture lock - maybe make this part of PanSession\n            var _b = _this.getProps(), drag = _b.drag, dragPropagation = _b.dragPropagation, onDragStart = _b.onDragStart;\n            if (drag && !dragPropagation) {\n                if (_this.openGlobalLock)\n                    _this.openGlobalLock();\n                _this.openGlobalLock = getGlobalLock(drag);\n                // If we don 't have the lock, don't start dragging\n                if (!_this.openGlobalLock)\n                    return;\n            }\n            _this.isDragging = true;\n            _this.currentDirection = null;\n            _this.resolveConstraints();\n            if (_this.visualElement.projection) {\n                _this.visualElement.projection.isAnimationBlocked = true;\n                _this.visualElement.projection.target = undefined;\n            }\n            /**\n             * Record gesture origin\n             */\n            eachAxis(function (axis) {\n                var _a, _b;\n                var current = _this.getAxisMotionValue(axis).get() || 0;\n                /**\n                 * If the MotionValue is a percentage value convert to px\n                 */\n                if (percent.test(current)) {\n                    var measuredAxis = (_b = (_a = _this.visualElement.projection) === null || _a === void 0 ? void 0 : _a.layout) === null || _b === void 0 ? void 0 : _b.actual[axis];\n                    if (measuredAxis) {\n                        var length_1 = calcLength(measuredAxis);\n                        current = length_1 * (parseFloat(current) / 100);\n                    }\n                }\n                _this.originPoint[axis] = current;\n            });\n            // Fire onDragStart event\n            onDragStart === null || onDragStart === void 0 ? void 0 : onDragStart(event, info);\n            (_a = _this.visualElement.animationState) === null || _a === void 0 ? void 0 : _a.setActive(AnimationType.Drag, true);\n        };\n        var onMove = function (event, info) {\n            // latestPointerEvent = event\n            var _a = _this.getProps(), dragPropagation = _a.dragPropagation, dragDirectionLock = _a.dragDirectionLock, onDirectionLock = _a.onDirectionLock, onDrag = _a.onDrag;\n            // If we didn't successfully receive the gesture lock, early return.\n            if (!dragPropagation && !_this.openGlobalLock)\n                return;\n            var offset = info.offset;\n            // Attempt to detect drag direction if directionLock is true\n            if (dragDirectionLock && _this.currentDirection === null) {\n                _this.currentDirection = getCurrentDirection(offset);\n                // If we've successfully set a direction, notify listener\n                if (_this.currentDirection !== null) {\n                    onDirectionLock === null || onDirectionLock === void 0 ? void 0 : onDirectionLock(_this.currentDirection);\n                }\n                return;\n            }\n            // Update each point with the latest position\n            _this.updateAxis(\"x\", info.point, offset);\n            _this.updateAxis(\"y\", info.point, offset);\n            /**\n             * Ideally we would leave the renderer to fire naturally at the end of\n             * this frame but if the element is about to change layout as the result\n             * of a re-render we want to ensure the browser can read the latest\n             * bounding box to ensure the pointer and element don't fall out of sync.\n             */\n            _this.visualElement.syncRender();\n            /**\n             * This must fire after the syncRender call as it might trigger a state\n             * change which itself might trigger a layout update.\n             */\n            onDrag === null || onDrag === void 0 ? void 0 : onDrag(event, info);\n        };\n        var onSessionEnd = function (event, info) {\n            return _this.stop(event, info);\n        };\n        this.panSession = new PanSession(originEvent, {\n            onSessionStart: onSessionStart,\n            onStart: onStart,\n            onMove: onMove,\n            onSessionEnd: onSessionEnd,\n        }, { transformPagePoint: this.visualElement.getTransformPagePoint() });\n    };\n    VisualElementDragControls.prototype.stop = function (event, info) {\n        var isDragging = this.isDragging;\n        this.cancel();\n        if (!isDragging)\n            return;\n        var velocity = info.velocity;\n        this.startAnimation(velocity);\n        var onDragEnd = this.getProps().onDragEnd;\n        onDragEnd === null || onDragEnd === void 0 ? void 0 : onDragEnd(event, info);\n    };\n    VisualElementDragControls.prototype.cancel = function () {\n        var _a, _b;\n        this.isDragging = false;\n        if (this.visualElement.projection) {\n            this.visualElement.projection.isAnimationBlocked = false;\n        }\n        (_a = this.panSession) === null || _a === void 0 ? void 0 : _a.end();\n        this.panSession = undefined;\n        var dragPropagation = this.getProps().dragPropagation;\n        if (!dragPropagation && this.openGlobalLock) {\n            this.openGlobalLock();\n            this.openGlobalLock = null;\n        }\n        (_b = this.visualElement.animationState) === null || _b === void 0 ? void 0 : _b.setActive(AnimationType.Drag, false);\n    };\n    VisualElementDragControls.prototype.updateAxis = function (axis, _point, offset) {\n        var drag = this.getProps().drag;\n        // If we're not dragging this axis, do an early return.\n        if (!offset || !shouldDrag(axis, drag, this.currentDirection))\n            return;\n        var axisValue = this.getAxisMotionValue(axis);\n        var next = this.originPoint[axis] + offset[axis];\n        // Apply constraints\n        if (this.constraints && this.constraints[axis]) {\n            next = applyConstraints(next, this.constraints[axis], this.elastic[axis]);\n        }\n        axisValue.set(next);\n    };\n    VisualElementDragControls.prototype.resolveConstraints = function () {\n        var _this = this;\n        var _a = this.getProps(), dragConstraints = _a.dragConstraints, dragElastic = _a.dragElastic;\n        var layout = (this.visualElement.projection || {}).layout;\n        var prevConstraints = this.constraints;\n        if (dragConstraints && isRefObject(dragConstraints)) {\n            if (!this.constraints) {\n                this.constraints = this.resolveRefConstraints();\n            }\n        }\n        else {\n            if (dragConstraints && layout) {\n                this.constraints = calcRelativeConstraints(layout.actual, dragConstraints);\n            }\n            else {\n                this.constraints = false;\n            }\n        }\n        this.elastic = resolveDragElastic(dragElastic);\n        /**\n         * If we're outputting to external MotionValues, we want to rebase the measured constraints\n         * from viewport-relative to component-relative.\n         */\n        if (prevConstraints !== this.constraints &&\n            layout &&\n            this.constraints &&\n            !this.hasMutatedConstraints) {\n            eachAxis(function (axis) {\n                if (_this.getAxisMotionValue(axis)) {\n                    _this.constraints[axis] = rebaseAxisConstraints(layout.actual[axis], _this.constraints[axis]);\n                }\n            });\n        }\n    };\n    VisualElementDragControls.prototype.resolveRefConstraints = function () {\n        var _a = this.getProps(), constraints = _a.dragConstraints, onMeasureDragConstraints = _a.onMeasureDragConstraints;\n        if (!constraints || !isRefObject(constraints))\n            return false;\n        var constraintsElement = constraints.current;\n        invariant(constraintsElement !== null, \"If `dragConstraints` is set as a React ref, that ref must be passed to another component's `ref` prop.\");\n        var projection = this.visualElement.projection;\n        // TODO\n        if (!projection || !projection.layout)\n            return false;\n        var constraintsBox = measurePageBox(constraintsElement, projection.root, this.visualElement.getTransformPagePoint());\n        var measuredConstraints = calcViewportConstraints(projection.layout.actual, constraintsBox);\n        /**\n         * If there's an onMeasureDragConstraints listener we call it and\n         * if different constraints are returned, set constraints to that\n         */\n        if (onMeasureDragConstraints) {\n            var userConstraints = onMeasureDragConstraints(convertBoxToBoundingBox(measuredConstraints));\n            this.hasMutatedConstraints = !!userConstraints;\n            if (userConstraints) {\n                measuredConstraints = convertBoundingBoxToBox(userConstraints);\n            }\n        }\n        return measuredConstraints;\n    };\n    VisualElementDragControls.prototype.startAnimation = function (velocity) {\n        var _this = this;\n        var _a = this.getProps(), drag = _a.drag, dragMomentum = _a.dragMomentum, dragElastic = _a.dragElastic, dragTransition = _a.dragTransition, dragSnapToOrigin = _a.dragSnapToOrigin, onDragTransitionEnd = _a.onDragTransitionEnd;\n        var constraints = this.constraints || {};\n        var momentumAnimations = eachAxis(function (axis) {\n            var _a;\n            if (!shouldDrag(axis, drag, _this.currentDirection)) {\n                return;\n            }\n            var transition = (_a = constraints === null || constraints === void 0 ? void 0 : constraints[axis]) !== null && _a !== void 0 ? _a : {};\n            if (dragSnapToOrigin)\n                transition = { min: 0, max: 0 };\n            /**\n             * Overdamp the boundary spring if `dragElastic` is disabled. There's still a frame\n             * of spring animations so we should look into adding a disable spring option to `inertia`.\n             * We could do something here where we affect the `bounceStiffness` and `bounceDamping`\n             * using the value of `dragElastic`.\n             */\n            var bounceStiffness = dragElastic ? 200 : 1000000;\n            var bounceDamping = dragElastic ? 40 : 10000000;\n            var inertia = __assign(__assign({ type: \"inertia\", velocity: dragMomentum ? velocity[axis] : 0, bounceStiffness: bounceStiffness, bounceDamping: bounceDamping, timeConstant: 750, restDelta: 1, restSpeed: 10 }, dragTransition), transition);\n            // If we're not animating on an externally-provided `MotionValue` we can use the\n            // component's animation controls which will handle interactions with whileHover (etc),\n            // otherwise we just have to animate the `MotionValue` itself.\n            return _this.startAxisValueAnimation(axis, inertia);\n        });\n        // Run all animations and then resolve the new drag constraints.\n        return Promise.all(momentumAnimations).then(onDragTransitionEnd);\n    };\n    VisualElementDragControls.prototype.startAxisValueAnimation = function (axis, transition) {\n        var axisValue = this.getAxisMotionValue(axis);\n        return startAnimation(axis, axisValue, 0, transition);\n    };\n    VisualElementDragControls.prototype.stopAnimation = function () {\n        var _this = this;\n        eachAxis(function (axis) { return _this.getAxisMotionValue(axis).stop(); });\n    };\n    /**\n     * Drag works differently depending on which props are provided.\n     *\n     * - If _dragX and _dragY are provided, we output the gesture delta directly to those motion values.\n     * - Otherwise, we apply the delta to the x/y motion values.\n     */\n    VisualElementDragControls.prototype.getAxisMotionValue = function (axis) {\n        var _a, _b;\n        var dragKey = \"_drag\" + axis.toUpperCase();\n        var externalMotionValue = this.visualElement.getProps()[dragKey];\n        return externalMotionValue\n            ? externalMotionValue\n            : this.visualElement.getValue(axis, (_b = (_a = this.visualElement.getProps().initial) === null || _a === void 0 ? void 0 : _a[axis]) !== null && _b !== void 0 ? _b : 0);\n    };\n    VisualElementDragControls.prototype.snapToCursor = function (point) {\n        var _this = this;\n        eachAxis(function (axis) {\n            var drag = _this.getProps().drag;\n            // If we're not dragging this axis, do an early return.\n            if (!shouldDrag(axis, drag, _this.currentDirection))\n                return;\n            var projection = _this.visualElement.projection;\n            var axisValue = _this.getAxisMotionValue(axis);\n            if (projection && projection.layout) {\n                var _a = projection.layout.actual[axis], min = _a.min, max = _a.max;\n                axisValue.set(point[axis] - mix(min, max, 0.5));\n            }\n        });\n    };\n    /**\n     * When the viewport resizes we want to check if the measured constraints\n     * have changed and, if so, reposition the element within those new constraints\n     * relative to where it was before the resize.\n     */\n    VisualElementDragControls.prototype.scalePositionWithinConstraints = function () {\n        var _this = this;\n        var _a;\n        var _b = this.getProps(), drag = _b.drag, dragConstraints = _b.dragConstraints;\n        var projection = this.visualElement.projection;\n        if (!isRefObject(dragConstraints) || !projection || !this.constraints)\n            return;\n        /**\n         * Stop current animations as there can be visual glitching if we try to do\n         * this mid-animation\n         */\n        this.stopAnimation();\n        /**\n         * Record the relative position of the dragged element relative to the\n         * constraints box and save as a progress value.\n         */\n        var boxProgress = { x: 0, y: 0 };\n        eachAxis(function (axis) {\n            var axisValue = _this.getAxisMotionValue(axis);\n            if (axisValue) {\n                var latest = axisValue.get();\n                boxProgress[axis] = calcOrigin({ min: latest, max: latest }, _this.constraints[axis]);\n            }\n        });\n        /**\n         * Update the layout of this element and resolve the latest drag constraints\n         */\n        var transformTemplate = this.visualElement.getProps().transformTemplate;\n        this.visualElement.getInstance().style.transform = transformTemplate\n            ? transformTemplate({}, \"\")\n            : \"none\";\n        (_a = projection.root) === null || _a === void 0 ? void 0 : _a.updateScroll();\n        projection.updateLayout();\n        this.resolveConstraints();\n        /**\n         * For each axis, calculate the current progress of the layout axis\n         * within the new constraints.\n         */\n        eachAxis(function (axis) {\n            if (!shouldDrag(axis, drag, null))\n                return;\n            /**\n             * Calculate a new transform based on the previous box progress\n             */\n            var axisValue = _this.getAxisMotionValue(axis);\n            var _a = _this.constraints[axis], min = _a.min, max = _a.max;\n            axisValue.set(mix(min, max, boxProgress[axis]));\n        });\n    };\n    VisualElementDragControls.prototype.addListeners = function () {\n        var _this = this;\n        var _a;\n        elementDragControls.set(this.visualElement, this);\n        var element = this.visualElement.getInstance();\n        /**\n         * Attach a pointerdown event listener on this DOM element to initiate drag tracking.\n         */\n        var stopPointerListener = addPointerEvent(element, \"pointerdown\", function (event) {\n            var _a = _this.getProps(), drag = _a.drag, _b = _a.dragListener, dragListener = _b === void 0 ? true : _b;\n            drag && dragListener && _this.start(event);\n        });\n        var measureDragConstraints = function () {\n            var dragConstraints = _this.getProps().dragConstraints;\n            if (isRefObject(dragConstraints)) {\n                _this.constraints = _this.resolveRefConstraints();\n            }\n        };\n        var projection = this.visualElement.projection;\n        var stopMeasureLayoutListener = projection.addEventListener(\"measure\", measureDragConstraints);\n        if (projection && !projection.layout) {\n            (_a = projection.root) === null || _a === void 0 ? void 0 : _a.updateScroll();\n            projection.updateLayout();\n        }\n        measureDragConstraints();\n        /**\n         * Attach a window resize listener to scale the draggable target within its defined\n         * constraints as the window resizes.\n         */\n        var stopResizeListener = addDomEvent(window, \"resize\", function () {\n            return _this.scalePositionWithinConstraints();\n        });\n        /**\n         * If the element's layout changes, calculate the delta and apply that to\n         * the drag gesture's origin point.\n         */\n        projection.addEventListener(\"didUpdate\", (function (_a) {\n            var delta = _a.delta, hasLayoutChanged = _a.hasLayoutChanged;\n            if (_this.isDragging && hasLayoutChanged) {\n                eachAxis(function (axis) {\n                    var motionValue = _this.getAxisMotionValue(axis);\n                    if (!motionValue)\n                        return;\n                    _this.originPoint[axis] += delta[axis].translate;\n                    motionValue.set(motionValue.get() + delta[axis].translate);\n                });\n                _this.visualElement.syncRender();\n            }\n        }));\n        return function () {\n            stopResizeListener();\n            stopPointerListener();\n            stopMeasureLayoutListener();\n        };\n    };\n    VisualElementDragControls.prototype.getProps = function () {\n        var props = this.visualElement.getProps();\n        var _a = props.drag, drag = _a === void 0 ? false : _a, _b = props.dragDirectionLock, dragDirectionLock = _b === void 0 ? false : _b, _c = props.dragPropagation, dragPropagation = _c === void 0 ? false : _c, _d = props.dragConstraints, dragConstraints = _d === void 0 ? false : _d, _e = props.dragElastic, dragElastic = _e === void 0 ? defaultElastic : _e, _f = props.dragMomentum, dragMomentum = _f === void 0 ? true : _f;\n        return __assign(__assign({}, props), { drag: drag, dragDirectionLock: dragDirectionLock, dragPropagation: dragPropagation, dragConstraints: dragConstraints, dragElastic: dragElastic, dragMomentum: dragMomentum });\n    };\n    return VisualElementDragControls;\n}());\nfunction shouldDrag(direction, drag, currentDirection) {\n    return ((drag === true || drag === direction) &&\n        (currentDirection === null || currentDirection === direction));\n}\n/**\n * Based on an x/y offset determine the current drag direction. If both axis' offsets are lower\n * than the provided threshold, return `null`.\n *\n * @param offset - The x/y offset from origin.\n * @param lockThreshold - (Optional) - the minimum absolute offset before we can determine a drag direction.\n */\nfunction getCurrentDirection(offset, lockThreshold) {\n    if (lockThreshold === void 0) { lockThreshold = 10; }\n    var direction = null;\n    if (Math.abs(offset.y) > lockThreshold) {\n        direction = \"y\";\n    }\n    else if (Math.abs(offset.x) > lockThreshold) {\n        direction = \"x\";\n    }\n    return direction;\n}\n\nexport { VisualElementDragControls, elementDragControls };\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 { useDrag } from '../../gestures/drag/use-drag.mjs';\nimport { usePanGesture } from '../../gestures/use-pan-gesture.mjs';\nimport { makeRenderlessComponent } from '../utils/make-renderless-component.mjs';\n\nvar drag = {\n    pan: makeRenderlessComponent(usePanGesture),\n    drag: makeRenderlessComponent(useDrag),\n};\n\nexport { drag };\n","import { useRef, useContext, useEffect } from 'react';\nimport { MotionConfigContext } from '../context/MotionConfigContext.mjs';\nimport { useUnmountEffect } from '../utils/use-unmount-effect.mjs';\nimport { usePointerEvent } from '../events/use-pointer-event.mjs';\nimport { PanSession } from './PanSession.mjs';\n\n/**\n *\n * @param handlers -\n * @param ref -\n *\n * @privateRemarks\n * Currently this sets new pan gesture functions every render. The memo route has been explored\n * in the past but ultimately we're still creating new functions every render. An optimisation\n * to explore is creating the pan gestures and loading them into a `ref`.\n *\n * @internal\n */\nfunction usePanGesture(_a) {\n    var onPan = _a.onPan, onPanStart = _a.onPanStart, onPanEnd = _a.onPanEnd, onPanSessionStart = _a.onPanSessionStart, visualElement = _a.visualElement;\n    var hasPanEvents = onPan || onPanStart || onPanEnd || onPanSessionStart;\n    var panSession = useRef(null);\n    var transformPagePoint = useContext(MotionConfigContext).transformPagePoint;\n    var handlers = {\n        onSessionStart: onPanSessionStart,\n        onStart: onPanStart,\n        onMove: onPan,\n        onEnd: function (event, info) {\n            panSession.current = null;\n            onPanEnd && onPanEnd(event, info);\n        },\n    };\n    useEffect(function () {\n        if (panSession.current !== null) {\n            panSession.current.updateHandlers(handlers);\n        }\n    });\n    function onPointerDown(event) {\n        panSession.current = new PanSession(event, handlers, {\n            transformPagePoint: transformPagePoint,\n        });\n    }\n    usePointerEvent(visualElement, \"pointerdown\", hasPanEvents && onPointerDown);\n    useUnmountEffect(function () { return panSession.current && panSession.current.end(); });\n}\n\nexport { usePanGesture };\n","import { useEffect } from 'react';\nimport { VisualElementDragControls } from './VisualElementDragControls.mjs';\nimport { useConstant } from '../../utils/use-constant.mjs';\n\n/**\n * A hook that allows an element to be dragged.\n *\n * @internal\n */\nfunction useDrag(props) {\n    var groupDragControls = props.dragControls, visualElement = props.visualElement;\n    var dragControls = useConstant(function () { return new VisualElementDragControls(visualElement); });\n    // If we've been provided a DragControls for manual control over the drag gesture,\n    // subscribe this component to it on mount.\n    useEffect(function () { return groupDragControls && groupDragControls.subscribe(dragControls); }, [dragControls, groupDragControls]);\n    // Apply the event listeners to the element\n    useEffect(function () { return dragControls.addListeners(); }, [dragControls]);\n}\n\nexport { useDrag };\n","import { px } from 'style-value-types';\n\nfunction pixelsToPercent(pixels, axis) {\n    if (axis.max === axis.min)\n        return 0;\n    return (pixels / (axis.max - axis.min)) * 100;\n}\n/**\n * We always correct borderRadius as a percentage rather than pixels to reduce paints.\n * For example, if you are projecting a box that is 100px wide with a 10px borderRadius\n * into a box that is 200px wide with a 20px borderRadius, that is actually a 10%\n * borderRadius in both states. If we animate between the two in pixels that will trigger\n * a paint each time. If we animate between the two in percentage we'll avoid a paint.\n */\nvar correctBorderRadius = {\n    correct: function (latest, node) {\n        if (!node.target)\n            return latest;\n        /**\n         * If latest is a string, if it's a percentage we can return immediately as it's\n         * going to be stretched appropriately. Otherwise, if it's a pixel, convert it to a number.\n         */\n        if (typeof latest === \"string\") {\n            if (px.test(latest)) {\n                latest = parseFloat(latest);\n            }\n            else {\n                return latest;\n            }\n        }\n        /**\n         * If latest is a number, it's a pixel value. We use the current viewportBox to calculate that\n         * pixel value as a percentage of each axis\n         */\n        var x = pixelsToPercent(latest, node.target.x);\n        var y = pixelsToPercent(latest, node.target.y);\n        return \"\".concat(x, \"% \").concat(y, \"%\");\n    },\n};\n\nexport { correctBorderRadius, pixelsToPercent };\n","import { mix } from 'popmotion';\nimport { complex } from 'style-value-types';\nimport { cssVariableRegex } from '../../render/dom/utils/css-variables-conversion.mjs';\n\nvar varToken = \"_$css\";\nvar correctBoxShadow = {\n    correct: function (latest, _a) {\n        var treeScale = _a.treeScale, projectionDelta = _a.projectionDelta;\n        var original = latest;\n        /**\n         * We need to first strip and store CSS variables from the string.\n         */\n        var containsCSSVariables = latest.includes(\"var(\");\n        var cssVariables = [];\n        if (containsCSSVariables) {\n            latest = latest.replace(cssVariableRegex, function (match) {\n                cssVariables.push(match);\n                return varToken;\n            });\n        }\n        var shadow = complex.parse(latest);\n        // TODO: Doesn't support multiple shadows\n        if (shadow.length > 5)\n            return original;\n        var template = complex.createTransformer(latest);\n        var offset = typeof shadow[0] !== \"number\" ? 1 : 0;\n        // Calculate the overall context scale\n        var xScale = projectionDelta.x.scale * treeScale.x;\n        var yScale = projectionDelta.y.scale * treeScale.y;\n        shadow[0 + offset] /= xScale;\n        shadow[1 + offset] /= yScale;\n        /**\n         * Ideally we'd correct x and y scales individually, but because blur and\n         * spread apply to both we have to take a scale average and apply that instead.\n         * We could potentially improve the outcome of this by incorporating the ratio between\n         * the two scales.\n         */\n        var averageScale = mix(xScale, yScale, 0.5);\n        // Blur\n        if (typeof shadow[2 + offset] === \"number\")\n            shadow[2 + offset] /= averageScale;\n        // Spread\n        if (typeof shadow[3 + offset] === \"number\")\n            shadow[3 + offset] /= averageScale;\n        var output = template(shadow);\n        if (containsCSSVariables) {\n            var i_1 = 0;\n            output = output.replace(varToken, function () {\n                var cssVariable = cssVariables[i_1];\n                i_1++;\n                return cssVariable;\n            });\n        }\n        return output;\n    },\n};\n\nexport { correctBoxShadow };\n","import { __extends, __assign, __read } from 'tslib';\nimport sync from 'framesync';\nimport React__default, { useContext } from 'react';\nimport { usePresence } from '../../../components/AnimatePresence/use-presence.mjs';\nimport { LayoutGroupContext } from '../../../context/LayoutGroupContext.mjs';\nimport { SwitchLayoutGroupContext } from '../../../context/SwitchLayoutGroupContext.mjs';\nimport { globalProjectionState } from '../../../projection/node/state.mjs';\nimport { correctBorderRadius } from '../../../projection/styles/scale-border-radius.mjs';\nimport { correctBoxShadow } from '../../../projection/styles/scale-box-shadow.mjs';\nimport { addScaleCorrector } from '../../../projection/styles/scale-correction.mjs';\n\nvar MeasureLayoutWithContext = /** @class */ (function (_super) {\n    __extends(MeasureLayoutWithContext, _super);\n    function MeasureLayoutWithContext() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    /**\n     * This only mounts projection nodes for components that\n     * need measuring, we might want to do it for all components\n     * in order to incorporate transforms\n     */\n    MeasureLayoutWithContext.prototype.componentDidMount = function () {\n        var _this = this;\n        var _a = this.props, visualElement = _a.visualElement, layoutGroup = _a.layoutGroup, switchLayoutGroup = _a.switchLayoutGroup, layoutId = _a.layoutId;\n        var projection = visualElement.projection;\n        addScaleCorrector(defaultScaleCorrectors);\n        if (projection) {\n            if (layoutGroup === null || layoutGroup === void 0 ? void 0 : layoutGroup.group)\n                layoutGroup.group.add(projection);\n            if ((switchLayoutGroup === null || switchLayoutGroup === void 0 ? void 0 : switchLayoutGroup.register) && layoutId) {\n                switchLayoutGroup.register(projection);\n            }\n            projection.root.didUpdate();\n            projection.addEventListener(\"animationComplete\", function () {\n                _this.safeToRemove();\n            });\n            projection.setOptions(__assign(__assign({}, projection.options), { onExitComplete: function () { return _this.safeToRemove(); } }));\n        }\n        globalProjectionState.hasEverUpdated = true;\n    };\n    MeasureLayoutWithContext.prototype.getSnapshotBeforeUpdate = function (prevProps) {\n        var _this = this;\n        var _a = this.props, layoutDependency = _a.layoutDependency, visualElement = _a.visualElement, drag = _a.drag, isPresent = _a.isPresent;\n        var projection = visualElement.projection;\n        if (!projection)\n            return null;\n        /**\n         * TODO: We use this data in relegate to determine whether to\n         * promote a previous element. There's no guarantee its presence data\n         * will have updated by this point - if a bug like this arises it will\n         * have to be that we markForRelegation and then find a new lead some other way,\n         * perhaps in didUpdate\n         */\n        projection.isPresent = isPresent;\n        if (drag ||\n            prevProps.layoutDependency !== layoutDependency ||\n            layoutDependency === undefined) {\n            projection.willUpdate();\n        }\n        else {\n            this.safeToRemove();\n        }\n        if (prevProps.isPresent !== isPresent) {\n            if (isPresent) {\n                projection.promote();\n            }\n            else if (!projection.relegate()) {\n                /**\n                 * If there's another stack member taking over from this one,\n                 * it's in charge of the exit animation and therefore should\n                 * be in charge of the safe to remove. Otherwise we call it here.\n                 */\n                sync.postRender(function () {\n                    var _a;\n                    if (!((_a = projection.getStack()) === null || _a === void 0 ? void 0 : _a.members.length)) {\n                        _this.safeToRemove();\n                    }\n                });\n            }\n        }\n        return null;\n    };\n    MeasureLayoutWithContext.prototype.componentDidUpdate = function () {\n        var projection = this.props.visualElement.projection;\n        if (projection) {\n            projection.root.didUpdate();\n            if (!projection.currentAnimation && projection.isLead()) {\n                this.safeToRemove();\n            }\n        }\n    };\n    MeasureLayoutWithContext.prototype.componentWillUnmount = function () {\n        var _a = this.props, visualElement = _a.visualElement, layoutGroup = _a.layoutGroup, promoteContext = _a.switchLayoutGroup;\n        var projection = visualElement.projection;\n        if (projection) {\n            projection.scheduleCheckAfterUnmount();\n            if (layoutGroup === null || layoutGroup === void 0 ? void 0 : layoutGroup.group)\n                layoutGroup.group.remove(projection);\n            if (promoteContext === null || promoteContext === void 0 ? void 0 : promoteContext.deregister)\n                promoteContext.deregister(projection);\n        }\n    };\n    MeasureLayoutWithContext.prototype.safeToRemove = function () {\n        var safeToRemove = this.props.safeToRemove;\n        safeToRemove === null || safeToRemove === void 0 ? void 0 : safeToRemove();\n    };\n    MeasureLayoutWithContext.prototype.render = function () {\n        return null;\n    };\n    return MeasureLayoutWithContext;\n}(React__default.Component));\nfunction MeasureLayout(props) {\n    var _a = __read(usePresence(), 2), isPresent = _a[0], safeToRemove = _a[1];\n    var layoutGroup = useContext(LayoutGroupContext);\n    return (React__default.createElement(MeasureLayoutWithContext, __assign({}, props, { layoutGroup: layoutGroup, switchLayoutGroup: useContext(SwitchLayoutGroupContext), isPresent: isPresent, safeToRemove: safeToRemove })));\n}\nvar defaultScaleCorrectors = {\n    borderRadius: __assign(__assign({}, correctBorderRadius), { applyTo: [\n            \"borderTopLeftRadius\",\n            \"borderTopRightRadius\",\n            \"borderBottomLeftRadius\",\n            \"borderBottomRightRadius\",\n        ] }),\n    borderTopLeftRadius: correctBorderRadius,\n    borderTopRightRadius: correctBorderRadius,\n    borderBottomLeftRadius: correctBorderRadius,\n    borderBottomRightRadius: correctBorderRadius,\n    boxShadow: correctBoxShadow,\n};\n\nexport { MeasureLayout };\n","import { MeasureLayout } from './MeasureLayout.mjs';\n\nvar layoutFeatures = {\n    measureLayout: MeasureLayout,\n};\n\nexport { layoutFeatures };\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) scale(1, 1)\";\nfunction buildProjectionTransform(delta, treeScale, latestTransform) {\n    /**\n     * The translations we use to calculate are always relative to the viewport coordinate space.\n     * But when we apply scales, we also scale the coordinate space of an element and its children.\n     * For instance if we have a treeScale (the culmination of all parent scales) of 0.5 and we need\n     * to move an element 100 pixels, we actually need to move it 200 in within that scaled space.\n     */\n    var xTranslate = delta.x.translate / treeScale.x;\n    var yTranslate = delta.y.translate / treeScale.y;\n    var transform = \"translate3d(\".concat(xTranslate, \"px, \").concat(yTranslate, \"px, 0) \");\n    /**\n     * Apply scale correction for the tree transform.\n     * This will apply scale to the screen-orientated axes.\n     */\n    transform += \"scale(\".concat(1 / treeScale.x, \", \").concat(1 / treeScale.y, \") \");\n    if (latestTransform) {\n        var rotate = latestTransform.rotate, rotateX = latestTransform.rotateX, rotateY = latestTransform.rotateY;\n        if (rotate)\n            transform += \"rotate(\".concat(rotate, \"deg) \");\n        if (rotateX)\n            transform += \"rotateX(\".concat(rotateX, \"deg) \");\n        if (rotateY)\n            transform += \"rotateY(\".concat(rotateY, \"deg) \");\n    }\n    /**\n     * Apply scale to match the size of the element to the size we want it.\n     * This will apply scale to the element-orientated axes.\n     */\n    var elementScaleX = delta.x.scale * treeScale.x;\n    var elementScaleY = delta.y.scale * treeScale.y;\n    transform += \"scale(\".concat(elementScaleX, \", \").concat(elementScaleY, \")\");\n    return transform === identityProjection ? \"none\" : transform;\n}\n\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';\nimport { globalProjectionState } from './state.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;\nfunction createProjectionNode(_a) {\n    var attachResizeListener = _a.attachResizeListener, defaultParent = _a.defaultParent, measureScroll = _a.measureScroll, checkIsScrollRoot = _a.checkIsScrollRoot, resetTransform = _a.resetTransform;\n    return /** @class */ (function () {\n        function ProjectionNode(id, latestValues, parent) {\n            var _this = this;\n            if (latestValues === void 0) { latestValues = {}; }\n            if (parent === void 0) { parent = defaultParent === null || defaultParent === void 0 ? void 0 : defaultParent(); }\n            /**\n             * A Set containing all this component's children. This is used to iterate\n             * through the children.\n             *\n             * TODO: This could be faster to iterate as a flat array stored on the root node.\n             */\n            this.children = new Set();\n            /**\n             * Options for the node. We use this to configure what kind of layout animations\n             * we should perform (if any).\n             */\n            this.options = {};\n            /**\n             * We use this to detect when its safe to shut down part of a projection tree.\n             * We have to keep projecting children for scale correction and relative projection\n             * until all their parents stop performing layout animations.\n             */\n            this.isTreeAnimating = false;\n            this.isAnimationBlocked = false;\n            /**\n             * Flag to true if we think this layout has been changed. We can't always know this,\n             * currently we set it to true every time a component renders, or if it has a layoutDependency\n             * if that has changed between renders. Additionally, components can be grouped by LayoutGroup\n             * and if one node is dirtied, they all are.\n             */\n            this.isLayoutDirty = false;\n            /**\n             * Block layout updates for instant layout transitions throughout the tree.\n             */\n            this.updateManuallyBlocked = false;\n            this.updateBlockedByResize = false;\n            /**\n             * Set to true between the start of the first `willUpdate` call and the end of the `didUpdate`\n             * call.\n             */\n            this.isUpdating = false;\n            /**\n             * If this is an SVG element we currently disable projection transforms\n             */\n            this.isSVG = false;\n            /**\n             * Flag to true (during promotion) if a node doing an instant layout transition needs to reset\n             * its projection styles.\n             */\n            this.needsReset = false;\n            /**\n             * Flags whether this node should have its transform reset prior to measuring.\n             */\n            this.shouldResetTransform = false;\n            /**\n             * An object representing the calculated contextual/accumulated/tree scale.\n             * This will be used to scale calculcated projection transforms, as these are\n             * calculated in screen-space but need to be scaled for elements to actually\n             * make it to their calculated destinations.\n             *\n             * TODO: Lazy-init\n             */\n            this.treeScale = { x: 1, y: 1 };\n            /**\n             *\n             */\n            this.eventHandlers = new Map();\n            // Note: Currently only running on root node\n            this.potentialNodes = new Map();\n            this.checkUpdateFailed = function () {\n                if (_this.isUpdating) {\n                    _this.isUpdating = false;\n                    _this.clearAllSnapshots();\n                }\n            };\n            this.updateProjection = function () {\n                _this.nodes.forEach(resolveTargetDelta);\n                _this.nodes.forEach(calcProjection);\n            };\n            this.hasProjected = false;\n            this.isVisible = true;\n            this.animationProgress = 0;\n            /**\n             * Shared layout\n             */\n            // TODO Only running on root node\n            this.sharedNodes = new Map();\n            this.id = id;\n            this.latestValues = latestValues;\n            this.root = parent ? parent.root || parent : this;\n            this.path = parent ? __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 _g = visualElement.getProps(), onLayoutAnimationStart = _g.onLayoutAnimationStart, onLayoutAnimationComplete = _g.onLayoutAnimationComplete;\n                    /**\n                     * The target layout of the element might stay the same,\n                     * but its position relative to its parent has changed.\n                     */\n                    var targetChanged = !_this.targetLayout ||\n                        !boxEquals(_this.targetLayout, newLayout) ||\n                        hasRelativeTargetChanged;\n                    /**\n                     * If the layout hasn't seemed to have changed, it might be that the\n                     * element is visually in the same place in the document but its position\n                     * relative to its parent has indeed changed. So here we check for that.\n                     */\n                    var hasOnlyRelativeTargetChanged = !hasLayoutChanged && hasRelativeTargetChanged;\n                    if (((_d = _this.resumeFrom) === null || _d === void 0 ? void 0 : _d.instance) ||\n                        hasOnlyRelativeTargetChanged ||\n                        (hasLayoutChanged &&\n                            (targetChanged || !_this.currentAnimation))) {\n                        if (_this.resumeFrom) {\n                            _this.resumingFrom = _this.resumeFrom;\n                            _this.resumingFrom.resumingFrom = undefined;\n                        }\n                        _this.setAnimationOrigin(delta, hasOnlyRelativeTargetChanged);\n                        var animationOptions = __assign(__assign({}, getValueTransition(layoutTransition, \"layout\")), { onPlay: onLayoutAnimationStart, onComplete: onLayoutAnimationComplete });\n                        if (visualElement.shouldReduceMotion) {\n                            animationOptions.delay = 0;\n                            animationOptions.type = false;\n                        }\n                        _this.startAnimation(animationOptions);\n                    }\n                    else {\n                        /**\n                         * If the layout hasn't changed and we have an animation that hasn't started yet,\n                         * finish it immediately. Otherwise it will be animating from a location\n                         * that was probably never commited to screen and look like a jumpy box.\n                         */\n                        if (!hasLayoutChanged &&\n                            _this.animationProgress === 0) {\n                            _this.finishAnimation();\n                        }\n                        _this.isLead() && ((_f = (_e = _this.options).onExitComplete) === null || _f === void 0 ? void 0 : _f.call(_e));\n                    }\n                    _this.targetLayout = newLayout;\n                });\n            }\n        };\n        ProjectionNode.prototype.unmount = function () {\n            var _a, _b;\n            this.options.layoutId && this.willUpdate();\n            this.root.nodes.remove(this);\n            (_a = this.getStack()) === null || _a === void 0 ? void 0 : _a.remove(this);\n            (_b = this.parent) === null || _b === void 0 ? void 0 : _b.children.delete(this);\n            this.instance = undefined;\n            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.isScrollRoot = checkIsScrollRoot(this.instance);\n                this.scroll = measureScroll(this.instance);\n            }\n        };\n        ProjectionNode.prototype.resetTransform = function () {\n            var _a;\n            if (!resetTransform)\n                return;\n            var isResetRequested = this.isLayoutDirty || this.shouldResetTransform;\n            var hasProjection = this.projectionDelta && !isDeltaZero(this.projectionDelta);\n            var transformTemplate = (_a = this.options.visualElement) === null || _a === void 0 ? void 0 : _a.getProps().transformTemplate;\n            var transformTemplateValue = transformTemplate === null || transformTemplate === void 0 ? void 0 : transformTemplate(this.latestValues, \"\");\n            var transformTemplateHasChanged = transformTemplateValue !== this.prevTransformTemplateValue;\n            if (isResetRequested &&\n                (hasProjection ||\n                    hasTransform(this.latestValues) ||\n                    transformTemplateHasChanged)) {\n                resetTransform(this.instance, transformTemplateValue);\n                this.shouldResetTransform = false;\n                this.scheduleRender();\n            }\n        };\n        ProjectionNode.prototype.measure = function () {\n            var visualElement = this.options.visualElement;\n            if (!visualElement)\n                return createBox();\n            var box = visualElement.measureViewportBox();\n            // Remove viewport scroll to give page-relative coordinates\n            var scroll = this.root.scroll;\n            if (scroll) {\n                translateAxis(box.x, scroll.x);\n                translateAxis(box.y, scroll.y);\n            }\n            return box;\n        };\n        ProjectionNode.prototype.removeElementScroll = function (box) {\n            var boxWithoutScroll = createBox();\n            copyBoxInto(boxWithoutScroll, box);\n            /**\n             * Performance TODO: Keep a cumulative scroll offset down the tree\n             * rather than loop back up the path.\n             */\n            for (var i = 0; i < this.path.length; i++) {\n                var node = this.path[i];\n                var scroll_1 = node.scroll, options = node.options, isScrollRoot = node.isScrollRoot;\n                if (node !== this.root && scroll_1 && options.layoutScroll) {\n                    /**\n                     * If this is a new scroll root, we want to remove all previous scrolls\n                     * from the viewport box.\n                     */\n                    if (isScrollRoot) {\n                        copyBoxInto(boxWithoutScroll, box);\n                        var rootScroll = this.root.scroll;\n                        /**\n                         * Undo the application of page scroll that was originally added\n                         * to the measured bounding box.\n                         */\n                        if (rootScroll) {\n                            translateAxis(boxWithoutScroll.x, -rootScroll.x);\n                            translateAxis(boxWithoutScroll.y, -rootScroll.y);\n                        }\n                    }\n                    translateAxis(boxWithoutScroll.x, scroll_1.x);\n                    translateAxis(boxWithoutScroll.y, scroll_1.y);\n                }\n            }\n            return boxWithoutScroll;\n        };\n        ProjectionNode.prototype.applyTransform = function (box, transformOnly) {\n            if (transformOnly === void 0) { transformOnly = false; }\n            var withTransforms = createBox();\n            copyBoxInto(withTransforms, box);\n            for (var i = 0; i < this.path.length; i++) {\n                var node = this.path[i];\n                if (!transformOnly &&\n                    node.options.layoutScroll &&\n                    node.scroll &&\n                    node !== node.root) {\n                    transformBox(withTransforms, {\n                        x: -node.scroll.x,\n                        y: -node.scroll.y,\n                    });\n                }\n                if (!hasTransform(node.latestValues))\n                    continue;\n                transformBox(withTransforms, node.latestValues);\n            }\n            if (hasTransform(this.latestValues)) {\n                transformBox(withTransforms, this.latestValues);\n            }\n            return withTransforms;\n        };\n        ProjectionNode.prototype.removeTransform = function (box) {\n            var _a;\n            var boxWithoutTransform = createBox();\n            copyBoxInto(boxWithoutTransform, box);\n            for (var i = 0; i < this.path.length; i++) {\n                var node = this.path[i];\n                if (!node.instance)\n                    continue;\n                if (!hasTransform(node.latestValues))\n                    continue;\n                hasScale(node.latestValues) && node.updateSnapshot();\n                var sourceBox = createBox();\n                var nodeBox = node.measure();\n                copyBoxInto(sourceBox, nodeBox);\n                removeBoxTransforms(boxWithoutTransform, node.latestValues, (_a = node.snapshot) === null || _a === void 0 ? void 0 : _a.layout, sourceBox);\n            }\n            if (hasTransform(this.latestValues)) {\n                removeBoxTransforms(boxWithoutTransform, this.latestValues);\n            }\n            return boxWithoutTransform;\n        };\n        /**\n         *\n         */\n        ProjectionNode.prototype.setTargetDelta = function (delta) {\n            this.targetDelta = delta;\n            this.root.scheduleUpdateProjection();\n        };\n        ProjectionNode.prototype.setOptions = function (options) {\n            var _a;\n            this.options = __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            this.notifyListeners(\"animationStart\");\n            (_a = this.currentAnimation) === null || _a === void 0 ? void 0 : _a.stop();\n            if (this.resumingFrom) {\n                (_b = this.resumingFrom.currentAnimation) === null || _b === void 0 ? void 0 : _b.stop();\n            }\n            if (this.pendingAnimation) {\n                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, mixAxis, mixAxisDelta, mixBox };\n","import { createProjectionNode } from './create-projection-node.mjs';\nimport { addDomEvent } from '../../events/use-dom-event.mjs';\n\nvar DocumentProjectionNode = createProjectionNode({\n    attachResizeListener: function (ref, notify) { return addDomEvent(ref, \"resize\", notify); },\n    measureScroll: function () { return ({\n        x: document.documentElement.scrollLeft || document.body.scrollLeft,\n        y: document.documentElement.scrollTop || document.body.scrollTop,\n    }); },\n    checkIsScrollRoot: function () { return true; },\n});\n\nexport { DocumentProjectionNode };\n","import { createProjectionNode } from './create-projection-node.mjs';\nimport { DocumentProjectionNode } from './DocumentProjectionNode.mjs';\n\nvar rootProjectionNode = {\n    current: undefined,\n};\nvar HTMLProjectionNode = createProjectionNode({\n    measureScroll: function (instance) { return ({\n        x: instance.scrollLeft,\n        y: instance.scrollTop,\n    }); },\n    defaultParent: function () {\n        if (!rootProjectionNode.current) {\n            var documentNode = new DocumentProjectionNode(0, {});\n            documentNode.mount(window);\n            documentNode.setOptions({ layoutScroll: true });\n            rootProjectionNode.current = documentNode;\n        }\n        return rootProjectionNode.current;\n    },\n    resetTransform: function (instance, value) {\n        instance.style.transform = value !== null && value !== void 0 ? value : \"none\";\n    },\n    checkIsScrollRoot: function (instance) {\n        return Boolean(window.getComputedStyle(instance).position === \"fixed\");\n    },\n});\n\nexport { HTMLProjectionNode, rootProjectionNode };\n","import { __assign } from 'tslib';\nimport { drag } from '../../motion/features/drag.mjs';\nimport { layoutFeatures } from '../../motion/features/layout/index.mjs';\nimport { domAnimation } from './features-animation.mjs';\nimport { HTMLProjectionNode } from '../../projection/node/HTMLProjectionNode.mjs';\n\n/**\n * @public\n */\nvar domMax = __assign(__assign(__assign(__assign({}, domAnimation), drag), layoutFeatures), { projectionNodeConstructor: HTMLProjectionNode });\n\nexport { domMax };\n"],"names":["token","singleMatcher","RegExp","multiMatcher","decodeComponents","components","split","decodeURIComponent","join","err","length","left","slice","right","Array","prototype","concat","call","decode","input","tokens","match","i","module","exports","encodedURI","TypeError","replace","replaceMap","exec","result","entries","Object","keys","key","customDecodeURIComponent","obj","predicate","ret","isArr","isArray","val","indexOf","strictUriEncode","decodeComponent","splitOnFirst","filterObject","encodeFragmentIdentifier","Symbol","validateArrayFormatSeparator","value","encode","options","strict","encodeURIComponent","keysSorter","sort","a","b","Number","map","removeHash","hashStart","extract","queryStart","parseValue","parseNumbers","isNaN","trim","parseBooleans","toLowerCase","parse","query","assign","arrayFormat","arrayFormatSeparator","formatter","accumulator","undefined","includes","isEncodedArray","newValue","item","test","arrayValue","parserForArrayFormat","create","param","k","reduce","Boolean","stringify","object","shouldFilter","skipNull","skipEmptyString","index","keyValueSep","encoderForArrayFormat","objectCopy","filter","x","parseUrl","url","url_","hash","parseFragmentIdentifier","fragmentIdentifier","stringifyUrl","queryFromUrl","parsedQueryFromUrl","queryString","getHash","pick","exclude","exclusionFilter","string","separator","separatorIndex","str","charCodeAt","toString","toUpperCase","animate","from","to","transition","stop","isAnimating","isPoint","point","hasOwnProperty","isPoint3D","distance1D","Math","abs","distance","xDelta","yDelta","y","zDelta","z","sqrt","pow","PanSession","event","handlers","_a","_this","this","transformPagePoint","startEvent","lastMoveEvent","lastMoveEventInfo","updatePoint","info","getPanInfo","history","isPanStarted","isDistancePastThreshold","offset","timestamp","push","onStart","onMove","handlePointerMove","transformPoint","buttons","handlePointerUp","end","onEnd","onSessionEnd","panInfo","touches","initialInfo","onSessionStart","removeListeners","pipe","window","updateHandlers","subtractPoint","delta","lastDevicePoint","startDevicePoint","velocity","getVelocity","timeDelta","timestampedPoint","lastPoint","time","currentVelocity","Infinity","calcLength","axis","max","min","isNear","target","maxDistance","calcAxisDelta","source","origin","originPoint","mix","scale","translate","calcBoxDelta","originX","originY","calcRelativeAxis","relative","parent","calcRelativeAxisPosition","layout","calcRelativePosition","calcRelativeAxisConstraints","calcViewportAxisConstraints","layoutAxis","constraintsAxis","defaultElastic","resolveAxisElastic","dragElastic","minLabel","maxLabel","resolvePointElastic","label","eachAxis","callback","elementDragControls","WeakMap","VisualElementDragControls","visualElement","openGlobalLock","isDragging","currentDirection","constraints","hasMutatedConstraints","elastic","start","originEvent","_c","snapToCursor","isPresent","panSession","stopAnimation","_b","getProps","drag","dragPropagation","onDragStart","resolveConstraints","projection","isAnimationBlocked","current","getAxisMotionValue","get","measuredAxis","actual","parseFloat","animationState","setActive","dragDirectionLock","onDirectionLock","onDrag","lockThreshold","direction","getCurrentDirection","updateAxis","syncRender","getTransformPagePoint","cancel","startAnimation","onDragEnd","_point","shouldDrag","axisValue","next","set","dragConstraints","prevConstraints","resolveRefConstraints","layoutBox","top","bottom","calcRelativeConstraints","resolveDragElastic","relativeConstraints","rebaseAxisConstraints","onMeasureDragConstraints","constraintsElement","constraintsBox","measure","root","measuredConstraints","calcViewportConstraints","userConstraints","dragMomentum","dragTransition","dragSnapToOrigin","onDragTransitionEnd","momentumAnimations","bounceStiffness","bounceDamping","inertia","type","timeConstant","restDelta","restSpeed","startAxisValueAnimation","Promise","all","then","dragKey","getValue","initial","scalePositionWithinConstraints","boxProgress","sourceLength","targetLength","latest","progress","clamp","transformTemplate","getInstance","style","transform","updateScroll","updateLayout","addListeners","element","stopPointerListener","dragListener","measureDragConstraints","stopMeasureLayoutListener","addEventListener","stopResizeListener","hasLayoutChanged","motionValue","props","_d","_e","_f","pan","onPan","onPanStart","onPanEnd","onPanSessionStart","hasPanEvents","useRef","useContext","MotionConfigContext","useEffect","groupDragControls","dragControls","subscribe","pixelsToPercent","pixels","correctBorderRadius","correct","node","px","varToken","correctBoxShadow","treeScale","projectionDelta","original","containsCSSVariables","cssVariables","shadow","complex","template","xScale","yScale","averageScale","output","i_1","cssVariable","MeasureLayoutWithContext","_super","apply","arguments","componentDidMount","layoutGroup","switchLayoutGroup","layoutId","defaultScaleCorrectors","group","add","register","didUpdate","safeToRemove","setOptions","onExitComplete","getSnapshotBeforeUpdate","prevProps","layoutDependency","willUpdate","promote","relegate","getStack","members","componentDidUpdate","currentAnimation","isLead","componentWillUnmount","promoteContext","scheduleCheckAfterUnmount","remove","deregister","render","borderRadius","applyTo","borderTopLeftRadius","borderTopRightRadius","borderBottomLeftRadius","borderBottomRightRadius","boxShadow","layoutFeatures","measureLayout","LayoutGroupContext","SwitchLayoutGroupContext","borders","numBorders","asNumber","isPx","getRadius","values","radiusName","easeCrossfadeIn","compress","easeCrossfadeOut","easing","p","copyAxisInto","originAxis","copyBoxInto","box","originBox","removePointDelta","boxScale","removeAxisTransforms","transforms","sourceAxis","scaleKey","originKey","removeAxisDelta","xKeys","yKeys","removeBoxTransforms","sourceBox","isAxisDeltaZero","isDeltaZero","boxEquals","NodeStack","scheduleRender","prevLead","lead","indexOfNode","findIndex","member","preserveFollowOpacity","show","instance","resumeFrom","preserveOpacity","snapshot","latestValues","animationValues","isShared","isUpdating","isLayoutDirty","crossfade","hide","exitAnimationComplete","forEach","resumingFrom","removeLeadSnapshot","buildProjectionTransform","latestTransform","xTranslate","yTranslate","rotate","rotateX","rotateY","elementScaleX","elementScaleY","compareByDepth","depth","FlatTree","children","isDirty","child","createProjectionNode","attachResizeListener","defaultParent","measureScroll","checkIsScrollRoot","resetTransform","ProjectionNode","id","Set","isTreeAnimating","updateManuallyBlocked","updateBlockedByResize","isSVG","needsReset","shouldResetTransform","eventHandlers","Map","potentialNodes","checkUpdateFailed","clearAllSnapshots","updateProjection","nodes","resolveTargetDelta","calcProjection","hasProjected","isVisible","animationProgress","sharedNodes","path","registerPotentialNode","name","handler","has","notifyListeners","args","_i","subscriptionManager","notify","hasListeners","mount","SVGElement","tagName","delete","unblockTimeout_1","resizeUnblockUpdate_1","clearTimeout","setTimeout","finishAnimation","registerSharedNode","hasRelativeTargetChanged","newLayout","isTreeAnimationBlocked","relativeTarget","layoutTransition","getDefaultTransition","defaultLayoutTransition","_g","onLayoutAnimationStart","onLayoutAnimationComplete","targetChanged","targetLayout","hasOnlyRelativeTargetChanged","setAnimationOrigin","animationOptions","onPlay","onComplete","shouldReduceMotion","delay","unmount","blockUpdate","unblockUpdate","isUpdateBlocked","startUpdate","resetRotation","shouldNotifyListeners","prevTransformTemplateValue","updateSnapshot","clearMeasurements","size","mountNodeEarly","clear","resetTransformStyle","notifyLayoutUpdate","clearSnapshot","removeLeadSnapshots","scheduleUpdateProjection","measured","removeTransform","removeElementScroll","roundBox","alwaysMeasureLayout","prevLayout","layoutCorrected","notifyLayoutMeasure","layoutScroll","isScrollRoot","scroll","isResetRequested","hasProjection","transformTemplateValue","transformTemplateHasChanged","measureViewportBox","boxWithoutScroll","scroll_1","rootScroll","applyTransform","transformOnly","withTransforms","boxWithoutTransform","setTargetDelta","targetDelta","relativeParent","getClosestProjectingParent","relativeTargetOrigin","targetWithTransforms","attemptToResolveRelativeTarget","pendingAnimation","getLead","projectionDeltaWithTransform","prevTreeScaleX","prevTreeScaleY","prevProjectionTransform","projectionTransform","notifyAll","snapshotLatestValues","mixedValues","relativeLayout","isSharedLayoutAnimation","isOnlyMember","shouldCrossfadeOpacity","some","hasOpacityCrossfade","mixTargetDelta","mixAxisDelta","mixAxis","follow","opacity","opacityExit","borderLabel","followRadius","leadRadius","mixValues","onUpdate","completeAnimation","applyTransformsToTarget","initialPromotionConfig","shouldPreserveFollowOpacity","stack","getPrevLead","hasRotate","resetValues","getStaticValue","setStaticValue","getProjectionStyles","styleProp","styles","visibility","pointerEvents","emptyStyles","valuesToRender","transformOrigin","_h","corrected","num","resetTree","layout_1","measuredLayout","animationType","axisSnapshot","layoutDelta","visualDelta","parentSnapshot","parentLayout","relativeSnapshot","onBeforeLayoutMeasure","notifyBeforeLayoutMeasure","duration","ease","searchNode","document","querySelector","roundAxis","round","DocumentProjectionNode","ref","documentElement","scrollLeft","body","scrollTop","rootProjectionNode","HTMLProjectionNode","documentNode","getComputedStyle","position","domMax","projectionNodeConstructor"],"sourceRoot":""}