{"version":3,"sources":["jsdelivr-header.js","/npm/jotai@1.11.2/index.js"],"names":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA,ACNA,aAEA,IAAI,MAAQ,QAAQ,SAChB,QAAU,QAAQ,iBAEtB,SAAS,WAYP,OAXA,SAAW,OAAO,OAAS,OAAO,OAAO,OAAS,SAAU,GAC1D,IAAK,IAAI,EAAI,EAAG,EAAI,UAAU,OAAQ,IAAK,CACzC,IAAI,EAAS,UAAU,GACvB,IAAK,IAAI,KAAO,EACV,OAAO,UAAU,eAAe,KAAK,EAAQ,KAC/C,EAAO,GAAO,EAAO,GAG3B,CACA,OAAO,CACT,EACO,SAAS,MAAM,KAAM,UAC9B,CACA,SAAS,4BAA4B,EAAG,GACtC,GAAK,EAAL,CACA,GAAiB,iBAAN,EAAgB,OAAO,kBAAkB,EAAG,GACvD,IAAI,EAAI,OAAO,UAAU,SAAS,KAAK,GAAG,MAAM,GAAI,GAEpD,MADU,WAAN,GAAkB,EAAE,cAAa,EAAI,EAAE,YAAY,MAC7C,QAAN,GAAqB,QAAN,EAAoB,MAAM,KAAK,GACxC,cAAN,GAAqB,2CAA2C,KAAK,GAAW,kBAAkB,EAAG,QAAzG,CALc,CAMhB,CACA,SAAS,kBAAkB,EAAK,IACnB,MAAP,GAAe,EAAM,EAAI,UAAQ,EAAM,EAAI,QAC/C,IAAK,IAAI,EAAI,EAAG,EAAO,IAAI,MAAM,GAAM,EAAI,EAAK,IAAK,EAAK,GAAK,EAAI,GACnE,OAAO,CACT,CACA,SAAS,gCAAgC,EAAG,GAC1C,IAAI,EAAuB,oBAAX,QAA0B,EAAE,OAAO,WAAa,EAAE,cAClE,GAAI,EAAI,OAAQ,EAAK,EAAG,KAAK,IAAI,KAAK,KAAK,GAC3C,GAAI,MAAM,QAAQ,KAAO,EAAK,4BAA4B,KAAO,GAAkB,GAAyB,iBAAb,EAAE,OAAqB,CAChH,IAAI,EAAI,GACZ,IAAI,EAAI,EACR,OAAO,WACL,OAAI,GAAK,EAAE,OAAe,CACxB,MAAM,GAED,CACL,MAAM,EACN,MAAO,EAAE,KAEb,CACF,CACA,MAAM,IAAI,UAAU,wIACtB,CAEA,IAAI,iBAAmB,SACnB,kBAAoB,SAA2B,GACjD,QAAS,EAAQ,iBACnB,EACI,kCAAoC,SAA2C,GACjF,OAAQ,EAAgB,kBAAkB,CAC5C,EACI,sBAAwB,SAA+B,GACzD,IAIM,EAJF,EAAwB,EAAgB,kBAC1C,EAAc,EAAsB,EACpC,EAAgB,EAAsB,EACpC,IAEF,IAC6D,OAA5D,EAAuB,gBAAgB,IAAI,KAAiC,IAEjF,EACI,uBAAyB,SAAS,EAAuB,EAAoB,GAC/E,IAAI,EAAqB,EAAmB,kBAAkB,EAC1D,EAAqB,EAAmB,kBAAkB,EAC9D,OAAO,IAAuB,GAAsB,IAAuB,GAAsB,kBAAkB,IAAuB,EAAuB,EAAoB,EACvL,EACI,sBAAwB,SAA+B,EAAa,GACtE,IAAI,EAAuB,CACzB,EAAG,EACH,EAAG,EACH,EAAG,MAED,EAAkB,IAAI,SAAQ,SAAU,GAC1C,EAAqB,EAAI,WACvB,EAAqB,EAAI,KACzB,GACF,EACA,EAAQ,QAAQ,EAAqB,EACvC,IAEA,OADA,EAAgB,kBAAoB,EAC7B,CACT,EACI,oBAAsB,SAA6B,GACrD,OAAO,sBAAsB,EAAgB,kBAAkB,EAAG,EAAgB,kBAAkB,EACtG,EACI,gBAAkB,IAAI,QACtB,qBAAuB,SAA8B,EAAa,GACpE,gBAAgB,IAAI,EAAa,EACnC,EAEI,gBAAkB,SAAyB,GAC7C,MAAO,SAAU,CACnB,EACI,UAAY,IACZ,WAAa,IACb,YAAc,IACd,eAAiB,IACjB,cAAgB,IAChB,oBAAsB,IACtB,sBAAwB,IACxB,mBAAqB,IACrB,gBAAkB,IAClB,YAAc,SAAqB,GACrC,IAAI,EAIA,EACA,EAJA,EAAwB,IAAI,QAC5B,EAAa,IAAI,QACjB,EAAa,IAAI,IAOrB,GAJ6B,eAAzB,QAAQ,IAAI,WACd,EAAiB,IAAI,IACrB,EAAe,IAAI,KAEjB,EACF,IAAK,IAAgE,EAA5D,EAAY,gCAAgC,KAAyB,EAAQ,KAAa,MAAO,CACxG,IAAI,EAAc,EAAM,MACtB,EAAO,EAAY,GAEjB,EAAY,CACd,EAFQ,EAAY,GAGpB,EAAG,EACH,GAAG,EACH,EAAG,IAAI,KAEoB,eAAzB,QAAQ,IAAI,WACd,OAAO,OAAO,GACT,gBAAgB,IACnB,QAAQ,KAAK,2EAA4E,IAG7F,EAAsB,IAAI,EAAM,EAClC,CAEF,IAghBM,EAhhBF,EAA0B,IAAI,QA6B9B,EAA2B,IAAI,QAC/B,EAA2B,SAAkC,GAC/D,IAAI,EAAwB,EAAyB,IAAI,GAKzD,OAJK,IACH,EAAwB,IAAI,IAC5B,EAAyB,IAAI,EAAS,IAEjC,CACT,EACI,EAAe,SAAS,EAAa,EAAS,GAChD,GAAI,EAAS,CACX,IAAI,EAAwB,EAAyB,GACjD,EAAa,EAAsB,IAAI,GAU3C,OATK,KACH,EAAa,EAAa,EAAQ,EAAG,KACnB,MAAO,GAAc,kCAAkC,EAAW,KAClF,OAAa,GAEX,GACF,EAAsB,IAAI,EAAM,IAG7B,CACT,CACA,OAAO,EAAsB,IAAI,EACnC,EACI,EAAe,SAAsB,EAAS,EAAM,GAItD,GAH6B,eAAzB,QAAQ,IAAI,UACd,OAAO,OAAO,GAEZ,EAAS,CACiB,EAAyB,GAC/B,IAAI,EAAM,EAClC,KAAO,CACL,IAAI,EAAgB,EAAsB,IAAI,GAC9C,EAAsB,IAAI,EAAM,GAC3B,EAAW,IAAI,IAClB,EAAW,IAAI,EAAM,EAEzB,CACF,EACI,EAAyB,SAAgC,EAAS,EAAsB,GAI1F,QAH6B,IAAzB,IACF,EAAuB,IAAI,MAExB,EACH,OAAO,EAET,IAAI,EAAmB,IAAI,IACvB,GAAU,EASd,OARA,EAAa,SAAQ,SAAU,GAC7B,IAAI,EACA,GAA6D,OAAhD,EAAgB,EAAa,EAAS,SAAiB,EAAS,EAAc,IAAM,EACrG,EAAiB,IAAI,EAAM,GACvB,EAAqB,IAAI,KAAU,IACrC,GAAU,EAEd,IACI,EAAqB,OAAS,EAAiB,MAAS,EAGrD,EAFE,CAGX,EACI,EAAe,SAAsB,EAAS,EAAM,EAAO,EAAc,GAC3E,IAAI,EAAY,EAAa,EAAS,GACtC,GAAI,EAAW,CACb,GAAI,MAAsB,MAAO,KAAe,uBAAuB,EAAU,EAAG,IAClF,OAAO,EAEL,MAAO,GACT,sBAAsB,EAAU,EAEpC,CACA,IAAI,EAAgB,CAClB,EAAG,EACH,GAAiB,MAAb,OAAoB,EAAS,EAAU,IAAM,EACjD,GAAG,EACH,EAAG,EAAuB,EAAsB,MAAb,OAAoB,EAAS,EAAU,EAAG,IAE3E,IAAyB,MAAb,GAAqB,EAAU,GAe/C,OAdK,GAAe,MAAO,GAAe,OAAO,GAAG,EAAU,EAAG,GAMtD,EAAc,IAAM,EAAU,GAAM,EAAc,EAAE,OAAS,EAAU,EAAE,MAAS,MAAM,KAAK,EAAc,EAAE,QAAQ,OAAM,SAAU,GAC9I,OAAO,EAAU,EAAE,IAAI,EACzB,MACE,GAAU,EACV,QAAQ,UAAU,MAAK,WACrB,EAAa,EACf,MAXA,GAAU,IACR,EAAc,EACZ,EAAc,EAAE,IAAI,KACtB,EAAc,EAAI,IAAI,IAAI,EAAc,GAAG,IAAI,EAAM,EAAc,KAUnE,IAAc,EACT,GAET,EAAa,EAAS,EAAM,GACrB,EACT,EACI,EAAmB,SAA0B,EAAS,EAAM,EAAO,EAAc,GACnF,IAAI,EAAY,EAAa,EAAS,GACtC,GAAI,EAAW,CACb,GAAI,MAAsB,MAAO,KAAe,uBAAuB,EAAU,EAAG,IAClF,OAAO,EAEL,MAAO,GACT,sBAAsB,EAAU,EAEpC,CACA,IAAI,EAAgB,CAClB,EAAG,EACH,IAAkB,MAAb,OAAoB,EAAS,EAAU,IAAM,GAAK,EACvD,GAAG,EACH,EAAG,EAAuB,EAAsB,MAAb,OAAoB,EAAS,EAAU,EAAG,IAG/E,OADA,EAAa,EAAS,EAAM,GACrB,CACT,EACI,EAAyB,SAAgC,EAAS,EAAM,EAAiB,GAC3F,IAAI,EAAY,EAAa,EAAS,GACtC,GAAI,GAAa,MAAO,EAAW,CACjC,GAAI,uBAAuB,EAAU,EAAG,KAAqB,kCAAkC,EAAU,GACvG,OAAK,EAAU,EAKR,EAJE,SAAS,CAAC,EAAG,EAAW,CAC7B,GAAG,IAKT,sBAAsB,EAAU,EAClC,EA/J8B,SAAmC,EAAS,EAAM,GAChF,IAAI,EAAQ,EAAwB,IAAI,GACnC,IACH,EAAQ,IAAI,IACZ,EAAwB,IAAI,EAAM,IAEpC,EAAgB,MAAK,WACf,EAAM,IAAI,KAAa,IACzB,EAAM,OAAO,GACR,EAAM,MACT,EAAwB,OAAO,GAGrC,IACA,EAAM,IAAI,EAAS,EACrB,CAiJE,CAA0B,EAAS,EAAM,GACzC,IAAI,EAAgB,CAClB,EAAG,EACH,IAAkB,MAAb,OAAoB,EAAS,EAAU,IAAM,GAAK,EACvD,GAAG,EACH,EAAG,EAAuB,EAAsB,MAAb,OAAoB,EAAS,EAAU,EAAG,IAG/E,OADA,EAAa,EAAS,EAAM,GACrB,CACT,EACI,EAAwB,SAA+B,EAAS,EAAM,EAAgB,GACxF,GAAI,aAA0B,QAAS,CACrC,IAAI,EAAkB,sBAAsB,EAAgB,EAAe,MAAK,SAAU,GACxF,EAAa,EAAS,EAAM,EAAO,EAAc,EACnD,IAAG,OAAM,SAAU,GACjB,GAAI,aAAa,QACf,OAAI,kBAAkB,GACb,EAAE,MAAK,WACZ,EAAc,EAAS,GAAM,EAC/B,IAEK,EAET,EAAiB,EAAS,EAAM,EAAG,EAAc,EACnD,KACA,OAAO,EAAuB,EAAS,EAAM,EAAiB,EAChE,CACA,OAAO,EAAa,EAAS,EAAM,EAAgB,EACrD,EAYI,EAAgB,SAAS,EAAc,EAAS,EAAM,GACxD,IAAK,EAAO,CACV,IAAI,EAAc,EAAa,EAAS,GACxC,GAAI,EAAa,CACf,GAAI,EAAY,GAAK,MAAO,IAAgB,kCAAkC,EAAY,GACxF,OAAO,EAcT,GAZA,EAAY,EAAE,SAAQ,SAAU,EAAG,GACjC,GAAI,IAAM,EACR,GAAK,EAAW,IAAI,GAEb,CACL,IAAI,EAAS,EAAa,EAAS,GAC/B,IAAW,EAAO,GACpB,EAAc,EAAS,EAE3B,MANE,EAAc,EAAS,EAQ7B,IACI,MAAM,KAAK,EAAY,GAAG,OAAM,SAAU,GAC5C,IAAI,EAAI,EAAK,GACX,EAAI,EAAK,GACP,EAAS,EAAa,EAAS,GACnC,OAAO,KAAY,MAAO,IAAW,EAAO,IAAM,CACpD,IACE,OAAK,EAAY,EAKV,EAJE,SAAS,CAAC,EAAG,EAAa,CAC/B,GAAG,GAKX,CACF,CACA,IAAI,EAAe,IAAI,IACvB,IACE,IAAI,EAAiB,EAAK,MAAK,SAAU,GACvC,EAAa,IAAI,GACjB,IAAI,EAAS,IAAM,EAAO,EAAa,EAAS,GAAK,EAAc,EAAS,GAC5E,GAAI,EAAQ,CACV,GAAI,MAAO,EACT,MAAM,EAAO,EAEf,GAAI,MAAO,EACT,MAAM,EAAO,EAEf,OAAO,EAAO,CAChB,CACA,GAAI,gBAAgB,GAClB,OAAO,EAAE,KAEX,MAAM,IAAI,MAAM,eAClB,IACA,OAAO,EAAsB,EAAS,EAAM,EAAgB,EAC9D,CAAE,MAAO,GACP,GAAI,aAA0B,QAAS,CACrC,IAAI,EAAkB,kBAAkB,IAAmB,kCAAkC,GAAkB,oBAAoB,GAAkB,sBAAsB,EAAgB,GAC3L,OAAO,EAAuB,EAAS,EAAM,EAAiB,EAChE,CACA,OAAO,EAAiB,EAAS,EAAM,EAAgB,EACzD,CACF,EACI,EAAW,SAAkB,EAAa,GAE5C,OADgB,EAAc,EAAS,EAEzC,EAQI,EAAiB,SAAwB,EAAM,GACjD,OAAQ,EAAQ,EAAE,QAAU,EAAQ,EAAE,MAA2B,IAAnB,EAAQ,EAAE,MAAc,EAAQ,EAAE,IAAI,GACtF,EAOI,EAAuB,SAAS,EAAqB,EAAS,GAChE,IAAI,EAAU,EAAW,IAAI,GAClB,MAAX,GAA2B,EAAQ,EAAE,SAAQ,SAAU,GACjD,IAAc,KAhGG,SAA4B,EAAS,GAC5D,IAAI,EAAY,EAAa,EAAS,GACtC,GAAI,EAAW,CACb,IAAI,EAAgB,SAAS,CAAC,EAAG,EAAW,CAC1C,GAAG,IAEL,EAAa,EAAS,EAAM,EAC9B,KAAoC,eAAzB,QAAQ,IAAI,UACrB,QAAQ,KAAK,+CAAgD,EAEjE,CAuFM,CAAmB,EAAS,GAC5B,EAAqB,EAAS,GAElC,GACF,EACI,EAAiB,SAAS,EAAe,EAAS,EAAM,GAC1D,IAAI,GAAS,EA0DT,EAAgB,EAAK,OAzDP,SAAS,EAAY,EAAG,GACxC,IAAI,EAAS,EAAc,EAAS,GACpC,GAAI,MAAO,EACT,MAAM,EAAO,EAEf,GAAI,MAAO,EAAQ,CACjB,GAAe,MAAX,GAAmB,EAAQ,iBAC7B,OAAO,EAAO,EAAE,MAAK,WACnB,IAAI,EAAI,EAAa,EAAS,GAC9B,OAAI,GAAK,MAAO,GAAK,EAAE,IAAM,EAAO,EAC3B,IAAI,SAAQ,SAAU,GAC3B,OAAO,WAAW,EACpB,IAAG,MAAK,WACN,OAAO,EAAY,EAAG,EACxB,IAEK,EAAY,EAAG,EACxB,IAKF,KAH6B,eAAzB,QAAQ,IAAI,UACd,QAAQ,KAAK,6EAA8E,GAEvF,EAAO,CACf,CACA,GAAI,MAAO,EACT,OAAO,EAAO,EAKhB,KAH6B,eAAzB,QAAQ,IAAI,UACd,QAAQ,KAAK,sFAAuF,GAEhG,IAAI,MAAM,iBAClB,IACa,SAAgB,EAAG,GAC9B,IAAI,EACJ,GAAI,IAAM,EAAM,CACd,IAAK,gBAAgB,GACnB,MAAM,IAAI,MAAM,qBAElB,IAAI,EA3T4B,SAAyC,GAC7E,IAAI,EAAa,IAAI,IACjB,EAAQ,EAAwB,IAAI,GAQxC,OAPI,IACF,EAAwB,OAAO,GAC/B,EAAM,SAAQ,SAAU,EAAiB,GACvC,sBAAsB,GACtB,EAAW,IAAI,EACjB,KAEK,CACT,CAgTuB,CAAgC,GACjD,EAAW,SAAQ,SAAU,GACvB,IAAqB,GACvB,EAAsB,EAAkB,EAAG,EAE/C,IACoB,EAAa,EAAS,KACtB,EAAsB,EAAS,EAAG,IAEpD,EAAqB,EAAS,EAElC,MACE,EAAgB,EAAe,EAAS,EAAG,GAK7C,OAHK,GACH,EAAa,GAER,CACT,GACoD,GAEpD,OADA,GAAS,EACF,CACT,EACI,EAAY,SAAmB,EAAa,EAAQ,GACtD,IAAI,EAAgB,EAAe,EAAS,EAAa,GAEzD,OADA,EAAa,GACN,CACT,EAII,EAAY,SAAS,EAAU,EAAS,EAAM,GAChD,IAAI,EAAU,CACZ,EAAG,IAAI,IAAI,GAAoB,CAAC,IAChC,EAAG,IAAI,KAiBT,GAfA,EAAW,IAAI,EAAM,GACQ,eAAzB,QAAQ,IAAI,UACd,EAAa,IAAI,GAEH,OAAc,EAAW,GAC/B,EAAE,SAAQ,SAAU,EAAG,GAC/B,IAAI,EAAW,EAAW,IAAI,GAC1B,EACF,EAAS,EAAE,IAAI,GAEX,IAAM,GACR,EAAU,EAAS,EAAG,EAG5B,IAtB2B,SAAgC,GAC3D,QAAS,EAAK,KAChB,CAqBM,CAAuB,IAAS,EAAK,QAAS,CAChD,IAGI,EAAY,EAAK,SAHP,SAAiB,GAC7B,OAAO,EAAU,EAAM,EAAQ,EACjC,IAEA,OAAU,EACN,IACF,EAAQ,EAAI,EAEhB,CACA,OAAO,CACT,EACI,EAAc,SAAS,EAAY,EAAS,GAC9C,IAAI,EACA,EAAwD,OAA3C,EAAkB,EAAW,IAAI,SAAiB,EAAS,EAAgB,EACxF,GACF,IAEF,EAAW,OAAO,GACW,eAAzB,QAAQ,IAAI,UACd,EAAa,OAAO,GAEtB,IAAI,EAAY,EAAa,EAAS,GAClC,GACE,MAAO,GACT,sBAAsB,EAAU,GAElC,EAAU,EAAE,SAAQ,SAAU,EAAG,GAC/B,GAAI,IAAM,EAAM,CACd,IAAI,EAAU,EAAW,IAAI,GACzB,IACF,EAAQ,EAAE,OAAO,GACb,EAAe,EAAG,IACpB,EAAY,EAAS,GAG3B,CACF,KACkC,eAAzB,QAAQ,IAAI,UACrB,QAAQ,KAAK,6CAA8C,EAE/D,EACI,EAAoB,SAA2B,EAAS,EAAM,EAAW,GAC3E,IAAI,EAAe,IAAI,IAAI,EAAU,EAAE,QACf,MAAxB,GAAwC,EAAqB,SAAQ,SAAU,EAAG,GAChF,GAAI,EAAa,IAAI,GACnB,EAAa,OAAO,OADtB,CAIA,IAAI,EAAU,EAAW,IAAI,GACzB,IACF,EAAQ,EAAE,OAAO,GACb,EAAe,EAAG,IACpB,EAAY,EAAS,GALzB,CAQF,IACA,EAAa,SAAQ,SAAU,GAC7B,IAAI,EAAU,EAAW,IAAI,GACzB,EACF,EAAQ,EAAE,IAAI,GACL,EAAW,IAAI,IACxB,EAAU,EAAS,EAAG,EAE1B,GACF,EACI,EAAe,SAAsB,GACvC,GAAI,EAAJ,CAC8B,EAAyB,GAC/B,SAAQ,SAAU,EAAW,GAEjD,GAAI,IADqB,EAAsB,IAAI,GACb,CACpC,IAAI,EAAU,EAAW,IAAI,GAClB,MAAX,GAA2B,EAAQ,EAAE,SAAQ,SAAU,GACrD,OAAO,EAAS,EAClB,GACF,CACF,GAEF,KAZA,CAaA,KAAO,EAAW,MAAM,CACtB,IAAI,EAAU,MAAM,KAAK,GACzB,EAAW,QACX,EAAQ,SAAQ,SAAU,GACxB,IAAI,EAAO,EAAM,GACf,EAAgB,EAAM,GACpB,EAAY,OAAa,EAAW,GAIxC,GAHI,GAAa,EAAU,KAAwB,MAAjB,OAAwB,EAAS,EAAc,IAC/E,OAAkB,EAAW,EAAM,EAA4B,MAAjB,OAAwB,EAAS,EAAc,IAE3F,GAAkB,EAAc,GAAkB,MAAb,IAAqB,EAAU,EAAxE,CAGA,IAAI,EAAU,EAAW,IAAI,GAClB,MAAX,GAA2B,EAAQ,EAAE,SAAQ,SAAU,GACrD,OAAO,GACT,GAJA,CAKF,GACF,CAC6B,eAAzB,QAAQ,IAAI,UACd,EAAe,SAAQ,SAAU,GAC/B,OAAO,GACT,GAvBF,CAyBF,EAaI,EAAa,SAAoB,EAAO,GACtC,GAb4B,SAAqC,GACzC,EAAyB,GAC/B,SAAQ,SAAU,EAAW,GACjD,IAAI,EAAgB,EAAsB,IAAI,KACzC,GAAiB,EAAU,EAAI,EAAc,GAAK,EAAU,IAAM,EAAc,GAAK,EAAU,IAAM,EAAc,GAAK,EAAU,IAAM,EAAc,KACzJ,EAAsB,IAAI,EAAM,GAC5B,EAAU,KAAwB,MAAjB,OAAwB,EAAS,EAAc,IAClE,EAAkB,EAAS,EAAM,EAA4B,MAAjB,OAAwB,EAAS,EAAc,GAGjG,GACF,CAGI,CAA4B,GAE9B,OAAa,EACf,EACI,EAAgB,SAAuB,EAAM,EAAU,GACzD,IAAI,EAhPQ,SAAiB,EAAS,GACtC,IAAI,EAAU,EAAW,IAAI,GAI7B,OAHK,IACH,EAAU,EAAU,EAAS,IAExB,CACT,CA0OgB,CAAQ,EAAS,GAC3B,EAAY,EAAQ,EAExB,OADA,EAAU,IAAI,GACP,WACL,EAAU,OAAO,GA1OP,SAAiB,EAAS,GACtC,IAAI,EAAU,EAAW,IAAI,GACzB,GAAW,EAAe,EAAc,IAC1C,EAAY,EAAS,EAEzB,CAsOI,CAAQ,EAAS,EACnB,CACF,EACI,EAAe,SAAsB,EAAQ,GAC/C,IAAK,IAA0D,EAAtD,EAAa,gCAAgC,KAAmB,EAAS,KAAc,MAAO,CACrG,IAAI,EAAe,EAAO,MACxB,EAAS,EAAa,GACtB,EAAS,EAAa,GACpB,gBAAgB,KAClB,EAAsB,EAAS,EAAQ,GACvC,EAAqB,EAAS,GAElC,CACA,EAAa,EACf,EACA,MAA6B,eAAzB,QAAQ,IAAI,WAEP,EAAQ,CAAC,GAAS,WAAa,EAAU,EAAM,YAAc,EAAW,EAAM,aAAe,EAAY,EAAM,gBAAkB,EAAe,EAAM,eAAiB,EAAc,EAAM,qBAAuB,SAAU,GAEjO,OADA,EAAe,IAAI,GACZ,WACL,EAAe,OAAO,EACxB,CACF,EAAG,EAAM,uBAAyB,WAChC,OAAO,EAAa,QACtB,EAAG,EAAM,oBAAsB,SAAU,GACvC,OAAO,EAAsB,IAAI,EACnC,EAAG,EAAM,iBAAmB,SAAU,GACpC,OAAO,EAAW,IAAI,EACxB,EAAG,KAEE,EAAQ,CAAC,GAAS,WAAa,EAAU,EAAM,YAAc,EAAW,EAAM,aAAe,EAAY,EAAM,gBAAkB,EAAe,EAAM,eAAiB,EAAc,EAC9L,EACI,qBAAuB,SAA8B,GACvD,IAAI,EAAQ,YAAY,GA+BxB,MAAO,CACL,IA/BQ,SAAa,GACrB,IAAI,EAAY,EAAM,WAAW,GACjC,GAAI,MAAO,EACT,MAAM,EAAU,EAElB,KAAI,MAAO,GAGX,OAAO,EAAU,CACnB,EAuBE,SAtBa,SAAS,EAAS,GAC/B,OAAO,IAAI,SAAQ,SAAU,EAAS,GACpC,IAAI,EAAY,EAAM,WAAW,GAC7B,MAAO,EACT,EAAO,EAAU,GAEjB,EADS,MAAO,EACR,EAAU,EAAE,MAAK,WACvB,OAAO,EAAS,EAClB,IAEQ,EAAU,EAEtB,GACF,EAUE,IATQ,SAAa,EAAM,GAC3B,OAAO,EAAM,YAAY,EAAM,EACjC,EAQE,IAPQ,SAAa,EAAM,GAC3B,OAAO,EAAM,gBAAgB,EAAM,EACrC,EAME,sBAAuB,EAE3B,EAEI,qBAAuB,SAA8B,EAAe,GAEtE,MAAO,CACL,EAFU,EAAuB,EAAqB,GAAe,sBAAwB,YAAY,GAI7G,EACI,gBAAkB,IAAI,IACtB,gBAAkB,SAAyB,GAI7C,OAHK,gBAAgB,IAAI,IACvB,gBAAgB,IAAI,EAAO,MAAM,cAAc,yBAE1C,gBAAgB,IAAI,EAC7B,EAEI,SAAW,SAAkB,GAC/B,IAAI,EAAW,EAAK,SAClB,EAAgB,EAAK,cACrB,EAAQ,EAAK,MACb,EAAuB,EAAK,qBAC5B,EAAgC,EAAK,8BACnC,EAAY,MAAM,SAAS,CAAC,GAC9B,EAAU,EAAU,GACpB,EAAa,EAAU,GACzB,MAAM,WAAU,WACd,IAAI,EAAiB,EAAkB,QACnC,EAAe,IACjB,EAAe,EAAE,aAAa,KAAM,UAC7B,EAAQ,EACf,EAAe,EAAI,EAEvB,GAAG,CAAC,IACJ,IAAI,EAAoB,MAAM,SAC9B,IAAK,EAAkB,QAAS,CAC9B,IAAI,EAAiB,qBAAqB,EAAe,GACzD,GAAI,EAA+B,CACjC,IAAI,EAAW,EACf,EAAe,EAAI,SAAU,GAC3B,GAAW,SAAU,GACnB,IAAI,EAAc,EAAW,EAAgB,CAC3C,EAAG,GAGL,OADA,EAAM,GACC,CACT,GACF,EACA,EAAe,EAAI,EACnB,EAAe,EAAI,SAAU,KACzB,EACF,MACE,CACJ,CACF,CACA,EAAkB,QAAU,CAC9B,CACA,IAAI,EAAwB,gBAAgB,GAC5C,OAAO,MAAM,cAAc,EAAsB,SAAU,CACzD,MAAO,EAAkB,SACxB,EACL,EAEA,SAAS,KAAK,EAAM,GAClB,OAAO,QAAQ,KAAK,EAAM,EAC5B,CAEA,SAAS,aAAa,EAAM,GAC1B,IAAI,EAAe,gBAAgB,GAC/B,EAAiB,MAAM,WAAW,GAClC,EAAQ,EAAe,EACzB,EAAsB,EAAe,EACnC,EAAe,SAAsB,GACvC,IAAI,EAAY,EAAM,WAAW,EAAM,GACvC,GAA6B,eAAzB,QAAQ,IAAI,WAA8B,EAAU,EACtD,MAAM,IAAI,MAAM,6BAElB,GAAI,MAAO,EACT,MAAM,EAAU,EAElB,GAAI,MAAO,EACT,MAAM,EAAU,EAElB,GAAI,MAAO,EACT,OAAO,EAAU,EAEnB,MAAM,IAAI,MAAM,gBAClB,EACI,EAAc,MAAM,YAAW,SAAU,EAAM,GAC/C,IAAI,EAAY,EAAa,GAC7B,OAAI,OAAO,GAAG,EAAK,GAAI,IAAc,EAAK,KAAO,EACxC,EAEF,CAAC,EAAa,EAAW,EAClC,GAAG,GAAqB,SAAU,GAEhC,MAAO,CAAC,EADW,EAAa,GACM,EACxC,IACA,EAAe,EAAY,GAC3B,EAAU,EAAa,GACvB,EAAmB,EAAa,GAChC,EAAkB,EAAa,GAC/B,EAAoB,EAAY,GAC9B,EAAQ,EAkBZ,OAjBI,IAAoB,IACtB,EAAkB,GAClB,EAAQ,EAAa,IAEvB,MAAM,WAAU,WACd,IAAI,EAAsB,EAAe,EACrC,GACF,EAAM,aAAa,EAAM,GAE3B,IAAI,EAAc,EAAM,gBAAgB,EAAM,EAAmB,GAEjE,OADA,EAAkB,GACX,CACT,GAAG,CAAC,EAAO,EAAM,IACjB,MAAM,WAAU,WACd,EAAM,aAAa,EAAM,EAC3B,IACA,MAAM,cAAc,GACb,CACT,CAEA,SAAS,WAAW,EAAM,GACxB,IAAI,EAAe,gBAAgB,GAC/B,EAAc,MAAM,WAAW,GACjC,EAAQ,EAAY,EACpB,EAAiB,EAAY,EAU/B,OATc,MAAM,aAAY,SAAU,GACxC,GAA6B,eAAzB,QAAQ,IAAI,YAA+B,UAAW,GACxD,MAAM,IAAI,MAAM,qBAElB,IAAI,EAAQ,SAAe,GACzB,OAAO,EAAM,YAAY,EAAM,EAAQ,EACzC,EACA,OAAO,EAAiB,EAAe,GAAS,GAClD,GAAG,CAAC,EAAO,EAAgB,GAE7B,CAEA,SAAS,QAAQ,EAAM,GAKrB,MAJI,UAAW,IACb,QAAQ,KAAK,qEACb,EAAQ,EAAK,OAER,CAAC,aAAa,EAAM,GAAQ,WAAW,EAAM,GACtD,CAEA,QAAQ,SAAW,SACnB,QAAQ,gCAAkC,gBAC1C,QAAQ,qCAAuC,qBAC/C,QAAQ,KAAO,KACf,QAAQ,qBAAuB,qBAC/B,QAAQ,QAAU,QAClB,QAAQ,aAAe,aACvB,QAAQ,WAAa","file":"/npm/jotai@1.11.2/index.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/jotai@1.11.2/index.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","'use strict';\n\nvar react = require('react');\nvar vanilla = require('jotai/vanilla');\n\nfunction _extends() {\n  _extends = Object.assign ? Object.assign.bind() : function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n    return target;\n  };\n  return _extends.apply(this, arguments);\n}\nfunction _unsupportedIterableToArray(o, minLen) {\n  if (!o) return;\n  if (typeof o === \"string\") return _arrayLikeToArray(o, minLen);\n  var n = Object.prototype.toString.call(o).slice(8, -1);\n  if (n === \"Object\" && o.constructor) n = o.constructor.name;\n  if (n === \"Map\" || n === \"Set\") return Array.from(o);\n  if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);\n}\nfunction _arrayLikeToArray(arr, len) {\n  if (len == null || len > arr.length) len = arr.length;\n  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];\n  return arr2;\n}\nfunction _createForOfIteratorHelperLoose(o, allowArrayLike) {\n  var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"];\n  if (it) return (it = it.call(o)).next.bind(it);\n  if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") {\n    if (it) o = it;\n    var i = 0;\n    return function () {\n      if (i >= o.length) return {\n        done: true\n      };\n      return {\n        done: false,\n        value: o[i++]\n      };\n    };\n  }\n  throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\n\nvar SUSPENSE_PROMISE = Symbol();\nvar isSuspensePromise = function isSuspensePromise(promise) {\n  return !!promise[SUSPENSE_PROMISE];\n};\nvar isSuspensePromiseAlreadyCancelled = function isSuspensePromiseAlreadyCancelled(suspensePromise) {\n  return !suspensePromise[SUSPENSE_PROMISE].c;\n};\nvar cancelSuspensePromise = function cancelSuspensePromise(suspensePromise) {\n  var _suspensePromise$SUSP = suspensePromise[SUSPENSE_PROMISE],\n    basePromise = _suspensePromise$SUSP.b,\n    cancelPromise = _suspensePromise$SUSP.c;\n  if (cancelPromise) {\n    var _promiseAbortMap$get;\n    cancelPromise();\n    (_promiseAbortMap$get = promiseAbortMap.get(basePromise)) == null ? void 0 : _promiseAbortMap$get();\n  }\n};\nvar isEqualSuspensePromise = function isEqualSuspensePromise(oldSuspensePromise, newSuspensePromise) {\n  var oldOriginalPromise = oldSuspensePromise[SUSPENSE_PROMISE].o;\n  var newOriginalPromise = newSuspensePromise[SUSPENSE_PROMISE].o;\n  return oldOriginalPromise === newOriginalPromise || oldSuspensePromise === newOriginalPromise || isSuspensePromise(oldOriginalPromise) && isEqualSuspensePromise(oldOriginalPromise, newSuspensePromise);\n};\nvar createSuspensePromise = function createSuspensePromise(basePromise, promise) {\n  var suspensePromiseExtra = {\n    b: basePromise,\n    o: promise,\n    c: null\n  };\n  var suspensePromise = new Promise(function (resolve) {\n    suspensePromiseExtra.c = function () {\n      suspensePromiseExtra.c = null;\n      resolve();\n    };\n    promise.finally(suspensePromiseExtra.c);\n  });\n  suspensePromise[SUSPENSE_PROMISE] = suspensePromiseExtra;\n  return suspensePromise;\n};\nvar copySuspensePromise = function copySuspensePromise(suspensePromise) {\n  return createSuspensePromise(suspensePromise[SUSPENSE_PROMISE].b, suspensePromise[SUSPENSE_PROMISE].o);\n};\nvar promiseAbortMap = new WeakMap();\nvar registerPromiseAbort = function registerPromiseAbort(basePromise, abort) {\n  promiseAbortMap.set(basePromise, abort);\n};\n\nvar hasInitialValue = function hasInitialValue(atom) {\n  return 'init' in atom;\n};\nvar READ_ATOM = 'r';\nvar WRITE_ATOM = 'w';\nvar COMMIT_ATOM = 'c';\nvar SUBSCRIBE_ATOM = 's';\nvar RESTORE_ATOMS = 'h';\nvar DEV_SUBSCRIBE_STATE = 'n';\nvar DEV_GET_MOUNTED_ATOMS = 'l';\nvar DEV_GET_ATOM_STATE = 'a';\nvar DEV_GET_MOUNTED = 'm';\nvar createStore = function createStore(initialValues) {\n  var _ref4;\n  var committedAtomStateMap = new WeakMap();\n  var mountedMap = new WeakMap();\n  var pendingMap = new Map();\n  var stateListeners;\n  var mountedAtoms;\n  if (process.env.NODE_ENV !== \"production\") {\n    stateListeners = new Set();\n    mountedAtoms = new Set();\n  }\n  if (initialValues) {\n    for (var _iterator = _createForOfIteratorHelperLoose(initialValues), _step; !(_step = _iterator()).done;) {\n      var _step$value = _step.value,\n        atom = _step$value[0],\n        value = _step$value[1];\n      var atomState = {\n        v: value,\n        r: 0,\n        y: true,\n        d: new Map()\n      };\n      if (process.env.NODE_ENV !== \"production\") {\n        Object.freeze(atomState);\n        if (!hasInitialValue(atom)) {\n          console.warn('Found initial value for derived atom which can cause unexpected behavior', atom);\n        }\n      }\n      committedAtomStateMap.set(atom, atomState);\n    }\n  }\n  var suspensePromiseCacheMap = new WeakMap();\n  var addSuspensePromiseToCache = function addSuspensePromiseToCache(version, atom, suspensePromise) {\n    var cache = suspensePromiseCacheMap.get(atom);\n    if (!cache) {\n      cache = new Map();\n      suspensePromiseCacheMap.set(atom, cache);\n    }\n    suspensePromise.then(function () {\n      if (cache.get(version) === suspensePromise) {\n        cache.delete(version);\n        if (!cache.size) {\n          suspensePromiseCacheMap.delete(atom);\n        }\n      }\n    });\n    cache.set(version, suspensePromise);\n  };\n  var cancelAllSuspensePromiseInCache = function cancelAllSuspensePromiseInCache(atom) {\n    var versionSet = new Set();\n    var cache = suspensePromiseCacheMap.get(atom);\n    if (cache) {\n      suspensePromiseCacheMap.delete(atom);\n      cache.forEach(function (suspensePromise, version) {\n        cancelSuspensePromise(suspensePromise);\n        versionSet.add(version);\n      });\n    }\n    return versionSet;\n  };\n  var versionedAtomStateMapMap = new WeakMap();\n  var getVersionedAtomStateMap = function getVersionedAtomStateMap(version) {\n    var versionedAtomStateMap = versionedAtomStateMapMap.get(version);\n    if (!versionedAtomStateMap) {\n      versionedAtomStateMap = new Map();\n      versionedAtomStateMapMap.set(version, versionedAtomStateMap);\n    }\n    return versionedAtomStateMap;\n  };\n  var getAtomState = function getAtomState(version, atom) {\n    if (version) {\n      var versionedAtomStateMap = getVersionedAtomStateMap(version);\n      var _atomState = versionedAtomStateMap.get(atom);\n      if (!_atomState) {\n        _atomState = getAtomState(version.p, atom);\n        if (_atomState && 'p' in _atomState && isSuspensePromiseAlreadyCancelled(_atomState.p)) {\n          _atomState = undefined;\n        }\n        if (_atomState) {\n          versionedAtomStateMap.set(atom, _atomState);\n        }\n      }\n      return _atomState;\n    }\n    return committedAtomStateMap.get(atom);\n  };\n  var setAtomState = function setAtomState(version, atom, atomState) {\n    if (process.env.NODE_ENV !== \"production\") {\n      Object.freeze(atomState);\n    }\n    if (version) {\n      var versionedAtomStateMap = getVersionedAtomStateMap(version);\n      versionedAtomStateMap.set(atom, atomState);\n    } else {\n      var prevAtomState = committedAtomStateMap.get(atom);\n      committedAtomStateMap.set(atom, atomState);\n      if (!pendingMap.has(atom)) {\n        pendingMap.set(atom, prevAtomState);\n      }\n    }\n  };\n  var createReadDependencies = function createReadDependencies(version, prevReadDependencies, dependencies) {\n    if (prevReadDependencies === void 0) {\n      prevReadDependencies = new Map();\n    }\n    if (!dependencies) {\n      return prevReadDependencies;\n    }\n    var readDependencies = new Map();\n    var changed = false;\n    dependencies.forEach(function (atom) {\n      var _getAtomState;\n      var revision = ((_getAtomState = getAtomState(version, atom)) == null ? void 0 : _getAtomState.r) || 0;\n      readDependencies.set(atom, revision);\n      if (prevReadDependencies.get(atom) !== revision) {\n        changed = true;\n      }\n    });\n    if (prevReadDependencies.size === readDependencies.size && !changed) {\n      return prevReadDependencies;\n    }\n    return readDependencies;\n  };\n  var setAtomValue = function setAtomValue(version, atom, value, dependencies, suspensePromise) {\n    var atomState = getAtomState(version, atom);\n    if (atomState) {\n      if (suspensePromise && (!('p' in atomState) || !isEqualSuspensePromise(atomState.p, suspensePromise))) {\n        return atomState;\n      }\n      if ('p' in atomState) {\n        cancelSuspensePromise(atomState.p);\n      }\n    }\n    var nextAtomState = {\n      v: value,\n      r: (atomState == null ? void 0 : atomState.r) || 0,\n      y: true,\n      d: createReadDependencies(version, atomState == null ? void 0 : atomState.d, dependencies)\n    };\n    var changed = !(atomState != null && atomState.y);\n    if (!atomState || !('v' in atomState) || !Object.is(atomState.v, value)) {\n      changed = true;\n      ++nextAtomState.r;\n      if (nextAtomState.d.has(atom)) {\n        nextAtomState.d = new Map(nextAtomState.d).set(atom, nextAtomState.r);\n      }\n    } else if (nextAtomState.d !== atomState.d && (nextAtomState.d.size !== atomState.d.size || !Array.from(nextAtomState.d.keys()).every(function (a) {\n      return atomState.d.has(a);\n    }))) {\n      changed = true;\n      Promise.resolve().then(function () {\n        flushPending(version);\n      });\n    }\n    if (atomState && !changed) {\n      return atomState;\n    }\n    setAtomState(version, atom, nextAtomState);\n    return nextAtomState;\n  };\n  var setAtomReadError = function setAtomReadError(version, atom, error, dependencies, suspensePromise) {\n    var atomState = getAtomState(version, atom);\n    if (atomState) {\n      if (suspensePromise && (!('p' in atomState) || !isEqualSuspensePromise(atomState.p, suspensePromise))) {\n        return atomState;\n      }\n      if ('p' in atomState) {\n        cancelSuspensePromise(atomState.p);\n      }\n    }\n    var nextAtomState = {\n      e: error,\n      r: ((atomState == null ? void 0 : atomState.r) || 0) + 1,\n      y: true,\n      d: createReadDependencies(version, atomState == null ? void 0 : atomState.d, dependencies)\n    };\n    setAtomState(version, atom, nextAtomState);\n    return nextAtomState;\n  };\n  var setAtomSuspensePromise = function setAtomSuspensePromise(version, atom, suspensePromise, dependencies) {\n    var atomState = getAtomState(version, atom);\n    if (atomState && 'p' in atomState) {\n      if (isEqualSuspensePromise(atomState.p, suspensePromise) && !isSuspensePromiseAlreadyCancelled(atomState.p)) {\n        if (!atomState.y) {\n          return _extends({}, atomState, {\n            y: true\n          });\n        }\n        return atomState;\n      }\n      cancelSuspensePromise(atomState.p);\n    }\n    addSuspensePromiseToCache(version, atom, suspensePromise);\n    var nextAtomState = {\n      p: suspensePromise,\n      r: ((atomState == null ? void 0 : atomState.r) || 0) + 1,\n      y: true,\n      d: createReadDependencies(version, atomState == null ? void 0 : atomState.d, dependencies)\n    };\n    setAtomState(version, atom, nextAtomState);\n    return nextAtomState;\n  };\n  var setAtomPromiseOrValue = function setAtomPromiseOrValue(version, atom, promiseOrValue, dependencies) {\n    if (promiseOrValue instanceof Promise) {\n      var suspensePromise = createSuspensePromise(promiseOrValue, promiseOrValue.then(function (value) {\n        setAtomValue(version, atom, value, dependencies, suspensePromise);\n      }).catch(function (e) {\n        if (e instanceof Promise) {\n          if (isSuspensePromise(e)) {\n            return e.then(function () {\n              readAtomState(version, atom, true);\n            });\n          }\n          return e;\n        }\n        setAtomReadError(version, atom, e, dependencies, suspensePromise);\n      }));\n      return setAtomSuspensePromise(version, atom, suspensePromise, dependencies);\n    }\n    return setAtomValue(version, atom, promiseOrValue, dependencies);\n  };\n  var setAtomInvalidated = function setAtomInvalidated(version, atom) {\n    var atomState = getAtomState(version, atom);\n    if (atomState) {\n      var nextAtomState = _extends({}, atomState, {\n        y: false\n      });\n      setAtomState(version, atom, nextAtomState);\n    } else if (process.env.NODE_ENV !== \"production\") {\n      console.warn('[Bug] could not invalidate non existing atom', atom);\n    }\n  };\n  var readAtomState = function readAtomState(version, atom, force) {\n    if (!force) {\n      var _atomState2 = getAtomState(version, atom);\n      if (_atomState2) {\n        if (_atomState2.y && 'p' in _atomState2 && !isSuspensePromiseAlreadyCancelled(_atomState2.p)) {\n          return _atomState2;\n        }\n        _atomState2.d.forEach(function (_, a) {\n          if (a !== atom) {\n            if (!mountedMap.has(a)) {\n              readAtomState(version, a);\n            } else {\n              var aState = getAtomState(version, a);\n              if (aState && !aState.y) {\n                readAtomState(version, a);\n              }\n            }\n          }\n        });\n        if (Array.from(_atomState2.d).every(function (_ref) {\n          var a = _ref[0],\n            r = _ref[1];\n          var aState = getAtomState(version, a);\n          return aState && !('p' in aState) && aState.r === r;\n        })) {\n          if (!_atomState2.y) {\n            return _extends({}, _atomState2, {\n              y: true\n            });\n          }\n          return _atomState2;\n        }\n      }\n    }\n    var dependencies = new Set();\n    try {\n      var promiseOrValue = atom.read(function (a) {\n        dependencies.add(a);\n        var aState = a === atom ? getAtomState(version, a) : readAtomState(version, a);\n        if (aState) {\n          if ('e' in aState) {\n            throw aState.e;\n          }\n          if ('p' in aState) {\n            throw aState.p;\n          }\n          return aState.v;\n        }\n        if (hasInitialValue(a)) {\n          return a.init;\n        }\n        throw new Error('no atom init');\n      });\n      return setAtomPromiseOrValue(version, atom, promiseOrValue, dependencies);\n    } catch (errorOrPromise) {\n      if (errorOrPromise instanceof Promise) {\n        var suspensePromise = isSuspensePromise(errorOrPromise) && isSuspensePromiseAlreadyCancelled(errorOrPromise) ? copySuspensePromise(errorOrPromise) : createSuspensePromise(errorOrPromise, errorOrPromise);\n        return setAtomSuspensePromise(version, atom, suspensePromise, dependencies);\n      }\n      return setAtomReadError(version, atom, errorOrPromise, dependencies);\n    }\n  };\n  var readAtom = function readAtom(readingAtom, version) {\n    var atomState = readAtomState(version, readingAtom);\n    return atomState;\n  };\n  var addAtom = function addAtom(version, addingAtom) {\n    var mounted = mountedMap.get(addingAtom);\n    if (!mounted) {\n      mounted = mountAtom(version, addingAtom);\n    }\n    return mounted;\n  };\n  var canUnmountAtom = function canUnmountAtom(atom, mounted) {\n    return !mounted.l.size && (!mounted.t.size || mounted.t.size === 1 && mounted.t.has(atom));\n  };\n  var delAtom = function delAtom(version, deletingAtom) {\n    var mounted = mountedMap.get(deletingAtom);\n    if (mounted && canUnmountAtom(deletingAtom, mounted)) {\n      unmountAtom(version, deletingAtom);\n    }\n  };\n  var invalidateDependents = function invalidateDependents(version, atom) {\n    var mounted = mountedMap.get(atom);\n    mounted == null ? void 0 : mounted.t.forEach(function (dependent) {\n      if (dependent !== atom) {\n        setAtomInvalidated(version, dependent);\n        invalidateDependents(version, dependent);\n      }\n    });\n  };\n  var writeAtomState = function writeAtomState(version, atom, update) {\n    var isSync = true;\n    var writeGetter = function writeGetter(a, options) {\n      var aState = readAtomState(version, a);\n      if ('e' in aState) {\n        throw aState.e;\n      }\n      if ('p' in aState) {\n        if (options != null && options.unstable_promise) {\n          return aState.p.then(function () {\n            var s = getAtomState(version, a);\n            if (s && 'p' in s && s.p === aState.p) {\n              return new Promise(function (resolve) {\n                return setTimeout(resolve);\n              }).then(function () {\n                return writeGetter(a, options);\n              });\n            }\n            return writeGetter(a, options);\n          });\n        }\n        if (process.env.NODE_ENV !== \"production\") {\n          console.info('Reading pending atom state in write operation. We throw a promise for now.', a);\n        }\n        throw aState.p;\n      }\n      if ('v' in aState) {\n        return aState.v;\n      }\n      if (process.env.NODE_ENV !== \"production\") {\n        console.warn('[Bug] no value found while reading atom in write operation. This is probably a bug.', a);\n      }\n      throw new Error('no value found');\n    };\n    var setter = function setter(a, v) {\n      var promiseOrVoid;\n      if (a === atom) {\n        if (!hasInitialValue(a)) {\n          throw new Error('atom not writable');\n        }\n        var versionSet = cancelAllSuspensePromiseInCache(a);\n        versionSet.forEach(function (cancelledVersion) {\n          if (cancelledVersion !== version) {\n            setAtomPromiseOrValue(cancelledVersion, a, v);\n          }\n        });\n        var prevAtomState = getAtomState(version, a);\n        var nextAtomState = setAtomPromiseOrValue(version, a, v);\n        if (prevAtomState !== nextAtomState) {\n          invalidateDependents(version, a);\n        }\n      } else {\n        promiseOrVoid = writeAtomState(version, a, v);\n      }\n      if (!isSync) {\n        flushPending(version);\n      }\n      return promiseOrVoid;\n    };\n    var promiseOrVoid = atom.write(writeGetter, setter, update);\n    isSync = false;\n    return promiseOrVoid;\n  };\n  var writeAtom = function writeAtom(writingAtom, update, version) {\n    var promiseOrVoid = writeAtomState(version, writingAtom, update);\n    flushPending(version);\n    return promiseOrVoid;\n  };\n  var isActuallyWritableAtom = function isActuallyWritableAtom(atom) {\n    return !!atom.write;\n  };\n  var mountAtom = function mountAtom(version, atom, initialDependent) {\n    var mounted = {\n      t: new Set(initialDependent && [initialDependent]),\n      l: new Set()\n    };\n    mountedMap.set(atom, mounted);\n    if (process.env.NODE_ENV !== \"production\") {\n      mountedAtoms.add(atom);\n    }\n    var atomState = readAtomState(undefined, atom);\n    atomState.d.forEach(function (_, a) {\n      var aMounted = mountedMap.get(a);\n      if (aMounted) {\n        aMounted.t.add(atom);\n      } else {\n        if (a !== atom) {\n          mountAtom(version, a, atom);\n        }\n      }\n    });\n    if (isActuallyWritableAtom(atom) && atom.onMount) {\n      var setAtom = function setAtom(update) {\n        return writeAtom(atom, update, version);\n      };\n      var onUnmount = atom.onMount(setAtom);\n      version = undefined;\n      if (onUnmount) {\n        mounted.u = onUnmount;\n      }\n    }\n    return mounted;\n  };\n  var unmountAtom = function unmountAtom(version, atom) {\n    var _mountedMap$get;\n    var onUnmount = (_mountedMap$get = mountedMap.get(atom)) == null ? void 0 : _mountedMap$get.u;\n    if (onUnmount) {\n      onUnmount();\n    }\n    mountedMap.delete(atom);\n    if (process.env.NODE_ENV !== \"production\") {\n      mountedAtoms.delete(atom);\n    }\n    var atomState = getAtomState(version, atom);\n    if (atomState) {\n      if ('p' in atomState) {\n        cancelSuspensePromise(atomState.p);\n      }\n      atomState.d.forEach(function (_, a) {\n        if (a !== atom) {\n          var mounted = mountedMap.get(a);\n          if (mounted) {\n            mounted.t.delete(atom);\n            if (canUnmountAtom(a, mounted)) {\n              unmountAtom(version, a);\n            }\n          }\n        }\n      });\n    } else if (process.env.NODE_ENV !== \"production\") {\n      console.warn('[Bug] could not find atom state to unmount', atom);\n    }\n  };\n  var mountDependencies = function mountDependencies(version, atom, atomState, prevReadDependencies) {\n    var dependencies = new Set(atomState.d.keys());\n    prevReadDependencies == null ? void 0 : prevReadDependencies.forEach(function (_, a) {\n      if (dependencies.has(a)) {\n        dependencies.delete(a);\n        return;\n      }\n      var mounted = mountedMap.get(a);\n      if (mounted) {\n        mounted.t.delete(atom);\n        if (canUnmountAtom(a, mounted)) {\n          unmountAtom(version, a);\n        }\n      }\n    });\n    dependencies.forEach(function (a) {\n      var mounted = mountedMap.get(a);\n      if (mounted) {\n        mounted.t.add(atom);\n      } else if (mountedMap.has(atom)) {\n        mountAtom(version, a, atom);\n      }\n    });\n  };\n  var flushPending = function flushPending(version) {\n    if (version) {\n      var versionedAtomStateMap = getVersionedAtomStateMap(version);\n      versionedAtomStateMap.forEach(function (atomState, atom) {\n        var committedAtomState = committedAtomStateMap.get(atom);\n        if (atomState !== committedAtomState) {\n          var mounted = mountedMap.get(atom);\n          mounted == null ? void 0 : mounted.l.forEach(function (listener) {\n            return listener(version);\n          });\n        }\n      });\n      return;\n    }\n    while (pendingMap.size) {\n      var pending = Array.from(pendingMap);\n      pendingMap.clear();\n      pending.forEach(function (_ref2) {\n        var atom = _ref2[0],\n          prevAtomState = _ref2[1];\n        var atomState = getAtomState(undefined, atom);\n        if (atomState && atomState.d !== (prevAtomState == null ? void 0 : prevAtomState.d)) {\n          mountDependencies(undefined, atom, atomState, prevAtomState == null ? void 0 : prevAtomState.d);\n        }\n        if (prevAtomState && !prevAtomState.y && atomState != null && atomState.y) {\n          return;\n        }\n        var mounted = mountedMap.get(atom);\n        mounted == null ? void 0 : mounted.l.forEach(function (listener) {\n          return listener();\n        });\n      });\n    }\n    if (process.env.NODE_ENV !== \"production\") {\n      stateListeners.forEach(function (l) {\n        return l();\n      });\n    }\n  };\n  var commitVersionedAtomStateMap = function commitVersionedAtomStateMap(version) {\n    var versionedAtomStateMap = getVersionedAtomStateMap(version);\n    versionedAtomStateMap.forEach(function (atomState, atom) {\n      var prevAtomState = committedAtomStateMap.get(atom);\n      if (!prevAtomState || atomState.r > prevAtomState.r || atomState.y !== prevAtomState.y || atomState.r === prevAtomState.r && atomState.d !== prevAtomState.d) {\n        committedAtomStateMap.set(atom, atomState);\n        if (atomState.d !== (prevAtomState == null ? void 0 : prevAtomState.d)) {\n          mountDependencies(version, atom, atomState, prevAtomState == null ? void 0 : prevAtomState.d);\n        }\n      }\n    });\n  };\n  var commitAtom = function commitAtom(_atom, version) {\n    if (version) {\n      commitVersionedAtomStateMap(version);\n    }\n    flushPending(undefined);\n  };\n  var subscribeAtom = function subscribeAtom(atom, callback, version) {\n    var mounted = addAtom(version, atom);\n    var listeners = mounted.l;\n    listeners.add(callback);\n    return function () {\n      listeners.delete(callback);\n      delAtom(version, atom);\n    };\n  };\n  var restoreAtoms = function restoreAtoms(values, version) {\n    for (var _iterator2 = _createForOfIteratorHelperLoose(values), _step2; !(_step2 = _iterator2()).done;) {\n      var _step2$value = _step2.value,\n        _atom2 = _step2$value[0],\n        _value = _step2$value[1];\n      if (hasInitialValue(_atom2)) {\n        setAtomPromiseOrValue(version, _atom2, _value);\n        invalidateDependents(version, _atom2);\n      }\n    }\n    flushPending(version);\n  };\n  if (process.env.NODE_ENV !== \"production\") {\n    var _ref3;\n    return _ref3 = {}, _ref3[READ_ATOM] = readAtom, _ref3[WRITE_ATOM] = writeAtom, _ref3[COMMIT_ATOM] = commitAtom, _ref3[SUBSCRIBE_ATOM] = subscribeAtom, _ref3[RESTORE_ATOMS] = restoreAtoms, _ref3[DEV_SUBSCRIBE_STATE] = function (l) {\n      stateListeners.add(l);\n      return function () {\n        stateListeners.delete(l);\n      };\n    }, _ref3[DEV_GET_MOUNTED_ATOMS] = function () {\n      return mountedAtoms.values();\n    }, _ref3[DEV_GET_ATOM_STATE] = function (a) {\n      return committedAtomStateMap.get(a);\n    }, _ref3[DEV_GET_MOUNTED] = function (a) {\n      return mountedMap.get(a);\n    }, _ref3;\n  }\n  return _ref4 = {}, _ref4[READ_ATOM] = readAtom, _ref4[WRITE_ATOM] = writeAtom, _ref4[COMMIT_ATOM] = commitAtom, _ref4[SUBSCRIBE_ATOM] = subscribeAtom, _ref4[RESTORE_ATOMS] = restoreAtoms, _ref4;\n};\nvar createStoreForExport = function createStoreForExport(initialValues) {\n  var store = createStore(initialValues);\n  var get = function get(atom) {\n    var atomState = store[READ_ATOM](atom);\n    if ('e' in atomState) {\n      throw atomState.e;\n    }\n    if ('p' in atomState) {\n      return undefined;\n    }\n    return atomState.v;\n  };\n  var asyncGet = function asyncGet(atom) {\n    return new Promise(function (resolve, reject) {\n      var atomState = store[READ_ATOM](atom);\n      if ('e' in atomState) {\n        reject(atomState.e);\n      } else if ('p' in atomState) {\n        resolve(atomState.p.then(function () {\n          return asyncGet(atom);\n        }));\n      } else {\n        resolve(atomState.v);\n      }\n    });\n  };\n  var set = function set(atom, update) {\n    return store[WRITE_ATOM](atom, update);\n  };\n  var sub = function sub(atom, callback) {\n    return store[SUBSCRIBE_ATOM](atom, callback);\n  };\n  return {\n    get: get,\n    asyncGet: asyncGet,\n    set: set,\n    sub: sub,\n    SECRET_INTERNAL_store: store\n  };\n};\n\nvar createScopeContainer = function createScopeContainer(initialValues, unstable_createStore) {\n  var store = unstable_createStore ? unstable_createStore(initialValues).SECRET_INTERNAL_store : createStore(initialValues);\n  return {\n    s: store\n  };\n};\nvar ScopeContextMap = new Map();\nvar getScopeContext = function getScopeContext(scope) {\n  if (!ScopeContextMap.has(scope)) {\n    ScopeContextMap.set(scope, react.createContext(createScopeContainer()));\n  }\n  return ScopeContextMap.get(scope);\n};\n\nvar Provider = function Provider(_ref) {\n  var children = _ref.children,\n    initialValues = _ref.initialValues,\n    scope = _ref.scope,\n    unstable_createStore = _ref.unstable_createStore,\n    unstable_enableVersionedWrite = _ref.unstable_enableVersionedWrite;\n  var _useState = react.useState({}),\n    version = _useState[0],\n    setVersion = _useState[1];\n  react.useEffect(function () {\n    var scopeContainer = scopeContainerRef.current;\n    if (scopeContainer.w) {\n      scopeContainer.s[COMMIT_ATOM](null, version);\n      delete version.p;\n      scopeContainer.v = version;\n    }\n  }, [version]);\n  var scopeContainerRef = react.useRef();\n  if (!scopeContainerRef.current) {\n    var scopeContainer = createScopeContainer(initialValues, unstable_createStore);\n    if (unstable_enableVersionedWrite) {\n      var retrying = 0;\n      scopeContainer.w = function (write) {\n        setVersion(function (parentVersion) {\n          var nextVersion = retrying ? parentVersion : {\n            p: parentVersion\n          };\n          write(nextVersion);\n          return nextVersion;\n        });\n      };\n      scopeContainer.v = version;\n      scopeContainer.r = function (fn) {\n        ++retrying;\n        fn();\n        --retrying;\n      };\n    }\n    scopeContainerRef.current = scopeContainer;\n  }\n  var ScopeContainerContext = getScopeContext(scope);\n  return react.createElement(ScopeContainerContext.Provider, {\n    value: scopeContainerRef.current\n  }, children);\n};\n\nfunction atom(read, write) {\n  return vanilla.atom(read, write);\n}\n\nfunction useAtomValue(atom, scope) {\n  var ScopeContext = getScopeContext(scope);\n  var scopeContainer = react.useContext(ScopeContext);\n  var store = scopeContainer.s,\n    versionFromProvider = scopeContainer.v;\n  var getAtomValue = function getAtomValue(version) {\n    var atomState = store[READ_ATOM](atom, version);\n    if (process.env.NODE_ENV !== \"production\" && !atomState.y) {\n      throw new Error('should not be invalidated');\n    }\n    if ('e' in atomState) {\n      throw atomState.e;\n    }\n    if ('p' in atomState) {\n      throw atomState.p;\n    }\n    if ('v' in atomState) {\n      return atomState.v;\n    }\n    throw new Error('no atom value');\n  };\n  var _useReducer = react.useReducer(function (prev, nextVersion) {\n      var nextValue = getAtomValue(nextVersion);\n      if (Object.is(prev[1], nextValue) && prev[2] === atom) {\n        return prev;\n      }\n      return [nextVersion, nextValue, atom];\n    }, versionFromProvider, function (initialVersion) {\n      var initialValue = getAtomValue(initialVersion);\n      return [initialVersion, initialValue, atom];\n    }),\n    _useReducer$ = _useReducer[0],\n    version = _useReducer$[0],\n    valueFromReducer = _useReducer$[1],\n    atomFromReducer = _useReducer$[2],\n    rerenderIfChanged = _useReducer[1];\n  var value = valueFromReducer;\n  if (atomFromReducer !== atom) {\n    rerenderIfChanged(version);\n    value = getAtomValue(version);\n  }\n  react.useEffect(function () {\n    var versionFromProvider = scopeContainer.v;\n    if (versionFromProvider) {\n      store[COMMIT_ATOM](atom, versionFromProvider);\n    }\n    var unsubscribe = store[SUBSCRIBE_ATOM](atom, rerenderIfChanged, versionFromProvider);\n    rerenderIfChanged(versionFromProvider);\n    return unsubscribe;\n  }, [store, atom, scopeContainer]);\n  react.useEffect(function () {\n    store[COMMIT_ATOM](atom, version);\n  });\n  react.useDebugValue(value);\n  return value;\n}\n\nfunction useSetAtom(atom, scope) {\n  var ScopeContext = getScopeContext(scope);\n  var _useContext = react.useContext(ScopeContext),\n    store = _useContext.s,\n    versionedWrite = _useContext.w;\n  var setAtom = react.useCallback(function (update) {\n    if (process.env.NODE_ENV !== \"production\" && !('write' in atom)) {\n      throw new Error('not writable atom');\n    }\n    var write = function write(version) {\n      return store[WRITE_ATOM](atom, update, version);\n    };\n    return versionedWrite ? versionedWrite(write) : write();\n  }, [store, versionedWrite, atom]);\n  return setAtom;\n}\n\nfunction useAtom(atom, scope) {\n  if ('scope' in atom) {\n    console.warn('atom.scope is deprecated. Please do useAtom(atom, scope) instead.');\n    scope = atom.scope;\n  }\n  return [useAtomValue(atom, scope), useSetAtom(atom, scope)];\n}\n\nexports.Provider = Provider;\nexports.SECRET_INTERNAL_getScopeContext = getScopeContext;\nexports.SECRET_INTERNAL_registerPromiseAbort = registerPromiseAbort;\nexports.atom = atom;\nexports.unstable_createStore = createStoreForExport;\nexports.useAtom = useAtom;\nexports.useAtomValue = useAtomValue;\nexports.useSetAtom = useSetAtom;\n"]}