{"mappings":";AAIM,SAAUA,GAASC,EAAgB,CACvC,OAAO,OAAOA,GAAY,QAC5B,CAEM,SAAUC,GAASD,EAAgB,CACvC,OAAO,OAAOA,GAAY,QAC5B,CAEM,SAAUE,GAAUF,EAAgB,CACxC,OAAO,OAAOA,GAAY,SAC5B,CAEM,SAAUG,GAASH,EAAgB,CACvC,OAAOI,OAAOC,UAAUC,SAASC,KAAKP,CAAO,IAAM,iBACrD,CAEM,SAAUQ,EAAQC,EAAS,CAC/B,OAAOC,KAAKC,IAAIF,CAAC,CACnB,CAEM,SAAUG,GAASH,EAAS,CAChC,OAAOC,KAAKG,KAAKJ,CAAC,CACpB,CAEgB,SAAAK,GAASC,EAAgBC,EAAc,CACrD,OAAOR,EAAQO,EAASC,CAAM,CAChC,CAEgB,SAAAC,GAAUF,EAAgBC,EAAc,CAEtD,GADID,IAAW,GAAKC,IAAW,GAC3BR,EAAQO,CAAM,GAAKP,EAAQQ,CAAM,EAAG,MAAO,GAC/C,IAAME,EAAOJ,GAASN,EAAQO,CAAM,EAAGP,EAAQQ,CAAM,CAAC,EACtD,OAAOR,EAAQU,EAAOH,CAAM,CAC9B,CAEM,SAAUI,GAAmBC,EAAW,CAC5C,OAAOV,KAAKW,MAAMD,EAAM,GAAG,EAAI,GACjC,CAEM,SAAUE,GAAgBC,EAAa,CAC3C,OAAOC,GAAWD,CAAK,EAAEE,IAAIC,MAAM,CACrC,CAEM,SAAUC,EAAgBJ,EAAa,CAC3C,OAAOA,EAAMK,GAAeL,CAAK,CAAC,CACpC,CAEM,SAAUK,GAAqBL,EAAa,CAChD,OAAOb,KAAKmB,IAAI,EAAGN,EAAMO,OAAS,CAAC,CACrC,CAEgB,SAAAC,GAAuBR,EAAeS,EAAa,CACjE,OAAOA,IAAUJ,GAAeL,CAAK,CACvC,UAEgBU,GAAgBxB,EAAWyB,EAAkB,EAAC,CAC5D,OAAOC,MAAMC,KAAKD,MAAM1B,CAAC,EAAG,CAAC4B,EAAGC,IAAMJ,EAAUI,CAAC,CACnD,CAEM,SAAUd,GAAgCe,EAAY,CAC1D,OAAOnC,OAAOoC,KAAKD,CAAM,CAC3B,CAEgB,SAAAE,GACdC,EACAC,EAAgC,CAEhC,MAAO,CAACD,EAASC,CAAO,EAAEC,OAAO,CAACC,EAAeC,KAC/CtB,GAAWsB,CAAa,EAAEC,QAASC,GAAO,CACxC,IAAMhC,EAAS6B,EAAcG,CAAG,EAC1BjC,EAAS+B,EAAcE,CAAG,EAC1BC,EAAa9C,GAASa,CAAM,GAAKb,GAASY,CAAM,EAEtD8B,EAAcG,CAAG,EAAIC,EACjBR,GAAiBzB,EAAQD,CAAM,EAC/BA,CACN,CAAC,EACM8B,GACN,CAAA,CAAE,CACP,CAEgB,SAAAK,GACdC,EACAC,EAAuB,CAEvB,OACE,OAAOA,EAAYC,WAAe,KAClCF,aAAeC,EAAYC,UAE/B,CCjFgB,SAAAC,GACdC,EACAC,EAAgB,CAEhB,IAAMC,EAAa,CAAEC,MAAAA,EAAOC,OAAAA,EAAQC,IAAAA,GAEpC,SAASF,GAAK,CACZ,MAAO,EACT,CAEA,SAASC,EAAOlD,EAAS,CACvB,OAAOmD,EAAInD,CAAC,EAAI,CAClB,CAEA,SAASmD,EAAInD,EAAS,CACpB,OAAO+C,EAAW/C,CACpB,CAEA,SAASoD,EAAQpD,EAAWuB,EAAa,CACvC,OAAI/B,GAASsD,CAAK,EAAUE,EAAWF,CAAK,EAAE9C,CAAC,EACxC8C,EAAMC,EAAU/C,EAAGuB,CAAK,CACjC,CAKA,MAH4B,CAC1B6B,QAAAA,EAGJ,UCxBgBC,IAAU,CACxB,IAAIC,EAAgC,CAAA,EAEpC,SAASC,EACPC,EACAC,EACAC,EACAC,EAA4B,CAAEC,QAAS,EAAM,EAAA,CAE7C,IAAIC,EAEJ,GAAI,qBAAsBL,EACxBA,EAAKM,iBAAiBL,EAAMC,EAASC,CAAO,EAC5CE,EAAiBA,IAAML,EAAKO,oBAAoBN,EAAMC,EAASC,CAAO,MACjE,CACL,IAAMK,EAAuCR,EAC7CQ,EAAqBC,YAAYP,CAAO,EACxCG,EAAiBA,IAAMG,EAAqBH,eAAeH,CAAO,CACpE,CAEAJ,OAAAA,EAAUY,KAAKL,CAAc,EACtBM,CACT,CAEA,SAASC,GAAK,CACZd,EAAYA,EAAUe,OAAQC,GAAWA,EAAM,CAAE,CACnD,CAEA,IAAMH,EAAuB,CAC3BZ,IAAAA,EACAa,MAAAA,GAEF,OAAOD,CACT,CChCM,SAAUI,GACdC,EACA7B,EACA8B,EACAC,EAA+B,CAE/B,IAAMC,EAAyBtB,GAAU,EACnCuB,EAAgB,IAAO,GAEzBC,EAA+B,KAC/BC,EAAkB,EAClBC,EAAc,EAElB,SAASC,GAAI,CACXL,EAAuBpB,IAAIiB,EAAe,mBAAoB,IAAK,CAC7DA,EAAcS,QAAQC,EAAK,CACjC,CAAC,CACH,CAEA,SAASC,GAAO,CACdC,EAAI,EACJT,EAAuBP,MAAK,CAC9B,CAEA,SAASiB,EAAQC,EAA8B,CAC7C,GAAI,CAACP,EAAa,OACbF,IACHA,EAAgBS,EAChBb,EAAM,EACNA,EAAM,GAGR,IAAMc,EAAcD,EAAYT,EAIhC,IAHAA,EAAgBS,EAChBR,GAAmBS,EAEZT,GAAmBF,GACxBH,EAAM,EACNK,GAAmBF,EAGrB,IAAMY,EAAQV,EAAkBF,EAChCF,EAAOc,CAAK,EAERT,IACFA,EAAcpC,EAAY8C,sBAAsBJ,CAAO,EAE3D,CAEA,SAASpC,GAAK,CACR8B,IACJA,EAAcpC,EAAY8C,sBAAsBJ,CAAO,EACzD,CAEA,SAASD,GAAI,CACXzC,EAAY+C,qBAAqBX,CAAW,EAC5CF,EAAgB,KAChBC,EAAkB,EAClBC,EAAc,CAChB,CAEA,SAASG,GAAK,CACZL,EAAgB,KAChBC,EAAkB,CACpB,CAUA,MAR6B,CAC3BE,KAAAA,EACAG,QAAAA,EACAlC,MAAAA,EACAmC,KAAAA,EACAX,OAAAA,EACAC,OAAAA,EAGJ,CC5EgB,SAAAiB,GACdC,EACAC,EAAyC,CAEzC,IAAMC,EAAgBD,IAAqB,MACrCE,EAAaH,IAAS,IACtBI,EAASD,EAAa,IAAM,IAC5BE,EAAQF,EAAa,IAAM,IAC3B3F,EAAO,CAAC2F,GAAcD,EAAgB,GAAK,EAC3CI,EAAYC,EAAY,EACxBC,EAAUC,EAAU,EAE1B,SAASC,EAAYC,EAAsB,CACzC,GAAM,CAAEC,OAAAA,EAAQC,MAAAA,CAAO,EAAGF,EAC1B,OAAOR,EAAaS,EAASC,CAC/B,CAEA,SAASN,GAAY,CACnB,OAAIJ,EAAmB,MAChBD,EAAgB,QAAU,MACnC,CAEA,SAASO,GAAU,CACjB,OAAIN,EAAmB,SAChBD,EAAgB,OAAS,OAClC,CAEA,SAASY,EAAU1G,EAAS,CAC1B,OAAOA,EAAII,CACb,CAUA,MARuB,CACrB4F,OAAAA,EACAC,MAAAA,EACAC,UAAAA,EACAE,QAAAA,EACAE,YAAAA,EACAI,UAAAA,EAGJ,UC1CgBC,GAAMC,EAAc,EAAGxF,EAAc,EAAC,CACpD,IAAMC,EAAStB,EAAQ6G,EAAMxF,CAAG,EAEhC,SAASyF,EAAW7G,EAAS,CAC3B,OAAOA,EAAI4G,CACb,CAEA,SAASE,EAAW9G,EAAS,CAC3B,OAAOA,EAAIoB,CACb,CAEA,SAAS2F,EAAW/G,EAAS,CAC3B,OAAO6G,EAAW7G,CAAC,GAAK8G,EAAW9G,CAAC,CACtC,CAEA,SAASgH,EAAUhH,EAAS,CAC1B,OAAK+G,EAAW/G,CAAC,EACV6G,EAAW7G,CAAC,EAAI4G,EAAMxF,EADFpB,CAE7B,CAEA,SAASiH,EAAajH,EAAS,CAC7B,OAAKqB,EACErB,EAAIqB,EAASpB,KAAKiH,MAAMlH,EAAIoB,GAAOC,CAAM,EAD5BrB,CAEtB,CAYA,MAVwB,CACtBqB,OAAAA,EACAD,IAAAA,EACAwF,IAAAA,EACAI,UAAAA,EACAD,WAAAA,EACAD,WAAAA,EACAD,WAAAA,EACAI,aAAAA,EAGJ,UCvCgBE,GACd/F,EACA6B,EACAmE,EAAa,CAEb,GAAM,CAAEJ,UAAAA,CAAS,EAAKL,GAAM,EAAGvF,CAAG,EAC5BiG,EAAUjG,EAAM,EAClBkG,EAAUC,EAAYtE,CAAK,EAE/B,SAASsE,EAAYvH,EAAS,CAC5B,OAAQoH,EAAsBrH,GAASsH,EAAUrH,GAAKqH,CAAO,EAA9CL,EAAUhH,CAAC,CAC5B,CAEA,SAASwH,GAAG,CACV,OAAOF,CACT,CAEA,SAASG,EAAIzH,EAAS,CACpBsH,OAAAA,EAAUC,EAAYvH,CAAC,EAChBmE,CACT,CAEA,SAASZ,EAAIvD,EAAS,CACpB,OAAO0H,EAAK,EAAGD,IAAID,EAAG,EAAKxH,CAAC,CAC9B,CAEA,SAAS0H,GAAK,CACZ,OAAOP,GAAQ/F,EAAKoG,EAAG,EAAIJ,CAAI,CACjC,CAEA,IAAMjD,EAAoB,CACxBqD,IAAAA,EACAC,IAAAA,EACAlE,IAAAA,EACAmE,MAAAA,GAEF,OAAOvD,CACT,UCXgBwD,GACd/B,EACAgC,EACApD,EACA7B,EACAkF,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EACA5G,EACA6G,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EAAgC,CAEhC,GAAM,CAAEzC,MAAO0C,EAAWjC,UAAAA,CAAS,EAAKd,EAClCgD,EAAa,CAAC,QAAS,SAAU,UAAU,EAC3CC,EAAkB,CAAEjF,QAAS,IAC7BkF,EAAazF,GAAU,EACvB0F,EAAa1F,GAAU,EACvB2F,EAAoBrC,GAAM,GAAI,GAAG,EAAEK,UAAUqB,EAAcjF,QAAQ,EAAE,CAAC,EACtE6F,EAAiB,CAAEC,MAAO,IAAKC,MAAO,KACtCC,EAAiB,CAAEF,MAAO,IAAKC,MAAO,KACtCE,EAAYf,EAAW,GAAK,GAE9BgB,EAAW,GACXC,EAAc,EACdC,EAAa,EACbC,EAAgB,GAChBC,EAAgB,GAChBC,EAAe,GACfC,EAAU,GAEd,SAAS5E,GAAK6E,EAA2B,CACvC,GAAI,CAACnB,EAAW,OAEhB,SAASoB,EAAcpH,EAAqB,EACtCjD,GAAUiJ,CAAS,GAAKA,EAAUmB,EAAUnH,CAAG,IAAGqH,GAAKrH,CAAG,CAChE,CAEA,IAAMc,EAAOoE,EACbkB,EACGvF,IAAIC,EAAM,YAAcd,GAAQA,EAAIsH,eAAc,EAAInB,CAAe,EACrEtF,IAAIC,EAAM,YAAa,IAAA,GAAiBqF,CAAe,EACvDtF,IAAIC,EAAM,WAAY,IAAA,EAAe,EACrCD,IAAIC,EAAM,aAAcsG,CAAa,EACrCvG,IAAIC,EAAM,YAAasG,CAAa,EACpCvG,IAAIC,EAAM,cAAeyG,CAAE,EAC3B1G,IAAIC,EAAM,cAAeyG,CAAE,EAC3B1G,IAAIC,EAAM,QAAS0G,EAAO,EAAI,CACnC,CAEA,SAAS/E,GAAO,CACd2D,EAAW1E,MAAK,EAChB2E,EAAW3E,MAAK,CAClB,CAEA,SAAS+F,IAAa,CACpB,IAAM3G,EAAOoG,EAAUpF,EAAgBoD,EACvCmB,EACGxF,IAAIC,EAAM,YAAa4G,EAAMvB,CAAe,EAC5CtF,IAAIC,EAAM,WAAYyG,CAAE,EACxB1G,IAAIC,EAAM,YAAa4G,EAAMvB,CAAe,EAC5CtF,IAAIC,EAAM,UAAWyG,CAAE,CAC5B,CAEA,SAASI,GAAY7G,EAAa,CAChC,IAAM8G,EAAW9G,EAAK8G,UAAY,GAClC,OAAO1B,EAAW2B,SAASD,CAAQ,CACrC,CAEA,SAASE,GAAU,CAGjB,OAFclC,EAAWc,EAAiBH,GAC7BW,EAAU,QAAU,OAChB,CACnB,CAEA,SAASa,GAAaC,EAAeC,EAAsB,CACzD,IAAMC,EAAOrJ,EAAMgC,IAAIpD,GAASuK,CAAK,EAAI,EAAE,EACrCG,EAAY1C,EAAa2C,WAAWJ,EAAO,CAACpC,CAAQ,EAAEyC,SAE5D,OAAIzC,GAAYvI,EAAQ2K,CAAK,EAAI1B,EAA0B6B,EACvDrC,GAAamC,EAAsBE,EAAY,GAE5C1C,EAAa6C,QAAQJ,EAAKpD,IAAG,EAAI,CAAC,EAAEuD,QAC7C,CAEA,SAAShB,GAAKrH,EAAqB,CACjC,IAAMuI,EAAaxI,GAAaC,EAAKC,CAAW,EAChDiH,EAAUqB,EACVtB,EAAerB,GAAY2C,GAAc,CAACvI,EAAIwI,SAAW5B,EACzDA,EAAWjJ,GAASwH,EAAOL,IAAG,EAAIO,EAASP,IAAG,CAAE,GAAK,EAEjDyD,EAAAA,GAAcvI,EAAIyI,SAAW,KAC7Bd,GAAY3H,EAAImF,MAAiB,IAErC4B,EAAgB,GAChB3B,EAAYsD,YAAY1I,CAAG,EAC3BwF,EAAWmD,YAAY,CAAC,EAAEC,YAAY,CAAC,EACvCzD,EAAOJ,IAAIM,CAAQ,EACnBoC,GAAa,EACbZ,EAAczB,EAAYyD,UAAU7I,CAAG,EACvC8G,EAAa1B,EAAYyD,UAAU7I,EAAKiG,CAAS,EACjDP,EAAaoD,KAAK,aAAa,GACjC,CAEA,SAASpB,EAAK1H,EAAqB,CAEjC,GADmB,CAACD,GAAaC,EAAKC,CAAW,GAC/BD,EAAI+I,QAAQpK,QAAU,EAAG,OAAO4I,EAAGvH,CAAG,EAExD,IAAMgJ,EAAa5D,EAAYyD,UAAU7I,CAAG,EACtCiJ,EAAY7D,EAAYyD,UAAU7I,EAAKiG,CAAS,EAChDiD,EAAavL,GAASqL,EAAYnC,CAAW,EAC7CsC,EAAYxL,GAASsL,EAAWnC,CAAU,EAEhD,GAAI,CAACE,GAAiB,CAACE,IACjB,CAAClH,EAAIoJ,aACTpC,EAAgBkC,EAAaC,EACzB,CAACnC,IAAe,OAAOO,EAAGvH,CAAG,EAEnC,IAAMjC,EAAOqH,EAAYiE,YAAYrJ,CAAG,EACpCkJ,EAAarD,IAAeoB,EAAe,IAE/CzB,EAAWmD,YAAY,EAAG,EAAEC,YAAY,GAAI,EAC5CtD,EAAU/E,MAAK,EACf4E,EAAOtE,IAAImD,EAAUjG,CAAI,CAAC,EAC1BiC,EAAIsH,eAAc,CACpB,CAEA,SAASC,EAAGvH,EAAqB,CAE/B,IAAMiI,EADkBxC,EAAa2C,WAAW,EAAG,EAAK,EAClBvJ,QAAUA,EAAMiG,IAAG,EACnDwE,EAAWlE,EAAYmE,UAAUvJ,CAAG,EAAI8H,EAAU,EAClDE,EAAQD,GAAa/D,EAAUsF,CAAQ,EAAGrB,CAAa,EACvDuB,EAAc1L,GAAUwL,EAAUtB,CAAK,EACvCyB,EAAQ9C,EAAY,GAAK6C,EACzBE,EAAW3D,EAAeyD,EAAc,GAE9CxC,EAAgB,GAChBD,EAAgB,GAChBV,EAAW3E,MAAK,EAChB8D,EAAWoD,YAAYa,CAAK,EAAEd,YAAYe,CAAQ,EAClDnE,EAAS8C,SAASL,EAAO,CAACpC,CAAQ,EAClCsB,EAAU,GACVxB,EAAaoD,KAAK,WAAW,CAC/B,CAEA,SAAStB,EAAMxH,EAAe,CACxBiH,IACFjH,EAAI2J,gBAAe,EACnB3J,EAAIsH,eAAc,EAClBL,EAAe,GAEnB,CAEA,SAASyB,GAAW,CAClB,OAAO3B,CACT,CAOA,MAL8B,CAC5BzE,KAAAA,GACAG,QAAAA,EACAiG,YAAAA,EAGJ,CClMgB,SAAAkB,GACd1G,EACAjD,EAAuB,CAIvB,IAAI4J,EACAC,EAEJ,SAASC,EAAS/J,EAAqB,CACrC,OAAOA,EAAI4C,SACb,CAEA,SAASiG,EAAU7I,EAAuBgK,EAAwB,CAEhE,IAAMC,EAA0B,UADfD,GAAW9G,EAAKI,UACqB,IAAM,IAAM,GAAG,GACrE,OAAQvD,GAAaC,EAAKC,CAAW,EAAID,EAAMA,EAAI+I,QAAQ,CAAC,GAAGkB,CAAK,CACtE,CAEA,SAASvB,EAAY1I,EAAqB,CACxC6J,OAAAA,EAAa7J,EACb8J,EAAY9J,EACL6I,EAAU7I,CAAG,CACtB,CAEA,SAASqJ,EAAYrJ,EAAqB,CACxC,IAAMjC,EAAO8K,EAAU7I,CAAG,EAAI6I,EAAUiB,CAAS,EAC3CI,EAAUH,EAAS/J,CAAG,EAAI+J,EAASF,CAAU,EAAIM,IAEvDL,OAAAA,EAAY9J,EACRkK,IAASL,EAAa7J,GACnBjC,CACT,CAEA,SAASwL,EAAUvJ,EAAqB,CACtC,GAAI,CAAC6J,GAAc,CAACC,EAAW,MAAO,GACtC,IAAMM,EAAWvB,EAAUiB,CAAS,EAAIjB,EAAUgB,CAAU,EACtDQ,EAAWN,EAAS/J,CAAG,EAAI+J,EAASF,CAAU,EAC9CK,EAAUH,EAAS/J,CAAG,EAAI+J,EAASD,CAAS,EAAIK,IAChDnC,EAAQoC,EAAWC,EAGzB,OAFgBA,GAAY,CAACH,GAAW7M,EAAQ2K,CAAK,EAAI,GAExCA,EAAQ,CAC3B,CAQA,MAN8B,CAC5BU,YAAAA,EACAW,YAAAA,EACAE,UAAAA,EACAV,UAAAA,EAGJ,UCpDgByB,IAAS,CACvB,SAAS5J,EAAQI,EAAiB,CAChC,GAAM,CAAEyJ,UAAAA,EAAWC,WAAAA,EAAYC,YAAAA,EAAaC,aAAAA,CAAY,EAAK5J,EAU7D,MAT6B,CAC3B6J,IAAKJ,EACLK,MAAOJ,EAAaC,EACpBI,OAAQN,EAAYG,EACpBI,KAAMN,EACNzG,MAAO0G,EACP3G,OAAQ4G,EAIZ,CAKA,MAH4B,CAC1BhK,QAAAA,EAGJ,CC5BM,SAAUqK,GAAc1K,EAAgB,CAC5C,SAASK,EAAQpD,EAAS,CACxB,OAAO+C,GAAY/C,EAAI,IACzB,CAKA,MAHgC,CAC9BoD,QAAAA,EAGJ,CCKgB,SAAAsK,GACdC,EACAvF,EACAzF,EACAiL,EACAhI,EACAiI,EACAC,EAAwB,CAExB,IAAMC,EAAe,CAACJ,CAAS,EAAEK,OAAOJ,CAAM,EAC1CK,EACAC,EACAC,EAAuB,CAAA,EACvBC,EAAY,GAEhB,SAASC,EAAS7K,EAAiB,CACjC,OAAOoC,EAAKU,YAAYwH,EAAU1K,QAAQI,CAAI,CAAC,CACjD,CAEA,SAASwB,EAAK6E,EAA2B,CACvC,GAAI,CAACgE,EAAa,OAElBK,EAAgBG,EAASV,CAAS,EAClCQ,EAAaP,EAAO5M,IAAIqN,CAAQ,EAEhC,SAASC,EAAgBC,EAA8B,CACrD,QAAWC,KAASD,EAAS,CAC3B,GAAIH,EAAW,OAEf,IAAMK,EAAcD,EAAM3G,SAAW8F,EAC/Be,EAAad,EAAOe,QAAqBH,EAAM3G,MAAM,EACrD+G,EAAWH,EAAcP,EAAgBC,EAAWO,CAAU,EAC9DG,EAAUR,EAASI,EAAcd,EAAYC,EAAOc,CAAU,CAAC,EAGrE,GAFiB3O,EAAQ8O,EAAUD,CAAQ,GAE3B,GAAK,CACnB/E,EAASiF,OAAM,EACf1G,EAAaoD,KAAK,QAAQ,EAE1B,KACF,CACF,CACF,CAEAyC,EAAiB,IAAIc,eAAgBR,GAAW,EAC1C9O,GAAUoO,CAAW,GAAKA,EAAYhE,EAAU0E,CAAO,IACzDD,EAAgBC,CAAO,CAE3B,CAAC,EAED5L,EAAY8C,sBAAsB,IAAK,CACrCsI,EAAazL,QAASkB,GAASyK,EAAee,QAAQxL,CAAI,CAAC,CAC7D,CAAC,CACH,CAEA,SAAS2B,GAAO,CACdiJ,EAAY,GACRH,GAAgBA,EAAegB,WAAU,CAC/C,CAMA,MAJgC,CAC9BjK,KAAAA,EACAG,QAAAA,EAGJ,CCpEgB,SAAA+J,GACdnH,EACAoH,EACAC,EACAvH,EACAwH,EACA5G,EAAoB,CAEpB,IAAI6G,EAAiB,EACjBC,EAAkB,EAClBC,EAAiBH,EACjBI,EAAiBhH,EACjBiH,EAAc3H,EAASP,IAAG,EAC1BmI,EAAsB,EAE1B,SAASC,GAAI,CACX,IAAMC,EAAehI,EAAOL,IAAG,EAAKO,EAASP,IAAG,EAC1CsI,EAAY,CAACN,EACfO,EAAiB,EAErB,OAAID,GACFR,EAAiB,EACjBF,EAAiB3H,IAAII,CAAM,EAC3BE,EAASN,IAAII,CAAM,EAEnBkI,EAAiBF,IAEjBT,EAAiB3H,IAAIM,CAAQ,EAE7BuH,GAAkBO,EAAeL,EACjCF,GAAkBG,EAClBC,GAAeJ,EACfvH,EAASxE,IAAI+L,CAAc,EAE3BS,EAAiBL,EAAcC,GAGjCJ,EAAkBpP,GAAS4P,CAAc,EACzCJ,EAAsBD,EACfvL,CACT,CAEA,SAAS6L,GAAO,CACd,IAAMvP,EAAOoH,EAAOL,IAAG,EAAK2H,EAAe3H,IAAG,EAC9C,OAAOzH,EAAQU,CAAI,EAAI,IACzB,CAEA,SAASwP,GAAQ,CACf,OAAOT,CACT,CAEA,SAAS9I,GAAS,CAChB,OAAO6I,CACT,CAEA,SAASW,GAAQ,CACf,OAAOZ,CACT,CAEA,SAASa,GAAe,CACtB,OAAO7E,EAAY+D,CAAY,CACjC,CAEA,SAASe,GAAe,CACtB,OAAO/E,EAAY5C,CAAY,CACjC,CAEA,SAAS6C,EAAYtL,EAAS,CAC5BwP,OAAAA,EAAiBxP,EACVmE,CACT,CAEA,SAASkH,EAAYrL,EAAS,CAC5ByP,OAAAA,EAAiBzP,EACVmE,CACT,CAEA,IAAMA,EAAuB,CAC3BuC,UAAAA,EACAuJ,SAAAA,EACAC,SAAAA,EACAN,KAAAA,EACAI,QAAAA,EACAI,gBAAAA,EACAD,gBAAAA,EACA9E,YAAAA,EACAC,YAAAA,GAEF,OAAOnH,CACT,CC5FM,SAAUkM,GACdC,EACAvI,EACAF,EACAK,EACAG,EAAgC,CAEhC,IAAMkI,EAAoBlI,EAAcjF,QAAQ,EAAE,EAC5CoN,EAAsBnI,EAAcjF,QAAQ,EAAE,EAC9CqN,EAAgB9J,GAAM,GAAK,GAAI,EACjC+J,EAAW,GAEf,SAASC,GAAe,CAGtB,MAFID,EAAAA,GACA,CAACJ,EAAMvJ,WAAWc,EAAOL,IAAG,CAAE,GAC9B,CAAC8I,EAAMvJ,WAAWgB,EAASP,IAAG,CAAE,EAEtC,CAEA,SAASR,EAAUoE,EAAoB,CACrC,GAAI,CAACuF,EAAe,EAAI,OACxB,IAAMC,EAAON,EAAMzJ,WAAWkB,EAASP,IAAG,CAAE,EAAI,MAAQ,MAClDqJ,EAAa9Q,EAAQuQ,EAAMM,CAAI,EAAI7I,EAASP,IAAG,CAAE,EACjDsJ,EAAejJ,EAAOL,IAAG,EAAKO,EAASP,IAAG,EAC1C4E,EAAWqE,EAAczJ,UAAU6J,EAAaL,CAAmB,EAEzE3I,EAAOkJ,SAASD,EAAe1E,CAAQ,EAEnC,CAAChB,GAAerL,EAAQ+Q,CAAY,EAAIP,IAC1C1I,EAAOJ,IAAI6I,EAAMtJ,UAAUa,EAAOL,IAAG,CAAE,CAAC,EACxCU,EAAWoD,YAAY,EAAE,EAAE8E,gBAAe,EAE9C,CAEA,SAASY,EAAaC,EAAe,CACnCP,EAAW,CAACO,CACd,CAOA,MAL+B,CAC7BN,gBAAAA,EACA3J,UAAAA,EACAgK,aAAAA,EAGJ,CC9CM,SAAUE,GACdnO,EACAoO,EACAC,EACAC,EACAC,EAAsB,CAEtB,IAAMC,EAAe5K,GAAM,CAACwK,EAAcpO,EAAU,CAAC,EAC/CyO,EAAeC,EAAc,EAC7BC,EAAqBC,EAAsB,EAC3CC,EAAiBC,EAAgB,EAEvC,SAASC,EAAkBC,EAAeC,EAAY,CACpD,OAAO3R,GAAS0R,EAAOC,CAAI,GAAK,CAClC,CAEA,SAASL,GAAsB,CAC7B,IAAMM,EAAYT,EAAa,CAAC,EAC1BU,EAAUhR,EAAUsQ,CAAY,EAChC5K,EAAM4K,EAAaW,YAAYF,CAAS,EACxC7Q,EAAMoQ,EAAa7C,QAAQuD,CAAO,EAAI,EAC5C,OAAOvL,GAAMC,EAAKxF,CAAG,CACvB,CAEA,SAASqQ,GAAc,CACrB,OAAOL,EACJpQ,IAAI,CAACoR,EAAa7Q,IAAS,CAC1B,GAAM,CAAEqF,IAAAA,EAAKxF,IAAAA,CAAK,EAAGmQ,EACfS,EAAOT,EAAavK,UAAUoL,CAAW,EACzCC,EAAU,CAAC9Q,EACX+Q,EAAShR,GAAiB8P,EAAc7P,CAAK,EACnD,OAAI8Q,EAAgBjR,EAChBkR,GACAR,EAAkBlL,EAAKoL,CAAI,EAAUpL,EACrCkL,EAAkB1Q,EAAK4Q,CAAI,EAAU5Q,EAClC4Q,CACT,CAAC,EACAhR,IAAKuR,GAAgBC,WAAWD,EAAYE,QAAQ,CAAC,CAAC,CAAC,CAC5D,CAEA,SAASZ,GAAgB,CACvB,GAAIV,GAAepO,EAAWuO,EAAgB,MAAO,CAACC,EAAanQ,GAAG,EACtE,GAAIiQ,IAAkB,YAAa,OAAOG,EAC1C,GAAM,CAAE5K,IAAAA,EAAKxF,IAAAA,CAAK,EAAGsQ,EACrB,OAAOF,EAAakB,MAAM9L,EAAKxF,CAAG,CACpC,CAMA,MAJgC,CAC9BwQ,eAAAA,EACAF,mBAAAA,EAGJ,UCvDgBiB,GACdxB,EACAyB,EACAxL,EAAa,CAEb,IAAMhG,EAAMwR,EAAY,CAAC,EACnBhM,EAAMQ,EAAOhG,EAAM+P,EAAcjQ,EAAU0R,CAAW,EAM5D,MAH8B,CAC5BtC,MAHY3J,GAAMC,EAAKxF,CAAG,EAM9B,CCbM,SAAUyR,GACd1B,EACAb,EACAvI,EACA+K,EAAuB,CAGvB,IAAMlM,EAAM0J,EAAM1J,IAAMmM,GAClB3R,EAAMkP,EAAMlP,IAAM2R,GAClB,CAAElM,WAAAA,EAAYC,WAAAA,CAAY,EAAGH,GAAMC,EAAKxF,CAAG,EAEjD,SAAS4R,EAAWtM,EAAiB,CACnC,OAAIA,IAAc,EAAUI,EAAWiB,EAASP,IAAG,CAAE,EACjDd,IAAc,GAAWG,EAAWkB,EAASP,IAAG,CAAE,EAC/C,EACT,CAEA,SAASJ,EAAKV,EAAiB,CAC7B,GAAI,CAACsM,EAAWtM,CAAS,EAAG,OAE5B,IAAMuM,EAAe9B,GAAezK,EAAY,IAChDoM,EAAQxQ,QAAS4Q,GAAMA,EAAE3P,IAAI0P,CAAY,CAAC,CAC5C,CAKA,MAH+B,CAC7B7L,KAAAA,EAGJ,CC7BM,SAAU+L,GAAe7C,EAAgB,CAC7C,GAAM,CAAElP,IAAAA,EAAKC,OAAAA,CAAQ,EAAGiP,EAExB,SAAS9I,EAAIxH,EAAS,CACpB,IAAMoT,EAAkBpT,EAAIoB,EAC5B,OAAOC,EAAS+R,EAAkB,CAAC/R,EAAS,CAC9C,CAKA,MAHiC,CAC/BmG,IAAAA,EAGJ,CCPM,SAAU6L,GACdzN,EACA0N,EACAC,EACAC,EACAC,EAAkC,CAElC,GAAM,CAAEvN,UAAAA,EAAWE,QAAAA,CAAS,EAAGR,EACzB,CAAE8N,YAAAA,CAAa,EAAGD,EAClBE,EAAaC,EAAY,EAAG5S,IAAIsS,EAAUlQ,OAAO,EACjDyQ,EAAQC,EAAgB,EACxB1C,EAAe2C,EAAc,EAEnC,SAASH,GAAY,CACnB,OAAOF,EAAYF,CAAU,EAC1BxS,IAAKgT,GAAU9S,EAAU8S,CAAK,EAAE5N,CAAO,EAAI4N,EAAM,CAAC,EAAE9N,CAAS,CAAC,EAC9DlF,IAAIjB,CAAO,CAChB,CAEA,SAAS+T,GAAgB,CACvB,OAAON,EACJxS,IAAKiT,GAASV,EAAcrN,CAAS,EAAI+N,EAAK/N,CAAS,CAAC,EACxDlF,IAAKgR,GAAS,CAACjS,EAAQiS,CAAI,CAAC,CACjC,CAEA,SAAS+B,GAAc,CACrB,OAAOL,EAAYG,CAAK,EACrB7S,IAAKkT,GAAMA,EAAE,CAAC,CAAC,EACflT,IAAI,CAACgR,EAAMzQ,IAAUyQ,EAAO2B,EAAWpS,CAAK,CAAC,CAClD,CAMA,MAJ8B,CAC5BsS,MAAAA,EACAzC,aAAAA,EAGJ,CCjCgB,SAAA+C,GACdC,EACA/C,EACAuB,EACAlB,EACA+B,EACAY,EAAsB,CAEtB,GAAM,CAAEX,YAAAA,CAAa,EAAGD,EAClB,CAAE7M,IAAAA,EAAKxF,IAAAA,CAAK,EAAGsQ,EACf4C,EAAgBC,EAAmB,EAEzC,SAASA,GAAmB,CAC1B,IAAMC,EAAsBd,EAAYW,CAAY,EAC9CI,EAAe,CAACL,GAAgB/C,IAAkB,YAExD,OAAIuB,EAAYvR,SAAW,EAAU,CAACgT,CAAY,EAC9CI,EAAqBD,EAElBA,EAAoB9B,MAAM9L,EAAKxF,CAAG,EAAEJ,IAAI,CAAC0T,EAAOnT,EAAOoT,IAAU,CACtE,IAAMtC,EAAU,CAAC9Q,EACX+Q,EAAShR,GAAiBqT,EAAQpT,CAAK,EAE7C,GAAI8Q,EAAS,CACX,IAAMuC,EAAQ1T,EAAUyT,EAAO,CAAC,CAAC,EAAI,EACrC,OAAOnT,GAAgBoT,CAAK,CAC9B,CACA,GAAItC,EAAQ,CACV,IAAMsC,EAAQzT,GAAekT,CAAY,EAAInT,EAAUyT,CAAM,EAAE,CAAC,EAAI,EACpE,OAAOnT,GAAgBoT,EAAO1T,EAAUyT,CAAM,EAAE,CAAC,CAAC,CACpD,CACA,OAAOD,CACT,CAAC,CACH,CAKA,MAHgC,CAC9BJ,cAAAA,EAGJ,CCtCM,SAAUO,GACdzN,EACAwL,EACAzB,EACAb,EACAwE,EAA0B,CAE1B,GAAM,CAAE/N,WAAAA,EAAYE,aAAAA,EAAcD,UAAAA,CAAS,EAAKsJ,EAEhD,SAASyE,EAAYC,EAAmB,CACtC,OAAOA,EAAUhH,OAAM,EAAGiH,KAAK,CAACC,EAAGC,IAAMpV,EAAQmV,CAAC,EAAInV,EAAQoV,CAAC,CAAC,EAAE,CAAC,CACrE,CAEA,SAASC,EAAevN,EAAc,CACpC,IAAMkD,EAAW3D,EAAOH,EAAaY,CAAM,EAAIb,EAAUa,CAAM,EACzDwN,EAAkBzC,EACrB5R,IAAI,CAACgR,EAAMzQ,KAAW,CAAEd,KAAM6U,EAAStD,EAAOjH,EAAU,CAAC,EAAGxJ,MAAAA,GAAQ,EACpE0T,KAAK,CAACM,EAAIC,IAAOzV,EAAQwV,EAAG9U,IAAI,EAAIV,EAAQyV,EAAG/U,IAAI,CAAC,EAEjD,CAAEc,MAAAA,CAAO,EAAG8T,EAAgB,CAAC,EACnC,MAAO,CAAE9T,MAAAA,EAAOwJ,SAAAA,EAClB,CAEA,SAASuK,EAASzN,EAAgBnB,EAAiB,CACjD,IAAM+O,EAAU,CAAC5N,EAAQA,EAASsJ,EAAatJ,EAASsJ,CAAW,EAEnE,GAAI,CAAC/J,EAAM,OAAOS,EAClB,GAAI,CAACnB,EAAW,OAAOqO,EAAYU,CAAO,EAE1C,IAAMC,EAAkBD,EAAQpR,OAAQsR,GAAMxV,GAASwV,CAAC,IAAMjP,CAAS,EACvE,OAAIgP,EAAgBrU,OAAe0T,EAAYW,CAAe,EACvDxU,EAAUuU,CAAO,EAAItE,CAC9B,CAEA,SAASnG,EAAQzJ,EAAemF,EAAiB,CAC/C,IAAMkP,EAAahD,EAAYrR,CAAK,EAAIuT,EAAatN,IAAG,EAClDuD,EAAWuK,EAASM,EAAYlP,CAAS,EAC/C,MAAO,CAAEnF,MAAAA,EAAOwJ,SAAAA,EAClB,CAEA,SAASD,EAAWC,EAAkBiH,EAAa,CACjD,IAAMnK,EAASiN,EAAatN,IAAG,EAAKuD,EAC9B,CAAExJ,MAAAA,EAAOwJ,SAAU8K,CAAoB,EAAGT,EAAevN,CAAM,EAC/DiO,EAAe,CAAC1O,GAAQL,EAAWc,CAAM,EAE/C,GAAI,CAACmK,GAAQ8D,EAAc,MAAO,CAAEvU,MAAAA,EAAOwJ,SAAAA,GAE3C,IAAM6K,EAAahD,EAAYrR,CAAK,EAAIsU,EAClCE,EAAehL,EAAWuK,EAASM,EAAY,CAAC,EAEtD,MAAO,CAAErU,MAAAA,EAAOwJ,SAAUgL,EAC5B,CAOA,MAL+B,CAC7BjL,WAAAA,EACAE,QAAAA,EACAsK,SAAAA,EAGJ,CC9DgB,SAAAU,GACdhO,EACAiO,EACAC,EACAhO,EACAC,EACA2M,EACA1M,EAA8B,CAE9B,SAASH,EAASJ,EAAkB,CAClC,IAAMsO,EAAetO,EAAOkD,SACtBqL,EAAYvO,EAAOtG,QAAU0U,EAAazO,IAAG,EAEnDsN,EAAavR,IAAI4S,CAAY,EAEzBA,IACEjO,EAAW+H,SAAQ,EACrBjI,EAAU/E,MAAK,GAEf+E,EAAUvD,OAAM,EAChBuD,EAAUtD,OAAO,CAAC,EAClBsD,EAAUvD,OAAM,IAIhB2R,IACFF,EAAczO,IAAIwO,EAAazO,IAAG,CAAE,EACpCyO,EAAaxO,IAAII,EAAOtG,KAAK,EAC7B6G,EAAaoD,KAAK,QAAQ,EAE9B,CAEA,SAAST,EAAS/K,EAAWgS,EAAa,CACxC,IAAMnK,EAASM,EAAa2C,WAAW9K,EAAGgS,CAAI,EAC9C/J,EAASJ,CAAM,CACjB,CAEA,SAAStG,EAAMvB,EAAW0G,EAAiB,CACzC,IAAM2P,EAAcJ,EAAavO,MAAK,EAAGD,IAAIzH,CAAC,EACxC6H,EAASM,EAAa6C,QAAQqL,EAAY7O,IAAG,EAAId,CAAS,EAChEuB,EAASJ,CAAM,CACjB,CAMA,MAJ2B,CACzBkD,SAAAA,EACAxJ,MAAAA,EAGJ,UCzCgB+U,GACdC,EACA3I,EACA0G,EACArM,EACAC,EACAsO,EACApO,EACAqO,EAAkC,CAElC,IAAMC,EAAuB,CAAE9S,QAAS,GAAM+S,QAAS,IACnDC,EAAmB,EAEvB,SAAS5R,EAAK6E,EAA2B,CACvC,GAAI,CAAC4M,EAAY,OAEjB,SAASnI,EAAgB/M,EAAa,CAIpC,GAHgB,IAAIsV,KAAI,EAAGC,QAAO,EACPF,EAEZ,GAAI,OAEnBxO,EAAaoD,KAAK,iBAAiB,EACnC+K,EAAKQ,WAAa,EAElB,IAAMrC,EAAQJ,EAAc0C,UAAWtC,GAAUA,EAAMnK,SAAShJ,CAAK,CAAC,EAEjEjC,GAASoV,CAAK,IAEnBxM,EAAWoD,YAAY,CAAC,EACxBrD,EAAS1G,MAAMmT,EAAO,CAAC,EAEvBtM,EAAaoD,KAAK,YAAY,EAChC,CAEAgL,EAAWjT,IAAI0T,SAAU,UAAWC,EAAkB,EAAK,EAE3DtJ,EAAOtL,QAAQ,CAAC6U,EAAOzI,IAAc,CACnC8H,EAAWjT,IACT4T,EACA,QACCzU,GAAmB,EACdjD,GAAUgX,CAAU,GAAKA,EAAW5M,EAAUnH,CAAG,IACnD4L,EAAgBI,CAAU,GAG9BgI,CAAoB,CAExB,CAAC,CACH,CAEA,SAASQ,EAAiBE,EAAoB,CACxCA,EAAMC,OAAS,QAAOT,EAAmB,IAAIC,KAAI,EAAGC,QAAO,EACjE,CAKA,MAH6B,CAC3B9R,KAAAA,EAGJ,CCrEM,SAAUsS,GAASC,EAAoB,CAC3C,IAAIC,EAAQD,EAEZ,SAAS/P,GAAG,CACV,OAAOgQ,CACT,CAEA,SAAS/P,EAAIzH,EAAwB,CACnCwX,EAAQC,EAAezX,CAAC,CAC1B,CAEA,SAASuD,EAAIvD,EAAwB,CACnCwX,GAASC,EAAezX,CAAC,CAC3B,CAEA,SAAS+Q,EAAS/Q,EAAwB,CACxCwX,GAASC,EAAezX,CAAC,CAC3B,CAEA,SAASyX,EAAezX,EAAwB,CAC9C,OAAOV,GAASU,CAAC,EAAIA,EAAIA,EAAEwH,IAAG,CAChC,CAQA,MAN2B,CACzBA,IAAAA,EACAC,IAAAA,EACAlE,IAAAA,EACAwN,SAAAA,EAGJ,CC9BgB,SAAA2G,GACd9R,EACA+H,EAAsB,CAEtB,IAAMgK,EAAY/R,EAAKI,SAAW,IAAM4R,EAAIC,EACtCC,EAAiBnK,EAAUoK,MAC7BC,EAAgC,KAChCtH,EAAW,GAEf,SAASkH,EAAE5X,EAAS,CAClB,MAAO,eAAeA,CAAC,aACzB,CAEA,SAAS6X,EAAE7X,EAAS,CAClB,MAAO,mBAAmBA,CAAC,SAC7B,CAEA,SAASiY,EAAGpQ,EAAc,CACxB,GAAI6I,EAAU,OAEd,IAAMwH,EAAYxX,GAAmBkF,EAAKc,UAAUmB,CAAM,CAAC,EACvDqQ,IAAcF,IAElBF,EAAeK,UAAYR,EAAUO,CAAS,EAC9CF,EAAiBE,EACnB,CAEA,SAASlH,EAAaC,EAAe,CACnCP,EAAW,CAACO,CACd,CAEA,SAAS7M,GAAK,CACRsM,IACJoH,EAAeK,UAAY,GACtBxK,EAAUyK,aAAa,OAAO,GAAGzK,EAAU0K,gBAAgB,OAAO,EACzE,CAOA,MAL4B,CAC1BjU,MAAAA,EACA6T,GAAAA,EACAjH,aAAAA,EAGJ,UC3BgBsH,GACd1S,EACA7C,EACAoO,EACAhD,EACAoK,EACA1E,EACAjB,EACA7K,EACA6F,EAAqB,CAGrB,IAAM4K,EAAW3X,GAAU0X,CAAkB,EACvCE,EAAY5X,GAAU0X,CAAkB,EAAEG,QAAO,EACjDC,EAAaC,EAAW,EAAG5K,OAAO6K,EAAS,CAAE,EAEnD,SAASC,EAAiBC,EAAmBpX,EAAY,CACvD,OAAOoX,EAAQ5W,OAAO,CAAC+S,EAAWrT,IACzBqT,EAAIqD,EAAmB1W,CAAC,EAC9BF,CAAI,CACT,CAEA,SAASqX,EAAYD,EAAmBE,EAAW,CACjD,OAAOF,EAAQ5W,OAAO,CAAC+S,EAAarT,IACbiX,EAAiB5D,EAAG+D,CAAG,EACtB,EAAI/D,EAAElH,OAAO,CAACnM,CAAC,CAAC,EAAIqT,EACzC,CAAA,CAAE,CACP,CAEA,SAASgE,EAAgBC,EAAc,CACrC,OAAOtF,EAAM7S,IAAI,CAACgR,EAAMzQ,KAAW,CACjC0B,MAAO+O,EAAO7D,EAAW5M,CAAK,EAAI6X,GAAiBD,EACnDhW,IAAK6O,EAAOjP,EAAWqW,GAAiBD,CACzC,EAAC,CACJ,CAEA,SAASE,EACPN,EACAI,EACAG,EAAkB,CAElB,IAAMC,EAAcL,EAAgBC,CAAM,EAE1C,OAAOJ,EAAQ/X,IAAKO,GAAS,CAC3B,IAAMiY,EAAUF,EAAY,EAAI,CAACnI,EAC3BsI,EAAUH,EAAYnI,EAAc,EACpCuI,EAAYJ,EAAY,MAAQ,QAChCK,EAAYJ,EAAYhY,CAAK,EAAEmY,CAAS,EAE9C,MAAO,CACLnY,MAAAA,EACAoY,UAAAA,EACAC,cAAetC,GAAS,EAAE,EAC1BK,UAAWD,GAAU9R,EAAMgI,EAAOrM,CAAK,CAAC,EACxCsG,OAAQA,IAAOE,EAASP,IAAG,EAAKmS,EAAYH,EAAUC,EAE1D,CAAC,CACH,CAEA,SAASb,GAAW,CAClB,IAAMK,EAAMrG,EAAY,CAAC,EACnBmG,EAAUC,EAAYP,EAAWQ,CAAG,EAC1C,OAAOI,EAAeN,EAAS5H,EAAa,EAAK,CACnD,CAEA,SAAS0H,GAAS,CAChB,IAAMI,EAAMlW,EAAW6P,EAAY,CAAC,EAAI,EAClCmG,EAAUC,EAAYR,EAAUS,CAAG,EACzC,OAAOI,EAAeN,EAAS,CAAC5H,EAAa,EAAI,CACnD,CAEA,SAAS0I,GAAO,CACd,OAAOlB,EAAWmB,MAAM,CAAC,CAAEvY,MAAAA,CAAO,IAAI,CACpC,IAAMwY,EAAevB,EAASnU,OAAQxC,GAAMA,IAAMN,CAAK,EACvD,OAAOuX,EAAiBiB,EAAchX,CAAQ,GAAK,EACrD,CAAC,CACH,CAEA,SAASqE,GAAI,CACXuR,EAAWrW,QAASqX,GAAa,CAC/B,GAAM,CAAE9R,OAAAA,EAAQ8P,UAAAA,EAAWiC,cAAAA,CAAa,EAAKD,EACvCK,EAAgBnS,EAAM,EACxBmS,IAAkBJ,EAAcpS,IAAG,IACvCmQ,EAAUM,GAAG+B,CAAa,EAC1BJ,EAAcnS,IAAIuS,CAAa,EACjC,CAAC,CACH,CAEA,SAAS5V,GAAK,CACZuU,EAAWrW,QAASqX,GAAcA,EAAUhC,UAAUvT,MAAK,CAAE,CAC/D,CAQA,MAN8B,CAC5ByV,QAAAA,EACAzV,MAAAA,EACAgD,KAAAA,EACAuR,WAAAA,EAGJ,UC5GgBsB,GACdtM,EACAvF,EACA8R,EAAoC,CAEpC,IAAIC,EACA/L,EAAY,GAEhB,SAASpJ,EAAK6E,EAA2B,CACvC,GAAI,CAACqQ,EAAa,OAElB,SAAS5L,EAAgB8L,EAA2B,CAClD,QAAWC,KAAYD,EACrB,GAAIC,EAAS5W,OAAS,YAAa,CACjCoG,EAASiF,OAAM,EACf1G,EAAaoD,KAAK,eAAe,EACjC,KACF,CAEJ,CAEA2O,EAAmB,IAAIG,iBAAkBF,GAAa,CAChDhM,IACA3O,GAAUya,CAAW,GAAKA,EAAYrQ,EAAUuQ,CAAS,IAC3D9L,EAAgB8L,CAAS,CAE7B,CAAC,EAEDD,EAAiBnL,QAAQrB,EAAW,CAAE4M,UAAW,EAAM,CAAA,CACzD,CAEA,SAASpV,GAAO,CACVgV,GAAkBA,EAAiBlL,WAAU,EACjDb,EAAY,EACd,CAMA,MAJgC,CAC9BpJ,KAAAA,EACAG,QAAAA,EAGJ,CC1CM,SAAUqV,GACd7M,EACAC,EACAxF,EACAqS,EAAkC,CAElC,IAAMC,EAAiD,CAAA,EACnDC,EAA+B,KAC/BC,EAAkC,KAClCC,EACAzM,EAAY,GAEhB,SAASpJ,GAAI,CACX6V,EAAuB,IAAIC,qBACxBvM,GAAW,CACNH,IAEJG,EAAQjM,QAASkM,GAAS,CACxB,IAAMjN,EAAQqM,EAAOe,QAAqBH,EAAM3G,MAAM,EACtD6S,EAAqBnZ,CAAK,EAAIiN,CAChC,CAAC,EAEDmM,EAAc,KACdC,EAAiB,KACjBxS,EAAaoD,KAAK,cAAc,EAClC,EACA,CACE+K,KAAM5I,EAAUoN,cAChBN,UAAAA,CACD,CAAA,EAGH7M,EAAOtL,QAAS6U,GAAU0D,EAAqB7L,QAAQmI,CAAK,CAAC,CAC/D,CAEA,SAAShS,GAAO,CACV0V,GAAsBA,EAAqB5L,WAAU,EACzDb,EAAY,EACd,CAEA,SAAS4M,EAAiBC,EAAe,CACvC,OAAOla,GAAW2Z,CAAoB,EAAEvY,OACtC,CAAC+Y,EAAgBxM,IAAc,CAC7B,IAAMnN,EAAQ4Z,SAASzM,CAAU,EAC3B,CAAE0M,eAAAA,CAAgB,EAAGV,EAAqBnZ,CAAK,EAIrD,OAHoB0Z,GAAUG,GACP,CAACH,GAAU,CAACG,IAEAF,EAAKhX,KAAK3C,CAAK,EAC3C2Z,GAET,CAAA,CAAE,CAEN,CAEA,SAAS1T,EAAIyT,EAAkB,GAAI,CACjC,GAAIA,GAAUN,EAAa,OAAOA,EAClC,GAAI,CAACM,GAAUL,EAAgB,OAAOA,EAEtC,IAAMvG,EAAe2G,EAAiBC,CAAM,EAE5C,OAAIA,IAAQN,EAActG,GACrB4G,IAAQL,EAAiBvG,GAEvBA,CACT,CAQA,MAN+B,CAC7BrP,KAAAA,EACAG,QAAAA,EACAqC,IAAAA,EAIJ,CC9EgB,SAAA6T,GACdzV,EACA2N,EACAC,EACA5F,EACA0N,EACA3Y,EAAuB,CAEvB,GAAM,CAAE2D,YAAAA,EAAaJ,UAAAA,EAAWE,QAAAA,CAAO,EAAKR,EACtC2V,EAAc/H,EAAW,CAAC,GAAK8H,EAC/BE,EAAWC,EAAe,EAC1BC,EAASC,EAAa,EACtBxN,EAAaqF,EAAWxS,IAAIsF,CAAW,EACvCiS,EAAqBqD,EAAe,EAE1C,SAASH,GAAe,CACtB,GAAI,CAACF,EAAa,MAAO,GACzB,IAAMM,EAAYrI,EAAW,CAAC,EAC9B,OAAOzT,EAAQwT,EAAcrN,CAAS,EAAI2V,EAAU3V,CAAS,CAAC,CAChE,CAEA,SAASyV,GAAa,CACpB,GAAI,CAACJ,EAAa,MAAO,GACzB,IAAMxD,EAAQpV,EAAYmZ,iBAAiB5a,EAAU0M,CAAM,CAAC,EAC5D,OAAO4E,WAAWuF,EAAMgE,iBAAiB,UAAU3V,CAAO,EAAE,CAAC,CAC/D,CAEA,SAASwV,GAAe,CACtB,OAAOpI,EACJxS,IAAI,CAACiT,EAAM1S,EAAOyS,IAAS,CAC1B,IAAM3B,EAAU,CAAC9Q,EACX+Q,EAAShR,GAAiB0S,EAAOzS,CAAK,EAC5C,OAAI8Q,EAAgBlE,EAAW5M,CAAK,EAAIia,EACpClJ,EAAenE,EAAW5M,CAAK,EAAIma,EAChC1H,EAAMzS,EAAQ,CAAC,EAAE2E,CAAS,EAAI+N,EAAK/N,CAAS,CACrD,CAAC,EACAlF,IAAIjB,CAAO,CAChB,CAQA,MAN6B,CAC3BoO,WAAAA,EACAoK,mBAAAA,EACAiD,SAAAA,EACAE,OAAAA,EAGJ,UCzCgBM,GACdpW,EACA7C,EACA0Q,EACArM,EACAmM,EACAC,EACAgI,EACAE,EACApK,EAAsB,CAEtB,GAAM,CAAEpL,UAAAA,EAAWE,QAAAA,EAASM,UAAAA,CAAS,EAAKd,EACpCqW,EAAgB3c,GAASmU,CAAc,EAE7C,SAASyI,EAAepb,EAAeqb,EAAiB,CACtD,OAAOtb,GAAUC,CAAK,EACnBuD,OAAQxC,GAAMA,EAAIsa,IAAc,CAAC,EACjCnb,IAAKa,GAAMf,EAAM4R,MAAM7Q,EAAGA,EAAIsa,CAAS,CAAC,CAC7C,CAEA,SAASC,EAAatb,EAAa,CACjC,OAAKA,EAAMO,OAEJR,GAAUC,CAAK,EACnBqB,OAAO,CAACwS,EAAkB0H,EAAO9a,IAAS,CACzC,IAAM+a,EAAQpb,EAAUyT,CAAM,GAAK,EAC7BtC,EAAUiK,IAAU,EACpBhK,EAAS+J,IAAUlb,GAAeL,CAAK,EAEvCyb,EAAQhJ,EAAcrN,CAAS,EAAIsN,EAAW8I,CAAK,EAAEpW,CAAS,EAC9DsW,EAAQjJ,EAAcrN,CAAS,EAAIsN,EAAW6I,CAAK,EAAEjW,CAAO,EAC5DqW,EAAO,CAACrV,GAAQiL,EAAU3L,EAAU8U,CAAQ,EAAI,EAChDkB,EAAO,CAACtV,GAAQkL,EAAS5L,EAAUgV,CAAM,EAAI,EAC7CiB,EAAY5c,EAAQyc,EAAQE,GAAQH,EAAQE,EAAK,EAEvD,OAAIlb,GAASob,EAAY5Z,EAAWuO,GAAgBqD,EAAOzQ,KAAKmY,CAAK,EACjE/J,GAAQqC,EAAOzQ,KAAKpD,EAAMO,MAAM,EAC7BsT,CACT,EAAG,CAAA,CAAE,EACJ3T,IAAI,CAAC4b,EAAarb,EAAOoT,IAAU,CAClC,IAAMkI,EAAe5c,KAAKmB,IAAIuT,EAAOpT,EAAQ,CAAC,GAAK,CAAC,EACpD,OAAOT,EAAM4R,MAAMmK,EAAcD,CAAW,CAC9C,CAAC,EArBuB,CAAA,CAsB5B,CAEA,SAASlJ,EAAkB5S,EAAa,CACtC,OAAOmb,EAAgBC,EAASpb,EAAO2S,CAAc,EAAI2I,EAAOtb,CAAK,CACvE,CAKA,MAHiC,CAC/B4S,YAAAA,EAGJ,CCOgB,SAAAoJ,GACdvG,EACA5I,EACAC,EACApJ,EACA7B,EACAgB,EACAyE,EAA8B,CAG9B,GAAM,CACJtF,MAAAA,EACA8C,KAAMmX,EACNrW,UAAAA,EACAsW,WAAAA,EACA5V,KAAAA,EACA6I,SAAAA,EACA3H,SAAAA,EACAC,cAAAA,EACA0U,gBAAAA,EACAxJ,eAAgBC,EAChBlL,UAAAA,EACA6I,cAAAA,EACAxD,YAAAA,EACAqM,YAAAA,EACAxR,UAAAA,EACA+N,WAAAA,CACD,EAAG9S,EAGE2N,EAAiB,EACjBxD,EAAYd,GAAS,EACrBuG,EAAgBzF,EAAU1K,QAAQuK,CAAS,EAC3C6F,EAAa5F,EAAO5M,IAAI8M,EAAU1K,OAAO,EACzCwC,EAAOD,GAAKoX,EAAYrW,CAAS,EACjC3D,EAAW6C,EAAKU,YAAYiN,CAAa,EACzClL,EAAgBoF,GAAc1K,CAAQ,EACtCuQ,EAAYzQ,GAAUC,EAAOC,CAAQ,EACrCqR,EAAe,CAAChN,GAAQ,CAAC,CAACiK,EAC1BiK,EAAclU,GAAQ,CAAC,CAACiK,EACxB,CAAElD,WAAAA,EAAYoK,mBAAAA,EAAoBiD,SAAAA,EAAUE,OAAAA,EAAQ,EAAGL,GAC3DzV,EACA2N,EACAC,EACA5F,EACA0N,EACA3Y,CAAW,EAEP8Q,EAAiBuI,GACrBpW,EACA7C,EACA2Q,EACAtM,EACAmM,EACAC,EACAgI,EACAE,GACApK,CAAc,EAEV,CAAEuC,MAAAA,GAAOzC,aAAAA,EAAc,EAAGiC,GAC9BzN,EACA0N,EACAC,EACAC,EACAC,CAAc,EAEVtC,EAAc,CAACjQ,EAAU2S,EAAK,EAAI3S,EAAUqX,CAAkB,EAC9D,CAAE3G,eAAAA,GAAgBF,mBAAAA,EAAoB,EAAGR,GAC7CnO,EACAoO,EACAC,GACAC,EACAC,CAAc,EAEVsB,EAAcwB,EAAexC,GAAiBR,GAC9C,CAAEd,MAAAA,GAAUqC,GAAYxB,EAAayB,EAAaxL,CAAI,EAGtD7F,EAAQ4F,GAAQhG,GAAeyR,CAAW,EAAGoK,EAAY5V,CAAI,EAC7D8O,EAAgB3U,EAAMmG,MAAK,EAC3B2M,EAAexT,GAAU+M,CAAM,EAG/BnJ,EAA+BA,CAAC,CACpCyY,YAAAA,GACAhV,WAAAA,GACAqJ,aAAAA,GACA5N,QAAS,CAAEyD,KAAAA,EAAM,CAAA,IACd,CACEA,IAAMmK,GAAavK,UAAUkW,GAAY9R,YAAW,CAAE,EAC3DlD,GAAW0H,KAAI,GAGXlL,EAA+BA,CACnC,CACEwD,WAAAA,GACAyP,UAAAA,GACA5P,SAAAA,GACAoH,eAAAA,GACAC,iBAAAA,GACA+N,aAAAA,GACAC,YAAAA,GACAF,YAAAA,GACAlV,UAAAA,GACAI,aAAAA,GACAmJ,aAAAA,GACA5N,QAAS,CAAEyD,KAAAA,EAAM,GAEnB5B,KACE,CACF,IAAM6X,GAAenV,GAAW8H,QAAO,EACjCsN,GAAe,CAAC/L,GAAaZ,gBAAe,EAC5C4M,GAAanW,GAAOiW,GAAeA,IAAgBC,GACnDE,GAAoBD,IAAc,CAACL,GAAY9R,YAAW,EAE5DoS,IAAmBxV,GAAU5C,KAAI,EAErC,IAAMqY,GACJ1V,GAASP,IAAG,EAAKhC,GAAQ4J,GAAiB5H,IAAG,GAAM,EAAIhC,IAEzD2J,GAAe1H,IAAIgW,EAAoB,EAEnCrW,KACF+V,GAAa/V,KAAKc,GAAWxB,UAAS,CAAE,EACxC0W,GAAYhW,KAAI,GAGlBuQ,GAAUM,GAAG9I,GAAe3H,IAAG,CAAE,EAE7BgW,IAAmBpV,GAAaoD,KAAK,QAAQ,EAC5C+R,IAAYnV,GAAaoD,KAAK,QAAQ,GAGvCxD,EAAYzD,GAChBC,EACA7B,EACA,IAAM8B,EAAOiZ,EAAM,EAClBlY,IAAkBd,EAAOgZ,GAAQlY,EAAK,CAAC,EAIpC4G,EAAW,IACXuR,EAAgB/K,EAAYrR,EAAMiG,IAAG,CAAE,EACvCO,EAAWuP,GAASqG,CAAa,EACjCvO,EAAmBkI,GAASqG,CAAa,EACzCxO,EAAiBmI,GAASqG,CAAa,EACvC9V,EAASyP,GAASqG,CAAa,EAC/BzV,GAAagH,GACjBnH,EACAoH,EACAC,EACAvH,EACAoI,EACA7D,CAAQ,EAEJjE,GAAe0M,GACnBzN,EACAwL,EACAzB,EACAb,EACAzI,CAAM,EAEFI,GAAW+N,GACfhO,EACAzG,EACA2U,EACAhO,GACAC,GACAN,EACAO,CAAY,EAERwV,GAAiBzK,GAAe7C,CAAK,EACrCkG,GAAanT,GAAU,EACvBwa,GAAerD,GACnB7M,EACAC,EACAxF,EACA6U,CAAe,EAEX,CAAE3I,cAAAA,EAAa,EAAKH,GACxBC,EACA/C,EACAuB,EACAlB,GACA+B,EACAY,CAAY,EAERyJ,GAAaxH,GACjBC,EACA3I,EACA0G,GACArM,GACAC,GACAsO,GACApO,EACAqO,CAAU,EAINiH,GAAqB,CACzBlZ,cAAAA,EACA7B,YAAAA,EACAyF,aAAAA,EACAmL,cAAAA,EACAC,WAAAA,EACAxL,UAAAA,EACApC,KAAAA,EACAsX,YAAavV,GACX/B,EACA2Q,EACA/R,EACA7B,EACAkF,EACAyE,GAAY1G,EAAMjD,CAAW,EAC7BoF,EACAC,EACAC,GACAC,GACAC,GACA5G,EACA6G,EACAC,EACAC,EACAC,EACAC,EACA4D,EACA1D,CAAS,EAEX8N,WAAAA,GACAnO,cAAAA,EACA9G,MAAAA,EACA2U,cAAAA,EACA5F,MAAAA,EACAvI,SAAAA,EACAoH,eAAAA,EACAC,iBAAAA,EACAzL,QAAAA,EACAoa,cAAerQ,GACbC,EACAvF,EACAzF,EACAiL,EACAhI,EACAiI,EACAC,CAAS,EAEX5F,WAAAA,GACAqJ,aAAclB,GACZC,EACAnB,EACAtH,EACAK,GACAG,CAAa,EAEf8U,aAActK,GAAa1B,EAAab,EAAOnB,EAAgB,CAC7DpH,EACAoH,EACAC,EACAvH,CAAM,CACP,EACD+V,eAAAA,GACAI,eAAgBpL,EAAY5R,IAAI4c,GAAepW,GAAG,EAClDoL,YAAAA,EACAzK,aAAAA,GACAF,SAAAA,GACAmV,YAAa9E,GACX1S,EACA7C,EACAoO,EACAhD,EACAoK,EACA1E,GACAjB,EACAzD,EACAvB,CAAM,EAERkQ,WAAAA,GACAG,cAAehE,GAActM,EAAWvF,EAAc8R,CAAW,EACjE2D,aAAAA,GACAxJ,aAAAA,EACAC,cAAAA,GACAb,eAAAA,EACA5L,OAAAA,EACA8P,UAAWD,GAAU9R,EAAM+H,CAAS,GAGtC,OAAO+P,EACT,UC5UgBQ,IAAY,CAC1B,IAAI5a,EAA2B,CAAA,EAC3B6a,EAEJ,SAASnZ,EAAK6E,EAA2B,CACvCsU,EAAMtU,CACR,CAEA,SAASuU,EAAa1b,EAAmB,CACvC,OAAOY,EAAUZ,CAAG,GAAK,CAAA,CAC3B,CAEA,SAAS8I,EAAK9I,EAAmB,CAC/B0b,OAAAA,EAAa1b,CAAG,EAAEJ,QAAS+b,GAAMA,EAAEF,EAAKzb,CAAG,CAAC,EACrCyB,CACT,CAEA,SAASma,EAAG5b,EAAqB6b,EAAgB,CAC/Cjb,OAAAA,EAAUZ,CAAG,EAAI0b,EAAa1b,CAAG,EAAEsL,OAAO,CAACuQ,CAAE,CAAC,EACvCpa,CACT,CAEA,SAASqa,EAAI9b,EAAqB6b,EAAgB,CAChDjb,OAAAA,EAAUZ,CAAG,EAAI0b,EAAa1b,CAAG,EAAE2B,OAAQga,GAAMA,IAAME,CAAE,EAClDpa,CACT,CAEA,SAASC,GAAK,CACZd,EAAY,CAAA,CACd,CAEA,IAAMa,EAAyB,CAC7Ba,KAAAA,EACAwG,KAAAA,EACAgT,IAAAA,EACAF,GAAAA,EACAla,MAAAA,GAEF,OAAOD,CACT,CC5BO,IAAMsa,GAA8B,CACzC3b,MAAO,SACP8C,KAAM,IACN+H,UAAW,KACXC,OAAQ,KACRyD,cAAe,YACf3K,UAAW,MACX+M,eAAgB,EAChBwJ,gBAAiB,EACjByB,YAAa,CAAA,EACbpW,SAAU,GACVC,cAAe,GACfnB,KAAM,GACNoB,UAAW,GACXyH,SAAU,GACV+M,WAAY,EACZ/L,OAAQ,GACRvI,UAAW,GACXmF,YAAa,GACbqM,YAAa,GACbzD,WAAY,IChDR,SAAUkI,GAAehc,EAAuB,CACpD,SAASic,EACPC,EACAC,EAAgB,CAEhB,OAAc9c,GAAiB6c,EAAUC,GAAY,CAAA,CAAE,CACzD,CAEA,SAASC,EAAyCpb,EAAa,CAC7D,IAAMob,EAAiBpb,EAAQ+a,aAAe,CAAA,EACxCM,EAAsBje,GAAWge,CAAc,EAClD1a,OAAQ4a,GAAUtc,EAAYuc,WAAWD,CAAK,EAAEE,OAAO,EACvDne,IAAKie,GAAUF,EAAeE,CAAK,CAAC,EACpC9c,OAAO,CAAC+S,EAAGkK,IAAgBR,EAAa1J,EAAGkK,CAAW,EAAG,CAAA,CAAE,EAE9D,OAAOR,EAAajb,EAASqb,CAAmB,CAClD,CAEA,SAASK,EAAoBC,EAA0B,CACrD,OAAOA,EACJte,IAAK2C,GAAY5C,GAAW4C,EAAQ+a,aAAe,CAAA,CAAE,CAAC,EACtDvc,OAAO,CAACod,EAAKC,IAAiBD,EAAIvR,OAAOwR,CAAY,EAAG,CAAA,CAAE,EAC1Dxe,IAAI2B,EAAYuc,UAAU,CAC/B,CAOA,MALiC,CAC/BN,aAAAA,EACAG,eAAAA,EACAM,oBAAAA,EAGJ,CCjCM,SAAUI,GACdC,EAAkC,CAElC,IAAIC,EAAmC,CAAA,EAEvC,SAAS3a,EACP6E,EACA+V,EAA0B,CAE1BD,OAAAA,EAAgBC,EAAQvb,OACtB,CAAC,CAAEV,QAAAA,KAAc+b,EAAeX,eAAepb,CAAO,EAAEsN,SAAW,EAAK,EAE1E0O,EAAcrd,QAASud,GAAWA,EAAO7a,KAAK6E,EAAU6V,CAAc,CAAC,EAEhEE,EAAQzd,OACb,CAACnB,EAAK6e,IAAWlgB,OAAOmgB,OAAO9e,EAAK,CAAE,CAAC6e,EAAOE,IAAI,EAAGF,CAAQ,CAAA,EAC7D,CAAA,CAAE,CAEN,CAEA,SAAS1a,GAAO,CACdwa,EAAgBA,EAActb,OAAQwb,GAAWA,EAAO1a,QAAO,CAAE,CACnE,CAMA,MAJiC,CAC/BH,KAAAA,EACAG,QAAAA,EAGJ,CCRA,SAAS6a,GACPzJ,EACA0J,EACAC,EAA+B,CAE/B,IAAM1b,EAAgB+R,EAAK/R,cACrB7B,EAA0B6B,EAAc2b,YACxCT,EAAiBf,GAAehc,CAAW,EAC3Cyd,EAAiBX,GAAeC,CAAc,EAC9CW,EAAgBhd,GAAU,EAC1B+E,EAAe8V,GAAY,EAC3B,CAAEU,aAAAA,EAAcG,eAAAA,EAAgBM,oBAAAA,CAAmB,EAAKK,EACxD,CAAEpB,GAAAA,EAAIE,IAAAA,EAAKhT,KAAAA,CAAI,EAAKpD,EACpB0G,EAASwR,EAEXlS,EAAY,GACZsP,EACA6C,EAAc3B,EAAaH,GAAgBuB,GAAcQ,aAAa,EACtE7c,EAAUib,EAAa2B,CAAW,EAClCE,EAAgC,CAAA,EAChCC,EAEA/S,EACAC,EAEJ,SAAS+S,GAAa,CACpB,GAAM,CAAEhT,UAAWiT,EAAehT,OAAQiT,CAAU,EAAKld,EAKzDgK,GAHwBnO,GAASohB,CAAa,EAC1CrK,EAAKuK,cAAcF,CAAa,EAChCA,IACyCrK,EAAKwK,SAAS,CAAC,EAE5D,IAAMC,EAAexhB,GAASqhB,CAAU,EACpClT,EAAUsT,iBAAiBJ,CAAU,EACrCA,EACJjT,EAAwB,CAAA,EAAG8E,MAAM5S,KAAKkhB,GAAgBrT,EAAUoT,QAAQ,CAC1E,CAEA,SAASG,EAAavd,EAAoB,CACxC,IAAM+Z,EAASZ,GACbvG,EACA5I,EACAC,EACApJ,EACA7B,EACAgB,EACAyE,CAAY,EAGd,GAAIzE,EAAQyD,MAAQ,CAACsW,EAAON,YAAYvD,QAAO,EAAI,CACjD,IAAMsH,EAAqBxhB,OAAOmgB,OAAO,CAAA,EAAInc,EAAS,CAAEyD,KAAM,EAAK,CAAE,EACrE,OAAO8Z,EAAaC,CAAkB,CACxC,CACA,OAAOzD,CACT,CAEA,SAAS0D,EACPC,EACAC,EAA+B,CAE3BlT,IAEJmS,EAAc3B,EAAa2B,EAAac,CAAW,EACnD1d,EAAUob,EAAewB,CAAW,EACpCE,EAAaa,GAAeb,EAE5BE,EAAa,EAEbjD,EAASwD,EAAavd,CAAO,EAE7B0b,EAAoB,CAClBkB,EACA,GAAGE,EAAWzf,IAAI,CAAC,CAAE2C,QAAAA,KAAcA,CAAO,CAAC,CAC5C,EAAErB,QAASif,GAAUlB,EAAc9c,IAAIge,EAAO,SAAUjB,CAAU,CAAC,EAE/D3c,EAAQsN,SAEbyM,EAAO/F,UAAUM,GAAGyF,EAAO3V,SAASP,IAAG,CAAE,EACzCkW,EAAO1V,UAAUhD,KAAI,EACrB0Y,EAAOG,aAAa7Y,KAAI,EACxB0Y,EAAOI,WAAW9Y,KAAKb,CAAI,EAC3BuZ,EAAOtV,aAAapD,KAAKb,CAAI,EAC7BuZ,EAAOK,cAAc/Y,KAAKb,CAAI,EAC9BuZ,EAAOO,cAAcjZ,KAAKb,CAAI,EAE1BuZ,EAAO/Z,QAAQyD,MAAMsW,EAAON,YAAYhW,KAAI,EAC5CuG,EAAU6T,cAAgB5T,EAAOvM,QAAQqc,EAAOR,YAAYlY,KAAKb,CAAI,EAEzEuc,EAAaN,EAAepb,KAAKb,EAAMsc,CAAU,GACnD,CAEA,SAASH,EACPe,EACAC,EAA+B,CAE/B,IAAMtE,EAAayE,EAAkB,EACrCC,EAAU,EACVN,EAASxC,EAAa,CAAE5B,WAAAA,CAAU,EAAIqE,CAAW,EAAGC,CAAW,EAC/DlZ,EAAaoD,KAAK,QAAQ,CAC5B,CAEA,SAASkW,GAAU,CACjBhE,EAAOR,YAAY/X,QAAO,EAC1BuY,EAAOlH,WAAWpS,MAAK,EACvBsZ,EAAO/F,UAAUvT,MAAK,EACtBsZ,EAAON,YAAYhZ,MAAK,EACxBsZ,EAAOK,cAAc5Y,QAAO,EAC5BuY,EAAOO,cAAc9Y,QAAO,EAC5BuY,EAAOG,aAAa1Y,QAAO,EAC3BuY,EAAO1V,UAAU7C,QAAO,EACxBib,EAAejb,QAAO,EACtBkb,EAAcjc,MAAK,CACrB,CAEA,SAASe,GAAO,CACViJ,IACJA,EAAY,GACZiS,EAAcjc,MAAK,EACnBsd,EAAU,EACVtZ,EAAaoD,KAAK,SAAS,EAC3BpD,EAAahE,MAAK,EACpB,CAEA,SAAS6D,EAAS1G,EAAeogB,EAAgBjb,EAAkB,CAC7D,CAAC/C,EAAQsN,QAAU7C,IACvBsP,EAAOxV,WACJkI,gBAAe,EACf9E,YAAYqW,IAAS,GAAO,EAAIhe,EAAQsM,QAAQ,EACnDyN,EAAOzV,SAAS1G,MAAMA,EAAOmF,GAAa,CAAC,EAC7C,CAEA,SAASkb,EAAWD,EAAc,CAChC,IAAM/W,EAAO8S,EAAOnc,MAAMgC,IAAI,CAAC,EAAEiE,IAAG,EACpCS,EAAS2C,EAAM+W,EAAM,EAAE,CACzB,CAEA,SAASE,EAAWF,EAAc,CAChC,IAAMG,EAAOpE,EAAOnc,MAAMgC,IAAI,EAAE,EAAEiE,IAAG,EACrCS,EAAS6Z,EAAMH,EAAM,CAAC,CACxB,CAEA,SAASI,GAAa,CAEpB,OADarE,EAAOnc,MAAMgC,IAAI,CAAC,EAAEiE,IAAG,IACpBia,EAAkB,CACpC,CAEA,SAASO,GAAa,CAEpB,OADatE,EAAOnc,MAAMgC,IAAI,EAAE,EAAEiE,IAAG,IACrBia,EAAkB,CACpC,CAEA,SAASzD,GAAc,CACrB,OAAON,EAAOM,cAChB,CAEA,SAASJ,IAAc,CACrB,OAAOF,EAAOE,eAAepW,IAAIkW,EAAOvO,eAAe3H,IAAG,CAAE,CAC9D,CAEA,SAASia,GAAkB,CACzB,OAAO/D,EAAOnc,MAAMiG,IAAG,CACzB,CAEA,SAASya,IAAkB,CACzB,OAAOvE,EAAOxH,cAAc1O,IAAG,CACjC,CAEA,SAASqW,IAAY,CACnB,OAAOH,EAAOG,aAAarW,IAAG,CAChC,CAEA,SAAS0a,GAAe,CACtB,OAAOxE,EAAOG,aAAarW,IAAI,EAAK,CACtC,CAEA,SAASoY,IAAO,CACd,OAAOc,CACT,CAEA,SAASyB,IAAc,CACrB,OAAOzE,CACT,CAEA,SAAS9V,GAAQ,CACf,OAAO2O,CACT,CAEA,SAAS6L,GAAa,CACpB,OAAOzU,CACT,CAEA,SAAS0U,GAAU,CACjB,OAAOzU,CACT,CAEA,IAAMzJ,EAA0B,CAC9B4d,cAAAA,EACAC,cAAAA,EACAI,cAAAA,EACAD,eAAAA,GACAhd,QAAAA,EACAqZ,IAAAA,EACAF,GAAAA,EACA9S,KAAAA,EACAoU,QAAAA,GACAqC,mBAAAA,GACAnT,OAAAA,EACAlH,SAAAA,EACAga,WAAAA,EACAC,WAAAA,EACAjE,eAAAA,GACAI,eAAAA,EACA/V,SAAAA,EACAwZ,mBAAAA,EACAY,WAAAA,EACAxE,aAAAA,GACAqE,gBAAAA,GAGFd,OAAAA,EAASnB,EAAaC,CAAW,EACjCoC,WAAW,IAAMla,EAAaoD,KAAK,MAAM,EAAG,CAAC,EACtCrH,CACT,CAMA6b,GAAcQ,cAAgB+B","names":["isNumber","subject","isString","isBoolean","isObject","Object","prototype","toString","call","mathAbs","n","Math","abs","mathSign","sign","deltaAbs","valueB","valueA","factorAbs","diff","roundToTwoDecimals","num","round","arrayKeys","array","objectKeys","map","Number","arrayLast","arrayLastIndex","max","length","arrayIsLastIndex","index","arrayFromNumber","startAt","Array","from","_","i","object","keys","objectsMergeDeep","objectA","objectB","reduce","mergedObjects","currentObject","forEach","key","areObjects","isMouseEvent","evt","ownerWindow","MouseEvent","Alignment","align","viewSize","predefined","start","center","end","measure","EventStore","listeners","add","node","type","handler","options","passive","removeListener","addEventListener","removeEventListener","legacyMediaQueryList","addListener","push","self","clear","filter","remove","Animations","ownerDocument","update","render","documentVisibleHandler","fixedTimeStep","lastTimeStamp","accumulatedTime","animationId","init","hidden","reset","destroy","stop","animate","timeStamp","timeElapsed","alpha","requestAnimationFrame","cancelAnimationFrame","Axis","axis","contentDirection","isRightToLeft","isVertical","scroll","cross","startEdge","getStartEdge","endEdge","getEndEdge","measureSize","nodeRect","height","width","direction","Limit","min","reachedMin","reachedMax","reachedAny","constrain","removeOffset","ceil","Counter","loop","loopEnd","counter","withinLimit","get","set","clone","DragHandler","rootNode","target","dragTracker","location","animation","scrollTo","scrollBody","scrollTarget","eventHandler","percentOfView","dragFree","dragThreshold","skipSnaps","baseFriction","watchDrag","crossAxis","focusNodes","nonPassiveEvent","initEvents","dragEvents","goToNextThreshold","snapForceBoost","mouse","touch","freeForceBoost","baseSpeed","isMoving","startScroll","startCross","pointerIsDown","preventScroll","preventClick","isMouse","emblaApi","downIfAllowed","down","preventDefault","up","click","addDragEvents","move","isFocusNode","nodeName","includes","forceBoost","allowedForce","force","targetChanged","next","baseForce","byDistance","distance","byIndex","isMouseEvt","buttons","button","pointerDown","useFriction","useDuration","readPoint","emit","touches","lastScroll","lastCross","diffScroll","diffCross","cancelable","pointerMove","rawForce","pointerUp","forceFactor","speed","friction","stopPropagation","DragTracker","startEvent","lastEvent","readTime","evtAxis","coord","expired","logInterval","diffDrag","diffTime","NodeRects","offsetTop","offsetLeft","offsetWidth","offsetHeight","top","right","bottom","left","PercentOfView","ResizeHandler","container","slides","watchResize","nodeRects","observeNodes","concat","resizeObserver","containerSize","slideSizes","destroyed","readSize","defaultCallback","entries","entry","isContainer","slideIndex","indexOf","lastSize","newSize","reInit","ResizeObserver","observe","disconnect","ScrollBody","offsetLocation","previousLocation","baseDuration","scrollVelocity","scrollDirection","scrollDuration","scrollFriction","rawLocation","rawLocationPrevious","seek","displacement","isInstant","scrollDistance","settled","duration","velocity","useBaseDuration","useBaseFriction","ScrollBounds","limit","pullBackThreshold","edgeOffsetTolerance","frictionLimit","disabled","shouldConstrain","edge","diffToEdge","diffToTarget","subtract","toggleActive","active","ScrollContain","contentSize","snapsAligned","containScroll","pixelTolerance","scrollBounds","snapsBounded","measureBounded","scrollContainLimit","findScrollContainLimit","snapsContained","measureContained","usePixelTolerance","bound","snap","startSnap","endSnap","lastIndexOf","snapAligned","isFirst","isLast","scrollBound","parseFloat","toFixed","slice","ScrollLimit","scrollSnaps","ScrollLooper","vectors","jointSafety","shouldLoop","loopDistance","v","ScrollProgress","currentLocation","ScrollSnaps","alignment","containerRect","slideRects","slidesToScroll","groupSlides","alignments","measureSizes","snaps","measureUnaligned","measureAligned","rects","rect","g","SlideRegistry","containSnaps","slideIndexes","slideRegistry","createSlideRegistry","groupedSlideIndexes","doNotContain","group","groups","range","ScrollTarget","targetVector","minDistance","distances","sort","a","b","findTargetSnap","ascDiffsToSnaps","shortcut","d1","d2","targets","matchingTargets","t","diffToSnap","targetSnapDistance","reachedBound","snapDistance","ScrollTo","indexCurrent","indexPrevious","distanceDiff","indexDiff","targetIndex","SlideFocus","root","eventStore","watchFocus","focusListenerOptions","capture","lastTabPressTime","Date","getTime","scrollLeft","findIndex","document","registerTabPress","slide","event","code","Vector1D","initialValue","value","normalizeInput","Translate","translate","x","y","containerStyle","style","previousTarget","to","newTarget","transform","getAttribute","removeAttribute","SlideLooper","slideSizesWithGaps","ascItems","descItems","reverse","loopPoints","startPoints","endPoints","removeSlideSizes","indexes","slidesInGap","gap","findSlideBounds","offset","roundingSafety","findLoopPoints","isEndEdge","slideBounds","initial","altered","boundEdge","loopPoint","slideLocation","canLoop","every","otherIndexes","shiftLocation","SlidesHandler","watchSlides","mutationObserver","mutations","mutation","MutationObserver","childList","SlidesInView","threshold","intersectionEntryMap","inViewCache","notInViewCache","intersectionObserver","IntersectionObserver","parentElement","createInViewList","inView","list","parseInt","isIntersecting","SlideSizes","readEdgeGap","withEdgeGap","startGap","measureStartGap","endGap","measureEndGap","measureWithGaps","slideRect","getComputedStyle","getPropertyValue","SlidesToScroll","groupByNumber","byNumber","groupSize","bySize","rectB","rectA","edgeA","edgeB","gapA","gapB","chunkSize","currentSize","previousSize","Engine","scrollAxis","startIndex","inViewThreshold","dragHandler","scrollLooper","slideLooper","shouldSettle","withinBounds","hasSettled","hasSettledAndIdle","interpolatedLocation","engine","startLocation","scrollProgress","slidesInView","slideFocus","resizeHandler","scrollSnapList","slidesHandler","EventHandler","api","getListeners","e","on","cb","off","defaultOptions","breakpoints","OptionsHandler","mergeOptions","optionsA","optionsB","optionsAtMedia","matchedMediaOptions","media","matchMedia","matches","mediaOption","optionsMediaQueries","optionsList","acc","mediaQueries","PluginsHandler","optionsHandler","activePlugins","plugins","plugin","assign","name","EmblaCarousel","userOptions","userPlugins","defaultView","pluginsHandler","mediaHandlers","reActivate","optionsBase","globalOptions","pluginList","pluginApis","storeElements","userContainer","userSlides","querySelector","children","customSlides","querySelectorAll","createEngine","optionsWithoutLoop","activate","withOptions","withPlugins","query","offsetParent","selectedScrollSnap","deActivate","jump","scrollNext","scrollPrev","prev","canScrollNext","canScrollPrev","previousScrollSnap","slidesNotInView","internalEngine","containerNode","slideNodes","setTimeout","undefined"],"sources":["../esm/npm/embla-carousel@8.6.0/node_modules/embla-carousel/src/components/utils.ts","../esm/npm/embla-carousel@8.6.0/node_modules/embla-carousel/src/components/Alignment.ts","../esm/npm/embla-carousel@8.6.0/node_modules/embla-carousel/src/components/EventStore.ts","../esm/npm/embla-carousel@8.6.0/node_modules/embla-carousel/src/components/Animations.ts","../esm/npm/embla-carousel@8.6.0/node_modules/embla-carousel/src/components/Axis.ts","../esm/npm/embla-carousel@8.6.0/node_modules/embla-carousel/src/components/Limit.ts","../esm/npm/embla-carousel@8.6.0/node_modules/embla-carousel/src/components/Counter.ts","../esm/npm/embla-carousel@8.6.0/node_modules/embla-carousel/src/components/DragHandler.ts","../esm/npm/embla-carousel@8.6.0/node_modules/embla-carousel/src/components/DragTracker.ts","../esm/npm/embla-carousel@8.6.0/node_modules/embla-carousel/src/components/NodeRects.ts","../esm/npm/embla-carousel@8.6.0/node_modules/embla-carousel/src/components/PercentOfView.ts","../esm/npm/embla-carousel@8.6.0/node_modules/embla-carousel/src/components/ResizeHandler.ts","../esm/npm/embla-carousel@8.6.0/node_modules/embla-carousel/src/components/ScrollBody.ts","../esm/npm/embla-carousel@8.6.0/node_modules/embla-carousel/src/components/ScrollBounds.ts","../esm/npm/embla-carousel@8.6.0/node_modules/embla-carousel/src/components/ScrollContain.ts","../esm/npm/embla-carousel@8.6.0/node_modules/embla-carousel/src/components/ScrollLimit.ts","../esm/npm/embla-carousel@8.6.0/node_modules/embla-carousel/src/components/ScrollLooper.ts","../esm/npm/embla-carousel@8.6.0/node_modules/embla-carousel/src/components/ScrollProgress.ts","../esm/npm/embla-carousel@8.6.0/node_modules/embla-carousel/src/components/ScrollSnaps.ts","../esm/npm/embla-carousel@8.6.0/node_modules/embla-carousel/src/components/SlideRegistry.ts","../esm/npm/embla-carousel@8.6.0/node_modules/embla-carousel/src/components/ScrollTarget.ts","../esm/npm/embla-carousel@8.6.0/node_modules/embla-carousel/src/components/ScrollTo.ts","../esm/npm/embla-carousel@8.6.0/node_modules/embla-carousel/src/components/SlideFocus.ts","../esm/npm/embla-carousel@8.6.0/node_modules/embla-carousel/src/components/Vector1d.ts","../esm/npm/embla-carousel@8.6.0/node_modules/embla-carousel/src/components/Translate.ts","../esm/npm/embla-carousel@8.6.0/node_modules/embla-carousel/src/components/SlideLooper.ts","../esm/npm/embla-carousel@8.6.0/node_modules/embla-carousel/src/components/SlidesHandler.ts","../esm/npm/embla-carousel@8.6.0/node_modules/embla-carousel/src/components/SlidesInView.ts","../esm/npm/embla-carousel@8.6.0/node_modules/embla-carousel/src/components/SlideSizes.ts","../esm/npm/embla-carousel@8.6.0/node_modules/embla-carousel/src/components/SlidesToScroll.ts","../esm/npm/embla-carousel@8.6.0/node_modules/embla-carousel/src/components/Engine.ts","../esm/npm/embla-carousel@8.6.0/node_modules/embla-carousel/src/components/EventHandler.ts","../esm/npm/embla-carousel@8.6.0/node_modules/embla-carousel/src/components/Options.ts","../esm/npm/embla-carousel@8.6.0/node_modules/embla-carousel/src/components/OptionsHandler.ts","../esm/npm/embla-carousel@8.6.0/node_modules/embla-carousel/src/components/PluginsHandler.ts","../esm/npm/embla-carousel@8.6.0/node_modules/embla-carousel/src/components/EmblaCarousel.ts"],"sourcesContent":["import { PointerEventType } from './DragTracker'\n\nexport type WindowType = Window \u0026 typeof globalThis\n\nexport function isNumber(subject: unknown): subject is number {\n  return typeof subject === 'number'\n}\n\nexport function isString(subject: unknown): subject is string {\n  return typeof subject === 'string'\n}\n\nexport function isBoolean(subject: unknown): subject is boolean {\n  return typeof subject === 'boolean'\n}\n\nexport function isObject(subject: unknown): subject is Record\u003cstring, unknown\u003e {\n  return Object.prototype.toString.call(subject) === '[object Object]'\n}\n\nexport function mathAbs(n: number): number {\n  return Math.abs(n)\n}\n\nexport function mathSign(n: number): number {\n  return Math.sign(n)\n}\n\nexport function deltaAbs(valueB: number, valueA: number): number {\n  return mathAbs(valueB - valueA)\n}\n\nexport function factorAbs(valueB: number, valueA: number): number {\n  if (valueB === 0 || valueA === 0) return 0\n  if (mathAbs(valueB) \u003c= mathAbs(valueA)) return 0\n  const diff = deltaAbs(mathAbs(valueB), mathAbs(valueA))\n  return mathAbs(diff / valueB)\n}\n\nexport function roundToTwoDecimals(num: number): number {\n  return Math.round(num * 100) / 100\n}\n\nexport function arrayKeys\u003cType\u003e(array: Type[]): number[] {\n  return objectKeys(array).map(Number)\n}\n\nexport function arrayLast\u003cType\u003e(array: Type[]): Type {\n  return array[arrayLastIndex(array)]\n}\n\nexport function arrayLastIndex\u003cType\u003e(array: Type[]): number {\n  return Math.max(0, array.length - 1)\n}\n\nexport function arrayIsLastIndex\u003cType\u003e(array: Type[], index: number): boolean {\n  return index === arrayLastIndex(array)\n}\n\nexport function arrayFromNumber(n: number, startAt: number = 0): number[] {\n  return Array.from(Array(n), (_, i) =\u003e startAt + i)\n}\n\nexport function objectKeys\u003cType extends object\u003e(object: Type): string[] {\n  return Object.keys(object)\n}\n\nexport function objectsMergeDeep(\n  objectA: Record\u003cstring, unknown\u003e,\n  objectB: Record\u003cstring, unknown\u003e\n): Record\u003cstring, unknown\u003e {\n  return [objectA, objectB].reduce((mergedObjects, currentObject) =\u003e {\n    objectKeys(currentObject).forEach((key) =\u003e {\n      const valueA = mergedObjects[key]\n      const valueB = currentObject[key]\n      const areObjects = isObject(valueA) \u0026\u0026 isObject(valueB)\n\n      mergedObjects[key] = areObjects\n        ? objectsMergeDeep(valueA, valueB)\n        : valueB\n    })\n    return mergedObjects\n  }, {})\n}\n\nexport function isMouseEvent(\n  evt: PointerEventType,\n  ownerWindow: WindowType\n): evt is MouseEvent {\n  return (\n    typeof ownerWindow.MouseEvent !== 'undefined' \u0026\u0026\n    evt instanceof ownerWindow.MouseEvent\n  )\n}\n","import { isString } from './utils'\n\nexport type AlignmentOptionType =\n  | 'start'\n  | 'center'\n  | 'end'\n  | ((viewSize: number, snapSize: number, index: number) =\u003e number)\n\nexport type AlignmentType = {\n  measure: (n: number, index: number) =\u003e number\n}\n\nexport function Alignment(\n  align: AlignmentOptionType,\n  viewSize: number\n): AlignmentType {\n  const predefined = { start, center, end }\n\n  function start(): number {\n    return 0\n  }\n\n  function center(n: number): number {\n    return end(n) / 2\n  }\n\n  function end(n: number): number {\n    return viewSize - n\n  }\n\n  function measure(n: number, index: number): number {\n    if (isString(align)) return predefined[align](n)\n    return align(viewSize, n, index)\n  }\n\n  const self: AlignmentType = {\n    measure\n  }\n  return self\n}\n","type EventNameType = keyof DocumentEventMap | keyof WindowEventMap\ntype EventHandlerType = (evt: any) =\u003e void\ntype EventOptionsType = boolean | AddEventListenerOptions | undefined\ntype EventRemoverType = () =\u003e void\n\nexport type EventStoreType = {\n  add: (\n    node: EventTarget,\n    type: EventNameType,\n    handler: EventHandlerType,\n    options?: EventOptionsType\n  ) =\u003e EventStoreType\n  clear: () =\u003e void\n}\n\nexport function EventStore(): EventStoreType {\n  let listeners: EventRemoverType[] = []\n\n  function add(\n    node: EventTarget,\n    type: EventNameType,\n    handler: EventHandlerType,\n    options: EventOptionsType = { passive: true }\n  ): EventStoreType {\n    let removeListener: EventRemoverType\n\n    if ('addEventListener' in node) {\n      node.addEventListener(type, handler, options)\n      removeListener = () =\u003e node.removeEventListener(type, handler, options)\n    } else {\n      const legacyMediaQueryList = \u003cMediaQueryList\u003enode\n      legacyMediaQueryList.addListener(handler)\n      removeListener = () =\u003e legacyMediaQueryList.removeListener(handler)\n    }\n\n    listeners.push(removeListener)\n    return self\n  }\n\n  function clear(): void {\n    listeners = listeners.filter((remove) =\u003e remove())\n  }\n\n  const self: EventStoreType = {\n    add,\n    clear\n  }\n  return self\n}\n","import { EngineType } from './Engine'\nimport { EventStore } from './EventStore'\nimport { WindowType } from './utils'\n\nexport type AnimationsUpdateType = (engine: EngineType) =\u003e void\nexport type AnimationsRenderType = (engine: EngineType, alpha: number) =\u003e void\n\nexport type AnimationsType = {\n  init: () =\u003e void\n  destroy: () =\u003e void\n  start: () =\u003e void\n  stop: () =\u003e void\n  update: () =\u003e void\n  render: (alpha: number) =\u003e void\n}\n\nexport function Animations(\n  ownerDocument: Document,\n  ownerWindow: WindowType,\n  update: () =\u003e void,\n  render: (alpha: number) =\u003e void\n): AnimationsType {\n  const documentVisibleHandler = EventStore()\n  const fixedTimeStep = 1000 / 60\n\n  let lastTimeStamp: number | null = null\n  let accumulatedTime = 0\n  let animationId = 0\n\n  function init(): void {\n    documentVisibleHandler.add(ownerDocument, 'visibilitychange', () =\u003e {\n      if (ownerDocument.hidden) reset()\n    })\n  }\n\n  function destroy(): void {\n    stop()\n    documentVisibleHandler.clear()\n  }\n\n  function animate(timeStamp: DOMHighResTimeStamp): void {\n    if (!animationId) return\n    if (!lastTimeStamp) {\n      lastTimeStamp = timeStamp\n      update()\n      update()\n    }\n\n    const timeElapsed = timeStamp - lastTimeStamp\n    lastTimeStamp = timeStamp\n    accumulatedTime += timeElapsed\n\n    while (accumulatedTime \u003e= fixedTimeStep) {\n      update()\n      accumulatedTime -= fixedTimeStep\n    }\n\n    const alpha = accumulatedTime / fixedTimeStep\n    render(alpha)\n\n    if (animationId) {\n      animationId = ownerWindow.requestAnimationFrame(animate)\n    }\n  }\n\n  function start(): void {\n    if (animationId) return\n    animationId = ownerWindow.requestAnimationFrame(animate)\n  }\n\n  function stop(): void {\n    ownerWindow.cancelAnimationFrame(animationId)\n    lastTimeStamp = null\n    accumulatedTime = 0\n    animationId = 0\n  }\n\n  function reset(): void {\n    lastTimeStamp = null\n    accumulatedTime = 0\n  }\n\n  const self: AnimationsType = {\n    init,\n    destroy,\n    start,\n    stop,\n    update,\n    render\n  }\n  return self\n}\n","import { NodeRectType } from './NodeRects'\n\nexport type AxisOptionType = 'x' | 'y'\nexport type AxisDirectionOptionType = 'ltr' | 'rtl'\ntype AxisEdgeType = 'top' | 'right' | 'bottom' | 'left'\n\nexport type AxisType = {\n  scroll: AxisOptionType\n  cross: AxisOptionType\n  startEdge: AxisEdgeType\n  endEdge: AxisEdgeType\n  measureSize: (nodeRect: NodeRectType) =\u003e number\n  direction: (n: number) =\u003e number\n}\n\nexport function Axis(\n  axis: AxisOptionType,\n  contentDirection: AxisDirectionOptionType\n): AxisType {\n  const isRightToLeft = contentDirection === 'rtl'\n  const isVertical = axis === 'y'\n  const scroll = isVertical ? 'y' : 'x'\n  const cross = isVertical ? 'x' : 'y'\n  const sign = !isVertical \u0026\u0026 isRightToLeft ? -1 : 1\n  const startEdge = getStartEdge()\n  const endEdge = getEndEdge()\n\n  function measureSize(nodeRect: NodeRectType): number {\n    const { height, width } = nodeRect\n    return isVertical ? height : width\n  }\n\n  function getStartEdge(): AxisEdgeType {\n    if (isVertical) return 'top'\n    return isRightToLeft ? 'right' : 'left'\n  }\n\n  function getEndEdge(): AxisEdgeType {\n    if (isVertical) return 'bottom'\n    return isRightToLeft ? 'left' : 'right'\n  }\n\n  function direction(n: number): number {\n    return n * sign\n  }\n\n  const self: AxisType = {\n    scroll,\n    cross,\n    startEdge,\n    endEdge,\n    measureSize,\n    direction\n  }\n  return self\n}\n","import { mathAbs } from './utils'\n\nexport type LimitType = {\n  min: number\n  max: number\n  length: number\n  constrain: (n: number) =\u003e number\n  reachedAny: (n: number) =\u003e boolean\n  reachedMax: (n: number) =\u003e boolean\n  reachedMin: (n: number) =\u003e boolean\n  removeOffset: (n: number) =\u003e number\n}\n\nexport function Limit(min: number = 0, max: number = 0): LimitType {\n  const length = mathAbs(min - max)\n\n  function reachedMin(n: number): boolean {\n    return n \u003c min\n  }\n\n  function reachedMax(n: number): boolean {\n    return n \u003e max\n  }\n\n  function reachedAny(n: number): boolean {\n    return reachedMin(n) || reachedMax(n)\n  }\n\n  function constrain(n: number): number {\n    if (!reachedAny(n)) return n\n    return reachedMin(n) ? min : max\n  }\n\n  function removeOffset(n: number): number {\n    if (!length) return n\n    return n - length * Math.ceil((n - max) / length)\n  }\n\n  const self: LimitType = {\n    length,\n    max,\n    min,\n    constrain,\n    reachedAny,\n    reachedMax,\n    reachedMin,\n    removeOffset\n  }\n  return self\n}\n","import { Limit } from './Limit'\nimport { mathAbs } from './utils'\n\nexport type CounterType = {\n  get: () =\u003e number\n  set: (n: number) =\u003e CounterType\n  add: (n: number) =\u003e CounterType\n  clone: () =\u003e CounterType\n}\n\nexport function Counter(\n  max: number,\n  start: number,\n  loop: boolean\n): CounterType {\n  const { constrain } = Limit(0, max)\n  const loopEnd = max + 1\n  let counter = withinLimit(start)\n\n  function withinLimit(n: number): number {\n    return !loop ? constrain(n) : mathAbs((loopEnd + n) % loopEnd)\n  }\n\n  function get(): number {\n    return counter\n  }\n\n  function set(n: number): CounterType {\n    counter = withinLimit(n)\n    return self\n  }\n\n  function add(n: number): CounterType {\n    return clone().set(get() + n)\n  }\n\n  function clone(): CounterType {\n    return Counter(max, get(), loop)\n  }\n\n  const self: CounterType = {\n    get,\n    set,\n    add,\n    clone\n  }\n  return self\n}\n","import { EmblaCarouselType } from './EmblaCarousel'\nimport { AnimationsType } from './Animations'\nimport { CounterType } from './Counter'\nimport { DragTrackerType, PointerEventType } from './DragTracker'\nimport { EventHandlerType } from './EventHandler'\nimport { AxisType } from './Axis'\nimport { EventStore } from './EventStore'\nimport { ScrollBodyType } from './ScrollBody'\nimport { ScrollTargetType } from './ScrollTarget'\nimport { ScrollToType } from './ScrollTo'\nimport { Vector1DType } from './Vector1d'\nimport { PercentOfViewType } from './PercentOfView'\nimport { Limit } from './Limit'\nimport {\n  deltaAbs,\n  factorAbs,\n  isBoolean,\n  isMouseEvent,\n  mathAbs,\n  mathSign,\n  WindowType\n} from './utils'\n\ntype DragHandlerCallbackType = (\n  emblaApi: EmblaCarouselType,\n  evt: PointerEventType\n) =\u003e boolean | void\n\nexport type DragHandlerOptionType = boolean | DragHandlerCallbackType\n\nexport type DragHandlerType = {\n  init: (emblaApi: EmblaCarouselType) =\u003e void\n  destroy: () =\u003e void\n  pointerDown: () =\u003e boolean\n}\n\nexport function DragHandler(\n  axis: AxisType,\n  rootNode: HTMLElement,\n  ownerDocument: Document,\n  ownerWindow: WindowType,\n  target: Vector1DType,\n  dragTracker: DragTrackerType,\n  location: Vector1DType,\n  animation: AnimationsType,\n  scrollTo: ScrollToType,\n  scrollBody: ScrollBodyType,\n  scrollTarget: ScrollTargetType,\n  index: CounterType,\n  eventHandler: EventHandlerType,\n  percentOfView: PercentOfViewType,\n  dragFree: boolean,\n  dragThreshold: number,\n  skipSnaps: boolean,\n  baseFriction: number,\n  watchDrag: DragHandlerOptionType\n): DragHandlerType {\n  const { cross: crossAxis, direction } = axis\n  const focusNodes = ['INPUT', 'SELECT', 'TEXTAREA']\n  const nonPassiveEvent = { passive: false }\n  const initEvents = EventStore()\n  const dragEvents = EventStore()\n  const goToNextThreshold = Limit(50, 225).constrain(percentOfView.measure(20))\n  const snapForceBoost = { mouse: 300, touch: 400 }\n  const freeForceBoost = { mouse: 500, touch: 600 }\n  const baseSpeed = dragFree ? 43 : 25\n\n  let isMoving = false\n  let startScroll = 0\n  let startCross = 0\n  let pointerIsDown = false\n  let preventScroll = false\n  let preventClick = false\n  let isMouse = false\n\n  function init(emblaApi: EmblaCarouselType): void {\n    if (!watchDrag) return\n\n    function downIfAllowed(evt: PointerEventType): void {\n      if (isBoolean(watchDrag) || watchDrag(emblaApi, evt)) down(evt)\n    }\n\n    const node = rootNode\n    initEvents\n      .add(node, 'dragstart', (evt) =\u003e evt.preventDefault(), nonPassiveEvent)\n      .add(node, 'touchmove', () =\u003e undefined, nonPassiveEvent)\n      .add(node, 'touchend', () =\u003e undefined)\n      .add(node, 'touchstart', downIfAllowed)\n      .add(node, 'mousedown', downIfAllowed)\n      .add(node, 'touchcancel', up)\n      .add(node, 'contextmenu', up)\n      .add(node, 'click', click, true)\n  }\n\n  function destroy(): void {\n    initEvents.clear()\n    dragEvents.clear()\n  }\n\n  function addDragEvents(): void {\n    const node = isMouse ? ownerDocument : rootNode\n    dragEvents\n      .add(node, 'touchmove', move, nonPassiveEvent)\n      .add(node, 'touchend', up)\n      .add(node, 'mousemove', move, nonPassiveEvent)\n      .add(node, 'mouseup', up)\n  }\n\n  function isFocusNode(node: Element): boolean {\n    const nodeName = node.nodeName || ''\n    return focusNodes.includes(nodeName)\n  }\n\n  function forceBoost(): number {\n    const boost = dragFree ? freeForceBoost : snapForceBoost\n    const type = isMouse ? 'mouse' : 'touch'\n    return boost[type]\n  }\n\n  function allowedForce(force: number, targetChanged: boolean): number {\n    const next = index.add(mathSign(force) * -1)\n    const baseForce = scrollTarget.byDistance(force, !dragFree).distance\n\n    if (dragFree || mathAbs(force) \u003c goToNextThreshold) return baseForce\n    if (skipSnaps \u0026\u0026 targetChanged) return baseForce * 0.5\n\n    return scrollTarget.byIndex(next.get(), 0).distance\n  }\n\n  function down(evt: PointerEventType): void {\n    const isMouseEvt = isMouseEvent(evt, ownerWindow)\n    isMouse = isMouseEvt\n    preventClick = dragFree \u0026\u0026 isMouseEvt \u0026\u0026 !evt.buttons \u0026\u0026 isMoving\n    isMoving = deltaAbs(target.get(), location.get()) \u003e= 2\n\n    if (isMouseEvt \u0026\u0026 evt.button !== 0) return\n    if (isFocusNode(evt.target as Element)) return\n\n    pointerIsDown = true\n    dragTracker.pointerDown(evt)\n    scrollBody.useFriction(0).useDuration(0)\n    target.set(location)\n    addDragEvents()\n    startScroll = dragTracker.readPoint(evt)\n    startCross = dragTracker.readPoint(evt, crossAxis)\n    eventHandler.emit('pointerDown')\n  }\n\n  function move(evt: PointerEventType): void {\n    const isTouchEvt = !isMouseEvent(evt, ownerWindow)\n    if (isTouchEvt \u0026\u0026 evt.touches.length \u003e= 2) return up(evt)\n\n    const lastScroll = dragTracker.readPoint(evt)\n    const lastCross = dragTracker.readPoint(evt, crossAxis)\n    const diffScroll = deltaAbs(lastScroll, startScroll)\n    const diffCross = deltaAbs(lastCross, startCross)\n\n    if (!preventScroll \u0026\u0026 !isMouse) {\n      if (!evt.cancelable) return up(evt)\n      preventScroll = diffScroll \u003e diffCross\n      if (!preventScroll) return up(evt)\n    }\n    const diff = dragTracker.pointerMove(evt)\n    if (diffScroll \u003e dragThreshold) preventClick = true\n\n    scrollBody.useFriction(0.3).useDuration(0.75)\n    animation.start()\n    target.add(direction(diff))\n    evt.preventDefault()\n  }\n\n  function up(evt: PointerEventType): void {\n    const currentLocation = scrollTarget.byDistance(0, false)\n    const targetChanged = currentLocation.index !== index.get()\n    const rawForce = dragTracker.pointerUp(evt) * forceBoost()\n    const force = allowedForce(direction(rawForce), targetChanged)\n    const forceFactor = factorAbs(rawForce, force)\n    const speed = baseSpeed - 10 * forceFactor\n    const friction = baseFriction + forceFactor / 50\n\n    preventScroll = false\n    pointerIsDown = false\n    dragEvents.clear()\n    scrollBody.useDuration(speed).useFriction(friction)\n    scrollTo.distance(force, !dragFree)\n    isMouse = false\n    eventHandler.emit('pointerUp')\n  }\n\n  function click(evt: MouseEvent): void {\n    if (preventClick) {\n      evt.stopPropagation()\n      evt.preventDefault()\n      preventClick = false\n    }\n  }\n\n  function pointerDown(): boolean {\n    return pointerIsDown\n  }\n\n  const self: DragHandlerType = {\n    init,\n    destroy,\n    pointerDown\n  }\n  return self\n}\n","import { AxisOptionType, AxisType } from './Axis'\nimport { isMouseEvent, mathAbs, WindowType } from './utils'\n\ntype PointerCoordType = keyof Touch | keyof MouseEvent\nexport type PointerEventType = TouchEvent | MouseEvent\n\nexport type DragTrackerType = {\n  pointerDown: (evt: PointerEventType) =\u003e number\n  pointerMove: (evt: PointerEventType) =\u003e number\n  pointerUp: (evt: PointerEventType) =\u003e number\n  readPoint: (evt: PointerEventType, evtAxis?: AxisOptionType) =\u003e number\n}\n\nexport function DragTracker(\n  axis: AxisType,\n  ownerWindow: WindowType\n): DragTrackerType {\n  const logInterval = 170\n\n  let startEvent: PointerEventType\n  let lastEvent: PointerEventType\n\n  function readTime(evt: PointerEventType): number {\n    return evt.timeStamp\n  }\n\n  function readPoint(evt: PointerEventType, evtAxis?: AxisOptionType): number {\n    const property = evtAxis || axis.scroll\n    const coord: PointerCoordType = `client${property === 'x' ? 'X' : 'Y'}`\n    return (isMouseEvent(evt, ownerWindow) ? evt : evt.touches[0])[coord]\n  }\n\n  function pointerDown(evt: PointerEventType): number {\n    startEvent = evt\n    lastEvent = evt\n    return readPoint(evt)\n  }\n\n  function pointerMove(evt: PointerEventType): number {\n    const diff = readPoint(evt) - readPoint(lastEvent)\n    const expired = readTime(evt) - readTime(startEvent) \u003e logInterval\n\n    lastEvent = evt\n    if (expired) startEvent = evt\n    return diff\n  }\n\n  function pointerUp(evt: PointerEventType): number {\n    if (!startEvent || !lastEvent) return 0\n    const diffDrag = readPoint(lastEvent) - readPoint(startEvent)\n    const diffTime = readTime(evt) - readTime(startEvent)\n    const expired = readTime(evt) - readTime(lastEvent) \u003e logInterval\n    const force = diffDrag / diffTime\n    const isFlick = diffTime \u0026\u0026 !expired \u0026\u0026 mathAbs(force) \u003e 0.1\n\n    return isFlick ? force : 0\n  }\n\n  const self: DragTrackerType = {\n    pointerDown,\n    pointerMove,\n    pointerUp,\n    readPoint\n  }\n  return self\n}\n","export type NodeRectType = {\n  top: number\n  right: number\n  bottom: number\n  left: number\n  width: number\n  height: number\n}\n\nexport type NodeRectsType = {\n  measure: (node: HTMLElement) =\u003e NodeRectType\n}\n\nexport function NodeRects(): NodeRectsType {\n  function measure(node: HTMLElement): NodeRectType {\n    const { offsetTop, offsetLeft, offsetWidth, offsetHeight } = node\n    const offset: NodeRectType = {\n      top: offsetTop,\n      right: offsetLeft + offsetWidth,\n      bottom: offsetTop + offsetHeight,\n      left: offsetLeft,\n      width: offsetWidth,\n      height: offsetHeight\n    }\n\n    return offset\n  }\n\n  const self: NodeRectsType = {\n    measure\n  }\n  return self\n}\n","export type PercentOfViewType = {\n  measure: (n: number) =\u003e number\n}\n\nexport function PercentOfView(viewSize: number): PercentOfViewType {\n  function measure(n: number): number {\n    return viewSize * (n / 100)\n  }\n\n  const self: PercentOfViewType = {\n    measure\n  }\n  return self\n}\n","import { AxisType } from './Axis'\nimport { EmblaCarouselType } from './EmblaCarousel'\nimport { EventHandlerType } from './EventHandler'\nimport { NodeRectsType } from './NodeRects'\nimport { isBoolean, mathAbs, WindowType } from './utils'\n\ntype ResizeHandlerCallbackType = (\n  emblaApi: EmblaCarouselType,\n  entries: ResizeObserverEntry[]\n) =\u003e boolean | void\n\nexport type ResizeHandlerOptionType = boolean | ResizeHandlerCallbackType\n\nexport type ResizeHandlerType = {\n  init: (emblaApi: EmblaCarouselType) =\u003e void\n  destroy: () =\u003e void\n}\n\nexport function ResizeHandler(\n  container: HTMLElement,\n  eventHandler: EventHandlerType,\n  ownerWindow: WindowType,\n  slides: HTMLElement[],\n  axis: AxisType,\n  watchResize: ResizeHandlerOptionType,\n  nodeRects: NodeRectsType\n): ResizeHandlerType {\n  const observeNodes = [container].concat(slides)\n  let resizeObserver: ResizeObserver\n  let containerSize: number\n  let slideSizes: number[] = []\n  let destroyed = false\n\n  function readSize(node: HTMLElement): number {\n    return axis.measureSize(nodeRects.measure(node))\n  }\n\n  function init(emblaApi: EmblaCarouselType): void {\n    if (!watchResize) return\n\n    containerSize = readSize(container)\n    slideSizes = slides.map(readSize)\n\n    function defaultCallback(entries: ResizeObserverEntry[]): void {\n      for (const entry of entries) {\n        if (destroyed) return\n\n        const isContainer = entry.target === container\n        const slideIndex = slides.indexOf(\u003cHTMLElement\u003eentry.target)\n        const lastSize = isContainer ? containerSize : slideSizes[slideIndex]\n        const newSize = readSize(isContainer ? container : slides[slideIndex])\n        const diffSize = mathAbs(newSize - lastSize)\n\n        if (diffSize \u003e= 0.5) {\n          emblaApi.reInit()\n          eventHandler.emit('resize')\n\n          break\n        }\n      }\n    }\n\n    resizeObserver = new ResizeObserver((entries) =\u003e {\n      if (isBoolean(watchResize) || watchResize(emblaApi, entries)) {\n        defaultCallback(entries)\n      }\n    })\n\n    ownerWindow.requestAnimationFrame(() =\u003e {\n      observeNodes.forEach((node) =\u003e resizeObserver.observe(node))\n    })\n  }\n\n  function destroy(): void {\n    destroyed = true\n    if (resizeObserver) resizeObserver.disconnect()\n  }\n\n  const self: ResizeHandlerType = {\n    init,\n    destroy\n  }\n  return self\n}\n","import { mathSign, mathAbs } from './utils'\nimport { Vector1DType } from './Vector1d'\n\nexport type ScrollBodyType = {\n  direction: () =\u003e number\n  duration: () =\u003e number\n  velocity: () =\u003e number\n  seek: () =\u003e ScrollBodyType\n  settled: () =\u003e boolean\n  useBaseFriction: () =\u003e ScrollBodyType\n  useBaseDuration: () =\u003e ScrollBodyType\n  useFriction: (n: number) =\u003e ScrollBodyType\n  useDuration: (n: number) =\u003e ScrollBodyType\n}\n\nexport function ScrollBody(\n  location: Vector1DType,\n  offsetLocation: Vector1DType,\n  previousLocation: Vector1DType,\n  target: Vector1DType,\n  baseDuration: number,\n  baseFriction: number\n): ScrollBodyType {\n  let scrollVelocity = 0\n  let scrollDirection = 0\n  let scrollDuration = baseDuration\n  let scrollFriction = baseFriction\n  let rawLocation = location.get()\n  let rawLocationPrevious = 0\n\n  function seek(): ScrollBodyType {\n    const displacement = target.get() - location.get()\n    const isInstant = !scrollDuration\n    let scrollDistance = 0\n\n    if (isInstant) {\n      scrollVelocity = 0\n      previousLocation.set(target)\n      location.set(target)\n\n      scrollDistance = displacement\n    } else {\n      previousLocation.set(location)\n\n      scrollVelocity += displacement / scrollDuration\n      scrollVelocity *= scrollFriction\n      rawLocation += scrollVelocity\n      location.add(scrollVelocity)\n\n      scrollDistance = rawLocation - rawLocationPrevious\n    }\n\n    scrollDirection = mathSign(scrollDistance)\n    rawLocationPrevious = rawLocation\n    return self\n  }\n\n  function settled(): boolean {\n    const diff = target.get() - offsetLocation.get()\n    return mathAbs(diff) \u003c 0.001\n  }\n\n  function duration(): number {\n    return scrollDuration\n  }\n\n  function direction(): number {\n    return scrollDirection\n  }\n\n  function velocity(): number {\n    return scrollVelocity\n  }\n\n  function useBaseDuration(): ScrollBodyType {\n    return useDuration(baseDuration)\n  }\n\n  function useBaseFriction(): ScrollBodyType {\n    return useFriction(baseFriction)\n  }\n\n  function useDuration(n: number): ScrollBodyType {\n    scrollDuration = n\n    return self\n  }\n\n  function useFriction(n: number): ScrollBodyType {\n    scrollFriction = n\n    return self\n  }\n\n  const self: ScrollBodyType = {\n    direction,\n    duration,\n    velocity,\n    seek,\n    settled,\n    useBaseFriction,\n    useBaseDuration,\n    useFriction,\n    useDuration\n  }\n  return self\n}\n","import { Limit, LimitType } from './Limit'\nimport { ScrollBodyType } from './ScrollBody'\nimport { Vector1DType } from './Vector1d'\nimport { mathAbs } from './utils'\nimport { PercentOfViewType } from './PercentOfView'\n\nexport type ScrollBoundsType = {\n  shouldConstrain: () =\u003e boolean\n  constrain: (pointerDown: boolean) =\u003e void\n  toggleActive: (active: boolean) =\u003e void\n}\n\nexport function ScrollBounds(\n  limit: LimitType,\n  location: Vector1DType,\n  target: Vector1DType,\n  scrollBody: ScrollBodyType,\n  percentOfView: PercentOfViewType\n): ScrollBoundsType {\n  const pullBackThreshold = percentOfView.measure(10)\n  const edgeOffsetTolerance = percentOfView.measure(50)\n  const frictionLimit = Limit(0.1, 0.99)\n  let disabled = false\n\n  function shouldConstrain(): boolean {\n    if (disabled) return false\n    if (!limit.reachedAny(target.get())) return false\n    if (!limit.reachedAny(location.get())) return false\n    return true\n  }\n\n  function constrain(pointerDown: boolean): void {\n    if (!shouldConstrain()) return\n    const edge = limit.reachedMin(location.get()) ? 'min' : 'max'\n    const diffToEdge = mathAbs(limit[edge] - location.get())\n    const diffToTarget = target.get() - location.get()\n    const friction = frictionLimit.constrain(diffToEdge / edgeOffsetTolerance)\n\n    target.subtract(diffToTarget * friction)\n\n    if (!pointerDown \u0026\u0026 mathAbs(diffToTarget) \u003c pullBackThreshold) {\n      target.set(limit.constrain(target.get()))\n      scrollBody.useDuration(25).useBaseFriction()\n    }\n  }\n\n  function toggleActive(active: boolean): void {\n    disabled = !active\n  }\n\n  const self: ScrollBoundsType = {\n    shouldConstrain,\n    constrain,\n    toggleActive\n  }\n  return self\n}\n","import { Limit, LimitType } from './Limit'\nimport { arrayIsLastIndex, arrayLast, deltaAbs } from './utils'\n\nexport type ScrollContainOptionType = false | 'trimSnaps' | 'keepSnaps'\n\nexport type ScrollContainType = {\n  snapsContained: number[]\n  scrollContainLimit: LimitType\n}\n\nexport function ScrollContain(\n  viewSize: number,\n  contentSize: number,\n  snapsAligned: number[],\n  containScroll: ScrollContainOptionType,\n  pixelTolerance: number\n): ScrollContainType {\n  const scrollBounds = Limit(-contentSize + viewSize, 0)\n  const snapsBounded = measureBounded()\n  const scrollContainLimit = findScrollContainLimit()\n  const snapsContained = measureContained()\n\n  function usePixelTolerance(bound: number, snap: number): boolean {\n    return deltaAbs(bound, snap) \u003c= 1\n  }\n\n  function findScrollContainLimit(): LimitType {\n    const startSnap = snapsBounded[0]\n    const endSnap = arrayLast(snapsBounded)\n    const min = snapsBounded.lastIndexOf(startSnap)\n    const max = snapsBounded.indexOf(endSnap) + 1\n    return Limit(min, max)\n  }\n\n  function measureBounded(): number[] {\n    return snapsAligned\n      .map((snapAligned, index) =\u003e {\n        const { min, max } = scrollBounds\n        const snap = scrollBounds.constrain(snapAligned)\n        const isFirst = !index\n        const isLast = arrayIsLastIndex(snapsAligned, index)\n        if (isFirst) return max\n        if (isLast) return min\n        if (usePixelTolerance(min, snap)) return min\n        if (usePixelTolerance(max, snap)) return max\n        return snap\n      })\n      .map((scrollBound) =\u003e parseFloat(scrollBound.toFixed(3)))\n  }\n\n  function measureContained(): number[] {\n    if (contentSize \u003c= viewSize + pixelTolerance) return [scrollBounds.max]\n    if (containScroll === 'keepSnaps') return snapsBounded\n    const { min, max } = scrollContainLimit\n    return snapsBounded.slice(min, max)\n  }\n\n  const self: ScrollContainType = {\n    snapsContained,\n    scrollContainLimit\n  }\n  return self\n}\n","import { Limit, LimitType } from './Limit'\nimport { arrayLast } from './utils'\n\nexport type ScrollLimitType = {\n  limit: LimitType\n}\n\nexport function ScrollLimit(\n  contentSize: number,\n  scrollSnaps: number[],\n  loop: boolean\n): ScrollLimitType {\n  const max = scrollSnaps[0]\n  const min = loop ? max - contentSize : arrayLast(scrollSnaps)\n  const limit = Limit(min, max)\n\n  const self: ScrollLimitType = {\n    limit\n  }\n  return self\n}\n","import { Limit, LimitType } from './Limit'\nimport { Vector1DType } from './Vector1d'\n\nexport type ScrollLooperType = {\n  loop: (direction: number) =\u003e void\n}\n\nexport function ScrollLooper(\n  contentSize: number,\n  limit: LimitType,\n  location: Vector1DType,\n  vectors: Vector1DType[]\n): ScrollLooperType {\n  const jointSafety = 0.1\n  const min = limit.min + jointSafety\n  const max = limit.max + jointSafety\n  const { reachedMin, reachedMax } = Limit(min, max)\n\n  function shouldLoop(direction: number): boolean {\n    if (direction === 1) return reachedMax(location.get())\n    if (direction === -1) return reachedMin(location.get())\n    return false\n  }\n\n  function loop(direction: number): void {\n    if (!shouldLoop(direction)) return\n\n    const loopDistance = contentSize * (direction * -1)\n    vectors.forEach((v) =\u003e v.add(loopDistance))\n  }\n\n  const self: ScrollLooperType = {\n    loop\n  }\n  return self\n}\n","import { LimitType } from './Limit'\n\nexport type ScrollProgressType = {\n  get: (n: number) =\u003e number\n}\n\nexport function ScrollProgress(limit: LimitType): ScrollProgressType {\n  const { max, length } = limit\n\n  function get(n: number): number {\n    const currentLocation = n - max\n    return length ? currentLocation / -length : 0\n  }\n\n  const self: ScrollProgressType = {\n    get\n  }\n  return self\n}\n","import { AlignmentType } from './Alignment'\nimport { AxisType } from './Axis'\nimport { NodeRectType } from './NodeRects'\nimport { SlidesToScrollType } from './SlidesToScroll'\nimport { arrayLast, mathAbs } from './utils'\n\nexport type ScrollSnapsType = {\n  snaps: number[]\n  snapsAligned: number[]\n}\n\nexport function ScrollSnaps(\n  axis: AxisType,\n  alignment: AlignmentType,\n  containerRect: NodeRectType,\n  slideRects: NodeRectType[],\n  slidesToScroll: SlidesToScrollType\n): ScrollSnapsType {\n  const { startEdge, endEdge } = axis\n  const { groupSlides } = slidesToScroll\n  const alignments = measureSizes().map(alignment.measure)\n  const snaps = measureUnaligned()\n  const snapsAligned = measureAligned()\n\n  function measureSizes(): number[] {\n    return groupSlides(slideRects)\n      .map((rects) =\u003e arrayLast(rects)[endEdge] - rects[0][startEdge])\n      .map(mathAbs)\n  }\n\n  function measureUnaligned(): number[] {\n    return slideRects\n      .map((rect) =\u003e containerRect[startEdge] - rect[startEdge])\n      .map((snap) =\u003e -mathAbs(snap))\n  }\n\n  function measureAligned(): number[] {\n    return groupSlides(snaps)\n      .map((g) =\u003e g[0])\n      .map((snap, index) =\u003e snap + alignments[index])\n  }\n\n  const self: ScrollSnapsType = {\n    snaps,\n    snapsAligned\n  }\n  return self\n}\n","import { LimitType } from './Limit'\nimport { ScrollContainOptionType } from './ScrollContain'\nimport { SlidesToScrollType } from './SlidesToScroll'\nimport {\n  arrayFromNumber,\n  arrayIsLastIndex,\n  arrayLast,\n  arrayLastIndex\n} from './utils'\n\nexport type SlideRegistryType = {\n  slideRegistry: number[][]\n}\n\nexport function SlideRegistry(\n  containSnaps: boolean,\n  containScroll: ScrollContainOptionType,\n  scrollSnaps: number[],\n  scrollContainLimit: LimitType,\n  slidesToScroll: SlidesToScrollType,\n  slideIndexes: number[]\n): SlideRegistryType {\n  const { groupSlides } = slidesToScroll\n  const { min, max } = scrollContainLimit\n  const slideRegistry = createSlideRegistry()\n\n  function createSlideRegistry(): number[][] {\n    const groupedSlideIndexes = groupSlides(slideIndexes)\n    const doNotContain = !containSnaps || containScroll === 'keepSnaps'\n\n    if (scrollSnaps.length === 1) return [slideIndexes]\n    if (doNotContain) return groupedSlideIndexes\n\n    return groupedSlideIndexes.slice(min, max).map((group, index, groups) =\u003e {\n      const isFirst = !index\n      const isLast = arrayIsLastIndex(groups, index)\n\n      if (isFirst) {\n        const range = arrayLast(groups[0]) + 1\n        return arrayFromNumber(range)\n      }\n      if (isLast) {\n        const range = arrayLastIndex(slideIndexes) - arrayLast(groups)[0] + 1\n        return arrayFromNumber(range, arrayLast(groups)[0])\n      }\n      return group\n    })\n  }\n\n  const self: SlideRegistryType = {\n    slideRegistry\n  }\n  return self\n}\n","import { LimitType } from './Limit'\nimport { Vector1DType } from './Vector1d'\nimport { arrayLast, mathAbs, mathSign } from './utils'\n\nexport type TargetType = {\n  distance: number\n  index: number\n}\n\nexport type ScrollTargetType = {\n  byIndex: (target: number, direction: number) =\u003e TargetType\n  byDistance: (force: number, snap: boolean) =\u003e TargetType\n  shortcut: (target: number, direction: number) =\u003e number\n}\n\nexport function ScrollTarget(\n  loop: boolean,\n  scrollSnaps: number[],\n  contentSize: number,\n  limit: LimitType,\n  targetVector: Vector1DType\n): ScrollTargetType {\n  const { reachedAny, removeOffset, constrain } = limit\n\n  function minDistance(distances: number[]): number {\n    return distances.concat().sort((a, b) =\u003e mathAbs(a) - mathAbs(b))[0]\n  }\n\n  function findTargetSnap(target: number): TargetType {\n    const distance = loop ? removeOffset(target) : constrain(target)\n    const ascDiffsToSnaps = scrollSnaps\n      .map((snap, index) =\u003e ({ diff: shortcut(snap - distance, 0), index }))\n      .sort((d1, d2) =\u003e mathAbs(d1.diff) - mathAbs(d2.diff))\n\n    const { index } = ascDiffsToSnaps[0]\n    return { index, distance }\n  }\n\n  function shortcut(target: number, direction: number): number {\n    const targets = [target, target + contentSize, target - contentSize]\n\n    if (!loop) return target\n    if (!direction) return minDistance(targets)\n\n    const matchingTargets = targets.filter((t) =\u003e mathSign(t) === direction)\n    if (matchingTargets.length) return minDistance(matchingTargets)\n    return arrayLast(targets) - contentSize\n  }\n\n  function byIndex(index: number, direction: number): TargetType {\n    const diffToSnap = scrollSnaps[index] - targetVector.get()\n    const distance = shortcut(diffToSnap, direction)\n    return { index, distance }\n  }\n\n  function byDistance(distance: number, snap: boolean): TargetType {\n    const target = targetVector.get() + distance\n    const { index, distance: targetSnapDistance } = findTargetSnap(target)\n    const reachedBound = !loop \u0026\u0026 reachedAny(target)\n\n    if (!snap || reachedBound) return { index, distance }\n\n    const diffToSnap = scrollSnaps[index] - targetSnapDistance\n    const snapDistance = distance + shortcut(diffToSnap, 0)\n\n    return { index, distance: snapDistance }\n  }\n\n  const self: ScrollTargetType = {\n    byDistance,\n    byIndex,\n    shortcut\n  }\n  return self\n}\n","import { AnimationsType } from './Animations'\nimport { CounterType } from './Counter'\nimport { EventHandlerType } from './EventHandler'\nimport { ScrollBodyType } from './ScrollBody'\nimport { ScrollTargetType, TargetType } from './ScrollTarget'\nimport { Vector1DType } from './Vector1d'\n\nexport type ScrollToType = {\n  distance: (n: number, snap: boolean) =\u003e void\n  index: (n: number, direction: number) =\u003e void\n}\n\nexport function ScrollTo(\n  animation: AnimationsType,\n  indexCurrent: CounterType,\n  indexPrevious: CounterType,\n  scrollBody: ScrollBodyType,\n  scrollTarget: ScrollTargetType,\n  targetVector: Vector1DType,\n  eventHandler: EventHandlerType\n): ScrollToType {\n  function scrollTo(target: TargetType): void {\n    const distanceDiff = target.distance\n    const indexDiff = target.index !== indexCurrent.get()\n\n    targetVector.add(distanceDiff)\n\n    if (distanceDiff) {\n      if (scrollBody.duration()) {\n        animation.start()\n      } else {\n        animation.update()\n        animation.render(1)\n        animation.update()\n      }\n    }\n\n    if (indexDiff) {\n      indexPrevious.set(indexCurrent.get())\n      indexCurrent.set(target.index)\n      eventHandler.emit('select')\n    }\n  }\n\n  function distance(n: number, snap: boolean): void {\n    const target = scrollTarget.byDistance(n, snap)\n    scrollTo(target)\n  }\n\n  function index(n: number, direction: number): void {\n    const targetIndex = indexCurrent.clone().set(n)\n    const target = scrollTarget.byIndex(targetIndex.get(), direction)\n    scrollTo(target)\n  }\n\n  const self: ScrollToType = {\n    distance,\n    index\n  }\n  return self\n}\n","import { EmblaCarouselType } from './EmblaCarousel'\nimport { EventHandlerType } from './EventHandler'\nimport { EventStoreType } from './EventStore'\nimport { ScrollBodyType } from './ScrollBody'\nimport { ScrollToType } from './ScrollTo'\nimport { SlideRegistryType } from './SlideRegistry'\nimport { isBoolean, isNumber } from './utils'\n\ntype FocusHandlerCallbackType = (\n  emblaApi: EmblaCarouselType,\n  evt: FocusEvent\n) =\u003e boolean | void\n\nexport type FocusHandlerOptionType = boolean | FocusHandlerCallbackType\n\nexport type SlideFocusType = {\n  init: (emblaApi: EmblaCarouselType) =\u003e void\n}\n\nexport function SlideFocus(\n  root: HTMLElement,\n  slides: HTMLElement[],\n  slideRegistry: SlideRegistryType['slideRegistry'],\n  scrollTo: ScrollToType,\n  scrollBody: ScrollBodyType,\n  eventStore: EventStoreType,\n  eventHandler: EventHandlerType,\n  watchFocus: FocusHandlerOptionType\n): SlideFocusType {\n  const focusListenerOptions = { passive: true, capture: true }\n  let lastTabPressTime = 0\n\n  function init(emblaApi: EmblaCarouselType): void {\n    if (!watchFocus) return\n\n    function defaultCallback(index: number): void {\n      const nowTime = new Date().getTime()\n      const diffTime = nowTime - lastTabPressTime\n\n      if (diffTime \u003e 10) return\n\n      eventHandler.emit('slideFocusStart')\n      root.scrollLeft = 0\n\n      const group = slideRegistry.findIndex((group) =\u003e group.includes(index))\n\n      if (!isNumber(group)) return\n\n      scrollBody.useDuration(0)\n      scrollTo.index(group, 0)\n\n      eventHandler.emit('slideFocus')\n    }\n\n    eventStore.add(document, 'keydown', registerTabPress, false)\n\n    slides.forEach((slide, slideIndex) =\u003e {\n      eventStore.add(\n        slide,\n        'focus',\n        (evt: FocusEvent) =\u003e {\n          if (isBoolean(watchFocus) || watchFocus(emblaApi, evt)) {\n            defaultCallback(slideIndex)\n          }\n        },\n        focusListenerOptions\n      )\n    })\n  }\n\n  function registerTabPress(event: KeyboardEvent): void {\n    if (event.code === 'Tab') lastTabPressTime = new Date().getTime()\n  }\n\n  const self: SlideFocusType = {\n    init\n  }\n  return self\n}\n","import { isNumber } from './utils'\n\nexport type Vector1DType = {\n  get: () =\u003e number\n  set: (n: Vector1DType | number) =\u003e void\n  add: (n: Vector1DType | number) =\u003e void\n  subtract: (n: Vector1DType | number) =\u003e void\n}\n\nexport function Vector1D(initialValue: number): Vector1DType {\n  let value = initialValue\n\n  function get(): number {\n    return value\n  }\n\n  function set(n: Vector1DType | number): void {\n    value = normalizeInput(n)\n  }\n\n  function add(n: Vector1DType | number): void {\n    value += normalizeInput(n)\n  }\n\n  function subtract(n: Vector1DType | number): void {\n    value -= normalizeInput(n)\n  }\n\n  function normalizeInput(n: Vector1DType | number): number {\n    return isNumber(n) ? n : n.get()\n  }\n\n  const self: Vector1DType = {\n    get,\n    set,\n    add,\n    subtract\n  }\n  return self\n}\n","import { AxisType } from './Axis'\nimport { roundToTwoDecimals } from './utils'\n\nexport type TranslateType = {\n  clear: () =\u003e void\n  to: (target: number) =\u003e void\n  toggleActive: (active: boolean) =\u003e void\n}\n\nexport function Translate(\n  axis: AxisType,\n  container: HTMLElement\n): TranslateType {\n  const translate = axis.scroll === 'x' ? x : y\n  const containerStyle = container.style\n  let previousTarget: number | null = null\n  let disabled = false\n\n  function x(n: number): string {\n    return `translate3d(${n}px,0px,0px)`\n  }\n\n  function y(n: number): string {\n    return `translate3d(0px,${n}px,0px)`\n  }\n\n  function to(target: number): void {\n    if (disabled) return\n\n    const newTarget = roundToTwoDecimals(axis.direction(target))\n    if (newTarget === previousTarget) return\n\n    containerStyle.transform = translate(newTarget)\n    previousTarget = newTarget\n  }\n\n  function toggleActive(active: boolean): void {\n    disabled = !active\n  }\n\n  function clear(): void {\n    if (disabled) return\n    containerStyle.transform = ''\n    if (!container.getAttribute('style')) container.removeAttribute('style')\n  }\n\n  const self: TranslateType = {\n    clear,\n    to,\n    toggleActive\n  }\n  return self\n}\n","import { AxisType } from './Axis'\nimport { arrayKeys } from './utils'\nimport { Vector1D, Vector1DType } from './Vector1d'\nimport { Translate, TranslateType } from './Translate'\n\ntype SlideBoundType = {\n  start: number\n  end: number\n}\n\ntype LoopPointType = {\n  loopPoint: number\n  index: number\n  translate: TranslateType\n  slideLocation: Vector1DType\n  target: () =\u003e number\n}\n\nexport type SlideLooperType = {\n  canLoop: () =\u003e boolean\n  clear: () =\u003e void\n  loop: () =\u003e void\n  loopPoints: LoopPointType[]\n}\n\nexport function SlideLooper(\n  axis: AxisType,\n  viewSize: number,\n  contentSize: number,\n  slideSizes: number[],\n  slideSizesWithGaps: number[],\n  snaps: number[],\n  scrollSnaps: number[],\n  location: Vector1DType,\n  slides: HTMLElement[]\n): SlideLooperType {\n  const roundingSafety = 0.5\n  const ascItems = arrayKeys(slideSizesWithGaps)\n  const descItems = arrayKeys(slideSizesWithGaps).reverse()\n  const loopPoints = startPoints().concat(endPoints())\n\n  function removeSlideSizes(indexes: number[], from: number): number {\n    return indexes.reduce((a: number, i) =\u003e {\n      return a - slideSizesWithGaps[i]\n    }, from)\n  }\n\n  function slidesInGap(indexes: number[], gap: number): number[] {\n    return indexes.reduce((a: number[], i) =\u003e {\n      const remainingGap = removeSlideSizes(a, gap)\n      return remainingGap \u003e 0 ? a.concat([i]) : a\n    }, [])\n  }\n\n  function findSlideBounds(offset: number): SlideBoundType[] {\n    return snaps.map((snap, index) =\u003e ({\n      start: snap - slideSizes[index] + roundingSafety + offset,\n      end: snap + viewSize - roundingSafety + offset\n    }))\n  }\n\n  function findLoopPoints(\n    indexes: number[],\n    offset: number,\n    isEndEdge: boolean\n  ): LoopPointType[] {\n    const slideBounds = findSlideBounds(offset)\n\n    return indexes.map((index) =\u003e {\n      const initial = isEndEdge ? 0 : -contentSize\n      const altered = isEndEdge ? contentSize : 0\n      const boundEdge = isEndEdge ? 'end' : 'start'\n      const loopPoint = slideBounds[index][boundEdge]\n\n      return {\n        index,\n        loopPoint,\n        slideLocation: Vector1D(-1),\n        translate: Translate(axis, slides[index]),\n        target: () =\u003e (location.get() \u003e loopPoint ? initial : altered)\n      }\n    })\n  }\n\n  function startPoints(): LoopPointType[] {\n    const gap = scrollSnaps[0]\n    const indexes = slidesInGap(descItems, gap)\n    return findLoopPoints(indexes, contentSize, false)\n  }\n\n  function endPoints(): LoopPointType[] {\n    const gap = viewSize - scrollSnaps[0] - 1\n    const indexes = slidesInGap(ascItems, gap)\n    return findLoopPoints(indexes, -contentSize, true)\n  }\n\n  function canLoop(): boolean {\n    return loopPoints.every(({ index }) =\u003e {\n      const otherIndexes = ascItems.filter((i) =\u003e i !== index)\n      return removeSlideSizes(otherIndexes, viewSize) \u003c= 0.1\n    })\n  }\n\n  function loop(): void {\n    loopPoints.forEach((loopPoint) =\u003e {\n      const { target, translate, slideLocation } = loopPoint\n      const shiftLocation = target()\n      if (shiftLocation === slideLocation.get()) return\n      translate.to(shiftLocation)\n      slideLocation.set(shiftLocation)\n    })\n  }\n\n  function clear(): void {\n    loopPoints.forEach((loopPoint) =\u003e loopPoint.translate.clear())\n  }\n\n  const self: SlideLooperType = {\n    canLoop,\n    clear,\n    loop,\n    loopPoints\n  }\n  return self\n}\n","import { EmblaCarouselType } from './EmblaCarousel'\nimport { EventHandlerType } from './EventHandler'\nimport { isBoolean } from './utils'\n\ntype SlidesHandlerCallbackType = (\n  emblaApi: EmblaCarouselType,\n  mutations: MutationRecord[]\n) =\u003e boolean | void\n\nexport type SlidesHandlerOptionType = boolean | SlidesHandlerCallbackType\n\nexport type SlidesHandlerType = {\n  init: (emblaApi: EmblaCarouselType) =\u003e void\n  destroy: () =\u003e void\n}\n\nexport function SlidesHandler(\n  container: HTMLElement,\n  eventHandler: EventHandlerType,\n  watchSlides: SlidesHandlerOptionType\n): SlidesHandlerType {\n  let mutationObserver: MutationObserver\n  let destroyed = false\n\n  function init(emblaApi: EmblaCarouselType): void {\n    if (!watchSlides) return\n\n    function defaultCallback(mutations: MutationRecord[]): void {\n      for (const mutation of mutations) {\n        if (mutation.type === 'childList') {\n          emblaApi.reInit()\n          eventHandler.emit('slidesChanged')\n          break\n        }\n      }\n    }\n\n    mutationObserver = new MutationObserver((mutations) =\u003e {\n      if (destroyed) return\n      if (isBoolean(watchSlides) || watchSlides(emblaApi, mutations)) {\n        defaultCallback(mutations)\n      }\n    })\n\n    mutationObserver.observe(container, { childList: true })\n  }\n\n  function destroy(): void {\n    if (mutationObserver) mutationObserver.disconnect()\n    destroyed = true\n  }\n\n  const self: SlidesHandlerType = {\n    init,\n    destroy\n  }\n  return self\n}\n","import { EventHandlerType } from './EventHandler'\nimport { objectKeys } from './utils'\n\ntype IntersectionEntryMapType = {\n  [key: number]: IntersectionObserverEntry\n}\n\nexport type SlidesInViewOptionsType = IntersectionObserverInit['threshold']\n\nexport type SlidesInViewType = {\n  init: () =\u003e void\n  destroy: () =\u003e void\n  get: (inView?: boolean) =\u003e number[]\n}\n\nexport function SlidesInView(\n  container: HTMLElement,\n  slides: HTMLElement[],\n  eventHandler: EventHandlerType,\n  threshold: SlidesInViewOptionsType\n): SlidesInViewType {\n  const intersectionEntryMap: IntersectionEntryMapType = {}\n  let inViewCache: number[] | null = null\n  let notInViewCache: number[] | null = null\n  let intersectionObserver: IntersectionObserver\n  let destroyed = false\n\n  function init(): void {\n    intersectionObserver = new IntersectionObserver(\n      (entries) =\u003e {\n        if (destroyed) return\n\n        entries.forEach((entry) =\u003e {\n          const index = slides.indexOf(\u003cHTMLElement\u003eentry.target)\n          intersectionEntryMap[index] = entry\n        })\n\n        inViewCache = null\n        notInViewCache = null\n        eventHandler.emit('slidesInView')\n      },\n      {\n        root: container.parentElement,\n        threshold\n      }\n    )\n\n    slides.forEach((slide) =\u003e intersectionObserver.observe(slide))\n  }\n\n  function destroy(): void {\n    if (intersectionObserver) intersectionObserver.disconnect()\n    destroyed = true\n  }\n\n  function createInViewList(inView: boolean): number[] {\n    return objectKeys(intersectionEntryMap).reduce(\n      (list: number[], slideIndex) =\u003e {\n        const index = parseInt(slideIndex)\n        const { isIntersecting } = intersectionEntryMap[index]\n        const inViewMatch = inView \u0026\u0026 isIntersecting\n        const notInViewMatch = !inView \u0026\u0026 !isIntersecting\n\n        if (inViewMatch || notInViewMatch) list.push(index)\n        return list\n      },\n      []\n    )\n  }\n\n  function get(inView: boolean = true): number[] {\n    if (inView \u0026\u0026 inViewCache) return inViewCache\n    if (!inView \u0026\u0026 notInViewCache) return notInViewCache\n\n    const slideIndexes = createInViewList(inView)\n\n    if (inView) inViewCache = slideIndexes\n    if (!inView) notInViewCache = slideIndexes\n\n    return slideIndexes\n  }\n\n  const self: SlidesInViewType = {\n    init,\n    destroy,\n    get\n  }\n\n  return self\n}\n","import { AxisType } from './Axis'\nimport { NodeRectType } from './NodeRects'\nimport { arrayIsLastIndex, arrayLast, mathAbs, WindowType } from './utils'\n\nexport type SlideSizesType = {\n  slideSizes: number[]\n  slideSizesWithGaps: number[]\n  startGap: number\n  endGap: number\n}\n\nexport function SlideSizes(\n  axis: AxisType,\n  containerRect: NodeRectType,\n  slideRects: NodeRectType[],\n  slides: HTMLElement[],\n  readEdgeGap: boolean,\n  ownerWindow: WindowType\n): SlideSizesType {\n  const { measureSize, startEdge, endEdge } = axis\n  const withEdgeGap = slideRects[0] \u0026\u0026 readEdgeGap\n  const startGap = measureStartGap()\n  const endGap = measureEndGap()\n  const slideSizes = slideRects.map(measureSize)\n  const slideSizesWithGaps = measureWithGaps()\n\n  function measureStartGap(): number {\n    if (!withEdgeGap) return 0\n    const slideRect = slideRects[0]\n    return mathAbs(containerRect[startEdge] - slideRect[startEdge])\n  }\n\n  function measureEndGap(): number {\n    if (!withEdgeGap) return 0\n    const style = ownerWindow.getComputedStyle(arrayLast(slides))\n    return parseFloat(style.getPropertyValue(`margin-${endEdge}`))\n  }\n\n  function measureWithGaps(): number[] {\n    return slideRects\n      .map((rect, index, rects) =\u003e {\n        const isFirst = !index\n        const isLast = arrayIsLastIndex(rects, index)\n        if (isFirst) return slideSizes[index] + startGap\n        if (isLast) return slideSizes[index] + endGap\n        return rects[index + 1][startEdge] - rect[startEdge]\n      })\n      .map(mathAbs)\n  }\n\n  const self: SlideSizesType = {\n    slideSizes,\n    slideSizesWithGaps,\n    startGap,\n    endGap\n  }\n  return self\n}\n","import { AxisType } from './Axis'\nimport { NodeRectType } from './NodeRects'\nimport {\n  arrayKeys,\n  arrayLast,\n  arrayLastIndex,\n  isNumber,\n  mathAbs\n} from './utils'\n\nexport type SlidesToScrollOptionType = 'auto' | number\n\nexport type SlidesToScrollType = {\n  groupSlides: \u003cType\u003e(array: Type[]) =\u003e Type[][]\n}\n\nexport function SlidesToScroll(\n  axis: AxisType,\n  viewSize: number,\n  slidesToScroll: SlidesToScrollOptionType,\n  loop: boolean,\n  containerRect: NodeRectType,\n  slideRects: NodeRectType[],\n  startGap: number,\n  endGap: number,\n  pixelTolerance: number\n): SlidesToScrollType {\n  const { startEdge, endEdge, direction } = axis\n  const groupByNumber = isNumber(slidesToScroll)\n\n  function byNumber\u003cType\u003e(array: Type[], groupSize: number): Type[][] {\n    return arrayKeys(array)\n      .filter((i) =\u003e i % groupSize === 0)\n      .map((i) =\u003e array.slice(i, i + groupSize))\n  }\n\n  function bySize\u003cType\u003e(array: Type[]): Type[][] {\n    if (!array.length) return []\n\n    return arrayKeys(array)\n      .reduce((groups: number[], rectB, index) =\u003e {\n        const rectA = arrayLast(groups) || 0\n        const isFirst = rectA === 0\n        const isLast = rectB === arrayLastIndex(array)\n\n        const edgeA = containerRect[startEdge] - slideRects[rectA][startEdge]\n        const edgeB = containerRect[startEdge] - slideRects[rectB][endEdge]\n        const gapA = !loop \u0026\u0026 isFirst ? direction(startGap) : 0\n        const gapB = !loop \u0026\u0026 isLast ? direction(endGap) : 0\n        const chunkSize = mathAbs(edgeB - gapB - (edgeA + gapA))\n\n        if (index \u0026\u0026 chunkSize \u003e viewSize + pixelTolerance) groups.push(rectB)\n        if (isLast) groups.push(array.length)\n        return groups\n      }, [])\n      .map((currentSize, index, groups) =\u003e {\n        const previousSize = Math.max(groups[index - 1] || 0)\n        return array.slice(previousSize, currentSize)\n      })\n  }\n\n  function groupSlides\u003cType\u003e(array: Type[]): Type[][] {\n    return groupByNumber ? byNumber(array, slidesToScroll) : bySize(array)\n  }\n\n  const self: SlidesToScrollType = {\n    groupSlides\n  }\n  return self\n}\n","import { Alignment } from './Alignment'\nimport {\n  Animations,\n  AnimationsType,\n  AnimationsUpdateType,\n  AnimationsRenderType\n} from './Animations'\nimport { Axis, AxisType } from './Axis'\nimport { Counter, CounterType } from './Counter'\nimport { DragHandler, DragHandlerType } from './DragHandler'\nimport { DragTracker } from './DragTracker'\nimport { EventHandlerType } from './EventHandler'\nimport { EventStore, EventStoreType } from './EventStore'\nimport { LimitType } from './Limit'\nimport { NodeRectType, NodeRects } from './NodeRects'\nimport { OptionsType } from './Options'\nimport { PercentOfView, PercentOfViewType } from './PercentOfView'\nimport { ResizeHandler, ResizeHandlerType } from './ResizeHandler'\nimport { ScrollBody, ScrollBodyType } from './ScrollBody'\nimport { ScrollBounds, ScrollBoundsType } from './ScrollBounds'\nimport { ScrollContain } from './ScrollContain'\nimport { ScrollLimit } from './ScrollLimit'\nimport { ScrollLooper, ScrollLooperType } from './ScrollLooper'\nimport { ScrollProgress, ScrollProgressType } from './ScrollProgress'\nimport { ScrollSnaps } from './ScrollSnaps'\nimport { SlideRegistry, SlideRegistryType } from './SlideRegistry'\nimport { ScrollTarget, ScrollTargetType } from './ScrollTarget'\nimport { ScrollTo, ScrollToType } from './ScrollTo'\nimport { SlideFocus, SlideFocusType } from './SlideFocus'\nimport { SlideLooper, SlideLooperType } from './SlideLooper'\nimport { SlidesHandler, SlidesHandlerType } from './SlidesHandler'\nimport { SlidesInView, SlidesInViewType } from './SlidesInView'\nimport { SlideSizes } from './SlideSizes'\nimport { SlidesToScroll, SlidesToScrollType } from './SlidesToScroll'\nimport { Translate, TranslateType } from './Translate'\nimport { arrayKeys, arrayLast, arrayLastIndex, WindowType } from './utils'\nimport { Vector1D, Vector1DType } from './Vector1d'\n\nexport type EngineType = {\n  ownerDocument: Document\n  ownerWindow: WindowType\n  eventHandler: EventHandlerType\n  axis: AxisType\n  animation: AnimationsType\n  scrollBounds: ScrollBoundsType\n  scrollLooper: ScrollLooperType\n  scrollProgress: ScrollProgressType\n  index: CounterType\n  indexPrevious: CounterType\n  limit: LimitType\n  location: Vector1DType\n  offsetLocation: Vector1DType\n  previousLocation: Vector1DType\n  options: OptionsType\n  percentOfView: PercentOfViewType\n  scrollBody: ScrollBodyType\n  dragHandler: DragHandlerType\n  eventStore: EventStoreType\n  slideLooper: SlideLooperType\n  slidesInView: SlidesInViewType\n  slidesToScroll: SlidesToScrollType\n  target: Vector1DType\n  translate: TranslateType\n  resizeHandler: ResizeHandlerType\n  slidesHandler: SlidesHandlerType\n  scrollTo: ScrollToType\n  scrollTarget: ScrollTargetType\n  scrollSnapList: number[]\n  scrollSnaps: number[]\n  slideIndexes: number[]\n  slideFocus: SlideFocusType\n  slideRegistry: SlideRegistryType['slideRegistry']\n  containerRect: NodeRectType\n  slideRects: NodeRectType[]\n}\n\nexport function Engine(\n  root: HTMLElement,\n  container: HTMLElement,\n  slides: HTMLElement[],\n  ownerDocument: Document,\n  ownerWindow: WindowType,\n  options: OptionsType,\n  eventHandler: EventHandlerType\n): EngineType {\n  // Options\n  const {\n    align,\n    axis: scrollAxis,\n    direction,\n    startIndex,\n    loop,\n    duration,\n    dragFree,\n    dragThreshold,\n    inViewThreshold,\n    slidesToScroll: groupSlides,\n    skipSnaps,\n    containScroll,\n    watchResize,\n    watchSlides,\n    watchDrag,\n    watchFocus\n  } = options\n\n  // Measurements\n  const pixelTolerance = 2\n  const nodeRects = NodeRects()\n  const containerRect = nodeRects.measure(container)\n  const slideRects = slides.map(nodeRects.measure)\n  const axis = Axis(scrollAxis, direction)\n  const viewSize = axis.measureSize(containerRect)\n  const percentOfView = PercentOfView(viewSize)\n  const alignment = Alignment(align, viewSize)\n  const containSnaps = !loop \u0026\u0026 !!containScroll\n  const readEdgeGap = loop || !!containScroll\n  const { slideSizes, slideSizesWithGaps, startGap, endGap } = SlideSizes(\n    axis,\n    containerRect,\n    slideRects,\n    slides,\n    readEdgeGap,\n    ownerWindow\n  )\n  const slidesToScroll = SlidesToScroll(\n    axis,\n    viewSize,\n    groupSlides,\n    loop,\n    containerRect,\n    slideRects,\n    startGap,\n    endGap,\n    pixelTolerance\n  )\n  const { snaps, snapsAligned } = ScrollSnaps(\n    axis,\n    alignment,\n    containerRect,\n    slideRects,\n    slidesToScroll\n  )\n  const contentSize = -arrayLast(snaps) + arrayLast(slideSizesWithGaps)\n  const { snapsContained, scrollContainLimit } = ScrollContain(\n    viewSize,\n    contentSize,\n    snapsAligned,\n    containScroll,\n    pixelTolerance\n  )\n  const scrollSnaps = containSnaps ? snapsContained : snapsAligned\n  const { limit } = ScrollLimit(contentSize, scrollSnaps, loop)\n\n  // Indexes\n  const index = Counter(arrayLastIndex(scrollSnaps), startIndex, loop)\n  const indexPrevious = index.clone()\n  const slideIndexes = arrayKeys(slides)\n\n  // Animation\n  const update: AnimationsUpdateType = ({\n    dragHandler,\n    scrollBody,\n    scrollBounds,\n    options: { loop }\n  }) =\u003e {\n    if (!loop) scrollBounds.constrain(dragHandler.pointerDown())\n    scrollBody.seek()\n  }\n\n  const render: AnimationsRenderType = (\n    {\n      scrollBody,\n      translate,\n      location,\n      offsetLocation,\n      previousLocation,\n      scrollLooper,\n      slideLooper,\n      dragHandler,\n      animation,\n      eventHandler,\n      scrollBounds,\n      options: { loop }\n    },\n    alpha\n  ) =\u003e {\n    const shouldSettle = scrollBody.settled()\n    const withinBounds = !scrollBounds.shouldConstrain()\n    const hasSettled = loop ? shouldSettle : shouldSettle \u0026\u0026 withinBounds\n    const hasSettledAndIdle = hasSettled \u0026\u0026 !dragHandler.pointerDown()\n\n    if (hasSettledAndIdle) animation.stop()\n\n    const interpolatedLocation =\n      location.get() * alpha + previousLocation.get() * (1 - alpha)\n\n    offsetLocation.set(interpolatedLocation)\n\n    if (loop) {\n      scrollLooper.loop(scrollBody.direction())\n      slideLooper.loop()\n    }\n\n    translate.to(offsetLocation.get())\n\n    if (hasSettledAndIdle) eventHandler.emit('settle')\n    if (!hasSettled) eventHandler.emit('scroll')\n  }\n\n  const animation = Animations(\n    ownerDocument,\n    ownerWindow,\n    () =\u003e update(engine),\n    (alpha: number) =\u003e render(engine, alpha)\n  )\n\n  // Shared\n  const friction = 0.68\n  const startLocation = scrollSnaps[index.get()]\n  const location = Vector1D(startLocation)\n  const previousLocation = Vector1D(startLocation)\n  const offsetLocation = Vector1D(startLocation)\n  const target = Vector1D(startLocation)\n  const scrollBody = ScrollBody(\n    location,\n    offsetLocation,\n    previousLocation,\n    target,\n    duration,\n    friction\n  )\n  const scrollTarget = ScrollTarget(\n    loop,\n    scrollSnaps,\n    contentSize,\n    limit,\n    target\n  )\n  const scrollTo = ScrollTo(\n    animation,\n    index,\n    indexPrevious,\n    scrollBody,\n    scrollTarget,\n    target,\n    eventHandler\n  )\n  const scrollProgress = ScrollProgress(limit)\n  const eventStore = EventStore()\n  const slidesInView = SlidesInView(\n    container,\n    slides,\n    eventHandler,\n    inViewThreshold\n  )\n  const { slideRegistry } = SlideRegistry(\n    containSnaps,\n    containScroll,\n    scrollSnaps,\n    scrollContainLimit,\n    slidesToScroll,\n    slideIndexes\n  )\n  const slideFocus = SlideFocus(\n    root,\n    slides,\n    slideRegistry,\n    scrollTo,\n    scrollBody,\n    eventStore,\n    eventHandler,\n    watchFocus\n  )\n\n  // Engine\n  const engine: EngineType = {\n    ownerDocument,\n    ownerWindow,\n    eventHandler,\n    containerRect,\n    slideRects,\n    animation,\n    axis,\n    dragHandler: DragHandler(\n      axis,\n      root,\n      ownerDocument,\n      ownerWindow,\n      target,\n      DragTracker(axis, ownerWindow),\n      location,\n      animation,\n      scrollTo,\n      scrollBody,\n      scrollTarget,\n      index,\n      eventHandler,\n      percentOfView,\n      dragFree,\n      dragThreshold,\n      skipSnaps,\n      friction,\n      watchDrag\n    ),\n    eventStore,\n    percentOfView,\n    index,\n    indexPrevious,\n    limit,\n    location,\n    offsetLocation,\n    previousLocation,\n    options,\n    resizeHandler: ResizeHandler(\n      container,\n      eventHandler,\n      ownerWindow,\n      slides,\n      axis,\n      watchResize,\n      nodeRects\n    ),\n    scrollBody,\n    scrollBounds: ScrollBounds(\n      limit,\n      offsetLocation,\n      target,\n      scrollBody,\n      percentOfView\n    ),\n    scrollLooper: ScrollLooper(contentSize, limit, offsetLocation, [\n      location,\n      offsetLocation,\n      previousLocation,\n      target\n    ]),\n    scrollProgress,\n    scrollSnapList: scrollSnaps.map(scrollProgress.get),\n    scrollSnaps,\n    scrollTarget,\n    scrollTo,\n    slideLooper: SlideLooper(\n      axis,\n      viewSize,\n      contentSize,\n      slideSizes,\n      slideSizesWithGaps,\n      snaps,\n      scrollSnaps,\n      offsetLocation,\n      slides\n    ),\n    slideFocus,\n    slidesHandler: SlidesHandler(container, eventHandler, watchSlides),\n    slidesInView,\n    slideIndexes,\n    slideRegistry,\n    slidesToScroll,\n    target,\n    translate: Translate(axis, container)\n  }\n\n  return engine\n}\n","import { EmblaCarouselType } from './EmblaCarousel'\n\ntype CallbackType = (emblaApi: EmblaCarouselType, evt: EmblaEventType) =\u003e void\ntype ListenersType = Partial\u003c{ [key in EmblaEventType]: CallbackType[] }\u003e\n\nexport type EmblaEventType = EmblaEventListType[keyof EmblaEventListType]\n\nexport interface EmblaEventListType {\n  init: 'init'\n  pointerDown: 'pointerDown'\n  pointerUp: 'pointerUp'\n  slidesChanged: 'slidesChanged'\n  slidesInView: 'slidesInView'\n  scroll: 'scroll'\n  select: 'select'\n  settle: 'settle'\n  destroy: 'destroy'\n  reInit: 'reInit'\n  resize: 'resize'\n  slideFocusStart: 'slideFocusStart'\n  slideFocus: 'slideFocus'\n}\n\nexport type EventHandlerType = {\n  init: (emblaApi: EmblaCarouselType) =\u003e void\n  emit: (evt: EmblaEventType) =\u003e EventHandlerType\n  on: (evt: EmblaEventType, cb: CallbackType) =\u003e EventHandlerType\n  off: (evt: EmblaEventType, cb: CallbackType) =\u003e EventHandlerType\n  clear: () =\u003e void\n}\n\nexport function EventHandler(): EventHandlerType {\n  let listeners: ListenersType = {}\n  let api: EmblaCarouselType\n\n  function init(emblaApi: EmblaCarouselType): void {\n    api = emblaApi\n  }\n\n  function getListeners(evt: EmblaEventType): CallbackType[] {\n    return listeners[evt] || []\n  }\n\n  function emit(evt: EmblaEventType): EventHandlerType {\n    getListeners(evt).forEach((e) =\u003e e(api, evt))\n    return self\n  }\n\n  function on(evt: EmblaEventType, cb: CallbackType): EventHandlerType {\n    listeners[evt] = getListeners(evt).concat([cb])\n    return self\n  }\n\n  function off(evt: EmblaEventType, cb: CallbackType): EventHandlerType {\n    listeners[evt] = getListeners(evt).filter((e) =\u003e e !== cb)\n    return self\n  }\n\n  function clear(): void {\n    listeners = {}\n  }\n\n  const self: EventHandlerType = {\n    init,\n    emit,\n    off,\n    on,\n    clear\n  }\n  return self\n}\n","import { AlignmentOptionType } from './Alignment'\nimport { AxisDirectionOptionType, AxisOptionType } from './Axis'\nimport { SlidesToScrollOptionType } from './SlidesToScroll'\nimport { ScrollContainOptionType } from './ScrollContain'\nimport { DragHandlerOptionType } from './DragHandler'\nimport { ResizeHandlerOptionType } from './ResizeHandler'\nimport { SlidesHandlerOptionType } from './SlidesHandler'\nimport { SlidesInViewOptionsType } from './SlidesInView'\nimport { FocusHandlerOptionType } from './SlideFocus'\n\nexport type LooseOptionsType = {\n  [key: string]: unknown\n}\n\nexport type CreateOptionsType\u003cType extends LooseOptionsType\u003e = Type \u0026 {\n  active: boolean\n  breakpoints: {\n    [key: string]: Omit\u003cPartial\u003cCreateOptionsType\u003cType\u003e\u003e, 'breakpoints'\u003e\n  }\n}\n\nexport type OptionsType = CreateOptionsType\u003c{\n  align: AlignmentOptionType\n  axis: AxisOptionType\n  container: string | HTMLElement | null\n  slides: string | HTMLElement[] | NodeListOf\u003cHTMLElement\u003e | null\n  containScroll: ScrollContainOptionType\n  direction: AxisDirectionOptionType\n  slidesToScroll: SlidesToScrollOptionType\n  dragFree: boolean\n  dragThreshold: number\n  inViewThreshold: SlidesInViewOptionsType\n  loop: boolean\n  skipSnaps: boolean\n  duration: number\n  startIndex: number\n  watchDrag: DragHandlerOptionType\n  watchResize: ResizeHandlerOptionType\n  watchSlides: SlidesHandlerOptionType\n  watchFocus: FocusHandlerOptionType\n}\u003e\n\nexport const defaultOptions: OptionsType = {\n  align: 'center',\n  axis: 'x',\n  container: null,\n  slides: null,\n  containScroll: 'trimSnaps',\n  direction: 'ltr',\n  slidesToScroll: 1,\n  inViewThreshold: 0,\n  breakpoints: {},\n  dragFree: false,\n  dragThreshold: 10,\n  loop: false,\n  skipSnaps: false,\n  duration: 25,\n  startIndex: 0,\n  active: true,\n  watchDrag: true,\n  watchResize: true,\n  watchSlides: true,\n  watchFocus: true\n}\n\nexport type EmblaOptionsType = Partial\u003cOptionsType\u003e\n","import { LooseOptionsType, CreateOptionsType } from './Options'\nimport { objectKeys, objectsMergeDeep, WindowType } from './utils'\n\ntype OptionsType = Partial\u003cCreateOptionsType\u003cLooseOptionsType\u003e\u003e\n\nexport type OptionsHandlerType = {\n  mergeOptions: \u003cTypeA extends OptionsType, TypeB extends OptionsType\u003e(\n    optionsA: TypeA,\n    optionsB?: TypeB\n  ) =\u003e TypeA\n  optionsAtMedia: \u003cType extends OptionsType\u003e(options: Type) =\u003e Type\n  optionsMediaQueries: (optionsList: OptionsType[]) =\u003e MediaQueryList[]\n}\n\nexport function OptionsHandler(ownerWindow: WindowType): OptionsHandlerType {\n  function mergeOptions\u003cTypeA extends OptionsType, TypeB extends OptionsType\u003e(\n    optionsA: TypeA,\n    optionsB?: TypeB\n  ): TypeA {\n    return \u003cTypeA\u003eobjectsMergeDeep(optionsA, optionsB || {})\n  }\n\n  function optionsAtMedia\u003cType extends OptionsType\u003e(options: Type): Type {\n    const optionsAtMedia = options.breakpoints || {}\n    const matchedMediaOptions = objectKeys(optionsAtMedia)\n      .filter((media) =\u003e ownerWindow.matchMedia(media).matches)\n      .map((media) =\u003e optionsAtMedia[media])\n      .reduce((a, mediaOption) =\u003e mergeOptions(a, mediaOption), {})\n\n    return mergeOptions(options, matchedMediaOptions)\n  }\n\n  function optionsMediaQueries(optionsList: OptionsType[]): MediaQueryList[] {\n    return optionsList\n      .map((options) =\u003e objectKeys(options.breakpoints || {}))\n      .reduce((acc, mediaQueries) =\u003e acc.concat(mediaQueries), [])\n      .map(ownerWindow.matchMedia)\n  }\n\n  const self: OptionsHandlerType = {\n    mergeOptions,\n    optionsAtMedia,\n    optionsMediaQueries\n  }\n  return self\n}\n","import { EmblaCarouselType } from './EmblaCarousel'\nimport { OptionsHandlerType } from './OptionsHandler'\nimport { EmblaPluginsType, EmblaPluginType } from './Plugins'\n\nexport type PluginsHandlerType = {\n  init: (\n    emblaApi: EmblaCarouselType,\n    plugins: EmblaPluginType[]\n  ) =\u003e EmblaPluginsType\n  destroy: () =\u003e void\n}\n\nexport function PluginsHandler(\n  optionsHandler: OptionsHandlerType\n): PluginsHandlerType {\n  let activePlugins: EmblaPluginType[] = []\n\n  function init(\n    emblaApi: EmblaCarouselType,\n    plugins: EmblaPluginType[]\n  ): EmblaPluginsType {\n    activePlugins = plugins.filter(\n      ({ options }) =\u003e optionsHandler.optionsAtMedia(options).active !== false\n    )\n    activePlugins.forEach((plugin) =\u003e plugin.init(emblaApi, optionsHandler))\n\n    return plugins.reduce(\n      (map, plugin) =\u003e Object.assign(map, { [plugin.name]: plugin }),\n      {}\n    )\n  }\n\n  function destroy(): void {\n    activePlugins = activePlugins.filter((plugin) =\u003e plugin.destroy())\n  }\n\n  const self: PluginsHandlerType = {\n    init,\n    destroy\n  }\n  return self\n}\n","import { Engine, EngineType } from './Engine'\nimport { EventStore } from './EventStore'\nimport { EventHandler, EventHandlerType } from './EventHandler'\nimport { defaultOptions, EmblaOptionsType, OptionsType } from './Options'\nimport { OptionsHandler } from './OptionsHandler'\nimport { PluginsHandler } from './PluginsHandler'\nimport { EmblaPluginsType, EmblaPluginType } from './Plugins'\nimport { isString, WindowType } from './utils'\n\nexport type EmblaCarouselType = {\n  canScrollNext: () =\u003e boolean\n  canScrollPrev: () =\u003e boolean\n  containerNode: () =\u003e HTMLElement\n  internalEngine: () =\u003e EngineType\n  destroy: () =\u003e void\n  off: EventHandlerType['off']\n  on: EventHandlerType['on']\n  emit: EventHandlerType['emit']\n  plugins: () =\u003e EmblaPluginsType\n  previousScrollSnap: () =\u003e number\n  reInit: (options?: EmblaOptionsType, plugins?: EmblaPluginType[]) =\u003e void\n  rootNode: () =\u003e HTMLElement\n  scrollNext: (jump?: boolean) =\u003e void\n  scrollPrev: (jump?: boolean) =\u003e void\n  scrollProgress: () =\u003e number\n  scrollSnapList: () =\u003e number[]\n  scrollTo: (index: number, jump?: boolean) =\u003e void\n  selectedScrollSnap: () =\u003e number\n  slideNodes: () =\u003e HTMLElement[]\n  slidesInView: () =\u003e number[]\n  slidesNotInView: () =\u003e number[]\n}\n\nfunction EmblaCarousel(\n  root: HTMLElement,\n  userOptions?: EmblaOptionsType,\n  userPlugins?: EmblaPluginType[]\n): EmblaCarouselType {\n  const ownerDocument = root.ownerDocument\n  const ownerWindow = \u003cWindowType\u003eownerDocument.defaultView\n  const optionsHandler = OptionsHandler(ownerWindow)\n  const pluginsHandler = PluginsHandler(optionsHandler)\n  const mediaHandlers = EventStore()\n  const eventHandler = EventHandler()\n  const { mergeOptions, optionsAtMedia, optionsMediaQueries } = optionsHandler\n  const { on, off, emit } = eventHandler\n  const reInit = reActivate\n\n  let destroyed = false\n  let engine: EngineType\n  let optionsBase = mergeOptions(defaultOptions, EmblaCarousel.globalOptions)\n  let options = mergeOptions(optionsBase)\n  let pluginList: EmblaPluginType[] = []\n  let pluginApis: EmblaPluginsType\n\n  let container: HTMLElement\n  let slides: HTMLElement[]\n\n  function storeElements(): void {\n    const { container: userContainer, slides: userSlides } = options\n\n    const customContainer = isString(userContainer)\n      ? root.querySelector(userContainer)\n      : userContainer\n    container = \u003cHTMLElement\u003e(customContainer || root.children[0])\n\n    const customSlides = isString(userSlides)\n      ? container.querySelectorAll(userSlides)\n      : userSlides\n    slides = \u003cHTMLElement[]\u003e[].slice.call(customSlides || container.children)\n  }\n\n  function createEngine(options: OptionsType): EngineType {\n    const engine = Engine(\n      root,\n      container,\n      slides,\n      ownerDocument,\n      ownerWindow,\n      options,\n      eventHandler\n    )\n\n    if (options.loop \u0026\u0026 !engine.slideLooper.canLoop()) {\n      const optionsWithoutLoop = Object.assign({}, options, { loop: false })\n      return createEngine(optionsWithoutLoop)\n    }\n    return engine\n  }\n\n  function activate(\n    withOptions?: EmblaOptionsType,\n    withPlugins?: EmblaPluginType[]\n  ): void {\n    if (destroyed) return\n\n    optionsBase = mergeOptions(optionsBase, withOptions)\n    options = optionsAtMedia(optionsBase)\n    pluginList = withPlugins || pluginList\n\n    storeElements()\n\n    engine = createEngine(options)\n\n    optionsMediaQueries([\n      optionsBase,\n      ...pluginList.map(({ options }) =\u003e options)\n    ]).forEach((query) =\u003e mediaHandlers.add(query, 'change', reActivate))\n\n    if (!options.active) return\n\n    engine.translate.to(engine.location.get())\n    engine.animation.init()\n    engine.slidesInView.init()\n    engine.slideFocus.init(self)\n    engine.eventHandler.init(self)\n    engine.resizeHandler.init(self)\n    engine.slidesHandler.init(self)\n\n    if (engine.options.loop) engine.slideLooper.loop()\n    if (container.offsetParent \u0026\u0026 slides.length) engine.dragHandler.init(self)\n\n    pluginApis = pluginsHandler.init(self, pluginList)\n  }\n\n  function reActivate(\n    withOptions?: EmblaOptionsType,\n    withPlugins?: EmblaPluginType[]\n  ): void {\n    const startIndex = selectedScrollSnap()\n    deActivate()\n    activate(mergeOptions({ startIndex }, withOptions), withPlugins)\n    eventHandler.emit('reInit')\n  }\n\n  function deActivate(): void {\n    engine.dragHandler.destroy()\n    engine.eventStore.clear()\n    engine.translate.clear()\n    engine.slideLooper.clear()\n    engine.resizeHandler.destroy()\n    engine.slidesHandler.destroy()\n    engine.slidesInView.destroy()\n    engine.animation.destroy()\n    pluginsHandler.destroy()\n    mediaHandlers.clear()\n  }\n\n  function destroy(): void {\n    if (destroyed) return\n    destroyed = true\n    mediaHandlers.clear()\n    deActivate()\n    eventHandler.emit('destroy')\n    eventHandler.clear()\n  }\n\n  function scrollTo(index: number, jump?: boolean, direction?: number): void {\n    if (!options.active || destroyed) return\n    engine.scrollBody\n      .useBaseFriction()\n      .useDuration(jump === true ? 0 : options.duration)\n    engine.scrollTo.index(index, direction || 0)\n  }\n\n  function scrollNext(jump?: boolean): void {\n    const next = engine.index.add(1).get()\n    scrollTo(next, jump, -1)\n  }\n\n  function scrollPrev(jump?: boolean): void {\n    const prev = engine.index.add(-1).get()\n    scrollTo(prev, jump, 1)\n  }\n\n  function canScrollNext(): boolean {\n    const next = engine.index.add(1).get()\n    return next !== selectedScrollSnap()\n  }\n\n  function canScrollPrev(): boolean {\n    const prev = engine.index.add(-1).get()\n    return prev !== selectedScrollSnap()\n  }\n\n  function scrollSnapList(): number[] {\n    return engine.scrollSnapList\n  }\n\n  function scrollProgress(): number {\n    return engine.scrollProgress.get(engine.offsetLocation.get())\n  }\n\n  function selectedScrollSnap(): number {\n    return engine.index.get()\n  }\n\n  function previousScrollSnap(): number {\n    return engine.indexPrevious.get()\n  }\n\n  function slidesInView(): number[] {\n    return engine.slidesInView.get()\n  }\n\n  function slidesNotInView(): number[] {\n    return engine.slidesInView.get(false)\n  }\n\n  function plugins(): EmblaPluginsType {\n    return pluginApis\n  }\n\n  function internalEngine(): EngineType {\n    return engine\n  }\n\n  function rootNode(): HTMLElement {\n    return root\n  }\n\n  function containerNode(): HTMLElement {\n    return container\n  }\n\n  function slideNodes(): HTMLElement[] {\n    return slides\n  }\n\n  const self: EmblaCarouselType = {\n    canScrollNext,\n    canScrollPrev,\n    containerNode,\n    internalEngine,\n    destroy,\n    off,\n    on,\n    emit,\n    plugins,\n    previousScrollSnap,\n    reInit,\n    rootNode,\n    scrollNext,\n    scrollPrev,\n    scrollProgress,\n    scrollSnapList,\n    scrollTo,\n    selectedScrollSnap,\n    slideNodes,\n    slidesInView,\n    slidesNotInView\n  }\n\n  activate(userOptions, userPlugins)\n  setTimeout(() =\u003e eventHandler.emit('init'), 0)\n  return self\n}\n\ndeclare namespace EmblaCarousel {\n  let globalOptions: EmblaOptionsType | undefined\n}\n\nEmblaCarousel.globalOptions = undefined\n\nexport default EmblaCarousel\n"],"version":3}