@alore/auth-react-ui 1.0.0-alpha → 1.0.2-alpha

package/dist/mjs/machine/index.js

@@ -1,3 +1,4 @@
+// @ts-nocheck
 /* eslint-disable no-unused-vars */
 import { assign, createMachine, interpret, State } from 'xstate';
 const initialContext = {
@@ -14,7 +15,7 @@ const initialContext = {
     RCRPublicKey: undefined,
 };
 export const authMachine = createMachine({
-    /** @xstate-layout N4IgpgJg5mDOIC5QEMCuAXAFgWWQY0wEsA7MAYgCUBRAZSoBUB9AYQHkA5eqgDXoG0ADAF1EoAA4B7WIXSEJxUSAAeiALQBGACwA2bQDoArACYjAZgDsRgQA5tp6+YA0IAJ6JTR9XtPGAnL6NrdT9tIwBfMOc0LFwCEjA9EnxZADdyAEl2dPp0gEEAGXSALSpBESQQSWlZeUUVBA0BbS91a19TdW0DAU1fcw9nNwQDXT1W8wFTAItA+wiojBx8IlJE4mTCNLJM7LzCkr51cvEpGTkFCvrVX3VzPXNzXwEn8xH2o0HETX69Iz6PARafoTXwGeYgaJLOKrDZbah0fjCRRVM61S5qdRNTS-EE3HSaaymGyfBrqeyGIyaQGaVoeayU8KRCGLWIrBKw8g0dIAcXYjAAqgAFMrI041C6geqWbFPHoBHrBYwfVxqR56LrmKndUGYymmcGQ1nxPQcsj5VjczIiioo8V1dy+bFUwJtAzGczaTSUkmaAx6TQeP7WAxaawOWwGlnLY2mgBirAo3NYTEFuRoNAA6gmACLWk7Vc724ZkvSg0xEtraIK3Xwk1Q+f0GTS9QJdIzaR3aSMxaMwvCpBIAdzAACNTMx5KR+xIAE56PCTsD9khQMhsdix9IUbCMDNUABCpkY5st7DzlTFhfRCD+ll+tnUJj+7W0mpJ9NMv3U4wDj6pQW7KE2RNZc0j0YcxwnYgp3QWc9DAABbZBCAAG3SYgxAwMgADUqAodJYwATUYKhsFydJ8hIwpLX3CjskI89bSvSVED+V972aJ9-FMV9NBJB4-U8H8OkpGx1EAo0+wHcDR3HRdpznNIZ0IAAzFwVyoJDUKoFDCCgQgR1QmQXDICB5ASEgUgkABrdko2hdlQKHWSoJguClNU9TiCgTTkJQnS9IMoz0BcBBLIkPBkHFMpGMvNEWIQCsnQMR4+mfHi3xVBB2k-cxvwcX9RIAplDV7RzpIguToKXWDFLAZS1I0rT-N0-TDN0kKyHqmc4LEFCopU2cEJNezgI5GTIPk2q9A8xrvN87TWqCjrQvCyLouEWKC3i5R3BsZLUssbjeJJbiv2Ev8BEeCSypAiqXKmuDEL8owVOQCcIHIXD8KIlh8nIncNyYUjyMooxY1yLbUQlXab18No9CCYETGOzKhkxYx7nyzURKpa6StGmMnImqq3LqhqvKgZh+sIBD2BU9AFpQ17kFM8y1is2yRp7By7s2ZzJuqhSZvqzyV2p5C6YZpmWbC4grPW84YqRG04ph+oOkBRHAU1I6XzRxBv2Cc6Ctxq7fBu3nxsq1yavc0W5qpmmpcZ5qWa6mcernPqBqG7mgKJ+7BbJkWKfF536ddl63rlhWoqVzaVfzaGi01rxrB1750pOrLv01LGLtE-GFh5sbiZtx650ICAUM5Kh8ioZgmHXdhG-oBMobta92z6QxXmCIkbkmdR33Y3xQimSZdHbNpLbL6SUIkfTiDIBEhUYahLRoLgKAFOgKE75jYasT1vHLekbn6IkjAMEkzG0AQ9AEK76QMBxAhGaw58D-m9EX5fEg13IK3Xgh8dr1HvncXUokb62BGHfV4n5Qhek1GGHQoJv5SV-v-EggDa5mgtJkXc2QAASu4Dzjg4K3JuHck4Xm2urQ249-QEhviGfotJb650eJ+BwRJgjNEBH+TB5VsFL1wdXfBSYLQN2PIQs8dCmLgNYn8Lw48Rj2EdCfV4d8XhP2bJ6MkbROiaBEXzMCODiB4PILkbM2FcjsGYFQRg7dGCpnTFmCguZFFqyLJSL0-pQT+BSgJB4pg77NGsGMKYxgRg9BvsEMx41LHWNXjyPkRCMykLcWmGgABpKgDEfEML8QSR+KUvS0kiX8LhQwaRv0RuoPomIng+EJEk4mKTJEJEXpFFCgpkCwFgLZFwNA9Ir03FkGgZD3H5MKXI08YDGE3iJIJAI8MeIn1aLUtQRgxi6Dyt8TUD9ggOA6QvcRVjul-wisgfpgzhlgFGeMsg+5cjMDyUsvxqzfjrMJKEJo2y6x7M6K+IExzARv3MOcsRADrm9LuQMoZIyxlQBXrMgpxF2DJkYDQIUgoExcG8ccehKdu4-L+EGTZgLgwkkxHcT0KVgwmAMFMawNIYUWMudYvQ0g0UZhkJgJFjyTKTPSNMnJ6ZMULKtMUslCUzBawzqYLUFgfCsLvsbZ+IYH4srZaYgmpcf5crhUA3l4yBVYGFSM157zPlyq7gq-h2sVUCFZf0Js9JNV+m1Z0AQer4YGpLgHLBJqJFmr5cQS1QqHk2oxfM7FTA8WCgJRQIlXzyVKsmKqj1GqspGA9I0j0uqb76s5T07l1zIQ0DwDOMAYAV4IhYBwbMuwOAFAFOkSVcyikkqUcskwD9fisoCN+LZtKsr2GxLcCYPgA3svLTc01td-Y1rrQ2sgYqJXxuIieWVfbfHd3bI-Uto7Hw0p2QgZsfp4ZliVCOhdhqQ2iLDVcs11ba31vRbk6VibcX4sJVQYlooSlHqHaeoS47L3XtLK6Odp7H3Bski+ity6EjdVnJunY26f3zL3Qog9oGFUmC8G6B+TR-ATEJHxLKbpPwquMf6hDQbmRGtDah8NK6MMzjIDuxgf7k2pvTQ6o+ECSOGDiRRvoNgVUkjo94AkQ950sdKlbTp3LLHYDAFgCQEAaBgFrsueQq965t27Z44DqsiPH38F4Z+wYPCegBNYEkbTfBPzMB0ZojomiBEXSkzT2nMC6f04Z8Uq96C5DTd26V+GM0Kp6HcHiZJ-BtBPjfVzhI-Q8RmKCN4EYn3IfMRxqxgWdN6YMzVc4tqPnxePoqbwwRx40hsD3cJk7vhRL9QyJsPgej+e5XW9AykwApBXDQO56A2arHClzVT89YW4KGyNsb3kJsoXQLHW5G0hB1Ygcq0s7YoUZVk-mvLvw3VCNsD4DwA2AHLcIKN8bk2PZez0D7dAg0ZzDXm8akregHtPbW5Nrbit5DK0I-K2GTSHCIzdD3W4BhHQ0aGGxOzBJzBBFCIEF0d2JEYQwMKwcs4IA1ftZDx1x8QxeGS2YR07xMco9Yq+fQ-RyN08pGcwrt1kmVoJ+gInJO1ysGwIKBuXBGDSO5LIrkvJGD7pA1DiBo7EY0gZEdwkkxXNmD2b6DOWhIVen1NztTFy4X88FzOUn30CK7vkXt9wKNEZdFCKEJps6nD5o9HshnAkUoFspHjqxs1Kb5EudNiy8sbJ2TYyhpduCQ8rjD8vUH8dweJwp6J9wtgT3NkBGqpHOgIlPFLJiewBbjABhU4Tdj8fg8O1D+HsyM2o9zZr3HlJifvLJ5IKnnbhxM-KMSsGfQj5QSTHhoEAICDgzqhx22PwTRoUm4W6+0OYtu9N-ZrNmPz7it1-X47HvxA+8J120YQfyz7AjDGDUif9I0t3zaI-DsV0F9-CX0Hw-jfl4R45tH-2IrXnABLvKAY-U-dPXbUwS-VOWwKJYMaTJHWwLoU7IYVZO4QvPEVlAtFVL-UA4-V7XqfqT7P2X7WvTvBvJPS5CA4gCHRXSnfbEwL8UEHGV-R0S9SkN0RGIIJHP4HwKsPoL-WAVAPAPAOAWAFSVAFCAg6gWMeEMhd5JxdMFxVgApAjegrPBAdleGMYRLJsSFOBCJG+QwOwajB4FrQPFfP7A-WACQBmQcZAOtd2dcTcbcXFDMZtbMUoETIfOwVoe4FVG4DwCwAQiJKsM+TA3QDoXoIQuw9ABwpwt6MgfkOgRgEhKLbMDMKLZxcGSGHw5ZJHTGfKa9Qo54T3VHHQEFDsbAnwSwcsMEKw8g7lWw+wxwsAd2N5WrfIosHQO8N+Z0MwToFVdrVHOwT8f1XozHHLXAxojvblUAlmD6cgZvSPTmXfIA9TEAyg7yRY3TMAGgugqzJXRACYAke4PoMMZ4EYPOO+JHdzARX0N0N+TwZfJDHnTYhPbYqAXYz6P-HfQA94s3T4sOHYt6JYg4zaI4DQofCYG-THYJJjF0FzL3Hie4WBKwMfeo43N403RbevEE74sEvYwg72Ygr7H7dvffCggkn4-YtaNPWgjPaE5ZOwMwM+AIBwOwf4ZUVHY5BTMkZ4FGMJL-TARwiABI9opIlI5xGgVgWMegLI6gRgXIh3YYMsHEHQB+PGQEZE1HFKfQMMD8DoDOOwSYEUsUiU92G3X6EhDw3IfkegEhVU1krwMwB4R0DoG4O+dsXXZHAtMkX0ZsavWPKk7lUUq3S0pIzo8nZk2AqwRpKYBjTUK47Qb014bwAIJsPKXg2eWY0MgBUgQcbMJ7MQ4XDcLcHcLw7CdIJxTw7wmA68B4dsdUfoKkHUZsW4J-AtMYEMcsR4T0GkRDVjPfYA3BQs4ssbUs+EKgdgbMOs1UyweMpHKsb3ZoKYXRTHUsJslAxBdoBonE1ff7UApYv41vdYwEvE7-cWPYiE3bbo68ekXoJ+anAtdoJpVlJ-Z4J+eGUIDOIIGePAr4k87jd7Mk0gyk0c-EjfKmG8+k-ve8hKbcjzSkDsdsT0R0J-H4NhanAkCwDZL-OtWABtCAa84gFSQgb7BkpmU8tYgE3EtfQi4i0i8iyi8UJmW8hcq6UjJ4AMNlSwOwVzSYP0BwEMSo30SwGwL-Z6VCd2ac2c+chC2Gfo-QQdFGAcso1zRze4DsE0tpJpbE4cjYoEqxaS5mJI604iEGCiZUiGZ0sdX5LQGeNsPoVzVofQV8MMW4bVfEKSt2KMu1VUnQVlOfD0J4-wF8Vy5hSkJ4Owf8N4AysguYrYgkmWJIlY--NvEMyCq8+aPy5ADixS+oaowSI2B4aoh+XUx3R8QwQEQFLzZ8fcwyi8tfUA1K1mECj7ckuiw8g-VqvKgqhshKZoY2fKJ4VlKYNhQSlKQwenLQbA1sgiuAJi3KvyE89K-4xK-MpbJa4gEila1CcEuCs-Z0nWbwC+d1B4Z+JnRKH5XrH054ZsKwRkA86w6k6CkhQcXIRYGigAza7K0Aj6r6rAAa2Mxs30PZdlZMgIXQSYEYlRQkQwIkfoDOAIPzPM-6r4wG769as87q16+YzGz6xYDiqEo4hgxADOYwpAnhFgvLb0hG1lK6ewQUtGl6po5K96omrAEk0C32b7PG9m4EzmoGzAEGsmzQ003Xao6IlpLQO+CwKJf8YJTkzHfrdGj4qxFSbTaEKAWMWcGAbMKKVmHG2iv6jWvQLW9AHWvWmcA2o2sW5OcmhANyvZIkf1J4EwFVT0CJX0X5CwXoXs8MRqs24yi27WlYXW-WsAQ29Adqz2IgvmikrK82y262qOmO-Ko6yA1UppTodUAkAMKwFVPXco1iQo7wUIEJN8qYV4QCgk7kCQJeWuAgk236iC820AhupusAcArOxku8wa2GewQtcsRMjoD0bZa6+oqJRmnwMkHiV+BK9u0OzuxuqAZu8PDqsC-mkOy81e7u3uqPMHfu1U1RdzWwR6ssNXHk9wHibEAQr0HQeDV8L-KANeje3-VuzKkc82t+g+6gvuw4x2zQllc+rUDsDoRmyqxKTwdzZM0FARbNJe5O0Ov+9enurfFvU25ey8tBj+3vQByEweiBSu-Zf1N3RM-obXJpe4KkQI3oNpFKV+9+jB3-LexOgWpK3BPB1hgho+hkoB0lJ2mHH1enBJKsR8ToQShG1W+kS6oxcSdW0OwHVbKmOtT6YgWQO5CgZgCgH67+oyy8lR8WdRhtLRlCHRigB2oRkB1oUjEMEYE5EMPoUuq9GedUQMFpIS9pJRox7TFbExyAMxwgbR3Rnmzq8ClBvx4bR7VR5gUxzRkJix3R6x-tPxOxiTARJx93VxgMO8DZMJOht+ZBn+0OyNQJjR8xyxrDKZGZXDO3RZQq1iToLwZoXQcjZ4c+a65sB4CI+o1pYpoQ8ZCp4J0JvR6M0+lp9UUFDpnKdlH0EdMYTrHwAZnxtmrhqxcp7yeJoJxJsZ3jep-jHFQTQDSzYBofTwZoaZ9p5+TpqdH0cjUsB+fp7xkpwxhi-x2Jlcapr+88+i-7Yx7ySx1Jw9J1LQRrCFVlKkZ4VMydenDM5+MwIpj8RamJoHKAap9hkgnenBj5tF1R4Fwhge0Gp1J86KwU7UFMn0N1J0CRgu7xswOu6CigMAfSWAdAeqQUVAEcXSPAPJJ5HZyppJ-Rv5nqt6x2FltljlmcLlnlwgPlgVhJ8xkF6zDWCR6JMjcsToBA2FtA+FyeOkFKF8HwJliV1lwgdlzl7l3l-llwQV0ZlCEVzhraqCs1qVq1uVhVu1pVpJkm4h9wdp0sGwcMY5LM6l7oUsDwTHZVOwQvU1ymSVi16V2Vm1xV3Z8xp13elqr4xNy1mV61+V21+1vZlCDii-Eloe18O4Wq7oEwJGWGn0MkP0R+gPEwTHRl3x7Ngk3N5Ngtr14tjN3551jG7t81vNlNwttNoVu5Di6AitjWCYOzXSzob3L2n0S534Z8N-HiK6YM0pvenNsd3tz1otn1u5cJ7epO-drt5lo9j11N719N31ol1UiwfwlG74PEaKt0VzJ4GnVpD+HhWN+N75u9-Nk9qdh1i9jhrNo8w9918Dh9gd59-h-vUm85q-PKc+h4FdgUh4Vx6-ejAD4MIDk1zt-7MQWNJ5bkVAMUsgJQdlqKdkBmeqAACgEAAEoyBYOD9KPkVqPaOrdJm3VEZ1VMRn45numqNGtmlnhXmv8+ORUaO6OGPY6OWTQWOZxWPxOuOeOUlFORllOhOmmbwMZROmxxO7n5mspvh2I-x9V5PyOAcwPUlplWAPCd5sAaBGBsBWBswChJmEaVVbgH8JG35dWMQ-hsRn5dAQxIUawuwnO60EPXOZy5zN5xV6AKBcgcgOASIyIKIc74YokiQ77FRPAi8spVAkZYMdAkYPQWxXimr-nnOUvukyBbF7FHFnFXFZkLNT7h7kKstojvgR4qvP5SxcLWhLitBOhF1kuk36pUl8NiFHTyFDwW425aF-Wbw3UfcnLegR8l86VqR-Q+D+43VugmueOFu83Uv6B14Mvt48I948IiudDcLNY4EsPrqNArBH4UEehX8kdkb5uXP2updZE4sTOkXPxz0glWh-vXGNBbg9kkXNQOTOgkCweUvpWEJYBsBdNz3mBzRUjPPvPfP-P8hJmb9n8mV0LLApGqvHwVUAjcLlV9KMEkuXOiLdqmo-JM3cWEhbvpXeVlqfJmoVXji4ZMRolKl6Vj0xuhhVBdAolHhYHHg6iLBruhfWvFu5xee9qJeBesWuqbuefxf2KX2TPOgS90EmU4CQeb6Ghiv87jWtAqw6Gcf9f4JmpsI7lq4GScI8Jbd8vQZX2rAZQdWWehiTA6x2hH59ocZegCQ34LZueUvTL-fdIIAg+JmYffQvB+5UoHNx4XKqvCQ9ldVn4Yluhezve7us+A-c-ws5K5y2AvDX3JhE+iQqRkF3hgg6xxPBIfAmUQwCp2wG-Re+qBeh3zeUuZ-UIpenb7AphfheLNRug2huJ4-yx1RYv1eszvwp+lvF-HXTfInr3heXOz-l-NDgvsQVUTAaWHx9S6x3TEZ-u+heIbghz5+ffP0THS3KTjYCi5xcziJ7llxy7pAOAgVDsmMHaDMo56TmXfn6FBQpR7M2-KYCfznCACOWwAsnCoXlzZgG4gVJrMOh9Ihcb4oIIflYD9DFMmwkfceGSGerNceqIvJbngLAAED8+O3YunAy8qBAA6BaIfntyeZdBJ8yCSGjgPnASAEIfUbTKBylYzgg+c-XXhwNwFyCFBsgIFkexUHig7+Q+XoDoSJASNB0sXJXmoByj78XcTlR4Ewwz4ACtBtcHQRiz0FB8L+OLKJmBA0GyD5BLgpQUm30HnBDByyb4DoCeadAGQ4YHiEPzzhPxc60NceMci-iOC7uqAIijOB2ZMdScsheQowEUK0BvO7cNQqqShbVs2USMCQfYFEFBBvAVKPCsPTVrrN98vgxinz10HKCqKzUQXt4Ov4pd2hRvHtsEPkBW9UOx1GHpYDuAT1UEIXPhPHy6CHZXyt4XrMHXUEuceGLdbfLjX-53dNhADcYdnRM7GkGUZgN0JcUHi2A4hmMCYDSzbD541hfQvXnsJYZbCsGbdJ4b4P2Ep4X26HGxkPmNLuYpgHYZsIGmfC0DmwonSkIuTfjXZEuLQ8aF8NeGb146pJGDusJS7fC+GcceCjt38Ss4Yk48CYqFTiFskVUxgTEAbjGJvNmq-Qn3oCyphhM1BnwlzgyOYApNreO3GkNVU5LXxggiCa6t+EfgqpN+-CYeEDxkFsiwmngq9u8zpF3cpRVjTkfOwdD5wP40NGkMWmd6qAjsW5MjCWkxDBgZBCKFCOyIoCooJk2GOplKnmSQC3uilNArDjVxxcAQc1ZwBAmCrBAy8WgR0FSNYG7DReJos0RaIOY2isUxzADGmiAyn1PRLon0TSD77O9yw7mZ0WXgxK+hjRtyU0boxDG8CVRN4WMd6JT5+ifQZLG+LVVdEZi0hgYrMZYxDFbprRPaAoQ6SdIw9Cxw8YsYmLkzfgn4FgF0emMeFX9nhNYvpHWJeTRkiB6QEgfWXzGloeyRY30V2Nox3hgwz8NMdSEHFyjhxS3E0WOLRShimxAmSMcJjxHtjoii43zCSFir78EkkwAcTIIcJnBvINtaptvCiwphDm0PPEaEG8BA8RK-EAJP6mm7YENxMgw3iuAnZ4BkO57ZkUON8HgTvIkE6CaW2VHi0jBfJfiqFRGCgif2zPLgiYCpAEgwwFVTHIowRHEx4J4vJCWe3P6ojea2LWUbSO3EG8qJfbZCaEJ6IDxvAHoHoDXWMHAoksmyLoLqELxuhJRYHLTOVlCxVZjMdABuE3HMw5hAqsNQJBjGaz9AgeqA-ZFETgSmDMc4khDpJOCwVYws1WN8dFj4x2iD4xwx4I-38CxtOStnOsNeKRzBtbOr4MagZP15GSQslWIzCvDzFoSr8udRGP4C4rGkA8dYcur6CaDBsC0AhTcUxLaGfN0WPzbYdgxZEDCUpBLDkYcJPomda2j-NtuhTDDttaBc+JAnSAzjuhHQ4k-Ft82lF0SImXguCayOykNSlReUwRmk2vC2cX8Fw3iHOg4I3B-Qj4fsaBOrFLcEJUAEWtRKfYwT0pHw1qSl2mmzS2JNEjideChZOg+g9SPspUmcnkhr4-ZUwizlSHkTpIlEjoTNMWBzTp2tEt7M1MYktcrpRvNaZ63YmoSMORYKFmgOqL+J-alXZXh4HczMC4uy5d8ldEXRfY36AuB5MTitypd5KHfGcUFKLB1EKQ8MNMbZmJBZQPQvCeGIClZQTwOUTnGGRIDhlDIEZEAVJNOQ-EeIlJBUp8jYGaCWBww34ASllBuD6Ajc48eKdSG+DQz9aFM4AWL2ulrVFpBjJieTMpmwBqZYso3odS6lMk0Z14R8BnHuDHIZ0yYtnPxDsDaxXgkNVoPhTJnCzZZ8s6acBSamXth2xMGWaLMtmwVlZxLVWQlEfLflkaZfewQMCyhyN7gV0OLpjlV46AhZttEWfDJJx6BCyBAlwhWUUleIFytgINpmTyg+llUJ3BsDFKDCakmUoc2GQ7OQCqMCBsErcfbIjmIzYAhciCeXIgCbSEoZIW4E8zbLwMPe0DXUGr30IdAV27YQWabLDnmzI5lcouTXOg4MTbZ0kMuVTMHlVzEJNcuubDHV4SYcOzwMaRPRO6Oh-ZeFNSc2DmDghiAexeABUESr5iNAolCkG6SsDXYHAQ-PKC0CxnVJmwRovMkkCcgnzsY6oC4qvN77Wc0CkI82ORhio0h2m5aE+ePCH4TxEYrwAGYSFsDjxF0FcIWLVFnHoU+4DjQeN6KvE-jdAioPrFu39G68EFIcBcIgpXCzjkaOIOUHrAyjXVkhJsHGJdGLhsDrChCu2HOFMroRMI6AMheSALSULs4BsZ2pSILimwGF6fC6b-BYXCwz+AUNqMFCGDfTu45C3hb0CoU5x0Y98OhYVDxhiKmFteSRdNFMq0luFUSZRWlFRiCjNRwi+hUXB0U8d9F9sAkhLFpiRw2qxiihSov4WCj4cmis2IwrsUPREFT0ZqFBBYoIRIAbi0xaooEW3A9+t8kRTYvgUBKQ43SMhb7QHgFpYSiqHoABNBnsojc4ldoAGCDz5jWgz8f0LYODBeiXGwKZhJUgfBjVgg1IL-CktdnQ5v+fcT3oEFzQTpleZIFSsEnGCR8LO8I3RRsx5QmjrUTyC0bOImIdL2UXS9VD0r2j+pI2GS14P7n6DNKI0FqQVJMvkX-CB0sy-UvMr4SepL0HQCwGdzOHMCeKzQ0ZS6x5Qfp10MMHqQlkpBzKvQpy1Ptrjyil4mkQCv8pJSc5dIzU3GGZe8uOWfLul5yvvv6EhRukvQKUEYF-jKzGTpJ-kshaCA8YrN2UlfDsK5ihSazywTQT0s4xGV6dBs7U4HBtlnH+51+bORxqFR-msR2CFIb2bZOVTNKLcNc2cePHgKnJ-UWZKNggh-HvAbg2oJsF0BA6b5l4+Y+DKWH8B05-UYYZHAgm7JVgP8Hk3iVznEVr5hCohcQpIWkKXJ8x2hVnAnyrYpYmevJSEUjgBDuhV+rKWIq0USLIB8xSBdzA9TL4Ap1UCCH4I8DvEJ9guOq+5SO2gpGLWlRVXWDVWYE9xwqzvY9CVxQSdZtWpU80hGTaIsx3V8MatnJxQK3oro3pH8Snz7EoJSuX+cciWTAD5jDkuuJmjMAga9An8G81hPpUA52BpVMFT6DWvaW8RYk+HfxJ+X0AMZK6nvC5YtUdlkUKKSENis1BrUgzIFGq3dqYXOXxJ6hWgNpNrwCA68nhKSQxW9GzVflksXoCYoSCoaTo3KLZOAtPC1aWFdVcHFKnlXzFtgVKDXZ4NvwniuVYc3QMdB6HsEgiJ1lvYJXsXdUgjNZsST9jrmgZe07gCBIMiYmKb4Ld1BNAkljSwDPrGeMa0bu7XbBw0bwsCRGru3+C0hbgX+VOhHRtp21Y6JS3FeUpGAfwqlDwO+HrnOL0hPQsUz1DSJa7itKYXddBsfjlXatdCKUFpo5mLqaVuyb8GHChQFIFZ71B+LES8tBZU4Ow-oBwNSE1AbqPQ0jV0k2HUTdBIGti3XikjZE0TLGNGs4kFV-IOMcmPoESJuzCn4yH4moIZmihGYltzNkaw2LRqs0MbnGTGmzs40MDGzF2O7FzcCspX1SgWujGZdVWMEUs5OoICLolBuA05t+ntHKOqk7U9t72k7R9vdLlW3g1NTbBMd+3OWpazqeWRxtQI9AKcqOLgIzhAAs2K0KlNm6pTZy6DRcbA8Od3PMpwEnyCQQ-YmRJh1wgiPAjAmQS0oUXEZG5kjJrEGV8y-dMQ7EN+O6Cfp2rywMgvHgTyJ4oRZx-3M6jgRGB5R2UugIfs6FGmggUYu0wEOSoxE+9ppTMEpWBt6AdhnNu7DRHWGDBOhTtbwZBCnxkFN8c+DJOVUJVY11caktwLoPHzzprb3QSMLQHuy3G+Cz+cq0IO5hB6Y7HilgePr8vabPFegsmozZlIAF1ogBPKrzW4z37zK+Zbk5LdcAbDoDCi42+nDIIXD+DFBnQoISDsp3fAPA9wIID+Wowdhkee5bSWRiiGlpzpoaiiS5wyH1RshHLJrZTuJmu16ktgLDlqV35QJZQN8HXBNWJ3LT6RO1IYe4NnV+RZxbZMYF5R3YrlIaogvfj0B3nEyDcSGo3S8P-qyrKdvC3XKYKrA2AA52m5njOn9lupEemodMXVICbbMYtlO+wLLwDA3BnwTSf1CdyiS7smMJaRBHdpJ13cgxOY8ZPmIECZY7gqYu8RNPk2+DdxBetFEXrkyeAg2VgaYILsfA573dovR8a4JfGx7ptsMYvVlBdwZkV2QZBeoCDAmsSPpNE-MXnlHxpY-1LxIbaXt2nnjjZk+LyXmx8kmSZJSm1VtniujaUNVDcuRt6Ar5sl-gwXRgc6C43sC2pUWjFj3oOU9E+S3QBUFiFaS1hme2Ibfk-QBV-gyJMuy6Rb2unvTeWyE91caVLDKVKij5S9KoGMEfzfQq-OUOWCR3SyzZwA91VrBZmo92ZUQ5LbxFq6egugy5DsnnPDlTzEZU2x-VtKTmvhPAXFL0HqA-1DB8ZoUk0mxFbJvwyDA8iueLyWIlKZMLZP1JdhL56zXagekSnhVql9z85Nc2QZ9H0yaMSlOqe8CRnQr6lOZLBn8UjX1IKhuRiUlrpPLlmRzo5FO3vUVW7JultesNFNRnOxD-dId-BKYIbtLnoG5DQ86uRQeV3mHDYvmVXIXybBhtc42aC7O7V7IaJ-A3B0WYp2pkTY0g3h6g-XMcblLTSuoO+s8BO6WH9CBmrkr3IiBAA */
+    /** #no-spell-check @xstate-layout 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 */
     id: 'authMachine',
     predictableActionArguments: true,
     tsTypes: {},
@@ -23,7 +24,6 @@ export const authMachine = createMachine({
         services: {},
         events: {},
     },
-    context: initialContext,
     states: {
         inactive: {
             on: {
@@ -38,6 +38,7 @@ export const authMachine = createMachine({
             exit: assign({
                 error: () => undefined,
                 sessionId: () => undefined,
+                credentialEmail: () => undefined,
             }),
         },
         active: {
@@ -169,22 +170,29 @@ export const authMachine = createMachine({
                             },
                             initial: 'authScreen',
                             on: {
-                                NEXT: {
-                                    target: '#authMachine.active.login.loginMethodSelection',
-                                    actions: assign({
-                                        googleOtpCode: () => undefined,
-                                        googleUser: () => undefined,
-                                        registerUser: () => undefined,
-                                        sessionId: () => undefined,
-                                        CCRPublicKey: () => undefined,
-                                        RCRPublicKey: () => undefined,
-                                        credentialEmail: (_, event) => event.payload.email,
-                                    }),
-                                },
                                 LOGIN_WITH_WEB3CONNECTOR: '#authMachine.active.web3Connector',
                                 GOOGLE_LOGIN: 'googleLogin',
                                 ADVANCE_TO_PASSWORD: 'inputPassword',
                                 SIGN_IN_WITH_PASSKEY: '#authMachine.active.login.idle.signWithPasskey',
+                                SELECT_PASSWORD_METHOD: [
+                                    {
+                                        target: '#authMachine.active.login.loginMethodSelection',
+                                        actions: assign({
+                                            googleOtpCode: () => undefined,
+                                            googleUser: () => undefined,
+                                            registerUser: () => undefined,
+                                            sessionId: () => undefined,
+                                            CCRPublicKey: () => undefined,
+                                            RCRPublicKey: () => undefined,
+                                        }),
+                                        cond: 'isPasswordAndPasskeyEnabled',
+                                    },
+                                    {
+                                        target: 'retrievingCredentialRCR',
+                                        cond: 'isPasskeyEnabled',
+                                    },
+                                    'retrievingSalt',
+                                ],
                             },
                             exit: assign({
                                 error: () => undefined,
@@ -193,7 +201,6 @@ export const authMachine = createMachine({
                         loginMethodSelection: {
                             on: {
                                 SELECT_PASSWORD: 'retrievingSalt',
-                                START_PASSKEY_LOGIN: '#authMachine.active.login.retrievingCredentialRCR',
                                 BACK: {
                                     target: '#authMachine.active.login',
                                     actions: assign({
@@ -226,14 +233,18 @@ export const authMachine = createMachine({
                         },
                         inputPassword: {
                             on: {
-                                BACK: {
-                                    target: '#authMachine.active.login.loginMethodSelection',
-                                    actions: assign({
-                                        googleUser: () => undefined,
-                                        registerUser: () => undefined,
-                                        error: () => undefined,
-                                    }),
-                                },
+                                BACK: [
+                                    {
+                                        target: '#authMachine.active.login.loginMethodSelection',
+                                        actions: assign({
+                                            googleUser: () => undefined,
+                                            registerUser: () => undefined,
+                                            error: () => undefined,
+                                        }),
+                                        cond: 'isPasskeyEnabled',
+                                    },
+                                    'idle',
+                                ],
                                 COMPLETE_GOOGLE_SIGN_IN: 'verifyingGoogleLogin',
                                 VERIFY_LOGIN: 'verifyingLogin',
                             },
@@ -508,7 +519,7 @@ export const authMachine = createMachine({
                                     }),
                                 },
                                 onError: {
-                                    target: '#authMachine.active.login.retrievingSalt',
+                                    target: 'idle',
                                     actions: assign({
                                         error: (_context, event) => event.data?.error || event.data?.message || event.data,
                                     }),
@@ -518,34 +529,23 @@ export const authMachine = createMachine({
                         signingCredentialRCR: {
                             on: {
                                 FINISH_PASSKEY_LOGIN: '#authMachine.active.login.verifyingRegisterPublicKeyCredential',
-                                BACK: '#authMachine.active.login.loginMethodSelection',
-                                PASSKEY_NOT_SUPPORTED: {
-                                    target: '#authMachine.active.login.loginMethodSelection',
-                                    actions: assign({
-                                        error: (_, event) => event.payload.error,
-                                    }),
-                                },
-                            },
-                        },
-                        retrievingRCR: {
-                            entry: assign({
-                                error: () => undefined,
-                            }),
-                            invoke: {
-                                src: 'startPasskeyAuth',
-                                onDone: {
-                                    target: '#authMachine.active.login.idle.authScreen',
-                                    actions: assign({
-                                        RCRPublicKey: (_context, event) => event.data.requestChallengeResponse,
-                                        sessionId: (_, event) => event.data.sessionId,
-                                    }),
-                                },
-                                onError: {
-                                    target: 'idle',
-                                    actions: assign({
-                                        error: (_context, event) => event.data?.error || event.data?.message || event.data,
-                                    }),
-                                },
+                                BACK: [
+                                    {
+                                        target: '#authMachine.active.login.loginMethodSelection',
+                                        cond: 'isPasswordAndPasskeyEnabled',
+                                    },
+                                    'idle.authScreen',
+                                ],
+                                PASSKEY_NOT_SUPPORTED: [
+                                    {
+                                        target: '#authMachine.active.login.loginMethodSelection',
+                                        actions: assign({
+                                            error: (_, event) => event.payload.error,
+                                        }),
+                                        cond: 'isPasswordAndPasskeyEnabled',
+                                    },
+                                    'idle',
+                                ],
                             },
                         },
                         verifyingRegisterPublicKeyCredential: {
@@ -587,22 +587,14 @@ export const authMachine = createMachine({
                                 ],
                             },
                         },
-                        passkeyGuard: {
-                            after: {
-                                0: {
-                                    target: '#authMachine.active.login.idle.authScreen',
-                                    cond: (context) => !!context.RCRPublicKey,
-                                },
-                                100: { target: 'retrievingRCR' },
-                            },
-                        },
                     },
-                    initial: 'passkeyGuard',
+                    initial: 'idle',
                     on: {
                         SETUP_REGISTER_USER: {
                             target: '.idle',
                             actions: 'setupRegisterUser',
                         },
+                        START_PASSKEY_LOGIN: '.retrievingCredentialRCR',
                     },
                     entry: assign({
                         error: () => undefined,
@@ -667,7 +659,12 @@ export const authMachine = createMachine({
                         },
                         emailValidation: {
                             on: {
-                                VERIFY_EMAIL: 'verifyingEmail',
+                                VERIFY_EMAIL: {
+                                    target: 'verifyingEmail',
+                                    actions: assign({
+                                        registerUser: (_, event) => event.payload?.registerUser,
+                                    }),
+                                },
                                 BACK: {
                                     target: 'idle',
                                     actions: assign({
@@ -680,7 +677,17 @@ export const authMachine = createMachine({
                         verifyingEmail: {
                             invoke: {
                                 src: 'verifyEmail',
-                                onDone: 'registerMethodSelection',
+                                onDone: [
+                                    {
+                                        target: 'registerMethodSelection',
+                                        cond: 'isPasswordAndPasskeyEnabled',
+                                    },
+                                    {
+                                        target: 'retrievingCCR',
+                                        cond: 'isPasskeyEnabled',
+                                    },
+                                    'createPassword',
+                                ],
                                 onError: {
                                     target: 'emailValidation',
                                     actions: assign({
@@ -809,12 +816,16 @@ export const authMachine = createMachine({
                         localCCRSign: {
                             on: {
                                 FINISH_PASSKEY_REGISTER: '#authMachine.active.register.sendingPublicCredential',
-                                PASSKEY_NOT_SUPPORTED: {
-                                    target: '#authMachine.active.register.registerMethodSelection',
-                                    actions: assign({
-                                        error: (_, event) => event.payload.error,
-                                    }),
-                                },
+                                PASSKEY_NOT_SUPPORTED: [
+                                    {
+                                        target: '#authMachine.active.register.registerMethodSelection',
+                                        actions: assign({
+                                            error: (_, event) => event.payload.error,
+                                        }),
+                                        cond: 'isPasswordAndPasskeyEnabled',
+                                    },
+                                    'idle',
+                                ],
                                 BACK: {
                                     target: '#authMachine.active.register.registerMethodSelection',
                                 },
@@ -824,12 +835,6 @@ export const authMachine = createMachine({
                             on: {
                                 FINISH_PASSKEY_AUTH: '#authMachine.active.register.sendingAuthPublicCredential',
                                 BACK_TO_IDLE: '#authMachine.active.register.idle',
-                                PASSKEY_NOT_SUPPORTED: {
-                                    target: '#authMachine.active.register.idle',
-                                    actions: assign({
-                                        error: (_, event) => event.payload.error,
-                                    }),
-                                },
                             },
                         },
                         waitingForRCR: {
@@ -962,7 +967,16 @@ export const authMachine = createMachine({
             initial: 'login',
             on: {
                 RESET: 'inactive',
-                SIGN_UP: '.register',
+                SIGN_UP: [
+                    {
+                        target: '.register',
+                        cond: 'requireEmailVerification',
+                    },
+                    {
+                        target: '.register.retrievingCCR',
+                        cond: 'isPasskeyEnabled',
+                    },
+                ],
                 LOGIN: '.login',
                 FORGOT_PASSWORD: '.forgotPassword',
             },
@@ -1090,6 +1104,7 @@ export const authMachine = createMachine({
             forgeData: () => undefined,
             CCRPublicKey: () => undefined,
             RCRPublicKey: () => undefined,
+            authProviderConfigs: () => undefined,
         }),
     },
 });
@@ -1107,83 +1122,99 @@ if (stateDefinition) {
     // @ts-ignore
     resolvedState = authMachine.resolveState(previousState);
 }
-export const authService = (services) => interpret(authMachine.withConfig({
-    services,
-    guards: {
-        // @ts-ignore
-        isNewUser: (_, event) => !!event.data.isNewUser,
-        forgeClaim: (_, event) => !!event.forgeId,
-        hasHardware2FA: (context, event) => {
-            const { data } = event;
-            const HARDWARE = 1;
+export const authService = (services, context) => {
+    const mergedContext = {
+        ...authMachine.context,
+        ...initialContext,
+        ...context,
+    };
+    return interpret(authMachine.withConfig({
+        services,
+        guards: {
             // @ts-ignore
-            if (data?.active2fa)
+            isNewUser: (_, event) => !!event.data.isNewUser,
+            forgeClaim: (_, event) => !!event.forgeId,
+            hasHardware2FA: (ctx, event) => {
+                const { data } = event;
+                const HARDWARE = 1;
                 // @ts-ignore
-                return data?.active2fa?.find((item) => item?.twoFaTypeId === HARDWARE);
-            return false;
-        },
-        // eslint-disable-next-line arrow-body-style
-        isNewDevice: () => {
-            // TODO removed until next-auth is out
-            return false;
-            // const { data } = event;
-            // // @ts-ignore
-            // if (data?.error?.includes('Invalid device')) {
-            //   return true;
-            // }
-            // return false;
-        },
-        hasSoftware2FA: (_, event) => {
-            const { data } = event;
-            const SOFTWARE = 2;
-            // @ts-ignore
-            if (data?.active2fa)
+                if (data?.active2fa)
+                    // @ts-ignore
+                    return data?.active2fa?.find((item) => item?.twoFaTypeId === HARDWARE);
+                return false;
+            },
+            // eslint-disable-next-line arrow-body-style
+            isNewDevice: () => {
+                // TODO removed until next-auth is out
+                return false;
+                // const { data } = event;
+                // // @ts-ignore
+                // if (data?.error?.includes('Invalid device')) {
+                //   return true;
+                // }
+                // return false;
+            },
+            hasSoftware2FA: (_, event) => {
+                const { data } = event;
+                const SOFTWARE = 2;
                 // @ts-ignore
-                return data?.active2fa?.find((item) => item?.twoFaTypeId === SOFTWARE);
-            return false;
+                if (data?.active2fa)
+                    // @ts-ignore
+                    return data?.active2fa?.find((item) => item?.twoFaTypeId === SOFTWARE);
+                return false;
+            },
+            isPasskeyEnabled: (ctx, _) => !!ctx.authProviderConfigs?.enablePasskeys,
+            isPasswordEnabled: (ctx, _) => !!ctx.authProviderConfigs?.enablePasswords,
+            isPasswordAndPasskeyEnabled: (ctx, _) => !!ctx.authProviderConfigs?.enablePasswords && !!ctx.authProviderConfigs?.enablePasskeys,
+            requireEmailVerification: (ctx, _) => {
+                return !!ctx.authProviderConfigs?.requireEmailVerification;
+            },
+            requireUsername: (ctx, _) => {
+                return !!ctx.authProviderConfigs?.requireUsername;
+            },
         },
-    },
-    actions: {
-        updateAccessToken: assign({
-            sessionUser: (context, event) => ({
-                ...context.sessionUser,
-                accessToken: event.newAccessToken,
+        actions: {
+            updateAccessToken: assign({
+                sessionUser: (ctx, event) => ({
+                    ...ctx.sessionUser,
+                    accessToken: event.newAccessToken,
+                }),
             }),
-        }),
-        setSessionId: assign({
-            sessionId: (_, event) => event.data.sessionId,
-        }),
-        setSessionUser: assign({
-            sessionUser: (_, event) => event.data,
-        }),
-        setupRegisterUser: assign({
-            registerUser: (_, event) => event?.registerUser || undefined,
-        }),
-        clearContext: assign({
-            salt: () => undefined,
-            error: () => undefined,
-            active2fa: () => undefined,
-            registerUser: () => undefined,
-            googleOtpCode: () => undefined,
-            googleUser: () => undefined,
-            sessionUser: () => undefined,
-            forgeData: () => undefined,
-            sessionId: () => undefined,
-            CCRPublicKey: () => undefined,
-            RCRPublicKey: () => undefined,
-        }),
-    },
-}, authMachine.context))
-    .onTransition((state) => {
-    const shouldUpdate = state.changed &&
-        (state.matches('inactive') ||
-            state.matches('active.register.userCreated') ||
-            state.matches('active.login.successfulLogin') ||
-            state.matches('active.web3Connector.emailConfirmed') ||
-            state.matches('active.forgotPassword.passwordSaved'));
-    if (shouldUpdate && typeof window !== 'undefined') {
-        localStorage.setItem('authState', JSON.stringify(state));
-    }
-})
-    .start(resolvedState);
+            setSessionId: assign({
+                sessionId: (_, event) => event.data.sessionId,
+            }),
+            setSessionUser: assign({
+                sessionUser: (_, event) => event.data,
+            }),
+            setupRegisterUser: assign({
+                registerUser: (_, event) => event?.registerUser || undefined,
+            }),
+            clearContext: assign({
+                salt: () => undefined,
+                error: () => undefined,
+                active2fa: () => undefined,
+                registerUser: () => undefined,
+                googleOtpCode: () => undefined,
+                googleUser: () => undefined,
+                sessionUser: () => undefined,
+                forgeData: () => undefined,
+                sessionId: () => undefined,
+                CCRPublicKey: () => undefined,
+                RCRPublicKey: () => undefined,
+            }),
+        },
+    }, mergedContext))
+        .onTransition((state) => {
+        const shouldUpdate = state.changed &&
+            (state.matches('inactive') ||
+                state.matches('active.register.userCreated') ||
+                state.matches('active.login.successfulLogin') ||
+                state.matches('active.web3Connector.emailConfirmed') ||
+                state.matches('active.forgotPassword.passwordSaved'));
+        if (shouldUpdate && typeof window !== 'undefined') {
+            localStorage.setItem('authState', JSON.stringify(state));
+        }
+    })
+        .start(resolvedState);
+};
 //# sourceMappingURL=index.js.map