{"version":3,"file":"static/chunks/8993-ad88e65356e328cb.js","mappings":"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CAAAD,EAAAE,UAAA,KAGA,IAAAD,EAAA,CACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,MACA,MACA,MACA,UACA,MACA,MACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,GACA,GACA,MACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,OACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,gBCnKA,IAAAE,EAAA,CACAC,KAAA,CACAC,MAAA,GAAAjjC,EAAAnN,KAAA,EAEAkmC,SAAA,CACAkK,MAAA,OAAAjjC,EAAA9J,IAAA,EAGAgtC,SAAA,CACAD,MAAA,GAAA59B,EAAArF,EAAAknB,WAAA,QACA,EACAic,oBAAA,CACAF,MAAAjjC,CAAA,EACA,IAAAojC,EAAAC,EAAA,IAAAh+B,EAAArF,EAAA+b,mBAAA,YACAunB,EAAAj+B,EACA,CACArF,EAAAmnB,SAAA,CACA9hB,EAAA,CAAArF,EAAA9J,IAAA,CAAAktC,EAAA,EACA/9B,EAAArF,EAAAmD,UAAA,MACA,CACA,KAIA,OAAAmgC,UAAAA,EAAA,GAAAA,EAAA,KAAAtjC,EAAAU,YAAA,CAEA,EACA6iC,mBAAA,CACAN,MAAA,EAAchnB,SAAAA,CAAA,CAAAunB,KAAAA,CAAA,CAAAlB,aAAAA,CAAA,CAAAn/B,WAAAA,CAAA,CAA0C,GACxD8Y,EACA,KACAunB,EACAH,EAAA,MAAAf,GACAe,EAAA,IAAAh+B,EAAAlC,EAAA,KACA,EACAsgC,aAAA,CACAR,MAAA,EAAchgC,WAAAA,CAAA,CAAY,GAAAygC,EAAAzgC,EAC1B,EACA0gC,MAAA,CACAV,MAAA,CAAYW,MAAAA,CAAA,CAAA1tC,KAAAA,CAAA,CAAA0G,UAAAnC,CAAA,CAAA0I,WAAAA,CAAA,CAAAzC,aAAAA,CAAA,CAAwD,EACpE,IAAA4iC,EAAAD,EAAA,GAAAO,EAAA,MAAA1tC,EACA2tC,EAAAP,EAAAD,EAAA,IAAAh+B,EAAA5K,EAAA,WAMA,OAJAopC,EAAAjwC,MAAA,CA5CA,IA6CAiwC,CAAAA,EAAAP,EAAAD,EAAA,MAAAS,EAAAz+B,EAAA5K,EAAA,eAGA4K,EAAA,CAAAw+B,EAAAx+B,EAAAlC,EAAA,KAAAzC,EAAA,KACA,CACA,EACAqjC,SAAA,CACAd,MAAA,EAAc/sC,KAAAA,CAAA,CAAArD,MAAAA,CAAA,CAAa,GAAAqD,EAAA,KAAArD,CAC3B,EAEA67B,eAAA,CACAuU,MAAA,EAAc/sC,KAAAA,CAAA,CAAAiN,WAAAA,CAAA,CAAkB,GAChC,MAAAjN,EAAAmtC,EAAA,IAAAh+B,EAAAlC,EAAA,KACA,EACA6gC,eAAA,CACAf,MAAA,EAAc/4B,cAAAA,CAAA,CAAA/G,WAAAA,CAAA,CAAAzC,aAAAA,CAAA,CAAyC,GACvD2E,EACA,CACA,MACAg+B,EAAA,MAAAn5B,GACA7E,EAAAlC,EAAA,KACAzC,EACA,CACA,IAEA,EACAujC,mBAAA,CACAhB,MAAA,CACA,CAAQ/sC,KAAAA,CAAA,CAAAgU,cAAAA,CAAA,CAAA6R,oBAAAA,CAAA,CAAA5Y,WAAAA,CAAA,CAAAzC,aAAAA,CAAA,CAAoE,GAG5E,YAAkBxK,EAAK,EAAEmtC,EAAA,IAAAh+B,EAAA0W,EAAA,WACzB,MAAY7R,EAAA,CAAe,EAAEm5B,EAAA,GAAAh+B,EAAAlC,EAAA,UAAqC,CADQ,CAE1EzC,CACA,EAEAwjC,SAAA,CACAjB,MAAA,EAAcpwC,MAAAA,CAAA,CAAO,GAAAA,CACrB,EACAsxC,WAAA,CACAlB,MAAA,EAAcpwC,MAAAA,CAAA,CAAO,GAAAA,CACrB,EACAuxC,YAAA,CACAnB,MAAA,EAAcpwC,MAAAA,CAAA,CAAA6wC,MAAAW,CAAA,CAA6B,GAC3CA,EAAsB,GAAAC,EAAAlhC,EAAA,EAAgBvQ,GD/FtC,IAAa+vC,EAAA5nC,OAAA,CAAA0nC,EAAAC,GAA4C,ICiGzD4B,aAAA,CACAtB,MAAA,EAAcpwC,MAAAA,CAAA,CAAO,GAAAA,EAAA,cACrB,EACA2xC,UAAA,CACAvB,MAAA,UACA,EACAwB,UAAA,CACAxB,MAAA,EAAcpwC,MAAAA,CAAA,CAAO,GAAAA,CACrB,EACA6xC,UAAA,CACAzB,MAAA,EAAc1+B,OAAAA,CAAA,CAAQ,OAAAc,EAAAd,EAAA,SACtB,EACAogC,YAAA,CACA1B,MAAA,EAAc7pC,OAAAA,CAAA,CAAQ,OAAOiM,EAAAjM,EAAA,SAC7B,EACAwrC,YAAA,CACA3B,MAAA,EAAc/sC,KAAAA,CAAA,CAAArD,MAAAA,CAAA,CAAa,GAAAqD,EAAA,KAAArD,CAC3B,EAEA05B,UAAA,CACA0W,MAAA,EAAc/sC,KAAAA,CAAA,CAAA0G,UAAAnC,CAAA,CAAuB,GACrC,IAAAvE,EAAAmtC,EAAA,IAAAh+B,EAAA5K,EAAA,UACA,EAEAoqC,UAAA,CACA5B,MAAA,EAAc/sC,KAAAA,CAAA,CAAM,GAAAA,CACpB,EACA4uC,SAAA,CACA7B,MAAA,EAAcO,KAAAA,CAAA,CAAM,OAAAA,EAAA,GACpB,EACAuB,YAAA,CACA9B,MAAA,EAAcO,KAAAA,CAAA,CAAM,GAAAA,EAAA,GACpB,EAEAwB,iBAAA,CACA/B,MAAA,EAAcgC,YAAAA,CAAA,CAAA9hC,WAAAA,CAAA,CAAA+hC,eAAAA,CAAA,CAAyC,GACvD7B,EAAA,GAAA4B,EAAA,MACA5/B,EAAA,UAAAA,EAAAlC,EAAA,KAAAugC,EAAAwB,GAAA,KACA,EACAC,wBAAA,CACAlC,MAAA,EAAc9b,UAAAA,CAAA,CAAAqc,KAAAA,CAAA,CAAiB,GAAArc,EAAA,KAAAqc,CAC/B,EACA4B,qBAAA,CACAnC,MAAA,EAAcgC,YAAAA,CAAA,CAAA/uC,KAAAA,CAAA,CAAAiN,WAAAA,CAAA,CAA+B,GAC7CkgC,EAAA,GAAA4B,EAAA,MACA5/B,EAAA,UAAAnP,EAAAmP,EAAAlC,EAAA,UACA,EACAkiC,qBAAA,CACApC,MAAA,EAAcgC,YAAAA,CAAA,CAAA/uC,KAAAA,CAAA,CAAAovC,WAAAA,CAAA,CAAAniC,WAAAA,CAAA,CAAA/J,OAAAA,CAAA,CAAmD,GACjEiqC,EAAA,GAAA4B,EAAA,MACA5/B,EACA,CACA,OACAnP,EACAmtC,EAAA,cAAAh+B,EAAAigC,EAAA,QACAjgC,EAAAlC,EAAA,KACAugC,EAAAtqC,GACA,CACA,IAEA,EACAmsC,gBAAA,CACAtC,MAAA,EAAcgC,YAAAA,CAAA,CAAA/uC,KAAAA,CAAA,CAAA0G,UAAAnC,CAAA,CAAA+oC,KAAAA,CAAA,CAAArgC,WAAAA,CAAA,CAAsD,GACpEkgC,EAAA,GAAA4B,EAAA,MACA/uC,EACAsvC,CAAAA,EAAA/qC,GACA4oC,EAAA,MAAAS,EAAAz+B,EAAA5K,EAAA,cACA4oC,EAAA,IAAAh+B,EAAA5K,EAAA,YACA,KACA+oC,EACAH,EAAA,IAAAh+B,EAAAlC,EAAA,KACA,EACAsiC,qBAAA,CACAxC,MAAA,EAAcgC,YAAAA,CAAA,CAAA/uC,KAAAA,CAAA,CAAAstC,KAAAA,CAAA,CAAAlB,aAAAA,CAAA,CAAAn/B,WAAAA,CAAA,CAAmD,GACjEkgC,EAAA,GAAA4B,EAAA,MACA5/B,EACA,CAAAnP,EAAA,KAAAstC,EAAAH,EAAA,KAAAf,GAAAj9B,EAAAlC,EAAA,MACA,IAEA,EACAuiC,wBAAA,CACAzC,MAAA,EAAcgC,YAAAA,CAAA,CAAA/uC,KAAAA,CAAA,CAAAovC,WAAAA,CAAA,CAAAniC,WAAAA,CAAA,CAAA/J,OAAAA,CAAA,CAAmD,GACjEiqC,EAAA,GAAA4B,EAAA,MACA5/B,EACA,CACA,YACAnP,EACAmtC,EAAA,cAAAh+B,EAAAigC,EAAA,QACAjgC,EAAAlC,EAAA,KACAugC,EAAAtqC,GACA,CACA,IAEA,EACAusC,oBAAA,CACA1C,MAAA,EAAcgC,YAAAA,CAAA,CAAA/uC,KAAAA,CAAA,CAAAiN,WAAAA,CAAA,CAAAyiC,MAAAA,CAAA,CAAsC,GACpDvC,EAAA,GAAA4B,EAAA,MACA5/B,EACA,SAAAnP,EAAAmP,EAAAlC,EAAA,KAAAkgC,EAAA,KAAAh+B,EAAAugC,EAAA,SACA,IAEA,EACAC,mBAAA,CACA5C,MAAA,EAAcgC,YAAAA,CAAA,CAAA/uC,KAAAA,CAAA,CAAAiN,WAAAA,CAAA,CAAAoB,OAAAA,CAAA,CAAuC,GACrD8+B,EAAA,GAAA4B,EAAA,MACA5/B,EAAA,QAAAnP,EAAAmP,EAAAlC,EAAA,KAAAugC,EAAAn/B,GAAA,KACA,EACAuhC,oBAAA,CACA7C,MAAA,EAAcgC,YAAAA,CAAA,CAAA/uC,KAAAA,CAAA,CAAAiN,WAAAA,CAAA,CAA+B,GAC7CkgC,EAAA,GAAA4B,EAAA,MAAA5/B,EAAA,CAAAnP,EAAAmP,EAAAlC,EAAA,UACA,EACA4iC,0BAAA,CACA9C,MAAA,EAAcgC,YAAAA,CAAA,CAAA/uC,KAAAA,CAAA,CAAAiN,WAAAA,CAAA,CAAA/J,OAAAA,CAAA,CAAuC,GACrDiqC,EAAA,GAAA4B,EAAA,MACA5/B,EAAA,SAAAnP,EAAAmP,EAAAlC,EAAA,KAAAugC,EAAAtqC,GAAA,KACA,EACA4sC,oBAAA,CACA/C,MAAA,EAAcgC,YAAAA,CAAA,CAAA/uC,KAAAA,CAAA,CAAA0G,UAAAnC,CAAA,CAAAwrC,WAAAA,CAAA,CAAAC,UAAAA,CAAA,CAA2D,GACzE7C,EAAA,GAAA4B,EAAA,MACA,cACA/uC,EACAsvC,CAAAA,EAAA/qC,GACA4oC,EAAA,MAAAS,EAAAz+B,EAAA5K,EAAA,cACA4oC,EAAA,IAAAh+B,EAAA5K,EAAA,YACAwrC,CAAAA,EAAA,kBACA,OACA5gC,EAAA6gC,EAAA,MACA,EACAC,gBAAA,CACAlD,MAAA,EAAc9/B,WAAAA,CAAA,CAAA+hC,eAAAA,CAAA,CAA4B,GAC1C7/B,EACA,iBAAAA,EAAAlC,EAAA,KAAAugC,EAAAwB,GAAA,CACA,IAEA,EACAkB,oBAAA,CACAnD,MAAA,EAAc/sC,KAAAA,CAAA,CAAAiN,WAAAA,CAAA,CAAkB,GAChCkC,EAAA,iBAAAnP,EAAAmP,EAAAlC,EAAA,UACA,EACAkjC,oBAAA,CACApD,MAAA,EAAc/sC,KAAAA,CAAA,CAAAovC,WAAAA,CAAA,CAAAniC,WAAAA,CAAA,CAAA/J,OAAAA,CAAA,CAAsC,GACpDiM,EACA,CACA,cACAnP,EACAmtC,EAAA,cAAAh+B,EAAAigC,EAAA,QACAjgC,EAAAlC,EAAA,KACAugC,EAAAtqC,GACA,CACA,IAEA,EACAktC,uBAAA,CACArD,MAAA,EAAc/sC,KAAAA,CAAA,CAAAovC,WAAAA,CAAA,CAAAniC,WAAAA,CAAA,CAAA/J,OAAAA,CAAA,CAAsC,GACpDiM,EACA,CACA,mBACAnP,EACAmtC,EAAA,cAAAh+B,EAAAigC,EAAA,QACAjgC,EAAAlC,EAAA,KACAugC,EAAAtqC,GACA,CACA,IAEA,EACAmtC,mBAAA,CACAtD,MAAA,EAAc/sC,KAAAA,CAAA,CAAAiN,WAAAA,CAAA,CAAAyiC,MAAAA,CAAA,CAAyB,GACvCvgC,EACA,CACA,eACAnP,EACAmP,EAAAlC,EAAA,KACAkgC,EAAA,KAAAh+B,EAAAugC,EAAA,QACA,CACA,IAEA,EACAY,kBAAA,CACAvD,MAAA,EAAc/sC,KAAAA,CAAA,CAAAiN,WAAAA,CAAA,CAAAoB,OAAAA,CAAA,CAA0B,GACxCc,EAAA,eAAAnP,EAAAmP,EAAAlC,EAAA,KAAAugC,EAAAn/B,GAAA,KACA,EACAkiC,yBAAA,CACAxD,MAAA,EAAc/sC,KAAAA,CAAA,CAAAiN,WAAAA,CAAA,CAAA/J,OAAAA,CAAA,CAA0B,GACxCiM,EAAA,gBAAAnP,EAAAmP,EAAAlC,EAAA,KAAAugC,EAAAtqC,GAAA,KACA,CACA,EAMA,SAAAiM,EAAAqhC,CAAA,CAAAC,EAAA,IACA,IAAAC,EAEA,cAAAA,CAAAA,EACAF,MAAAA,EACA,OACAA,EAAAtiC,MAAA,IAAA6vB,GAAA5uB,IAAA,CAAAshC,EAAA,GACAC,KAAA,IAAAA,EACAA,EACA,EACA,CAKA,SAAAlD,EAAA3jC,CAAA,EACA,OAAAsjC,EAAA,MAAgBS,EAAAz+B,EAAAtF,EAAA,aAChB,CAKA,SAAAsjC,EAAA7rB,CAAA,CAAAqvB,CAAA,CAAAC,EAAA,IACA,OAAAD,MAAAA,GAAAA,KAAAA,EACArvB,EAAAqvB,EAAAC,EACA,EACA,CAEA,SAAAhD,EAAAlB,CAAA,EACA,OAAAS,EAAA,KAAAT,EAAA5nC,OAAA,eACA,CAEA,SAAAwqC,EAAAkB,CAAA,EACA,IAAAK,EAKA,cAAAA,CAAAA,EACAL,MAAAA,EACA,OACAA,EAAA1qB,IAAA,IAAA4mB,EAAA50B,QAAA,UACA+4B,KAAA,IAAAA,GACAA,CAEA,sCC9UWC,EAAKx0C,OAAAC,MAAA,UAAAqkC,CAAA,EAChB,IAAAjlC,EAAA4wC,EAAAxrC,GAAA,CAAA6/B,GAKA,OAJAjlC,IACAA,EDES,GAAAw6B,EAAAC,EAAA,ECFiBwK,EDEZiM,GCDdN,EAAA5iC,GAAA,CAAAi3B,EAAAjlC,IAEAA,CACA,EAAC,CACDigB,MAAA,WACA2wB,EAAA,IAAyB5uB,EAAAre,CAAoB,CAAC7G,EAAAC,CAAU,CAAAmjB,KAAA,MACxD,CACA,GACAi1B,EAAKl1B,KAAA,GACL,KAAA/e,WAAAC,OAAA,EACI,GAAAC,EAAAuqC,EAAA,EAAmB,mBAAwB,OAAAiF,EAAAA,EAAAj5B,IAAA,gOC+JxC,SAAAy9B,EAAAp1C,CAAA,CAAA6O,CAAA,CAAA7K,CAAA,EAEP,QADAD,EACA0E,EAAA,EAAAzJ,EAAA6P,EAAAuC,UAAA,CAAmD3I,EAAAzJ,EAAA+C,MAAA,CAAgB0G,IAAA,CACnE,IAAA4I,EAAArS,CAAA,CAAAyJ,EAAA,CACA,GAAA4sC,EAAAhkC,GACA,IAAAA,eAAAA,EAAAhN,IAAA,CAAArD,KAAA,CACA,OAAAhB,CAAA,CAAAs1C,EAAAjkC,GAAA,MAGAtN,EACAA,EAAAyF,IAAA,CAAA6H,GAGAtN,EAAA,CAAAsN,EAAA,CAGA,oBAAArR,EAAAwC,UAAA,CACA,OAAAxC,EAAAwC,UAAA,CAEA,GAAAuB,EACA,QAAA4H,EAAA,EAAA4pC,EAAAxxC,EAAkD4H,EAAA4pC,EAAAxzC,MAAA,CAAyB4J,IAAA,CAC3E,IAAA0F,EAAAkkC,CAAA,CAAA5pC,EAAA,CACA9C,EAAAusC,EAAAp1C,EAAyD,GAAAw1C,EAAA3jC,EAAA,EAAwBR,EAAArN,GAAA6K,YAAA,CAAA7K,GACjF,oBAAA6E,EACA,OAAAA,CAEA,CAEA,4HAzMO,SAAA4sC,EAAA/2C,CAAA,EACP,OAAa2G,MAAAqR,OAAAhY,EAAA,CACb,CACO,SAAAkJ,EAAAyB,CAAA,EACP,MAAAqS,CAAAA,CAAArS,CAAAA,GAAA,iBAAAA,GAAA,iBAAAA,EAAAhE,KAAA,CACA,CACO,SAAAqwC,EAAA10C,CAAA,EACP,MAAY,GAAA20C,EAAAhyC,CAAA,EAAe3C,IAC3BA,aAAAA,EAAA8Q,IAAA,EACAlQ,MAAAC,OAAA,CAAAb,EAAAq0B,WAAA,CACA,CA4BO,SAAAugB,EAAAC,CAAA,CAAAxxC,CAAA,CAAArD,CAAA,CAAAU,CAAA,EACP,GAAAo0C,aArBA90C,EAAA8Q,IAAA,EAGA9Q,eAAAA,EAAA8Q,IAAA,CAmBA+jC,CAAA,CAAAxxC,EAAArD,KAAA,EAAA+0C,OAAA/0C,EAAAA,KAAA,OAEA,GAAAg1C,iBA3BAh1C,EAAA8Q,IAAA,EAHA9Q,gBAAAA,EAAA8Q,IAAA,CA+BA+jC,CAAA,CAAAxxC,EAAArD,KAAA,EAAAA,EAAAA,KAAA,MAEA,GAlBAA,gBAAAA,EAAA8Q,IAAA,CAkBA,CACA,IAAAmkC,EAAA,GACAj1C,EAAAuG,MAAA,CAAAlH,GAAA,UAAAgJ,CAAA,EACA,OAAAusC,EAAAK,EAAA5sC,EAAAhF,IAAA,CAAAgF,EAAArI,KAAA,CAAAU,EACA,GACAm0C,CAAA,CAAAxxC,EAAArD,KAAA,EAAAi1C,CACA,MACA,GA5BAj1C,aAAAA,EAAA8Q,IAAA,CA4BA,CACA,IAAAokC,EAAA,CAAAx0C,GAAA,GAA4C,CAAAV,EAAAqD,IAAA,CAAArD,KAAA,EAC5C60C,CAAA,CAAAxxC,EAAArD,KAAA,EAAAk1C,CACA,MACA,GA1BAl1C,cAAAA,EAAA8Q,IAAA,CA2BA+jC,CAAA,CAAAxxC,EAAArD,KAAA,EAAAA,EAAA0R,MAAA,CAAArS,GAAA,UAAA81C,CAAA,EACA,IAAAC,EAAA,GAEA,OADAR,EAAAQ,EAAA/xC,EAAA8xC,EAAAz0C,GACA00C,CAAA,CAAA/xC,EAAArD,KAAA,SAGA,GA9BAA,cAAAA,EAAA8Q,IAAA,CA+BA+jC,CAAA,CAAAxxC,EAAArD,KAAA,EAAAA,EAAAA,KAAA,MAEA,GA9BAA,cAAAA,EAAA8Q,IAAA,CA+BA+jC,CAAA,CAAAxxC,EAAArD,KAAA,YAGA,KAAc,GAAA4tC,EAAA18B,EAAA,EAAiB,GAAA7N,EAAArD,KAAA,CAAAA,EAAA8Q,IAAA,CAE/B,CACO,SAAAukC,EAAAvmC,CAAA,CAAApO,CAAA,EACP,IAAA40C,EAAA,IACAxmC,CAAAA,EAAAwB,UAAA,GACAglC,EAAA,GACAxmC,EAAAwB,UAAA,CAAAlK,OAAA,UAAA+0B,CAAA,EACAma,CAAA,CAAAna,EAAA93B,IAAA,CAAArD,KAAA,KACAm7B,EAAApxB,SAAA,EACAoxB,EAAApxB,SAAA,CAAA3D,OAAA,UAAApI,CAAA,EACA,IAAAqF,EAAArF,EAAAqF,IAAA,CAAArD,EAAAhC,EAAAgC,KAAA,CACA,OAAA40C,EAAAU,CAAA,CAAAna,EAAA93B,IAAA,CAAArD,KAAA,EAAAqD,EAAArD,EAAAU,EACA,EAEA,IAEA,IAAAm0C,EAAA,KAQA,OAPA/lC,EAAA/E,SAAA,EAAA+E,EAAA/E,SAAA,CAAAhJ,MAAA,GACA8zC,EAAA,GACA/lC,EAAA/E,SAAA,CAAA3D,OAAA,UAAApI,CAAA,EACA,IAAAqF,EAAArF,EAAAqF,IAAA,CAAArD,EAAAhC,EAAAgC,KAAA,CACA,OAAA40C,EAAAC,EAAAxxC,EAAArD,EAAAU,EACA,IAEA60C,EAAAzmC,EAAAzL,IAAA,CAAArD,KAAA,CAAA60C,EAAAS,EACA,CACA,IAAAE,EAAA,CACA,aACA,UACA,OACA,SACA,OACA,SACA,cACA,CAIAC,EAA4BC,EAAArrC,CAAkB,CACvCkrC,EAAA51C,OAAAC,MAAA,UAAAoF,CAAA,CAAA4C,CAAA,CAAA0I,CAAA,EACP,GAAA1I,GACA0I,GACAA,EAAA,YACAA,EAAA,gBACA,GAAAA,CAAAA,EAAA,oBACAA,CAAAA,EAAA,kBAAAvP,MAAA,IAYA,OAAAuP,EAAA,eAXA,IAAAqlC,EAAArlC,EAAA,kBACAA,EAAA,kBACA,GACAqlC,EAAAjtC,IAAA,GACA,IAAAktC,EAAA,GAIA,OAHAD,EAAAvvC,OAAA,UAAAsD,CAAA,EACAksC,CAAA,CAAAlsC,EAAA,CAAA9B,CAAA,CAAA8B,EAAA,GAEA,GAAA/H,MAAA,CAAA2O,EAAA,oBAAA3O,MAAA,CAAA8zC,EAAAG,GAAA,IAKA,CACA,IAAAC,EAAA7wC,EACA,GAAA4C,EAAA,CAIA,IAAAkuC,EAAAL,EAAA7tC,GACAiuC,GAAA,IAAAl0C,MAAA,CAAAm0C,EAAA,IACA,CAaA,OAZAxlC,GACA3Q,OAAAwG,IAAA,CAAAmK,GAAAlK,OAAA,UAAAsD,CAAA,EACA,KAAA8rC,EAAA/9B,OAAA,CAAA/N,KAEA4G,CAAA,CAAA5G,EAAA,EAAA/J,OAAAwG,IAAA,CAAAmK,CAAA,CAAA5G,EAAA,EAAA3I,MAAA,CACA80C,GAAA,IAAAl0C,MAAA,CAAA+H,EAAA,KAAA/H,MAAA,CAAA8zC,EAAAnlC,CAAA,CAAA5G,EAAA,OAGAmsC,GAAA,IAAAl0C,MAAA,CAAA+H,GAEA,GAEAmsC,CACA,EAAC,CACDE,aAAA,SAAApzC,CAAA,EACA,IAAAsnB,EAAAwrB,EAEA,OADAA,EAAA9yC,EACAsnB,CACA,CACA,GACO,SAAA+rB,EAAAlnC,CAAA,CAAApO,CAAA,EACP,GAAAoO,EAAA/E,SAAA,EAAA+E,EAAA/E,SAAA,CAAAhJ,MAAA,EACA,IAAAk1C,EAAA,GAKA,OAJAnnC,EAAA/E,SAAA,CAAA3D,OAAA,UAAApI,CAAA,EAEA,OAAA42C,EAAAqB,EADAj4C,EAAAqF,IAAA,CAAArF,EAAAgC,KAAA,CACAU,EACA,GACAu1C,CACA,CACA,WACA,CACO,SAAA3B,EAAAxlC,CAAA,EACP,OAAAA,EAAAiiC,KAAA,CAAAjiC,EAAAiiC,KAAA,CAAA/wC,KAAA,CAAA8O,EAAAzL,IAAA,CAAArD,KAAA,CA+BO,SAAAq0C,EAAAhkC,CAAA,EACP,MAAAA,UAAAA,EAAAS,IAAA,CAEO,SAAAolC,EAAA7lC,CAAA,EACP,MAAAA,mBAAAA,EAAAS,IAAA,8NC3MAqlC,EAAA,CACArlC,KAAUs9B,EAAAp9B,CAAI,CAAAknB,KAAA,CACd70B,KAAA,CACAyN,KAAcs9B,EAAAp9B,CAAI,CAAAolC,IAAA,CAClBp2C,MAAA,YACA,CACA,EAsCA,SAAAq2C,EAAAC,CAAA,EACA,IAAAj3C,EAAA,IAAAmN,IACA,gBAAA9C,CAAA,EACA,SAAAA,GAA8BA,CAAAA,EAAA4sC,CAAA,EAC9B,IAAAC,EAAAl3C,EAAA+E,GAAA,CAAAsF,GAWA,OAVA6sC,GACAl3C,EAAA2N,GAAA,CAAAtD,EAAA6sC,EAAA,CAKA71C,UAAA,IAAAuI,IACAutC,gBAAA,IAAAvtC,GACA,GAEAstC,CACA,CACA,CACO,SAAAE,EAAAnmC,CAAA,CAAAs+B,CAAA,EACH,GAAA8H,EAAArJ,EAAA,EAAauB,GAuBjB,QAlEAX,EACA0I,EAPA/H,EAsDAgI,EAAAP,EAAA,IACAQ,EAAAR,EAAA,IACAS,EAAA,SAAAlb,CAAA,EACA,QAAAnwB,EAAA,EAAAsrC,EAAA,OAA2CtrC,EAAAmwB,EAAA76B,MAAA,EAAAg2C,CAAAA,EAAAnb,CAAA,CAAAnwB,EAAA,EAAmD,EAAAA,EAC9F,IAAgB,GAAAurC,EAAA96C,CAAA,EAAO66C,IAEvB,GAAAA,EAAAjmC,IAAA,GAAkCs9B,EAAAp9B,CAAI,CAAAimC,oBAAA,CAEtC,OAAAL,EAAAG,EAAA1zC,IAAA,EAAA0zC,EAAA1zC,IAAA,CAAArD,KAAA,EAEA,GAAA+2C,EAAAjmC,IAAA,GAAkCs9B,EAAAp9B,CAAI,CAAAkmC,mBAAA,CACtC,OAAAL,EAAAE,EAAA1zC,IAAA,CAAArD,KAAA,EAIA,MADAE,CAAA,IAAAA,WAAAC,OAAA,EAAwCytC,EAAAhoC,EAAS,CAAAtG,KAAA,KACjD,IACA,EACA63C,EAAA,EACAr2C,EAAA8tC,EAAAva,WAAA,CAAAtzB,MAAA,GAA6CD,GAAA,EAAQ,EAAAA,EACrD8tC,EAAAva,WAAA,CAAAvzB,EAAA,CAAAgQ,IAAA,GAAwCs9B,EAAAp9B,CAAI,CAAAimC,oBAAA,EAC5C,EAAAE,EAGA,IAAAC,GAvEAnJ,EAAA,IAAAzhC,IACAmqC,EAAA,IAAAnqC,IACAk5B,EAAAt/B,OAAA,UAAA+0B,CAAA,EACAA,IACAA,EAAA93B,IAAA,CACA4qC,EAAAjhC,GAAA,CAAAmuB,EAAA93B,IAAA,CAAA83B,GAEAA,EAAArkB,IAAA,EACA6/B,EAAA3pC,GAAA,CAAAmuB,EAAArkB,IAAA,CAAAqkB,GAGA,GACA,SAAAA,CAAA,EACA,IAAA/4B,EAAA6rC,EAAA7pC,GAAA,CAAA+2B,EAAA93B,IAAA,CAAArD,KAAA,EAQA,MAPA,CAAAoC,GAAAu0C,EAAAhgC,IAAA,EACAggC,EAAAvwC,OAAA,UAAAixC,CAAA,CAAAvgC,CAAA,EACAA,EAAAqkB,IACA/4B,CAAAA,EAAAi1C,CAAA,CAEA,GAEAj1C,CACA,GAkDAk1C,EAAA,SAAAC,CAAA,EACA,MAAe,GAAAP,EAAAhkC,CAAA,EAAeukC,IAC9BA,EACAl4C,GAAA,CAAA+3C,GACAjuB,IAAA,UAAA/mB,CAAA,EAA0C,OAAAA,GAAAA,EAAA+xB,MAAA,EAC1C,EACAqjB,EAAA,IAAAhrC,IAMAirC,EAAA,GACAC,EAAA,CACA/d,MAAA,SAAAxsB,CAAA,EACA,GAAAmqC,EAAAnqC,EAAAmD,UAAA,EAEA,OADAmnC,EAAA,GACA,IAEA,CACA,EACAE,EAAsC,GAAAC,EAAAne,EAAA,EAAKmV,EAAA,CAE3CkC,MAAA4G,EACAvG,eAAAuG,EACAhH,mBAAA,CACA/W,MAAA,WAKA,QACA,CACA,EACAuM,SAAA,CACAvM,MAAA,SAAAxsB,CAAA,CAAAg5B,CAAA,CAAA0R,CAAA,CAAAC,CAAA,CAAAlc,CAAA,EACA,IAAA2a,EAAAO,EAAAlb,GACA2a,GACAA,EAAA71C,SAAA,CAAAwI,GAAA,CAAAiE,EAAA9J,IAAA,CAAArD,KAAA,CAEA,CACA,EACA67B,eAAA,CACAlC,MAAA,SAAAxsB,CAAA,CAAAg5B,CAAA,CAAA0R,CAAA,CAAAC,CAAA,CAAAlc,CAAA,EACA,GAAA0b,EAAAnqC,EAAAmD,UAAA,EAEA,OADAmnC,EAAA,GACA,KAEA,IAAAlB,EAAAO,EAAAlb,GACA2a,GACAA,EAAAC,eAAA,CAAAttC,GAAA,CAAAiE,EAAA9J,IAAA,CAAArD,KAAA,CAOA,CACA,EACAoxC,mBAAA,CACAzX,MAAA,SAAAxsB,CAAA,CAAAg5B,CAAA,CAAA0R,CAAA,CAAAp3C,CAAA,EACA+2C,EAAAxqC,GAAA,CAAApL,KAAAC,SAAA,CAAApB,GAAA0M,EACA,EACAijC,MAAA,SAAAjjC,CAAA,CAAAg5B,CAAA,CAAA0R,CAAA,CAAAp3C,CAAA,SAEA,IADA+2C,EAAApzC,GAAA,CAAAxC,KAAAC,SAAA,CAAApB,IAQA0M,EAMAgqC,EAAA,GACAhqC,EAAAU,YAAA,CAAAuC,UAAA,CAAAyH,KAAA,UAAAxH,CAAA,EACA,OAAAA,EAAAS,IAAA,GAAkDs9B,EAAAp9B,CAAI,CAAAknB,KAAA,EACtD7nB,eAAAA,EAAAhN,IAAA,CAAArD,KAAA,IAKA62C,EAAA1pC,EAAA9J,IAAA,CAAArD,KAAA,EAAA+3C,OAAA,IACAN,EAAA,GACA,YAEA,CACA,EACA/d,UAAA,CACA0W,MAAA,SAAAjjC,CAAA,EAIA,GAAAiqC,EAAAjqC,GAEA,OADAsqC,EAAA,GACA,IAEA,CACA,CACA,GACA,IAAAA,EAGA,OAAA7I,EAOA,IAAAoJ,EAAA,SAAAzB,CAAA,EAWA,OAVAA,EAAA0B,cAAA,GACA1B,EAAA0B,cAAA,KAAAhvC,IAAAstC,EAAA71C,SAAA,EACA61C,EAAAwB,OAAA,EACAxB,EAAAC,eAAA,CAAApwC,OAAA,UAAA8xC,CAAA,EACAF,EAAAnB,EAAAqB,IAAAD,cAAA,CAAA7xC,OAAA,UAAA+xC,CAAA,EACA5B,EAAA0B,cAAA,CAAA/uC,GAAA,CAAAivC,EACA,EACA,IAGA5B,CACA,EAIA6B,EAAA,IAAAnvC,IACA0uC,EAAAtjB,WAAA,CAAAjuB,OAAA,UAAA9C,CAAA,EACAA,EAAAwN,IAAA,GAAyBs9B,EAAAp9B,CAAI,CAAAimC,oBAAA,CAC7Be,EAAApB,EAAAtzC,EAAAD,IAAA,EAAAC,EAAAD,IAAA,CAAArD,KAAA,GAAAw2C,eAAA,CAAApwC,OAAA,UAAA8xC,CAAA,EACAE,EAAAlvC,GAAA,CAAAgvC,EACA,GAEA50C,EAAAwN,IAAA,GAA8Bs9B,EAAAp9B,CAAI,CAAAkmC,mBAAA,EAKlCC,IAAAA,GACAN,EAAAvzC,EAAAD,IAAA,CAAArD,KAAA,EAAA+3C,OAAA,EACAK,EAAAlvC,GAAA,CAAA5F,EAAAD,IAAA,CAAArD,KAAA,CAEA,GAIAo4C,EAAAhyC,OAAA,UAAAtI,CAAA,EAGAk6C,EAAAnB,EAAA/4C,IAAA04C,eAAA,CAAApwC,OAAA,UAAA8xC,CAAA,EACAE,EAAAlvC,GAAA,CAAAgvC,EACA,EACA,GASA,IAAAG,EAAA,CACA1e,MAAA,SAAAxsB,CAAA,MATArP,EAUA,GAVAA,EAUAqP,EAAA9J,IAAA,CAAArD,KAAA,CALA,CAAAo4C,EAAA5zC,GAAA,CAAA1G,IACA+4C,EAAA/4C,GAAAi6C,OAAA,CAKA,WAEA,CACA,EACA,OA1PAnJ,EA0P4B,GAAAgJ,EAAAne,EAAA,EAAKke,EAAA,CAGjC9b,eAAAwc,EAEAjH,mBAAAiH,EACA/H,oBAAA,CACAF,MAAA,SAAAjjC,CAAA,EAGA,GAAAA,EAAA+b,mBAAA,EACA,IAAAovB,EAAAN,EAEApB,EAAAzpC,EAAA9J,IAAA,EAAA8J,EAAA9J,IAAA,CAAArD,KAAA,GAAAi4C,cAAA,CAYA,GAAAK,EAAA3hC,IAAA,CAAAxJ,EAAA+b,mBAAA,CAAAnoB,MAAA,CACA,MAA+B,GAAAw3C,EAAA/6C,EAAA,EAAS,GAAA+6C,EAAA/6C,EAAA,EAAQ,GAAG2P,GAAA,CAAW+b,oBAAA/b,EAAA+b,mBAAA,CAAA3X,MAAA,UAAAinC,CAAA,EAC9D,OAAAF,EAAA9zC,GAAA,CAAAg0C,EAAApvB,QAAA,CAAA/lB,IAAA,CAAArD,KAAA,CACA,EAA6B,EAE7B,CACA,CACA,CACA,GA1RA,CAAAy4C,SARAA,EAAA3X,CAAA,CAAA99B,CAAA,EACA,OAAA89B,GACAA,EAAAjzB,YAAA,CAAAuC,UAAA,CAAAyH,KAAA,UAAAxH,CAAA,EACA,OAAAA,EAAAS,IAAA,GAAsCs9B,EAAAp9B,CAAI,CAAAC,eAAA,EAC1CwnC,EAAAz1C,CAAA,CAAAqN,EAAAhN,IAAA,CAAArD,KAAA,EAAAgD,EACA,EACA,EAEoB,GAAA0zC,EAAA58B,EAAA,EAAsB80B,IAAS,GAAA8H,EAAAgC,EAAA,EAAqB9J,GAAO,GAAA4F,EAAAvxC,CAAA,EAAkB,GAAAyzC,EAAAvzC,EAAA,EAAsByrC,KAEvHA,EADA,IA0RA,CACO,IAAA5uB,EAAArgB,OAAAC,MAAA,UAAAgvC,CAAA,EACP,MAAW,GAAAgJ,EAAAne,EAAA,EAAKmV,EAAA,CAChBgC,aAAA,CACAjX,MAAA,SAAAxsB,CAAA,CAAAg5B,CAAA,CAAA9gC,CAAA,EAEA,GAAAA,CAAAA,GACAA,EAAAyL,IAAA,GACwBs9B,EAAAp9B,CAAI,CAAAimC,oBAAA,EAI5B,IAAA7mC,EAAAjD,EAAAiD,UAAA,CACA,MAAAA,GAKAA,EAAA+Y,IAAA,UAAA9Y,CAAA,EACA,MAA4B,GAAAsoC,EAAAnoC,EAAA,EAAOH,IACnCA,CAAAA,eAAAA,EAAAhN,IAAA,CAAArD,KAAA,EACAqQ,IAAAA,EAAAhN,IAAA,CAAArD,KAAA,CAAA44C,WAAA,SACA,MAOoB,IAAAD,EAAAnoC,EAAA,EADpBnL,IAEAyJ,EAAAwB,UAAA,EACAxB,EAAAwB,UAAA,CAAA6Y,IAAA,UAAAlf,CAAA,EAAyD,MAAAA,WAAAA,EAAA5G,IAAA,CAAArD,KAAA,EAAmC,EAI5F,MAAuB,GAAAu4C,EAAA/6C,EAAA,EAAS,GAAA+6C,EAAA/6C,EAAA,EAAQ,GAAG2P,GAAA,CAAWiD,WAAY,GAAAmoC,EAAAlM,EAAA,EAAc,GAAAkM,EAAAlM,EAAA,EAAa,GAAAj8B,EAAA,KAAA+lC,EAAA,OAC7F,CACA,CACA,EACA,EAAC,CACDvlC,MAAA,SAAA9B,CAAA,EACA,OAAAA,IAAAqnC,CACA,CACA,GAyGO,SAAA0C,EAAA97C,CAAA,QAGP,UADAwxC,CADqB,EAAAmI,EAAAnnC,EAAA,EAAiBxS,GACtCu3B,SAAA,CAGAv3B,EAGsB,GAAA66C,EAAAne,EAAA,EAAK18B,EAAA,CAC3BuzC,oBAAA,CACA3W,MAAA,SAAAxsB,CAAA,EACA,MAAuB,GAAAorC,EAAA/6C,EAAA,EAAS,GAAA+6C,EAAA/6C,EAAA,EAAQ,GAAG2P,GAAA,CAAWmnB,UAAA,SACtD,CACA,CACA,EAEA,CAEO,SAAAwkB,EAAA/7C,CAAA,EAQP,MAPI,GAAA25C,EAAArJ,EAAA,EAAatwC,GACjB05C,EAAA,CACA,CACA3/B,KAAA,SAAAqkB,CAAA,EAAyC,MAAAA,WAAAA,EAAA93B,IAAA,CAAArD,KAAA,EACzCm0B,OAAA,EACA,EACA,CAAAp3B,EAEA,yDC3dA,IAAAg8C,EAAA,IAAAp5C,OAAA8D,MAAA,OAEA,CAAQ2C,QAAAA,CAAA,CAAA0G,MAAAA,CAAA,EAAiBlM,MAAAzE,SAAA,CACzB,CAAQiF,eAAAA,CAAA,EAAiBzB,OAAAxD,SAAA,OAClB68C,EACPC,YAAAC,EAAA,GAAAC,EAAAJ,CAAA,EACA,KAAAG,QAAA,CAAAA,EACA,KAAAC,QAAA,CAAAA,CACA,CACA51C,QAAA,CACA,YAAAuG,WAAA,CAAAC,UACA,CACAD,YAAAoD,CAAA,EACA,IAAAC,EAAA,KAEA,OADA/G,EAAAzF,IAAA,CAAAuM,EAAAxD,GAAAyD,EAAAA,EAAAisC,YAAA,CAAA1vC,IACAtI,EAAAT,IAAA,CAAAwM,EAAA,QACAA,EAAApO,IAAA,CACAoO,EAAApO,IAAA,MAAAo6C,QAAA,CAAArsC,EAAAnM,IAAA,CAAAuM,GACA,CACAoB,MAAA,CACA,YAAA+qC,SAAA,CAAAtvC,UACA,CACAsvC,UAAAnsC,CAAA,EACA,IAAAC,EAAA,KACA,QAAArM,EAAA,EAAAw4C,EAAApsC,EAAAnM,MAAA,CAA4CoM,GAAArM,EAAAw4C,EAAiB,EAAAx4C,EAAA,CAC7D,IAAAzB,EAAA8N,EAAAosC,MAAA,CAAArsC,CAAA,CAAApM,EAAA,KACAqM,EAAA9N,GAAAA,EAAA+E,GAAA,CAAA8I,CAAA,CAAApM,EAAA,CACA,CACA,OAAAqM,GAAAA,EAAApO,IAAA,CAEAo1B,QAAA,CACA,YAAAqlB,WAAA,CAAAzvC,UACA,CACAyvC,YAAAtsC,CAAA,EACA,IAAAnO,EACA,GAAAmO,EAAAnM,MAAA,EACA,IAAA04C,EAAAvsC,CAAA,IACA7N,EAAA,KAAAk6C,MAAA,CAAAE,EAAA,IACA9vC,EAAAtK,GAAAA,EAAA+E,GAAA,CAAAq1C,IACA9vC,IACA5K,EAAA4K,EAAA6vC,WAAA,CAAA1sC,EAAAnM,IAAA,CAAAuM,EAAA,IACAvD,EAAA5K,IAAA,EAAA4K,EAAA1N,IAAA,EAAA0N,EAAA+vC,MAAA,EAAA/vC,EAAA+vC,MAAA,CAAA/iC,IAAA,EACAtX,EAAAsI,MAAA,CAAA8xC,GAGA,MAEA16C,EAAA,KAAAA,IAAA,CACA,YAAAA,IAAA,CAEA,OAAAA,CACA,CACAq6C,aAAA1vC,CAAA,EACA,IAAArK,EAAA,KAAAk6C,MAAA,CAAA7vC,EAAA,IACAC,EAAAtK,EAAA+E,GAAA,CAAAsF,GAGA,OAFAC,GACAtK,EAAA2N,GAAA,CAAAtD,EAAAC,EAAA,IAAAqvC,EAAA,KAAAE,QAAA,MAAAC,QAAA,GACAxvC,CACA,CACA4vC,OAAA7vC,CAAA,CAAAjG,CAAA,EACA,YAAAy1C,QAAA,EAAAS,SAKA35C,CAAA,EACA,cAAAA,GACA,aACA,GAAAA,OAAAA,EACA,KAEA,gBACA,QACA,CACA,QACA,EAfA0J,GACA,KAAAzN,IAAA,EAAAwH,CAAAA,EAAA,KAAAxH,IAAA,KAAAqQ,QAAA,QACA,KAAAotC,MAAA,EAAAj2C,CAAAA,EAAA,KAAAi2C,MAAA,KAAAltC,IAAA,OACA,CACA,kIC5DO,IAAAotC,EAAAj6C,OAAAyN,MAAA,KAgFA,SAAAysC,EAAArwC,CAAA,CAAAgwB,CAAA,CAAAsgB,EAA4CC,EAAAC,EAAiB,MAQpE7sB,EAMAzjB,EACArE,EAdA,IAAA40C,EAAA,IAAAztC,IAEA,QAAAsE,KAAAnR,OAAA+R,MAAA,CAAmCwoC,EAAAlpC,CAAI,EACvCipC,EAAAjtC,GAAA,CAAA8D,EAAAqpC,SA4OO3gB,CAAA,CAAA1oB,CAAA,EACP,IAAAspC,EAAA5gB,CAAA,CAAA1oB,EAAA,OAEA,iBAAAspC,EAEAA,EACI,mBAAAA,EAEJ,CACAzgB,MAAAygB,EACAhK,MAAA/oC,KAAAA,CACA,EAGA,CACAsyB,MAAAH,EAAAG,KAAA,CACAyW,MAAA5W,EAAA4W,KAAA,CAEA,EA9PA5W,EAAA1oB,IAKA,IAAAupC,EAAAz5C,MAAAC,OAAA,CAAA2I,GACArD,EAAA,CAAAqD,EAAA,CACA8wC,EAAA,GACAC,EAAA,GACAptC,EAAA3D,EAGA/I,EAAA,GACAm7B,EAAA,GAGA,OAwDA4e,EAAAC,EA+CAC,MAlDA17C,CApDAs7C,CAAAA,IACA,IAAAK,EAAAL,IAAAn0C,EAAApF,MAAA,CACA65C,EAAAD,GAAAJ,IAAAA,EAAAx5C,MAAA,CAEA,GAAA45C,EAAA,CAKA,GAJAjxC,EAAAkyB,IAAAA,EAAA76B,MAAA,CAAAsG,KAAAA,EAAA5G,CAAA,CAAAA,EAAAM,MAAA,IACAoM,EAAA9H,EACAA,EAAAu2B,EAAAte,GAAA,GAEAs9B,GACA,GAAAP,EAAA,CACAltC,EAAAA,EAAAL,KAAA,GACA,IAAA+tC,EAAA,EAEA,QAAAC,EAAAC,EAAA,GAAAR,EAAA,CACA,IAAAS,EAAAF,EAAAD,CAEAE,QAAAA,GACA5tC,EAAA8J,MAAA,CAAA+jC,EAAA,GACAH,KAEA1tC,CAAA,CAAA6tC,EAAA,CAAAD,CAEA,CACA,MAMA,QAAAD,EAAAC,EAAA,GALA5tC,EAAAxN,OAAAs7C,gBAAA,CACA,GACAt7C,OAAAu7C,yBAAA,CAAA/tC,IAGAotC,GACAptC,CAAA,CAAA2tC,EAAA,CAAAC,EAKAT,EAAAntB,EAAAmtB,KAAA,CACAn0C,EAAAgnB,EAAAhnB,IAAA,CACAo0C,EAAAptB,EAAAotB,KAAA,CACAF,EAAAltB,EAAAktB,OAAA,CACAltB,EAAAA,EAAAguB,IAAA,MACM,GAAA91C,EAAA,CAIN,GAAA8H,MAFAA,CAAAA,EAAA9H,CAAA,CADAqE,EAAA2wC,EAAAC,EAAAn0C,CAAA,CAAAm0C,EAAA,CACA,EAGA,SAGA75C,EAAA+H,IAAA,CAAAkB,EACA,CAIA,IAAA9I,MAAAC,OAAA,CAAAsM,GAAA,CAGM,GAAA4sC,EAAAqB,EAAA,EAAMjuC,IAAU,GAAAkuC,EAAAC,CAAA,EAAS,wBAA6B,GAAAC,EAAAj/B,CAAA,EAAOnP,GAAO,IAC1E,IAAAquC,EAAAb,EACA,OAAAH,CAAAA,EAAAP,EAAA71C,GAAA,CAAA+I,EAAA2D,IAAA,IACA0pC,KAAA,IAAAA,EACA,OACAA,EAAApK,KAAA,CACA,OAAAqK,CAAAA,EAAAR,EAAA71C,GAAA,CAAA+I,EAAA2D,IAAA,IACA2pC,KAAA,IAAAA,EACA,OACAA,EAAA9gB,KAAA,CAMA,GAAA36B,CALAA,EACAw8C,MAAAA,EACA,OACAA,EAAA76C,IAAA,CAAA64B,EAAArsB,EAAAzD,EAAArE,EAAA5E,EAAAm7B,EAAA,IAEAge,EACA,MAGA,GAAA56C,CAAA,IAAAA,EACA,KAAA27C,EAAA,CACAl6C,EAAA6c,GAAA,GACA,QACA,OACQ,GAAAte,KAAAqI,IAAArI,IACRu7C,EAAA/xC,IAAA,EAAAkB,EAAA1K,EAAA,EAEA,CAAA27C,IACA,GAAc,GAAAZ,EAAAqB,EAAA,EAAMp8C,GACpBmO,EAAAnO,MACY,CACZyB,EAAA6c,GAAA,GACA,QACA,EAGA,CAEAjW,KAAAA,IAAArI,GAAA47C,GACAL,EAAA/xC,IAAA,EAAAkB,EAAAyD,EAAA,EAGAwtC,EACAl6C,EAAA6c,GAAA,IAIA6P,EAAA,CACAktB,QAAAA,EACAC,MAAAA,EACAn0C,KAAAA,EACAo0C,MAAAA,EACAY,KAAAhuB,CACA,EAEAhnB,EAAAk0C,CADAA,EAAAz5C,MAAAC,OAAA,CAAAsM,EAAA,EAEAA,EACA,OAAAutC,CAAAA,EAAAZ,CAAA,CAAA3sC,EAAA2D,IAAA,IACA4pC,KAAA,IAAAA,EACAA,EACA,GACAJ,EAAA,GACAC,EAAA,GAEAl1C,GACAu2B,EAAApzB,IAAA,CAAAnD,GAGAA,EAAA8H,EAEA,OAAIggB,KAAA9lB,IAAA8lB,EAAA,QAEJ,IAAAotB,EAAAx5C,MAAA,CAEAw5C,CAAA,CAAAA,EAAAx5C,MAAA,OAGAyI,CACA,6BQ9NAiyC,mFPlBA,IAAA1C,EAAA,IAAAp5C,OAAA8D,MAAA,OAEA,CAAQ2C,QAAAA,CAAA,CAAA0G,MAAAA,CAAA,EAAiBlM,MAAAzE,SAAA,CACzB,CAAQiF,eAAcs6C,CAAA,EAAG/7C,OAAAxD,SAAA,OAClB68C,EACPC,YAAAC,EAAA,GAAAC,EAAAJ,CAAA,EACA,KAAAG,QAAA,CAAAA,EACA,KAAAC,QAAA,CAAAA,CACA,CACA51C,OAAA,GAAA2J,CAAA,EACA,YAAApD,WAAA,CAAAoD,EACA,CACApD,YAAAoD,CAAA,EACA,IAAAC,EAAA,KAEA,OADA/G,EAAAzF,IAAA,CAAAuM,EAAAxD,GAAAyD,EAAAA,EAAAisC,YAAA,CAAA1vC,IACegyC,EAAc/6C,IAAA,CAAAwM,EAAA,QAC7BA,EAAApO,IAAA,CACAoO,EAAApO,IAAA,MAAAo6C,QAAA,CAAArsC,EAAAnM,IAAA,CAAAuM,GACA,CACAoB,KAAA,GAAApB,CAAA,EACA,YAAAmsC,SAAA,CAAAnsC,EACA,CACAmsC,UAAAnsC,CAAA,EACA,IAAAC,EAAA,KACA,QAAArM,EAAA,EAAAw4C,EAAApsC,EAAAnM,MAAA,CAA4CoM,GAAArM,EAAAw4C,EAAiB,EAAAx4C,EAAA,CAC7D,IAAAzB,EAAA,KAAA65C,QAAA,EAAAS,EAAAzsC,CAAA,CAAApM,EAAA,EAAAqM,EAAAlR,IAAA,CAAAkR,EAAAusC,MAAA,CACAvsC,EAAA9N,GAAAA,EAAA+E,GAAA,CAAA8I,CAAA,CAAApM,EAAA,CACA,CACA,OAAAqM,GAAAA,EAAApO,IAAA,CAEAq6C,aAAA1vC,CAAA,EACA,IAAArK,EAAA,KAAA65C,QAAA,EAAAS,EAAAjwC,GACA,KAAAzN,IAAA,QAAAA,IAAA,KAAAqQ,OAAA,EACA,KAAAotC,MAAA,QAAAA,MAAA,KAAAltC,GAAA,EACA7C,EAAAtK,EAAA+E,GAAA,CAAAsF,GAGA,OAFAC,GACAtK,EAAA2N,GAAA,CAAAtD,EAAAC,EAAA,IAAAqvC,EAAA,KAAAE,QAAA,MAAAC,QAAA,GACAxvC,CACA,CACA,CACA,SAAAgwC,EAAA35C,CAAA,EACA,cAAAA,GACA,aACA,GAAAA,OAAAA,EACA,KAEA,gBACA,QACA,CACA,QACA,eCpDA,IAAA27C,EAAA,KAGAC,EAAA,GACAC,EAAA,EAsGA,SAAAC,EAAAjd,CAAA,EACA,IACA,OAAAA,GACA,CACA,MAAAkd,EAAA,EACA,CASA,IAAAC,EAAA,oBACAC,EAGAH,EAAA,IAAA57C,aAIA47C,EAAA,IAAAI,SAIAv8C,OAAA8D,MAAA,OAIO04C,EAAAC,CAAA,CAAAJ,EAAA,EAGPp7C,KAAA,CAAAo7C,EAAA,EACA,SAAAG,CAAA,EACA,IACAx8C,OAAA4jB,cAAA,CAPA04B,EAOAD,EAAA,CACAh8C,MAAAm8C,EACAp1B,WAAA,GACAs1B,SAAA,GAOAr1B,aAAA,EACA,EACA,QACA,CACA,OAAAm1B,CACA,CACA,EAtJA,MACAlD,aAAA,CAIA,KAAAv7C,EAAA,EACA,OACAm+C,IACAS,KAAAC,GAAA,GACAC,KAAAC,MAAA,GAAA7R,QAAA,KAAA99B,KAAA,IACA,CAAA0F,IAAA,KACA,CACAkqC,UAAA,CACA,QAAAn7C,EAAAo6C,EAA2Cp6C,EAASA,EAAAA,EAAA8D,MAAA,CAGpD,QAAA3H,EAAA,IAAA6D,EAAAo7C,KAAA,EACA,IAAA38C,EAAAuB,EAAAo7C,KAAA,MAAAj/C,EAAA,EACA,GAAAsC,IAAA47C,EACA,MAOA,OANAr6C,IAAAo6C,GAIAA,CAAAA,EAAAgB,KAAA,MAAAj/C,EAAA,EAAAsC,CAAA,EAEA,EACA,CAQA,OANA27C,GAIAA,CAAAA,EAAAgB,KAAA,MAAAj/C,EAAA,EAAAk+C,CAAA,EAEA,EACA,CACAx6B,UAAA,CACA,QAAAs7B,QAAA,GACA,OAAAf,EAAAgB,KAAA,MAAAj/C,EAAA,EAGA6a,UAAAvY,CAAA,CAAArB,CAAA,CAGAiJ,CAAA,CAAAg1C,CAAA,EACA,IAAAD,EAAA,CACA37C,UAAA,KACA,MAAAtD,EAAA,EAAAsC,CACA,EACAqF,EAAAs2C,EACAA,EAAA,CAA2Bt2C,OAAAA,EAAAs3C,MAAAA,CAAA,EAC3B,IAGA,OAAAh+C,EAAA+M,KAAA,CAAAkxC,EAAAh1C,EACA,QACA,CACA+zC,EAAAt2C,CACA,CACA,CAGA,OAAA8gB,KAAAxnB,CAAA,EACA,IAAA4C,EAAAo6C,EACA,kBACA,IAAAkB,EAAAlB,EACA,IAEA,OADAA,EAAAp6C,EACA5C,EAAA+M,KAAA,MAAA3B,UACA,QACA,CACA4xC,EAAAkB,CACA,CACA,CACA,CAEA,OAAAC,UAAAn+C,CAAA,CAGAiJ,CAAA,CAAAg1C,CAAA,EACA,IAAAjB,EAaA,OAAAh9C,EAAA+M,KAAA,CAAAkxC,EAAAh1C,EAbA,EACA,IAAAi1C,EAAAlB,EACA,IAIA,OAHAA,EAAA,KAGAh9C,EAAA+M,KAAA,CAAAkxC,EAAAh1C,EACA,QACA,CACA+zC,EAAAkB,CACA,CACA,CAIA,CACA,GC1GO,CAAQ12B,KAAAA,CAAA,CAAA22B,UAAAA,CAAA,EAAoBX,ECD5BY,EAAA,IAA4BZ,ECD5B,CAAQ/6C,eAAc47C,CAAA,EAAIr9C,OAAAxD,SAAA,CAC1B8gD,EAAAr8C,MAAA7C,IAAA,EACP,SAAAiP,CAAA,EACA,IAAAE,EAAA,GAEA,OADAF,EAAA5G,OAAA,CAAAoL,GAAAtE,EAAA1E,IAAA,CAAAgJ,IACAtE,CACA,EACO,SAAAgwC,EAAAC,CAAA,EACP,IAAY56B,YAAAA,CAAA,EAAc46B,CAC1B,oBAAA56B,IACA46B,EAAA56B,WAAA,QACAA,IAEA,CCXA,IAAA66B,EAAA,GAIA,SAAAC,EAAAC,CAAA,CAAAC,CAAA,EACA,IAAAD,EACA,YAAAC,GAAA,oBAEA,CACA,SAAAC,EAAAlC,CAAA,CAAAmC,CAAA,EACA,IAAAnE,EAAAgC,EAAAv6C,MAAA,CACA,OAEAu4C,EAAA,GAEAA,IAAAmE,EAAA18C,MAAA,EAEAu6C,CAAA,CAAAhC,EAAA,KAAAmE,CAAA,CAAAnE,EAAA,GAEA,SAAAoE,EAAA19C,CAAA,EACA,OAAAA,EAAAe,MAAA,EACA,mCACA,eAAAf,CAAA,SACA,QAAAA,CAAA,IAEA,CAIO,MAAA29C,EACP1E,YAAApa,CAAA,EACA,KAAAA,EAAA,CAAAA,EACA,KAAA+e,OAAA,KAAA30C,IACA,KAAA40C,WAAA,KAAArxC,IAIA,KAAAsxC,aAAA,MACA,KAAAx3C,KAAA,IACA,KAAAy3C,WAAA,IACA,KAAA/9C,KAAA,IACA,KAAAg+C,IAAA,MACA,EAAAL,EAAA50C,KAAA,CAEAuF,MAAA,CACA,YAAAtO,KAAA,CAAAe,MAAA,GAAAk9C,EAAA,MAEA,OADAC,EAAA,MACA,KAAAl+C,KAAA,IASAm+C,UAAAv2C,CAAA,MAyIA+B,EAtIA,OAFA0zC,EAAA,MAAAU,WAAA,wBACAG,EAAA,MACAD,EAAA,QA4EAG,EA3EA,MA6EIrB,EAAexkC,SAAA,CA7EnB,KA6EmB8lC,EAAA,CA7EnB,KAAAz2C,EA6EmB,EACnB02C,SA6IA/nB,CAAA,CAAA3uB,CAAA,EACA,sBAAA2uB,EAAAjU,SAAA,CACA,IACY46B,EAAgB3mB,GAC5BA,EAAAhU,WAAA,CAAAgU,EAAAjU,SAAA,CAAA5W,KAAA,MAAA9D,EACA,CACA,MAAA8T,EAAA,CAMA,OADA6a,EAAAgoB,QAAA,GACA,EACA,CAIA,QACA,EA7OA,KAAA32C,KA0HA2uB,IA1HA,CA0HAjwB,KAAA,IACA23C,EA3HA,QAqIAt0C,EArIA,KAsIA60C,EAAA70C,EAAA80C,MArIAf,EAAA,KAAA19C,KAAA,CACA,CACAu+C,UAAA,CACA,KAAAj4C,KAAA,GAEA,KAAAA,KAAA,IA6HAk4C,EA5HA,KA4HAE,GAxHQxB,EAAgB,MACxB,CACAyB,SAAA,CACA,KAAAJ,QAAA,GAIAH,EAAA,MAYAI,EAAA,MAAAn5C,EAAAsE,KACAtE,EAAAk5C,QAAA,GACAK,EAAAv5C,EAAA,KACA,EACA,CACA2Z,QAAA,CAIA,KAAA2/B,OAAA,EACA,CACAE,SAAAl+B,CAAA,EACAA,EAAAzX,GAAA,OACA,KAAA80C,IAAA,EACA,MAAAA,IAAA,CAAAZ,EAAA9/B,GAAA,QAAArU,GAAA,EAEA,KAAA+0C,IAAA,CAAA90C,GAAA,CAAAyX,EACA,CACAm+B,YAAA,CACA,KAAAd,IAAA,GACYf,EAAY,KAAAe,IAAA,EAAA53C,OAAA,CAAAua,GAAAA,EAAAhZ,MAAA,QACxB,KAAAq2C,IAAA,CAAA91C,KAAA,GACAk1C,EAAA50C,IAAA,MAAAw1C,IAAA,EACA,KAAAA,IAAA,MAEA,CACA,CAEA,SAAAE,EAAAv0C,CAAA,EACA,IAAAtE,EAAmB03C,EAAe37B,QAAA,GAClC,GAAA/b,EAWA,OAVAsE,EAAAi0C,OAAA,CAAA10C,GAAA,CAAA7D,GACAA,EAAAw4C,WAAA,CAAAr5C,GAAA,CAAAmF,IACAtE,EAAAw4C,WAAA,CAAA7wC,GAAA,CAAArD,EAAA,IAEAs0C,EAAAt0C,GACA+0C,EAAAr5C,EAAAsE,GAGA80C,EAAAp5C,EAAAsE,GAEAtE,CAEA,CAYA,SAAAg5C,EAAA9nB,CAAA,CAAA3uB,CAAA,MAGAm3C,CAFAxoB,CAAAA,EAAAwnB,WAAA,IACA,IAAYiB,gBAAAA,CAAA,EAAkBzoB,EAE9ByoB,GAAAzoB,IAAAA,EAAAv2B,KAAA,CAAAe,MAAA,EACAg+C,CAAAA,EA3HA/+C,EA2HAA,KAAA,CA3HA8M,KAAA,GA2HA,EAGAypB,EAAAv2B,KAAA,CAAAe,MAAA,GACA,IAOA,GALAw1B,EAAAv2B,KAAA,IAAAu2B,EAAAsI,EAAA,CAAAnzB,KAAA,MAAA9D,GAKAo3C,GAAAD,GAAA,CAAAvB,EAAAuB,EAAAxoB,EAAAv2B,KAAA,EACA,IACAu2B,EAAAv2B,KAAA,IAAAg/C,EAAAzoB,EAAAv2B,KAAA,IAAA++C,CAAA,IACA,CACA,MAAA/gD,EAAA,CAGA,CAEA,CACA,MAAA0d,EAAA,CAEA6a,EAAAv2B,KAAA,IAAA0b,CACA,CAEA6a,EAAAwnB,WAAA,GACA,CACA,SAAAE,EAAA1nB,CAAA,EACA,OAAAA,EAAAjwB,KAAA,IAAAiwB,CAAAA,EAAAunB,aAAA,EAAAvnB,EAAAunB,aAAA,CAAAnnC,IAAA,CACA,CAgBA,SAAA6nC,EAAA70C,CAAA,CAAAhL,CAAA,EACA,IAAAsgD,EAAAt1C,EAAAi0C,OAAA,CAAAjnC,IAAA,CACA,GAAAsoC,EAAA,CACA,IAAArB,EAAwBX,EAAYtzC,EAAAi0C,OAAA,EACpC,QAAA98C,EAAA,EAAwBA,EAAAm+C,EAAiB,EAAAn+C,EACzCnC,EAAAi/C,CAAA,CAAA98C,EAAA,CAAA6I,EAEA,CACA,CAEA,SAAA+0C,EAAAr5C,CAAA,CAAAsE,CAAA,EAGA0zC,EAAAh4C,EAAAw4C,WAAA,CAAAr5C,GAAA,CAAAmF,IACA0zC,EAAAY,EAAAt0C,IACA,IAAAu1C,EAAA,CAAAjB,EAAA54C,GACA,GAAAA,EAAAy4C,aAAA,CAGA,IAAAz4C,EAAAy4C,aAAA,CAAAt5C,GAAA,CAAAmF,GAIA,MACA,MAPAtE,EAAAy4C,aAAA,CAAAV,EAAA9/B,GAAA,QAAArU,IAQA5D,EAAAy4C,aAAA,CAAA50C,GAAA,CAAAS,GAGAu1C,GAjCAV,EAkCAn5C,EAlCAq5C,EAoCA,CAEA,SAAAD,EAAAp5C,CAAA,CAAAsE,CAAA,EAGA0zC,EAAAh4C,EAAAw4C,WAAA,CAAAr5C,GAAA,CAAAmF,IACA0zC,EAAA,CAAAY,EAAAt0C,IACA,IAAAw1C,EAAA95C,EAAAw4C,WAAA,CAAAz5C,GAAA,CAAAuF,EACAw1C,CAAA,IAAAA,EAAAp+C,MAAA,CACAsE,EAAAw4C,WAAA,CAAA7wC,GAAA,CAAArD,EAjNA3J,EAiNAA,KAAA,CAjNA8M,KAAA,KAmNA0wC,EAAA2B,EAAAx1C,EAAA3J,KAAA,GACAqF,EAAAk5C,QAAA,GAEAa,EAAA/5C,EAAAsE,GACAs0C,EAAA54C,IAhDAm5C,EAmDAn5C,EAnDAo5C,EAoDA,CACA,SAAAW,EAAA/5C,CAAA,CAAAsE,CAAA,EACA,IAAA01C,EAAAh6C,EAAAy4C,aAAA,CACAuB,IACAA,EAAA13C,MAAA,CAAAgC,GACA,IAAA01C,EAAA1oC,IAAA,GACAymC,EAAAr8C,MAAA,CA3PA,KA4PAq8C,EAAA50C,IAAA,CAAA62C,GAEAh6C,EAAAy4C,aAAA,OAGA,CAGA,SAAAM,EAAA/4C,CAAA,EACAA,EAAAw4C,WAAA,CAAAlnC,IAAA,IACAtR,EAAAw4C,WAAA,CAAAz3C,OAAA,EAAAk5C,EAAA31C,KACAi1C,EAAAv5C,EAAAsE,EACA,GAIAtE,EAAAy5C,UAAA,GAGAzB,EAAAh4C,OAAAA,EAAAy4C,aAAA,CACA,CACA,SAAAc,EAAAv5C,CAAA,CAAAsE,CAAA,EACAA,EAAAi0C,OAAA,CAAAj2C,MAAA,CAAAtC,GACAA,EAAAw4C,WAAA,CAAAl2C,MAAA,CAAAgC,GACAy1C,EAAA/5C,EAAAsE,EACA,CAjKAg0C,EAAA50C,KAAA,GCrHA,IAAAw2C,EAAA,CACAhB,SAAA,GACAI,QAAA,GACA3/B,OAAA,EACA,EACO,SAAA2B,EAAAtkB,CAAA,EACP,IAAAmjD,EAAA,IAAAhzC,IACA8V,EAAAjmB,GAAAA,EAAAimB,SAAA,CACA,SAAArd,EAAAyE,CAAA,EACA,IAAArE,EAAuB03C,EAAe37B,QAAA,GACtC,GAAA/b,EAAA,CACA,IAAAsb,EAAA6+B,EAAAp7C,GAAA,CAAAsF,GACAiX,GACA6+B,EAAAxyC,GAAA,CAAAtD,EAAAiX,EAAA,IAAA1X,KAEA5D,EAAAw5C,QAAA,CAAAl+B,GACA,mBAAA2B,IACgB46B,EAAgBv8B,GAChCA,EAAA4B,WAAA,CAAAD,EAAA5Y,GAEA,CACA,CAcA,OAbAzE,EAAAqB,KAAA,UAAAoD,CAAA,CAAA+1C,CAAA,EACA,IAAA9+B,EAAA6+B,EAAAp7C,GAAA,CAAAsF,GACA,GAAAiX,EAAA,CACA,IAAA++B,EAAA,GACgB1C,EAAcr8C,IAAA,CAAA4+C,EAAAE,GAAAA,EAAA,WAIlBxC,EAAYt8B,GAAAva,OAAA,CAAAmwB,GAAAA,CAAA,CAAAmpB,EAAA,IACxBF,EAAA73C,MAAA,CAAA+B,GACYwzC,EAAgBv8B,EAC5B,CACA,EACA1b,CACA,CCdO,SAAA06C,EAAA,GAAA/3C,CAAA,EACP,IAAAg4C,EAAAnE,GAAAA,CAAAA,EAAA,IAAyDzC,EAAI,mBAAA1sC,QAAA,EAC7D,OAAAszC,EAAA91C,WAAA,CAAAlC,EACA,CAMA,IAAAoZ,EAAA,IAAA/X,IACO,SAAAunC,EAAAqP,CAAA,EAAkChkD,IAAAA,EAAA2gD,KAAA,CAAA9tC,QAAAA,CAAA,CAAA9E,aAAAA,EAAA+1C,CAAA,CAAAX,gBAAAA,CAAA,CAAA18B,UAAAA,CAAA,CAAAtmB,MAAA8jD,EAAqHpG,EAAAh+B,CAAW,EAAI/b,OAAA8D,MAAA,QAC7K,IAAAzH,EAAA,mBAAA8jD,EACA,IAAAA,EAAAjkD,EAAA06B,GAAAA,EAAAooB,OAAA,IACAmB,EACArjD,EAAA,WACA,IAAAiN,EAAAE,EAAA8B,KAAA,MAAAgD,EAAAA,EAAAhD,KAAA,MAAA3B,WAAAA,WACA,GAAAL,KAAA,IAAAA,EACA,OAAAm2C,EAAAn0C,KAAA,MAAA3B,WAEA,IAAAwsB,EAAAv6B,EAAAoI,GAAA,CAAAsF,GACA6sB,IACAv6B,EAAAgR,GAAA,CAAAtD,EAAA6sB,EAAA,IAAuConB,EAAKkC,IAC5CtpB,EAAAyoB,eAAA,CAAAA,EACAzoB,EAAAjU,SAAA,CAAAA,EAGAiU,EAAAvX,MAAA,KAAAhjB,EAAA2L,MAAA,CAAA+B,IAEA,IAAA1J,EAAAu2B,EAAA4nB,SAAA,CAAAv9C,MAAAzE,SAAA,CAAA2Q,KAAA,CAAAnM,IAAA,CAAAoJ,YAYA,OATA/N,EAAAgR,GAAA,CAAAtD,EAAA6sB,GACAvV,EAAA9X,GAAA,CAAAlN,GAIa+gD,EAAeL,QAAA,KAC5B17B,EAAA5a,OAAA,CAAApK,GAAAA,EAAA+jD,KAAA,IACA/+B,EAAA9Y,KAAA,IAEAlI,CACA,EAcA,SAAAggD,EAAAt2C,CAAA,EACA,IAAA6sB,EAAA7sB,GAAA1N,EAAAoI,GAAA,CAAAsF,GACA6sB,GACAA,EAAAgoB,QAAA,EAEA,CAKA,SAAA0B,EAAAv2C,CAAA,EACA,IAAA6sB,EAAA7sB,GAAA1N,EAAAoI,GAAA,CAAAsF,GACA,GAAA6sB,EACA,OAAAA,EAAAjoB,IAAA,EAEA,CAKA,SAAA4xC,EAAAx2C,CAAA,EACA,MAAAA,EAAAA,GAAA1N,EAAA2L,MAAA,CAAA+B,EACA,CASA,OA5CA/J,OAAA4jB,cAAA,CAAA9mB,EAAA,QACA2H,IAAA,IAAApI,EAAA2a,IAAA,CACAqQ,aAAA,GACAD,WAAA,EACA,GACApnB,OAAAyN,MAAA,CAAA3Q,EAAAJ,OAAA,EACAR,IAAAA,EACA6S,QAAAA,EACA9E,aAAAA,EACAo1C,gBAAAA,EACA18B,UAAAA,EACAtmB,MAAAA,CACA,GAOAS,EAAAujD,QAAA,CAAAA,EACAvjD,EAAA6J,KAAA,YACA05C,EAAAp2C,EAAA8B,KAAA,MAAA3B,WACA,EAOAtN,EAAAwjD,OAAA,CAAAA,EACAxjD,EAAA6R,IAAA,YACA,OAAA2xC,EAAAr2C,EAAA8B,KAAA,MAAA3B,WACA,EAIAtN,EAAAyjD,SAAA,CAAAA,EACAzjD,EAAAuiB,MAAA,YACA,OAAAkhC,EAAAt2C,EAAA8B,KAAA,MAAA3B,WACA,EACAtN,EAAAmN,YAAA,CAAAA,EACAnN,EAAA0jD,MAAA,CAAAzxC,EAAA,WACA,OAAA9E,EAAA8B,KAAA,MAAAgD,EAAAhD,KAAA,MAAA3B,WACA,EAAMH,EACNjK,OAAAyN,MAAA,CAAA3Q,EACA,yBC3GA,SAAA2jD,EAAAC,CAAA,CAAA/G,CAAA,EAAuCA,CAAAA,MAAAA,GAAAA,EAAA+G,EAAAt/C,MAAA,GAAAu4C,CAAAA,EAAA+G,EAAAt/C,MAAA,EAAuD,QAAAD,EAAA,EAAAw/C,EAAA,MAAAhH,GAAuCx4C,EAAAw4C,EAASx4C,IAAOw/C,CAAA,CAAAx/C,EAAA,CAAAu/C,CAAA,CAAAv/C,EAAA,CAAoB,OAAAw/C,CAAA,CAEzK,SAAAC,EAAA1U,CAAA,CAAA2U,CAAA,EAA4C,QAAA1/C,EAAA,EAAgBA,EAAA0/C,EAAAz/C,MAAA,CAAkBD,IAAA,CAAO,IAAA2/C,EAAAD,CAAA,CAAA1/C,EAAA,CAA2B2/C,EAAA15B,UAAA,CAAA05B,EAAA15B,UAAA,KAAwD05B,EAAAz5B,YAAA,IAAgC,UAAAy5B,GAAAA,CAAAA,EAAApE,QAAA,KAAuD18C,OAAA4jB,cAAA,CAAAsoB,EAAA4U,EAAA/2C,GAAA,CAAA+2C,EAAA,EAE/P,SAAAC,EAAAC,CAAA,CAAAC,CAAA,CAAAC,CAAA,EAAwQ,OAA1MD,GAAAL,EAAAI,EAAAxkD,SAAA,CAAAykD,GAAsEC,GAAAN,EAAAI,EAAAE,GAA8DlhD,OAAA4jB,cAAA,CAAAo9B,EAAA,aAAkDtE,SAAA,KAAoBsE,CAAA,iCAGxQ,IAAAG,EAAA,WACA,yBAAAr9B,MACA,EAEAs9B,EAAA,SAAA19C,CAAA,EACA,OAAAy9C,KAAApmC,CAAAA,CAAA+I,MAAA,CAAApgB,EAAA,EAGA29C,EAAA,SAAA39C,CAAA,EACA,OAAA09C,EAAA19C,GAAAogB,MAAA,CAAApgB,EAAA,MAAAA,CACA,EAEAy9C,KAAA,CAAAC,EAAA,eACAt9B,CAAAA,OAAA/B,UAAA,CAAA+B,OAAA,eAGA,IAAAw9B,EAAAD,EAAA,YACAE,EAAAF,EAAA,cACAG,EAAAH,EAAA,WAEA,SAAAI,EAAA/4C,CAAA,CAAAqB,CAAA,EACA,IAAA1J,EAAAqI,CAAA,CAAAqB,EAAA,CACA,GAAA1J,MAAAA,GACA,sBAAAA,EAAA,gBAAAA,EAAA,sBACA,OAAAA,EACA,CAEA,SAAAqhD,EAAAh5C,CAAA,EACA,IAAAi5C,EAAAj5C,EAAA4wC,WAAA,CAUA,OARA5xC,KAAAA,IAAAi6C,GAGAA,OAFAA,CAAAA,EAAAA,CAAA,CAAAH,EAAA,GAGAG,CAAAA,EAAAj6C,KAAAA,CAAA,EAIAi6C,KAAAj6C,IAAAi6C,EAAAA,EAAAC,CACA,CAMA,SAAAC,EAAA9lC,CAAA,EACA8lC,EAAAjjB,GAAA,CACAijB,EAAAjjB,GAAA,CAAA7iB,GAEA0I,WAAA,WACA,MAAA1I,CACA,EAEA,CAEA,SAAA+lC,EAAA5iB,CAAA,EACAtf,QAAAC,OAAA,GAAAsC,IAAA,YACA,IACA+c,GACA,CAAM,MAAAnjB,EAAA,CACN8lC,EAAA9lC,EACA,CACA,EACA,CAEA,SAAAgmC,EAAAx6B,CAAA,EACA,IAAA6hB,EAAA7hB,EAAAy6B,QAAA,CACA,GAAA5Y,KAAA1hC,IAAA0hC,GAGA,GAFA7hB,EAAAy6B,QAAA,CAAAt6C,KAAAA,EAEA,CAAA0hC,EACA,OAGA,IACA,sBAAAA,EACAA,QACM,CACN,IAAAxmB,EAAA6+B,EAAArY,EAAA,eAEAxmB,GACAA,EAAA5hB,IAAA,CAAAooC,EAEA,CACA,CAAI,MAAArtB,EAAA,CACJ8lC,EAAA9lC,EACA,EACA,CAEA,SAAAkmC,EAAA16B,CAAA,EACAA,EAAA3B,SAAA,CAAAle,KAAAA,EACA6f,EAAA26B,MAAA,CAAAx6C,KAAAA,EACA6f,EAAA46B,MAAA,SACA,CAkBA,SAAAC,EAAA76B,CAAA,CAAAypB,CAAA,CAAA3wC,CAAA,EACAknB,EAAA46B,MAAA,WACA,IAAAtjD,EAAA0oB,EAAA3B,SAAA,CAEA,IACA,IAAAm6B,EAAA0B,EAAA5iD,EAAAmyC,GAEA,OAAAA,GACA,WACA+O,GAAAA,EAAA/+C,IAAA,CAAAnC,EAAAwB,GACA,KAEA,aAEA,GADA4hD,EAAA16B,GACAw4B,EAAAA,EAAA/+C,IAAA,CAAAnC,EAAAwB,QAAuC,MAAAA,EACvC,KAEA,gBACA4hD,EAAA16B,GACAw4B,GAAAA,EAAA/+C,IAAA,CAAAnC,EAEA,CACA,CAAI,MAAAkd,EAAA,CACJ8lC,EAAA9lC,EACA,CAEAwL,WAAAA,EAAA46B,MAAA,CAAAJ,EAAAx6B,GAA0E,YAAAA,EAAA46B,MAAA,EAAA56B,CAAAA,EAAA46B,MAAA,SAC1E,CAEA,SAAAE,EAAA96B,CAAA,CAAAypB,CAAA,CAAA3wC,CAAA,EACA,GAAAknB,WAAAA,EAAA46B,MAAA,EAEA,GAAA56B,cAAAA,EAAA46B,MAAA,EACA56B,EAAA26B,MAAA,CAAAr5C,IAAA,EACAmoC,KAAAA,EACA3wC,MAAAA,CACA,GAEA,MACA,CAEA,GAAAknB,UAAAA,EAAA46B,MAAA,EACA56B,EAAA46B,MAAA,aACA56B,EAAA26B,MAAA,GACAlR,KAAAA,EACA3wC,MAAAA,CACA,EAAK,CACLyhD,EAAA,WACA,OAAAQ,SAhEA/6B,CAAA,EACA,IAAAg7B,EAAAh7B,EAAA26B,MAAA,CAEA,GAAAK,GAIAh7B,EAAA26B,MAAA,CAAAx6C,KAAAA,EACA6f,EAAA46B,MAAA,SAEA,QAAAhhD,EAAA,EAAkBA,EAAAohD,EAAAnhD,MAAA,GAClBghD,EAAA76B,EAAAg7B,CAAA,CAAAphD,EAAA,CAAA6vC,IAAA,CAAAuR,CAAA,CAAAphD,EAAA,CAAAd,KAAA,EACAknB,WAAAA,EAAA46B,MAAA,EAFoC,EAAAhhD,IAIpC,EAkDAomB,EACA,GACA,MACA,CAEA66B,EAAA76B,EAAAypB,EAAA3wC,GACA,CAEA,IAAAmiD,EAAA,WACA,SAAAA,EAAA3jD,CAAA,CAAA4jD,CAAA,EAGA,KAAAT,QAAA,CAAAt6C,KAAAA,EACA,KAAAke,SAAA,CAAA/mB,EACA,KAAAqjD,MAAA,CAAAx6C,KAAAA,EACA,KAAAy6C,MAAA,gBACA,IAAAO,EAAA,IAAAC,EAAA,MAEA,IACA,KAAAX,QAAA,CAAAS,EAAAzhD,IAAA,CAAA0G,KAAAA,EAAAg7C,EACA,CAAM,MAAA3mC,EAAA,CACN2mC,EAAA/iD,KAAA,CAAAoc,EACA,CAEA,sBAAAomC,MAAA,QAAAA,MAAA,SACA,CAkBA,OAdAS,EAFApmD,SAAA,CAEAomB,WAAA,YACA,gBAAAu/B,MAAA,GACAF,EAAA,MACAF,EAAA,MAEA,EAEAhB,EAAAyB,EAAA,EACAz4C,IAAA,SACAtF,IAAA,WACA,sBAAA09C,MAAA,CAEA,EAAG,EAEHK,CACA,IAEAG,EAAA,WACA,SAAAA,EAAAp7B,CAAA,EACA,KAAA5B,aAAA,CAAA4B,CACA,CAEA,IAAAs7B,EAAAF,EAAAnmD,SAAA,CAqBA,OAnBAqmD,EAAAjjD,IAAA,UAAAS,CAAA,EACAgiD,EAAA,KAAA18B,aAAA,QAAAtlB,EACA,EAEAwiD,EAAAljD,KAAA,UAAAU,CAAA,EACAgiD,EAAA,KAAA18B,aAAA,SAAAtlB,EACA,EAEAwiD,EAAAvjD,QAAA,YACA+iD,EAAA,KAAA18B,aAAA,YACA,EAEAo7B,EAAA4B,EAAA,EACA54C,IAAA,SACAtF,IAAA,WACA,sBAAAkhB,aAAA,CAAAw8B,MAAA,CAEA,EAAG,EAEHQ,CACA,IAEAf,EAAA,WACA,SAAAA,EAAAa,CAAA,EACA,qBAAAb,CAAA,+DACA,sBAAAa,EAAA,4DACA,MAAAK,WAAA,CAAAL,CACA,CAEA,IAAAM,EAAAnB,EAAAplD,SAAA,CAsTA,OApTAumD,EAAApgC,SAAA,UAAA9jB,CAAA,EASA,MARA,kBAAAA,GAAAA,OAAAA,CAAA,GACAA,CAAAA,EAAA,CACAe,KAAAf,EACAc,MAAAyK,SAAA,IACA9K,SAAA8K,SAAA,IACA,EAGA,IAAAo4C,EAAA3jD,EAAA,KAAAikD,WAAA,CACA,EAEAC,EAAAt8C,OAAA,UAAAy4B,CAAA,EACA,IAAAtiC,EAAA,KAEA,WAAAgjB,QAAA,SAAAC,CAAA,CAAAyE,CAAA,EACA,sBAAA4a,EAAA,CACA5a,EAAA,UAAA4a,EAAA,uBACA,MACA,CAEA,SAAAoJ,IACA/gB,EAAA3E,WAAA,GACA/C,GACA,CAEA,IAAA0H,EAAA3qB,EAAA+lB,SAAA,EACA/iB,KAAA,SAAAS,CAAA,EACA,IACA6+B,EAAA7+B,EAAAioC,EACA,CAAY,MAAAvsB,EAAA,CACZuI,EAAAvI,GACAwL,EAAA3E,WAAA,EACA,CACA,EACAjjB,MAAA2kB,EACAhlB,SAAAugB,CACA,EACA,EACA,EAEAkjC,EAAArjD,GAAA,UAAAw/B,CAAA,EACA,IAAA8jB,EAAA,KAEA,sBAAA9jB,EAAA,gBAAAA,EAAA,sBAEA,UADAwiB,CAAAA,EAAA,OACA,SAAA7iD,CAAA,EACA,OAAAmkD,EAAArgC,SAAA,EACA/iB,KAAA,SAAAS,CAAA,EACA,IACAA,EAAA6+B,EAAA7+B,EACA,CAAY,MAAA0b,EAAA,CACZ,OAAAld,EAAAc,KAAA,CAAAoc,EACA,CAEAld,EAAAe,IAAA,CAAAS,EACA,EACAV,MAAA,SAAAoc,CAAA,EACAld,EAAAc,KAAA,CAAAoc,EACA,EACAzc,SAAA,WACAT,EAAAS,QAAA,EACA,CACA,EACA,EACA,EAEAyjD,EAAAnxC,MAAA,UAAAstB,CAAA,EACA,IAAA+jB,EAAA,KAEA,sBAAA/jB,EAAA,gBAAAA,EAAA,sBAEA,UADAwiB,CAAAA,EAAA,OACA,SAAA7iD,CAAA,EACA,OAAAokD,EAAAtgC,SAAA,EACA/iB,KAAA,SAAAS,CAAA,EACA,IACA,IAAA6+B,EAAA7+B,GAAA,MACA,CAAY,MAAA0b,EAAA,CACZ,OAAAld,EAAAc,KAAA,CAAAoc,EACA,CAEAld,EAAAe,IAAA,CAAAS,EACA,EACAV,MAAA,SAAAoc,CAAA,EACAld,EAAAc,KAAA,CAAAoc,EACA,EACAzc,SAAA,WACAT,EAAAS,QAAA,EACA,CACA,EACA,EACA,EAEAyjD,EAAA7uC,MAAA,UAAAgrB,CAAA,EACA,IAAAgkB,EAAA,KAEA,sBAAAhkB,EAAA,gBAAAA,EAAA,sBACA,IAAAikB,EAAAzB,EAAA,MACA0B,EAAAh5C,UAAAhJ,MAAA,GACA27C,EAAA,GACA9xC,EAAAb,SAAA,IACAi5C,EAAAp4C,EACA,WAAAk4C,EAAA,SAAAtkD,CAAA,EACA,OAAAqkD,EAAAvgC,SAAA,EACA/iB,KAAA,SAAAS,CAAA,EACA,IAAAylB,EAAA,CAAAi3B,EAGA,GAFAA,EAAA,GAEA,CAAAj3B,GAAAs9B,EACA,IACAC,EAAAnkB,EAAAmkB,EAAAhjD,EACA,CAAc,MAAA0b,EAAA,CACd,OAAAld,EAAAc,KAAA,CAAAoc,EACA,MAEAsnC,EAAAhjD,CAEA,EACAV,MAAA,SAAAoc,CAAA,EACAld,EAAAc,KAAA,CAAAoc,EACA,EACAzc,SAAA,WACA,IAAAy9C,GAAA,CAAAqG,EAAA,OAAAvkD,EAAAc,KAAA,+CACAd,EAAAe,IAAA,CAAAyjD,GACAxkD,EAAAS,QAAA,EACA,CACA,EACA,EACA,EAEAyjD,EAAA/gD,MAAA,YAGA,QAFAshD,EAAA,KAEAC,EAAAn5C,UAAAhJ,MAAA,CAAA8iB,EAAA,MAAAq/B,GAAA/c,EAAA,EAA2EA,EAAA+c,EAAa/c,IACxFtiB,CAAA,CAAAsiB,EAAA,CAAAp8B,SAAA,CAAAo8B,EAAA,CAHA,IAMA2c,EAAAzB,EAAA,MACA,WAAAyB,EAAA,SAAAtkD,CAAA,EAEA,IADA0oB,EACAozB,EAAA,EAsBA,OADA6I,SAnBAA,EAAA5jD,CAAA,EACA2nB,EAAA3nB,EAAA+iB,SAAA,EACA/iB,KAAA,SAAA2Z,CAAA,EACA1a,EAAAe,IAAA,CAAA2Z,EACA,EACA5Z,MAAA,SAAAoc,CAAA,EACAld,EAAAc,KAAA,CAAAoc,EACA,EACAzc,SAAA,WACAq7C,IAAAz2B,EAAA9iB,MAAA,EACAmmB,EAAA7f,KAAAA,EACA7I,EAAAS,QAAA,IAEAkkD,EAAAL,EAAA/kD,IAAA,CAAA8lB,CAAA,CAAAy2B,IAAA,EAEA,CACA,EACA,EAEA2I,GACA,WACA/7B,IACAA,EAAA3E,WAAA,GACA2E,EAAA7f,KAAAA,EAEA,CACA,EACA,EAEAq7C,EAAAU,OAAA,UAAAvkB,CAAA,EACA,IAAAwkB,EAAA,KAEA,sBAAAxkB,EAAA,gBAAAA,EAAA,sBACA,IAAAikB,EAAAzB,EAAA,MACA,WAAAyB,EAAA,SAAAtkD,CAAA,EACA,IAAAqnB,EAAA,GAEAy9B,EAAAD,EAAA/gC,SAAA,EACA/iB,KAAA,SAAAS,CAAA,EACA,GAAA6+B,EACA,IACA7+B,EAAA6+B,EAAA7+B,EACA,CAAc,MAAA0b,EAAA,CACd,OAAAld,EAAAc,KAAA,CAAAoc,EACA,CAGA,IAAA6nC,EAAAT,EAAA/kD,IAAA,CAAAiC,GAAAsiB,SAAA,EACA/iB,KAAA,SAAAS,CAAA,EACAxB,EAAAe,IAAA,CAAAS,EACA,EACAV,MAAA,SAAAoc,CAAA,EACAld,EAAAc,KAAA,CAAAoc,EACA,EACAzc,SAAA,WACA,IAAA6B,EAAA+kB,EAAApO,OAAA,CAAA8rC,GACAziD,GAAA,GAAA+kB,EAAA5O,MAAA,CAAAnW,EAAA,GACA0iD,GACA,CACA,GACA39B,EAAArd,IAAA,CAAA+6C,EACA,EACAjkD,MAAA,SAAAoc,CAAA,EACAld,EAAAc,KAAA,CAAAoc,EACA,EACAzc,SAAA,WACAukD,GACA,CACA,GAEA,SAAAA,IACAF,EAAAnhC,MAAA,EAAA0D,IAAAA,EAAA9kB,MAAA,EAAAvC,EAAAS,QAAA,EACA,CAEA,kBACA4mB,EAAAzf,OAAA,UAAAzD,CAAA,EACA,OAAAA,EAAA4f,WAAA,EACA,GACA+gC,EAAA/gC,WAAA,EACA,CACA,EACA,EAEAmgC,CAAA,CAAAxB,EAAA,YACA,aAGAK,EAAAxjD,IAAA,UAAAqjC,CAAA,EACA,IAAA0hB,EAAA,6BAAAvB,EACA,GAAAngB,MAAAA,EAAA,gBAAAA,EAAA,qBACA,IAAAne,EAAAm+B,EAAAhgB,EAAA8f,GAEA,GAAAj+B,EAAA,CACA,IAAAvB,EAAAuB,EAAAtiB,IAAA,CAAAygC,GACA,GAAAzhC,OAAA+hB,KAAAA,EAAA,gBAAAA,EAAA,4BACA,aAtbA6/B,GAsbA7/B,EAAAu3B,WAAA,GAAA6J,EAAAphC,EACA,IAAAohC,EAAA,SAAAtkD,CAAA,EACA,OAAAkjB,EAAAY,SAAA,CAAA9jB,EACA,EACA,CAEA,GAAAuiD,EAAA,aACA99B,CAAAA,EAAAm+B,EAAAhgB,EAAA6f,EAAA,EAGA,WAAA6B,EAAA,SAAAtkD,CAAA,EACAijD,EAAA,WACA,IAAAjjD,EAAA2jB,MAAA,EAEA,QAAAshC,EAAAC,EAAAC,SAzfA11C,CAAA,CAAA21C,CAAA,EAA8D,IAAAC,EAAA,oBAAApgC,QAAAxV,CAAA,CAAAwV,OAAAof,QAAA,GAAA50B,CAAA,eAAiF,GAAA41C,EAAA,OAAAA,EAAAA,EAAAljD,IAAA,CAAAsN,EAAA,EAAA1O,IAAA,CAAA4mB,IAAA,CAAA09B,GAAgD,GAAAjjD,MAAAC,OAAA,CAAAoN,IAAA41C,CAAAA,EAAAC,SAE/L71C,CAAA,CAAA81C,CAAA,EAAkD,GAAA91C,GAAgB,oBAAAA,EAAA,OAAAmyC,EAAAnyC,EAAA81C,GAAgE,IAAAC,EAAArkD,OAAAxD,SAAA,CAAAyuC,QAAA,CAAAjqC,IAAA,CAAAsN,GAAAnB,KAAA,OAAqH,GAA7D,WAAAk3C,GAAA/1C,EAAAgrC,WAAA,EAAA+K,CAAAA,EAAA/1C,EAAAgrC,WAAA,CAAA51C,IAAA,EAA6D2gD,QAAAA,GAAAA,QAAAA,EAAA,OAAApjD,MAAA7C,IAAA,CAAAkQ,GAAsD,GAAA+1C,cAAAA,GAAA,2CAAAltC,IAAA,CAAAktC,GAAA,OAAA5D,EAAAnyC,EAAA81C,GAAA,EAF9G91C,EAAA,GAAwH41C,GAAA51C,CAAAA,EAAA41C,CAAA,EAAgB,IAAA/iD,EAAA,EAAW,yBAAqB,GAAAmN,EAAAlN,MAAA,EAA4BknC,KAAA,IAAc,CAASA,KAAA,GAAAjoC,MAAAiO,CAAA,CAAAnN,IAAA,GAAmC,0JAyf7bmiB,EAAAtiB,IAAA,CAAAygC,IAAyF,EAAAqiB,EAAAC,GAAA,EAAAzb,IAAA,EAA4B,CACrH,IAAAz2B,EAAAiyC,EAAAzjD,KAAA,CAEA,GADAxB,EAAAe,IAAA,CAAAiS,GACAhT,EAAA2jB,MAAA,OACA,CAEA3jB,EAAAS,QAAA,GACA,EACA,GAIA,GAAA2B,MAAAC,OAAA,CAAAugC,GACA,WAAA0hB,EAAA,SAAAtkD,CAAA,EACAijD,EAAA,WACA,IAAAjjD,EAAA2jB,MAAA,EAEA,QAAArhB,EAAA,EAA0BA,EAAAsgC,EAAArgC,MAAA,CAAc,EAAAD,EAExC,GADAtC,EAAAe,IAAA,CAAA6hC,CAAA,CAAAtgC,EAAA,EACAtC,EAAA2jB,MAAA,QAGA3jB,EAAAS,QAAA,GACA,EACA,EAGA,iBAAAmiC,EAAA,qBACA,EAEAmgB,EAAA/qB,EAAA,YACA,QAAAytB,EAAAl6C,UAAAhJ,MAAA,CAAAmjD,EAAA,MAAAD,GAAAE,EAAA,EAA4EA,EAAAF,EAAeE,IAC3FD,CAAA,CAAAC,EAAA,CAAAp6C,SAAA,CAAAo6C,EAAA,CAIA,UADA,8BAAA5C,CAAA,EACA,SAAA/iD,CAAA,EACAijD,EAAA,WACA,IAAAjjD,EAAA2jB,MAAA,EAEA,QAAArhB,EAAA,EAAwBA,EAAAojD,EAAAnjD,MAAA,CAAkB,EAAAD,EAE1C,GADAtC,EAAAe,IAAA,CAAA2kD,CAAA,CAAApjD,EAAA,EACAtC,EAAA2jB,MAAA,QAGA3jB,EAAAS,QAAA,GACA,EACA,EACA,EAEAyhD,EAAAa,EAAA,OACA73C,IAAAy3C,EACA/8C,IAAA,WACA,YAEA,EAAG,EAEHm9C,CACA,IAEAT,KACAnhD,OAAA4jB,cAAA,CAAAg+B,EAAA99B,OAAA,eACAzjB,MAAA,CACAokD,OAAAlD,EACAM,gBAAAA,CACA,EACAx6B,aAAA,EACA","sources":["webpack://_N_E/./node_modules/@apollo/client/cache/core/cache.js","webpack://_N_E/./node_modules/@apollo/client/cache/core/types/common.js","webpack://_N_E/./node_modules/@apollo/client/cache/inmemory/helpers.js","webpack://_N_E/./node_modules/@apollo/client/cache/inmemory/entityStore.js","webpack://_N_E/./node_modules/@apollo/client/cache/inmemory/object-canon.js","webpack://_N_E/./node_modules/@apollo/client/cache/inmemory/readFromStore.js","webpack://_N_E/./node_modules/@apollo/client/cache/inmemory/key-extractor.js","webpack://_N_E/./node_modules/@apollo/client/cache/inmemory/policies.js","webpack://_N_E/./node_modules/@apollo/client/cache/inmemory/writeToStore.js","webpack://_N_E/./node_modules/@apollo/client/cache/inmemory/inMemoryCache.js","webpack://_N_E/./node_modules/@apollo/client/cache/inmemory/reactiveVars.js","webpack://_N_E/./node_modules/@apollo/client/link/core/execute.js","webpack://_N_E/./node_modules/@apollo/client/utilities/observables/asyncMap.js","webpack://_N_E/./node_modules/@apollo/client/utilities/common/errorHandling.js","webpack://_N_E/./node_modules/@apollo/client/utilities/observables/iteration.js","webpack://_N_E/./node_modules/@apollo/client/utilities/observables/subclassing.js","webpack://_N_E/./node_modules/@apollo/client/utilities/observables/Concast.js","webpack://_N_E/./node_modules/@apollo/client/core/ObservableQuery.js","webpack://_N_E/./node_modules/@apollo/client/core/QueryInfo.js","webpack://_N_E/./node_modules/@apollo/client/core/QueryManager.js","webpack://_N_E/./node_modules/graphql/language/predicates.mjs","webpack://_N_E/./node_modules/@apollo/client/core/LocalState.js","webpack://_N_E/./node_modules/@apollo/client/core/ApolloClient.js","webpack://_N_E/./node_modules/@apollo/client/core/equalByQuery.js","webpack://_N_E/./node_modules/@apollo/client/link/utils/createOperation.js","webpack://_N_E/./node_modules/@apollo/client/link/utils/transformOperation.js","webpack://_N_E/./node_modules/@apollo/client/link/utils/validateOperation.js","webpack://_N_E/./node_modules/@apollo/client/link/core/ApolloLink.js","webpack://_N_E/./node_modules/@apollo/client/link/core/from.js","webpack://_N_E/./node_modules/@apollo/client/link/error/index.js","webpack://_N_E/./node_modules/@apollo/client/link/http/serializeFetchParameter.js","webpack://_N_E/./node_modules/@apollo/client/link/http/selectURI.js","webpack://_N_E/./node_modules/@apollo/client/link/http/iterators/async.js","webpack://_N_E/./node_modules/@apollo/client/link/http/iterators/nodeStream.js","webpack://_N_E/./node_modules/@apollo/client/link/http/iterators/promise.js","webpack://_N_E/./node_modules/@apollo/client/link/http/iterators/reader.js","webpack://_N_E/./node_modules/@apollo/client/link/http/responseIterator.js","webpack://_N_E/./node_modules/@apollo/client/link/utils/throwServerError.js","webpack://_N_E/./node_modules/@apollo/client/link/http/parseAndCheckHttpResponse.js","webpack://_N_E/./node_modules/@apollo/client/link/http/checkFetcher.js","webpack://_N_E/./node_modules/@apollo/client/link/http/selectHttpOptionsAndBody.js","webpack://_N_E/./node_modules/@apollo/client/link/http/rewriteURIForGET.js","webpack://_N_E/./node_modules/@apollo/client/link/utils/fromError.js","webpack://_N_E/./node_modules/@apollo/client/link/utils/filterOperationVariables.js","webpack://_N_E/./node_modules/@apollo/client/link/http/createHttpLink.js","webpack://_N_E/./node_modules/@apollo/client/link/http/HttpLink.js","webpack://_N_E/./node_modules/@apollo/client/utilities/common/canonicalStringify.js","webpack://_N_E/./node_modules/@apollo/client/utilities/common/cloneDeep.js","webpack://_N_E/./node_modules/@apollo/client/utilities/common/incrementalResult.js","webpack://_N_E/./node_modules/@apollo/client/utilities/common/mergeDeep.js","webpack://_N_E/./node_modules/@apollo/client/utilities/graphql/DocumentTransform.js","webpack://_N_E/./node_modules/@apollo/client/utilities/graphql/directives.js","webpack://_N_E/./node_modules/@apollo/client/utilities/graphql/fragments.js","webpack://_N_E/./node_modules/@apollo/client/utilities/graphql/getFromAST.js","webpack://_N_E/./node_modules/graphql/language/printString.mjs","webpack://_N_E/./node_modules/graphql/language/printer.mjs","webpack://_N_E/./node_modules/@apollo/client/utilities/graphql/print.js","webpack://_N_E/./node_modules/@apollo/client/utilities/graphql/storeUtils.js","webpack://_N_E/./node_modules/@apollo/client/utilities/graphql/transform.js","webpack://_N_E/./node_modules/@wry/trie/lib/index.js","webpack://_N_E/./node_modules/graphql/language/visitor.mjs","webpack://_N_E/./node_modules/optimism/node_modules/@wry/trie/lib/index.js","webpack://_N_E/./node_modules/@wry/context/lib/slot.js","webpack://_N_E/./node_modules/@wry/context/lib/index.js","webpack://_N_E/./node_modules/optimism/lib/context.js","webpack://_N_E/./node_modules/optimism/lib/helpers.js","webpack://_N_E/./node_modules/optimism/lib/entry.js","webpack://_N_E/./node_modules/optimism/lib/dep.js","webpack://_N_E/./node_modules/optimism/lib/index.js","webpack://_N_E/./node_modules/zen-observable-ts/module.js","webpack://_N_E/<anon>"],"sourcesContent":["import { __assign, __rest } from \"tslib\";\nimport { wrap } from \"optimism\";\nimport { Observable, cacheSizes, getFragmentQueryDocument, mergeDeepArray, } from \"../../utilities/index.js\";\nimport { WeakCache } from \"@wry/caches\";\nimport { getApolloCacheMemoryInternals } from \"../../utilities/caching/getMemoryInternals.js\";\nimport { equalByQuery } from \"../../core/equalByQuery.js\";\nvar ApolloCache = /** @class */ (function () {\n    function ApolloCache() {\n        this.assumeImmutableResults = false;\n        // Make sure we compute the same (===) fragment query document every\n        // time we receive the same fragment in readFragment.\n        this.getFragmentDoc = wrap(getFragmentQueryDocument, {\n            max: cacheSizes[\"cache.fragmentQueryDocuments\"] ||\n                1000 /* defaultCacheSizes[\"cache.fragmentQueryDocuments\"] */,\n            cache: WeakCache,\n        });\n    }\n    // Transactional API\n    // The batch method is intended to replace/subsume both performTransaction\n    // and recordOptimisticTransaction, but performTransaction came first, so we\n    // provide a default batch implementation that's just another way of calling\n    // performTransaction. Subclasses of ApolloCache (such as InMemoryCache) can\n    // override the batch method to do more interesting things with its options.\n    ApolloCache.prototype.batch = function (options) {\n        var _this = this;\n        var optimisticId = typeof options.optimistic === \"string\" ? options.optimistic\n            : options.optimistic === false ? null\n                : void 0;\n        var updateResult;\n        this.performTransaction(function () { return (updateResult = options.update(_this)); }, optimisticId);\n        return updateResult;\n    };\n    ApolloCache.prototype.recordOptimisticTransaction = function (transaction, optimisticId) {\n        this.performTransaction(transaction, optimisticId);\n    };\n    // Optional API\n    // Called once per input document, allowing the cache to make static changes\n    // to the query, such as adding __typename fields.\n    ApolloCache.prototype.transformDocument = function (document) {\n        return document;\n    };\n    // Called before each ApolloLink request, allowing the cache to make dynamic\n    // changes to the query, such as filling in missing fragment definitions.\n    ApolloCache.prototype.transformForLink = function (document) {\n        return document;\n    };\n    ApolloCache.prototype.identify = function (object) {\n        return;\n    };\n    ApolloCache.prototype.gc = function () {\n        return [];\n    };\n    ApolloCache.prototype.modify = function (options) {\n        return false;\n    };\n    // DataProxy API\n    ApolloCache.prototype.readQuery = function (options, optimistic) {\n        if (optimistic === void 0) { optimistic = !!options.optimistic; }\n        return this.read(__assign(__assign({}, options), { rootId: options.id || \"ROOT_QUERY\", optimistic: optimistic }));\n    };\n    /** {@inheritDoc @apollo/client!ApolloClient#watchFragment:member(1)} */\n    ApolloCache.prototype.watchFragment = function (options) {\n        var _this = this;\n        var fragment = options.fragment, fragmentName = options.fragmentName, from = options.from, _a = options.optimistic, optimistic = _a === void 0 ? true : _a, otherOptions = __rest(options, [\"fragment\", \"fragmentName\", \"from\", \"optimistic\"]);\n        var query = this.getFragmentDoc(fragment, fragmentName);\n        var diffOptions = __assign(__assign({}, otherOptions), { returnPartialData: true, id: \n            // While our TypeScript types do not allow for `undefined` as a valid\n            // `from`, its possible `useFragment` gives us an `undefined` since it\n            // calls` cache.identify` and provides that value to `from`. We are\n            // adding this fix here however to ensure those using plain JavaScript\n            // and using `cache.identify` themselves will avoid seeing the obscure\n            // warning.\n            typeof from === \"undefined\" || typeof from === \"string\" ?\n                from\n                : this.identify(from), query: query, optimistic: optimistic });\n        var latestDiff;\n        return new Observable(function (observer) {\n            return _this.watch(__assign(__assign({}, diffOptions), { immediate: true, callback: function (diff) {\n                    if (\n                    // Always ensure we deliver the first result\n                    latestDiff &&\n                        equalByQuery(query, { data: latestDiff === null || latestDiff === void 0 ? void 0 : latestDiff.result }, { data: diff.result })) {\n                        return;\n                    }\n                    var result = {\n                        data: diff.result,\n                        complete: !!diff.complete,\n                    };\n                    if (diff.missing) {\n                        result.missing = mergeDeepArray(diff.missing.map(function (error) { return error.missing; }));\n                    }\n                    latestDiff = diff;\n                    observer.next(result);\n                } }));\n        });\n    };\n    ApolloCache.prototype.readFragment = function (options, optimistic) {\n        if (optimistic === void 0) { optimistic = !!options.optimistic; }\n        return this.read(__assign(__assign({}, options), { query: this.getFragmentDoc(options.fragment, options.fragmentName), rootId: options.id, optimistic: optimistic }));\n    };\n    ApolloCache.prototype.writeQuery = function (_a) {\n        var id = _a.id, data = _a.data, options = __rest(_a, [\"id\", \"data\"]);\n        return this.write(Object.assign(options, {\n            dataId: id || \"ROOT_QUERY\",\n            result: data,\n        }));\n    };\n    ApolloCache.prototype.writeFragment = function (_a) {\n        var id = _a.id, data = _a.data, fragment = _a.fragment, fragmentName = _a.fragmentName, options = __rest(_a, [\"id\", \"data\", \"fragment\", \"fragmentName\"]);\n        return this.write(Object.assign(options, {\n            query: this.getFragmentDoc(fragment, fragmentName),\n            dataId: id,\n            result: data,\n        }));\n    };\n    ApolloCache.prototype.updateQuery = function (options, update) {\n        return this.batch({\n            update: function (cache) {\n                var value = cache.readQuery(options);\n                var data = update(value);\n                if (data === void 0 || data === null)\n                    return value;\n                cache.writeQuery(__assign(__assign({}, options), { data: data }));\n                return data;\n            },\n        });\n    };\n    ApolloCache.prototype.updateFragment = function (options, update) {\n        return this.batch({\n            update: function (cache) {\n                var value = cache.readFragment(options);\n                var data = update(value);\n                if (data === void 0 || data === null)\n                    return value;\n                cache.writeFragment(__assign(__assign({}, options), { data: data }));\n                return data;\n            },\n        });\n    };\n    return ApolloCache;\n}());\nexport { ApolloCache };\nif (globalThis.__DEV__ !== false) {\n    ApolloCache.prototype.getMemoryInternals = getApolloCacheMemoryInternals;\n}\n//# sourceMappingURL=cache.js.map","import { __extends } from \"tslib\";\nvar MissingFieldError = /** @class */ (function (_super) {\n    __extends(MissingFieldError, _super);\n    function MissingFieldError(message, path, query, variables) {\n        var _a;\n        // 'Error' breaks prototype chain here\n        var _this = _super.call(this, message) || this;\n        _this.message = message;\n        _this.path = path;\n        _this.query = query;\n        _this.variables = variables;\n        if (Array.isArray(_this.path)) {\n            _this.missing = _this.message;\n            for (var i = _this.path.length - 1; i >= 0; --i) {\n                _this.missing = (_a = {}, _a[_this.path[i]] = _this.missing, _a);\n            }\n        }\n        else {\n            _this.missing = _this.path;\n        }\n        // We're not using `Object.setPrototypeOf` here as it isn't fully supported\n        // on Android (see issue #3236).\n        _this.__proto__ = MissingFieldError.prototype;\n        return _this;\n    }\n    return MissingFieldError;\n}(Error));\nexport { MissingFieldError };\n//# sourceMappingURL=common.js.map","import { isReference, isField, DeepMerger, resultKeyNameFromField, shouldInclude, isNonNullObject, compact, createFragmentMap, getFragmentDefinitions, isArray, } from \"../../utilities/index.js\";\nexport var hasOwn = Object.prototype.hasOwnProperty;\nexport function isNullish(value) {\n    return value === null || value === void 0;\n}\nexport { isArray };\nexport function defaultDataIdFromObject(_a, context) {\n    var __typename = _a.__typename, id = _a.id, _id = _a._id;\n    if (typeof __typename === \"string\") {\n        if (context) {\n            context.keyObject =\n                !isNullish(id) ? { id: id }\n                    : !isNullish(_id) ? { _id: _id }\n                        : void 0;\n        }\n        // If there is no object.id, fall back to object._id.\n        if (isNullish(id) && !isNullish(_id)) {\n            id = _id;\n        }\n        if (!isNullish(id)) {\n            return \"\".concat(__typename, \":\").concat(typeof id === \"number\" || typeof id === \"string\" ?\n                id\n                : JSON.stringify(id));\n        }\n    }\n}\nvar defaultConfig = {\n    dataIdFromObject: defaultDataIdFromObject,\n    addTypename: true,\n    resultCaching: true,\n    // Thanks to the shouldCanonizeResults helper, this should be the only line\n    // you have to change to reenable canonization by default in the future.\n    canonizeResults: false,\n};\nexport function normalizeConfig(config) {\n    return compact(defaultConfig, config);\n}\nexport function shouldCanonizeResults(config) {\n    var value = config.canonizeResults;\n    return value === void 0 ? defaultConfig.canonizeResults : value;\n}\nexport function getTypenameFromStoreObject(store, objectOrReference) {\n    return isReference(objectOrReference) ?\n        store.get(objectOrReference.__ref, \"__typename\")\n        : objectOrReference && objectOrReference.__typename;\n}\nexport var TypeOrFieldNameRegExp = /^[_a-z][_0-9a-z]*/i;\nexport function fieldNameFromStoreName(storeFieldName) {\n    var match = storeFieldName.match(TypeOrFieldNameRegExp);\n    return match ? match[0] : storeFieldName;\n}\nexport function selectionSetMatchesResult(selectionSet, result, variables) {\n    if (isNonNullObject(result)) {\n        return isArray(result) ?\n            result.every(function (item) {\n                return selectionSetMatchesResult(selectionSet, item, variables);\n            })\n            : selectionSet.selections.every(function (field) {\n                if (isField(field) && shouldInclude(field, variables)) {\n                    var key = resultKeyNameFromField(field);\n                    return (hasOwn.call(result, key) &&\n                        (!field.selectionSet ||\n                            selectionSetMatchesResult(field.selectionSet, result[key], variables)));\n                }\n                // If the selection has been skipped with @skip(true) or\n                // @include(false), it should not count against the matching. If\n                // the selection is not a field, it must be a fragment (inline or\n                // named). We will determine if selectionSetMatchesResult for that\n                // fragment when we get to it, so for now we return true.\n                return true;\n            });\n    }\n    return false;\n}\nexport function storeValueIsStoreObject(value) {\n    return isNonNullObject(value) && !isReference(value) && !isArray(value);\n}\nexport function makeProcessedFieldsMerger() {\n    return new DeepMerger();\n}\nexport function extractFragmentContext(document, fragments) {\n    // FragmentMap consisting only of fragments defined directly in document, not\n    // including other fragments registered in the FragmentRegistry.\n    var fragmentMap = createFragmentMap(getFragmentDefinitions(document));\n    return {\n        fragmentMap: fragmentMap,\n        lookupFragment: function (name) {\n            var def = fragmentMap[name];\n            if (!def && fragments) {\n                def = fragments.lookup(name);\n            }\n            return def || null;\n        },\n    };\n}\n//# sourceMappingURL=helpers.js.map","import { __assign, __extends, __rest } from \"tslib\";\nimport { invariant } from \"../../utilities/globals/index.js\";\nimport { dep } from \"optimism\";\nimport { equal } from \"@wry/equality\";\nimport { Trie } from \"@wry/trie\";\nimport { isReference, makeReference, DeepMerger, maybeDeepFreeze, canUseWeakMap, isNonNullObject, } from \"../../utilities/index.js\";\nimport { hasOwn, fieldNameFromStoreName } from \"./helpers.js\";\nvar DELETE = Object.create(null);\nvar delModifier = function () { return DELETE; };\nvar INVALIDATE = Object.create(null);\nvar EntityStore = /** @class */ (function () {\n    function EntityStore(policies, group) {\n        var _this = this;\n        this.policies = policies;\n        this.group = group;\n        this.data = Object.create(null);\n        // Maps root entity IDs to the number of times they have been retained, minus\n        // the number of times they have been released. Retained entities keep other\n        // entities they reference (even indirectly) from being garbage collected.\n        this.rootIds = Object.create(null);\n        // Lazily tracks { __ref: <dataId> } strings contained by this.data[dataId].\n        this.refs = Object.create(null);\n        // Bound function that can be passed around to provide easy access to fields\n        // of Reference objects as well as ordinary objects.\n        this.getFieldValue = function (objectOrReference, storeFieldName) {\n            return maybeDeepFreeze(isReference(objectOrReference) ?\n                _this.get(objectOrReference.__ref, storeFieldName)\n                : objectOrReference && objectOrReference[storeFieldName]);\n        };\n        // Returns true for non-normalized StoreObjects and non-dangling\n        // References, indicating that readField(name, objOrRef) has a chance of\n        // working. Useful for filtering out dangling references from lists.\n        this.canRead = function (objOrRef) {\n            return isReference(objOrRef) ?\n                _this.has(objOrRef.__ref)\n                : typeof objOrRef === \"object\";\n        };\n        // Bound function that converts an id or an object with a __typename and\n        // primary key fields to a Reference object. If called with a Reference object,\n        // that same Reference object is returned. Pass true for mergeIntoStore to persist\n        // an object into the store.\n        this.toReference = function (objOrIdOrRef, mergeIntoStore) {\n            if (typeof objOrIdOrRef === \"string\") {\n                return makeReference(objOrIdOrRef);\n            }\n            if (isReference(objOrIdOrRef)) {\n                return objOrIdOrRef;\n            }\n            var id = _this.policies.identify(objOrIdOrRef)[0];\n            if (id) {\n                var ref = makeReference(id);\n                if (mergeIntoStore) {\n                    _this.merge(id, objOrIdOrRef);\n                }\n                return ref;\n            }\n        };\n    }\n    // Although the EntityStore class is abstract, it contains concrete\n    // implementations of the various NormalizedCache interface methods that\n    // are inherited by the Root and Layer subclasses.\n    EntityStore.prototype.toObject = function () {\n        return __assign({}, this.data);\n    };\n    EntityStore.prototype.has = function (dataId) {\n        return this.lookup(dataId, true) !== void 0;\n    };\n    EntityStore.prototype.get = function (dataId, fieldName) {\n        this.group.depend(dataId, fieldName);\n        if (hasOwn.call(this.data, dataId)) {\n            var storeObject = this.data[dataId];\n            if (storeObject && hasOwn.call(storeObject, fieldName)) {\n                return storeObject[fieldName];\n            }\n        }\n        if (fieldName === \"__typename\" &&\n            hasOwn.call(this.policies.rootTypenamesById, dataId)) {\n            return this.policies.rootTypenamesById[dataId];\n        }\n        if (this instanceof Layer) {\n            return this.parent.get(dataId, fieldName);\n        }\n    };\n    EntityStore.prototype.lookup = function (dataId, dependOnExistence) {\n        // The has method (above) calls lookup with dependOnExistence = true, so\n        // that it can later be invalidated when we add or remove a StoreObject for\n        // this dataId. Any consumer who cares about the contents of the StoreObject\n        // should not rely on this dependency, since the contents could change\n        // without the object being added or removed.\n        if (dependOnExistence)\n            this.group.depend(dataId, \"__exists\");\n        if (hasOwn.call(this.data, dataId)) {\n            return this.data[dataId];\n        }\n        if (this instanceof Layer) {\n            return this.parent.lookup(dataId, dependOnExistence);\n        }\n        if (this.policies.rootTypenamesById[dataId]) {\n            return Object.create(null);\n        }\n    };\n    EntityStore.prototype.merge = function (older, newer) {\n        var _this = this;\n        var dataId;\n        // Convert unexpected references to ID strings.\n        if (isReference(older))\n            older = older.__ref;\n        if (isReference(newer))\n            newer = newer.__ref;\n        var existing = typeof older === \"string\" ? this.lookup((dataId = older)) : older;\n        var incoming = typeof newer === \"string\" ? this.lookup((dataId = newer)) : newer;\n        // If newer was a string ID, but that ID was not defined in this store,\n        // then there are no fields to be merged, so we're done.\n        if (!incoming)\n            return;\n        invariant(typeof dataId === \"string\", 1);\n        var merged = new DeepMerger(storeObjectReconciler).merge(existing, incoming);\n        // Even if merged === existing, existing may have come from a lower\n        // layer, so we always need to set this.data[dataId] on this level.\n        this.data[dataId] = merged;\n        if (merged !== existing) {\n            delete this.refs[dataId];\n            if (this.group.caching) {\n                var fieldsToDirty_1 = Object.create(null);\n                // If we added a new StoreObject where there was previously none, dirty\n                // anything that depended on the existence of this dataId, such as the\n                // EntityStore#has method.\n                if (!existing)\n                    fieldsToDirty_1.__exists = 1;\n                // Now invalidate dependents who called getFieldValue for any fields\n                // that are changing as a result of this merge.\n                Object.keys(incoming).forEach(function (storeFieldName) {\n                    if (!existing ||\n                        existing[storeFieldName] !== merged[storeFieldName]) {\n                        // Always dirty the full storeFieldName, which may include\n                        // serialized arguments following the fieldName prefix.\n                        fieldsToDirty_1[storeFieldName] = 1;\n                        // Also dirty fieldNameFromStoreName(storeFieldName) if it's\n                        // different from storeFieldName and this field does not have\n                        // keyArgs configured, because that means the cache can't make\n                        // any assumptions about how field values with the same field\n                        // name but different arguments might be interrelated, so it\n                        // must err on the side of invalidating all field values that\n                        // share the same short fieldName, regardless of arguments.\n                        var fieldName = fieldNameFromStoreName(storeFieldName);\n                        if (fieldName !== storeFieldName &&\n                            !_this.policies.hasKeyArgs(merged.__typename, fieldName)) {\n                            fieldsToDirty_1[fieldName] = 1;\n                        }\n                        // If merged[storeFieldName] has become undefined, and this is the\n                        // Root layer, actually delete the property from the merged object,\n                        // which is guaranteed to have been created fresh in this method.\n                        if (merged[storeFieldName] === void 0 && !(_this instanceof Layer)) {\n                            delete merged[storeFieldName];\n                        }\n                    }\n                });\n                if (fieldsToDirty_1.__typename &&\n                    !(existing && existing.__typename) &&\n                    // Since we return default root __typename strings\n                    // automatically from store.get, we don't need to dirty the\n                    // ROOT_QUERY.__typename field if merged.__typename is equal\n                    // to the default string (usually \"Query\").\n                    this.policies.rootTypenamesById[dataId] === merged.__typename) {\n                    delete fieldsToDirty_1.__typename;\n                }\n                Object.keys(fieldsToDirty_1).forEach(function (fieldName) {\n                    return _this.group.dirty(dataId, fieldName);\n                });\n            }\n        }\n    };\n    EntityStore.prototype.modify = function (dataId, fields) {\n        var _this = this;\n        var storeObject = this.lookup(dataId);\n        if (storeObject) {\n            var changedFields_1 = Object.create(null);\n            var needToMerge_1 = false;\n            var allDeleted_1 = true;\n            var sharedDetails_1 = {\n                DELETE: DELETE,\n                INVALIDATE: INVALIDATE,\n                isReference: isReference,\n                toReference: this.toReference,\n                canRead: this.canRead,\n                readField: function (fieldNameOrOptions, from) {\n                    return _this.policies.readField(typeof fieldNameOrOptions === \"string\" ?\n                        {\n                            fieldName: fieldNameOrOptions,\n                            from: from || makeReference(dataId),\n                        }\n                        : fieldNameOrOptions, { store: _this });\n                },\n            };\n            Object.keys(storeObject).forEach(function (storeFieldName) {\n                var fieldName = fieldNameFromStoreName(storeFieldName);\n                var fieldValue = storeObject[storeFieldName];\n                if (fieldValue === void 0)\n                    return;\n                var modify = typeof fields === \"function\" ? fields : (fields[storeFieldName] || fields[fieldName]);\n                if (modify) {\n                    var newValue = modify === delModifier ? DELETE : (modify(maybeDeepFreeze(fieldValue), __assign(__assign({}, sharedDetails_1), { fieldName: fieldName, storeFieldName: storeFieldName, storage: _this.getStorage(dataId, storeFieldName) })));\n                    if (newValue === INVALIDATE) {\n                        _this.group.dirty(dataId, storeFieldName);\n                    }\n                    else {\n                        if (newValue === DELETE)\n                            newValue = void 0;\n                        if (newValue !== fieldValue) {\n                            changedFields_1[storeFieldName] = newValue;\n                            needToMerge_1 = true;\n                            fieldValue = newValue;\n                            if (globalThis.__DEV__ !== false) {\n                                var checkReference = function (ref) {\n                                    if (_this.lookup(ref.__ref) === undefined) {\n                                        globalThis.__DEV__ !== false && invariant.warn(2, ref);\n                                        return true;\n                                    }\n                                };\n                                if (isReference(newValue)) {\n                                    checkReference(newValue);\n                                }\n                                else if (Array.isArray(newValue)) {\n                                    // Warn about writing \"mixed\" arrays of Reference and non-Reference objects\n                                    var seenReference = false;\n                                    var someNonReference = void 0;\n                                    for (var _i = 0, newValue_1 = newValue; _i < newValue_1.length; _i++) {\n                                        var value = newValue_1[_i];\n                                        if (isReference(value)) {\n                                            seenReference = true;\n                                            if (checkReference(value))\n                                                break;\n                                        }\n                                        else {\n                                            // Do not warn on primitive values, since those could never be represented\n                                            // by a reference. This is a valid (albeit uncommon) use case.\n                                            if (typeof value === \"object\" && !!value) {\n                                                var id = _this.policies.identify(value)[0];\n                                                // check if object could even be referenced, otherwise we are not interested in it for this warning\n                                                if (id) {\n                                                    someNonReference = value;\n                                                }\n                                            }\n                                        }\n                                        if (seenReference && someNonReference !== undefined) {\n                                            globalThis.__DEV__ !== false && invariant.warn(3, someNonReference);\n                                            break;\n                                        }\n                                    }\n                                }\n                            }\n                        }\n                    }\n                }\n                if (fieldValue !== void 0) {\n                    allDeleted_1 = false;\n                }\n            });\n            if (needToMerge_1) {\n                this.merge(dataId, changedFields_1);\n                if (allDeleted_1) {\n                    if (this instanceof Layer) {\n                        this.data[dataId] = void 0;\n                    }\n                    else {\n                        delete this.data[dataId];\n                    }\n                    this.group.dirty(dataId, \"__exists\");\n                }\n                return true;\n            }\n        }\n        return false;\n    };\n    // If called with only one argument, removes the entire entity\n    // identified by dataId. If called with a fieldName as well, removes all\n    // fields of that entity whose names match fieldName according to the\n    // fieldNameFromStoreName helper function. If called with a fieldName\n    // and variables, removes all fields of that entity whose names match fieldName\n    // and whose arguments when cached exactly match the variables passed.\n    EntityStore.prototype.delete = function (dataId, fieldName, args) {\n        var _a;\n        var storeObject = this.lookup(dataId);\n        if (storeObject) {\n            var typename = this.getFieldValue(storeObject, \"__typename\");\n            var storeFieldName = fieldName && args ?\n                this.policies.getStoreFieldName({ typename: typename, fieldName: fieldName, args: args })\n                : fieldName;\n            return this.modify(dataId, storeFieldName ? (_a = {},\n                _a[storeFieldName] = delModifier,\n                _a) : delModifier);\n        }\n        return false;\n    };\n    EntityStore.prototype.evict = function (options, limit) {\n        var evicted = false;\n        if (options.id) {\n            if (hasOwn.call(this.data, options.id)) {\n                evicted = this.delete(options.id, options.fieldName, options.args);\n            }\n            if (this instanceof Layer && this !== limit) {\n                evicted = this.parent.evict(options, limit) || evicted;\n            }\n            // Always invalidate the field to trigger rereading of watched\n            // queries, even if no cache data was modified by the eviction,\n            // because queries may depend on computed fields with custom read\n            // functions, whose values are not stored in the EntityStore.\n            if (options.fieldName || evicted) {\n                this.group.dirty(options.id, options.fieldName || \"__exists\");\n            }\n        }\n        return evicted;\n    };\n    EntityStore.prototype.clear = function () {\n        this.replace(null);\n    };\n    EntityStore.prototype.extract = function () {\n        var _this = this;\n        var obj = this.toObject();\n        var extraRootIds = [];\n        this.getRootIdSet().forEach(function (id) {\n            if (!hasOwn.call(_this.policies.rootTypenamesById, id)) {\n                extraRootIds.push(id);\n            }\n        });\n        if (extraRootIds.length) {\n            obj.__META = { extraRootIds: extraRootIds.sort() };\n        }\n        return obj;\n    };\n    EntityStore.prototype.replace = function (newData) {\n        var _this = this;\n        Object.keys(this.data).forEach(function (dataId) {\n            if (!(newData && hasOwn.call(newData, dataId))) {\n                _this.delete(dataId);\n            }\n        });\n        if (newData) {\n            var __META = newData.__META, rest_1 = __rest(newData, [\"__META\"]);\n            Object.keys(rest_1).forEach(function (dataId) {\n                _this.merge(dataId, rest_1[dataId]);\n            });\n            if (__META) {\n                __META.extraRootIds.forEach(this.retain, this);\n            }\n        }\n    };\n    EntityStore.prototype.retain = function (rootId) {\n        return (this.rootIds[rootId] = (this.rootIds[rootId] || 0) + 1);\n    };\n    EntityStore.prototype.release = function (rootId) {\n        if (this.rootIds[rootId] > 0) {\n            var count = --this.rootIds[rootId];\n            if (!count)\n                delete this.rootIds[rootId];\n            return count;\n        }\n        return 0;\n    };\n    // Return a Set<string> of all the ID strings that have been retained by\n    // this layer/root *and* any layers/roots beneath it.\n    EntityStore.prototype.getRootIdSet = function (ids) {\n        if (ids === void 0) { ids = new Set(); }\n        Object.keys(this.rootIds).forEach(ids.add, ids);\n        if (this instanceof Layer) {\n            this.parent.getRootIdSet(ids);\n        }\n        else {\n            // Official singleton IDs like ROOT_QUERY and ROOT_MUTATION are\n            // always considered roots for garbage collection, regardless of\n            // their retainment counts in this.rootIds.\n            Object.keys(this.policies.rootTypenamesById).forEach(ids.add, ids);\n        }\n        return ids;\n    };\n    // The goal of garbage collection is to remove IDs from the Root layer of the\n    // store that are no longer reachable starting from any IDs that have been\n    // explicitly retained (see retain and release, above). Returns an array of\n    // dataId strings that were removed from the store.\n    EntityStore.prototype.gc = function () {\n        var _this = this;\n        var ids = this.getRootIdSet();\n        var snapshot = this.toObject();\n        ids.forEach(function (id) {\n            if (hasOwn.call(snapshot, id)) {\n                // Because we are iterating over an ECMAScript Set, the IDs we add here\n                // will be visited in later iterations of the forEach loop only if they\n                // were not previously contained by the Set.\n                Object.keys(_this.findChildRefIds(id)).forEach(ids.add, ids);\n                // By removing IDs from the snapshot object here, we protect them from\n                // getting removed from the root store layer below.\n                delete snapshot[id];\n            }\n        });\n        var idsToRemove = Object.keys(snapshot);\n        if (idsToRemove.length) {\n            var root_1 = this;\n            while (root_1 instanceof Layer)\n                root_1 = root_1.parent;\n            idsToRemove.forEach(function (id) { return root_1.delete(id); });\n        }\n        return idsToRemove;\n    };\n    EntityStore.prototype.findChildRefIds = function (dataId) {\n        if (!hasOwn.call(this.refs, dataId)) {\n            var found_1 = (this.refs[dataId] = Object.create(null));\n            var root = this.data[dataId];\n            if (!root)\n                return found_1;\n            var workSet_1 = new Set([root]);\n            // Within the store, only arrays and objects can contain child entity\n            // references, so we can prune the traversal using this predicate:\n            workSet_1.forEach(function (obj) {\n                if (isReference(obj)) {\n                    found_1[obj.__ref] = true;\n                    // In rare cases, a { __ref } Reference object may have other fields.\n                    // This often indicates a mismerging of References with StoreObjects,\n                    // but garbage collection should not be fooled by a stray __ref\n                    // property in a StoreObject (ignoring all the other fields just\n                    // because the StoreObject looks like a Reference). To avoid this\n                    // premature termination of findChildRefIds recursion, we fall through\n                    // to the code below, which will handle any other properties of obj.\n                }\n                if (isNonNullObject(obj)) {\n                    Object.keys(obj).forEach(function (key) {\n                        var child = obj[key];\n                        // No need to add primitive values to the workSet, since they cannot\n                        // contain reference objects.\n                        if (isNonNullObject(child)) {\n                            workSet_1.add(child);\n                        }\n                    });\n                }\n            });\n        }\n        return this.refs[dataId];\n    };\n    EntityStore.prototype.makeCacheKey = function () {\n        return this.group.keyMaker.lookupArray(arguments);\n    };\n    return EntityStore;\n}());\nexport { EntityStore };\n// A single CacheGroup represents a set of one or more EntityStore objects,\n// typically the Root store in a CacheGroup by itself, and all active Layer\n// stores in a group together. A single EntityStore object belongs to only\n// one CacheGroup, store.group. The CacheGroup is responsible for tracking\n// dependencies, so store.group is helpful for generating unique keys for\n// cached results that need to be invalidated when/if those dependencies\n// change. If we used the EntityStore objects themselves as cache keys (that\n// is, store rather than store.group), the cache would become unnecessarily\n// fragmented by all the different Layer objects. Instead, the CacheGroup\n// approach allows all optimistic Layer objects in the same linked list to\n// belong to one CacheGroup, with the non-optimistic Root object belonging\n// to another CacheGroup, allowing resultCaching dependencies to be tracked\n// separately for optimistic and non-optimistic entity data.\nvar CacheGroup = /** @class */ (function () {\n    function CacheGroup(caching, parent) {\n        if (parent === void 0) { parent = null; }\n        this.caching = caching;\n        this.parent = parent;\n        this.d = null;\n        this.resetCaching();\n    }\n    CacheGroup.prototype.resetCaching = function () {\n        this.d = this.caching ? dep() : null;\n        this.keyMaker = new Trie(canUseWeakMap);\n    };\n    CacheGroup.prototype.depend = function (dataId, storeFieldName) {\n        if (this.d) {\n            this.d(makeDepKey(dataId, storeFieldName));\n            var fieldName = fieldNameFromStoreName(storeFieldName);\n            if (fieldName !== storeFieldName) {\n                // Fields with arguments that contribute extra identifying\n                // information to the fieldName (thus forming the storeFieldName)\n                // depend not only on the full storeFieldName but also on the\n                // short fieldName, so the field can be invalidated using either\n                // level of specificity.\n                this.d(makeDepKey(dataId, fieldName));\n            }\n            if (this.parent) {\n                this.parent.depend(dataId, storeFieldName);\n            }\n        }\n    };\n    CacheGroup.prototype.dirty = function (dataId, storeFieldName) {\n        if (this.d) {\n            this.d.dirty(makeDepKey(dataId, storeFieldName), \n            // When storeFieldName === \"__exists\", that means the entity identified\n            // by dataId has either disappeared from the cache or was newly added,\n            // so the result caching system would do well to \"forget everything it\n            // knows\" about that object. To achieve that kind of invalidation, we\n            // not only dirty the associated result cache entry, but also remove it\n            // completely from the dependency graph. For the optimism implementation\n            // details, see https://github.com/benjamn/optimism/pull/195.\n            storeFieldName === \"__exists\" ? \"forget\" : \"setDirty\");\n        }\n    };\n    return CacheGroup;\n}());\nfunction makeDepKey(dataId, storeFieldName) {\n    // Since field names cannot have '#' characters in them, this method\n    // of joining the field name and the ID should be unambiguous, and much\n    // cheaper than JSON.stringify([dataId, fieldName]).\n    return storeFieldName + \"#\" + dataId;\n}\nexport function maybeDependOnExistenceOfEntity(store, entityId) {\n    if (supportsResultCaching(store)) {\n        // We use this pseudo-field __exists elsewhere in the EntityStore code to\n        // represent changes in the existence of the entity object identified by\n        // entityId. This dependency gets reliably dirtied whenever an object with\n        // this ID is deleted (or newly created) within this group, so any result\n        // cache entries (for example, StoreReader#executeSelectionSet results) that\n        // depend on __exists for this entityId will get dirtied as well, leading to\n        // the eventual recomputation (instead of reuse) of those result objects the\n        // next time someone reads them from the cache.\n        store.group.depend(entityId, \"__exists\");\n    }\n}\n(function (EntityStore) {\n    // Refer to this class as EntityStore.Root outside this namespace.\n    var Root = /** @class */ (function (_super) {\n        __extends(Root, _super);\n        function Root(_a) {\n            var policies = _a.policies, _b = _a.resultCaching, resultCaching = _b === void 0 ? true : _b, seed = _a.seed;\n            var _this = _super.call(this, policies, new CacheGroup(resultCaching)) || this;\n            _this.stump = new Stump(_this);\n            _this.storageTrie = new Trie(canUseWeakMap);\n            if (seed)\n                _this.replace(seed);\n            return _this;\n        }\n        Root.prototype.addLayer = function (layerId, replay) {\n            // Adding an optimistic Layer on top of the Root actually adds the Layer\n            // on top of the Stump, so the Stump always comes between the Root and\n            // any Layer objects that we've added.\n            return this.stump.addLayer(layerId, replay);\n        };\n        Root.prototype.removeLayer = function () {\n            // Never remove the root layer.\n            return this;\n        };\n        Root.prototype.getStorage = function () {\n            return this.storageTrie.lookupArray(arguments);\n        };\n        return Root;\n    }(EntityStore));\n    EntityStore.Root = Root;\n})(EntityStore || (EntityStore = {}));\n// Not exported, since all Layer instances are created by the addLayer method\n// of the EntityStore.Root class.\nvar Layer = /** @class */ (function (_super) {\n    __extends(Layer, _super);\n    function Layer(id, parent, replay, group) {\n        var _this = _super.call(this, parent.policies, group) || this;\n        _this.id = id;\n        _this.parent = parent;\n        _this.replay = replay;\n        _this.group = group;\n        replay(_this);\n        return _this;\n    }\n    Layer.prototype.addLayer = function (layerId, replay) {\n        return new Layer(layerId, this, replay, this.group);\n    };\n    Layer.prototype.removeLayer = function (layerId) {\n        var _this = this;\n        // Remove all instances of the given id, not just the first one.\n        var parent = this.parent.removeLayer(layerId);\n        if (layerId === this.id) {\n            if (this.group.caching) {\n                // Dirty every ID we're removing. Technically we might be able to avoid\n                // dirtying fields that have values in higher layers, but we don't have\n                // easy access to higher layers here, and we're about to recreate those\n                // layers anyway (see parent.addLayer below).\n                Object.keys(this.data).forEach(function (dataId) {\n                    var ownStoreObject = _this.data[dataId];\n                    var parentStoreObject = parent[\"lookup\"](dataId);\n                    if (!parentStoreObject) {\n                        // The StoreObject identified by dataId was defined in this layer\n                        // but will be undefined in the parent layer, so we can delete the\n                        // whole entity using this.delete(dataId). Since we're about to\n                        // throw this layer away, the only goal of this deletion is to dirty\n                        // the removed fields.\n                        _this.delete(dataId);\n                    }\n                    else if (!ownStoreObject) {\n                        // This layer had an entry for dataId but it was undefined, which\n                        // means the entity was deleted in this layer, and it's about to\n                        // become undeleted when we remove this layer, so we need to dirty\n                        // all fields that are about to be reexposed.\n                        _this.group.dirty(dataId, \"__exists\");\n                        Object.keys(parentStoreObject).forEach(function (storeFieldName) {\n                            _this.group.dirty(dataId, storeFieldName);\n                        });\n                    }\n                    else if (ownStoreObject !== parentStoreObject) {\n                        // If ownStoreObject is not exactly the same as parentStoreObject,\n                        // dirty any fields whose values will change as a result of this\n                        // removal.\n                        Object.keys(ownStoreObject).forEach(function (storeFieldName) {\n                            if (!equal(ownStoreObject[storeFieldName], parentStoreObject[storeFieldName])) {\n                                _this.group.dirty(dataId, storeFieldName);\n                            }\n                        });\n                    }\n                });\n            }\n            return parent;\n        }\n        // No changes are necessary if the parent chain remains identical.\n        if (parent === this.parent)\n            return this;\n        // Recreate this layer on top of the new parent.\n        return parent.addLayer(this.id, this.replay);\n    };\n    Layer.prototype.toObject = function () {\n        return __assign(__assign({}, this.parent.toObject()), this.data);\n    };\n    Layer.prototype.findChildRefIds = function (dataId) {\n        var fromParent = this.parent.findChildRefIds(dataId);\n        return hasOwn.call(this.data, dataId) ? __assign(__assign({}, fromParent), _super.prototype.findChildRefIds.call(this, dataId)) : fromParent;\n    };\n    Layer.prototype.getStorage = function () {\n        var p = this.parent;\n        while (p.parent)\n            p = p.parent;\n        return p.getStorage.apply(p, \n        // @ts-expect-error\n        arguments);\n    };\n    return Layer;\n}(EntityStore));\n// Represents a Layer permanently installed just above the Root, which allows\n// reading optimistically (and registering optimistic dependencies) even when\n// no optimistic layers are currently active. The stump.group CacheGroup object\n// is shared by any/all Layer objects added on top of the Stump.\nvar Stump = /** @class */ (function (_super) {\n    __extends(Stump, _super);\n    function Stump(root) {\n        return _super.call(this, \"EntityStore.Stump\", root, function () { }, new CacheGroup(root.group.caching, root.group)) || this;\n    }\n    Stump.prototype.removeLayer = function () {\n        // Never remove the Stump layer.\n        return this;\n    };\n    Stump.prototype.merge = function (older, newer) {\n        // We never want to write any data into the Stump, so we forward any merge\n        // calls to the Root instead. Another option here would be to throw an\n        // exception, but the toReference(object, true) function can sometimes\n        // trigger Stump writes (which used to be Root writes, before the Stump\n        // concept was introduced).\n        return this.parent.merge(older, newer);\n    };\n    return Stump;\n}(Layer));\nfunction storeObjectReconciler(existingObject, incomingObject, property) {\n    var existingValue = existingObject[property];\n    var incomingValue = incomingObject[property];\n    // Wherever there is a key collision, prefer the incoming value, unless\n    // it is deeply equal to the existing value. It's worth checking deep\n    // equality here (even though blindly returning incoming would be\n    // logically correct) because preserving the referential identity of\n    // existing data can prevent needless rereading and rerendering.\n    return equal(existingValue, incomingValue) ? existingValue : incomingValue;\n}\nexport function supportsResultCaching(store) {\n    // When result caching is disabled, store.depend will be null.\n    return !!(store instanceof EntityStore && store.group.caching);\n}\n//# sourceMappingURL=entityStore.js.map","import { __assign } from \"tslib\";\nimport { Trie } from \"@wry/trie\";\nimport { canUseWeakMap, canUseWeakSet, isNonNullObject as isObjectOrArray, } from \"../../utilities/index.js\";\nimport { isArray } from \"./helpers.js\";\nfunction shallowCopy(value) {\n    if (isObjectOrArray(value)) {\n        return isArray(value) ?\n            value.slice(0)\n            : __assign({ __proto__: Object.getPrototypeOf(value) }, value);\n    }\n    return value;\n}\n// When programmers talk about the \"canonical form\" of an object, they\n// usually have the following meaning in mind, which I've copied from\n// https://en.wiktionary.org/wiki/canonical_form:\n//\n// 1. A standard or normal presentation of a mathematical entity [or\n//    object]. A canonical form is an element of a set of representatives\n//    of equivalence classes of forms such that there is a function or\n//    procedure which projects every element of each equivalence class\n//    onto that one element, the canonical form of that equivalence\n//    class. The canonical form is expected to be simpler than the rest of\n//    the forms in some way.\n//\n// That's a long-winded way of saying any two objects that have the same\n// canonical form may be considered equivalent, even if they are !==,\n// which usually means the objects are structurally equivalent (deeply\n// equal), but don't necessarily use the same memory.\n//\n// Like a literary or musical canon, this ObjectCanon class represents a\n// collection of unique canonical items (JavaScript objects), with the\n// important property that canon.admit(a) === canon.admit(b) if a and b\n// are deeply equal to each other. In terms of the definition above, the\n// canon.admit method is the \"function or procedure which projects every\"\n// object \"onto that one element, the canonical form.\"\n//\n// In the worst case, the canonicalization process may involve looking at\n// every property in the provided object tree, so it takes the same order\n// of time as deep equality checking. Fortunately, already-canonicalized\n// objects are returned immediately from canon.admit, so the presence of\n// canonical subtrees tends to speed up canonicalization.\n//\n// Since consumers of canonical objects can check for deep equality in\n// constant time, canonicalizing cache results can massively improve the\n// performance of application code that skips re-rendering unchanged\n// results, such as \"pure\" UI components in a framework like React.\n//\n// Of course, since canonical objects may be shared widely between\n// unrelated consumers, it's important to think of them as immutable, even\n// though they are not actually frozen with Object.freeze in production,\n// due to the extra performance overhead that comes with frozen objects.\n//\n// Custom scalar objects whose internal class name is neither Array nor\n// Object can be included safely in the admitted tree, but they will not\n// be replaced with a canonical version (to put it another way, they are\n// assumed to be canonical already).\n//\n// If we ignore custom objects, no detection of cycles or repeated object\n// references is currently required by the StoreReader class, since\n// GraphQL result objects are JSON-serializable trees (and thus contain\n// neither cycles nor repeated subtrees), so we can avoid the complexity\n// of keeping track of objects we've already seen during the recursion of\n// the admit method.\n//\n// In the future, we may consider adding additional cases to the switch\n// statement to handle other common object types, such as \"[object Date]\"\n// objects, as needed.\nvar ObjectCanon = /** @class */ (function () {\n    function ObjectCanon() {\n        // Set of all canonical objects this ObjectCanon has admitted, allowing\n        // canon.admit to return previously-canonicalized objects immediately.\n        this.known = new (canUseWeakSet ? WeakSet : Set)();\n        // Efficient storage/lookup structure for canonical objects.\n        this.pool = new Trie(canUseWeakMap);\n        // Make the ObjectCanon assume this value has already been\n        // canonicalized.\n        this.passes = new WeakMap();\n        // Arrays that contain the same elements in a different order can share\n        // the same SortedKeysInfo object, to save memory.\n        this.keysByJSON = new Map();\n        // This has to come last because it depends on keysByJSON.\n        this.empty = this.admit({});\n    }\n    ObjectCanon.prototype.isKnown = function (value) {\n        return isObjectOrArray(value) && this.known.has(value);\n    };\n    ObjectCanon.prototype.pass = function (value) {\n        if (isObjectOrArray(value)) {\n            var copy = shallowCopy(value);\n            this.passes.set(copy, value);\n            return copy;\n        }\n        return value;\n    };\n    ObjectCanon.prototype.admit = function (value) {\n        var _this = this;\n        if (isObjectOrArray(value)) {\n            var original = this.passes.get(value);\n            if (original)\n                return original;\n            var proto = Object.getPrototypeOf(value);\n            switch (proto) {\n                case Array.prototype: {\n                    if (this.known.has(value))\n                        return value;\n                    var array = value.map(this.admit, this);\n                    // Arrays are looked up in the Trie using their recursively\n                    // canonicalized elements, and the known version of the array is\n                    // preserved as node.array.\n                    var node = this.pool.lookupArray(array);\n                    if (!node.array) {\n                        this.known.add((node.array = array));\n                        // Since canonical arrays may be shared widely between\n                        // unrelated consumers, it's important to regard them as\n                        // immutable, even if they are not frozen in production.\n                        if (globalThis.__DEV__ !== false) {\n                            Object.freeze(array);\n                        }\n                    }\n                    return node.array;\n                }\n                case null:\n                case Object.prototype: {\n                    if (this.known.has(value))\n                        return value;\n                    var proto_1 = Object.getPrototypeOf(value);\n                    var array_1 = [proto_1];\n                    var keys = this.sortedKeys(value);\n                    array_1.push(keys.json);\n                    var firstValueIndex_1 = array_1.length;\n                    keys.sorted.forEach(function (key) {\n                        array_1.push(_this.admit(value[key]));\n                    });\n                    // Objects are looked up in the Trie by their prototype (which\n                    // is *not* recursively canonicalized), followed by a JSON\n                    // representation of their (sorted) keys, followed by the\n                    // sequence of recursively canonicalized values corresponding to\n                    // those keys. To keep the final results unambiguous with other\n                    // sequences (such as arrays that just happen to contain [proto,\n                    // keys.json, value1, value2, ...]), the known version of the\n                    // object is stored as node.object.\n                    var node = this.pool.lookupArray(array_1);\n                    if (!node.object) {\n                        var obj_1 = (node.object = Object.create(proto_1));\n                        this.known.add(obj_1);\n                        keys.sorted.forEach(function (key, i) {\n                            obj_1[key] = array_1[firstValueIndex_1 + i];\n                        });\n                        // Since canonical objects may be shared widely between\n                        // unrelated consumers, it's important to regard them as\n                        // immutable, even if they are not frozen in production.\n                        if (globalThis.__DEV__ !== false) {\n                            Object.freeze(obj_1);\n                        }\n                    }\n                    return node.object;\n                }\n            }\n        }\n        return value;\n    };\n    // It's worthwhile to cache the sorting of arrays of strings, since the\n    // same initial unsorted arrays tend to be encountered many times.\n    // Fortunately, we can reuse the Trie machinery to look up the sorted\n    // arrays in linear time (which is faster than sorting large arrays).\n    ObjectCanon.prototype.sortedKeys = function (obj) {\n        var keys = Object.keys(obj);\n        var node = this.pool.lookupArray(keys);\n        if (!node.keys) {\n            keys.sort();\n            var json = JSON.stringify(keys);\n            if (!(node.keys = this.keysByJSON.get(json))) {\n                this.keysByJSON.set(json, (node.keys = { sorted: keys, json: json }));\n            }\n        }\n        return node.keys;\n    };\n    return ObjectCanon;\n}());\nexport { ObjectCanon };\n//# sourceMappingURL=object-canon.js.map","import { __assign } from \"tslib\";\nimport { invariant, newInvariantError } from \"../../utilities/globals/index.js\";\nimport { Kind } from \"graphql\";\nimport { wrap } from \"optimism\";\nimport { isField, resultKeyNameFromField, isReference, makeReference, shouldInclude, addTypenameToDocument, getDefaultValues, getMainDefinition, getQueryDefinition, getFragmentFromSelection, maybeDeepFreeze, mergeDeepArray, DeepMerger, isNonNullObject, canUseWeakMap, compact, canonicalStringify, cacheSizes, } from \"../../utilities/index.js\";\nimport { maybeDependOnExistenceOfEntity, supportsResultCaching, } from \"./entityStore.js\";\nimport { isArray, extractFragmentContext, getTypenameFromStoreObject, shouldCanonizeResults, } from \"./helpers.js\";\nimport { MissingFieldError } from \"../core/types/common.js\";\nimport { ObjectCanon } from \"./object-canon.js\";\nfunction execSelectionSetKeyArgs(options) {\n    return [\n        options.selectionSet,\n        options.objectOrReference,\n        options.context,\n        // We split out this property so we can pass different values\n        // independently without modifying options.context itself.\n        options.context.canonizeResults,\n    ];\n}\nvar StoreReader = /** @class */ (function () {\n    function StoreReader(config) {\n        var _this = this;\n        this.knownResults = new (canUseWeakMap ? WeakMap : Map)();\n        this.config = compact(config, {\n            addTypename: config.addTypename !== false,\n            canonizeResults: shouldCanonizeResults(config),\n        });\n        this.canon = config.canon || new ObjectCanon();\n        // memoized functions in this class will be \"garbage-collected\"\n        // by recreating the whole `StoreReader` in\n        // `InMemoryCache.resetResultsCache`\n        // (triggered from `InMemoryCache.gc` with `resetResultCache: true`)\n        this.executeSelectionSet = wrap(function (options) {\n            var _a;\n            var canonizeResults = options.context.canonizeResults;\n            var peekArgs = execSelectionSetKeyArgs(options);\n            // Negate this boolean option so we can find out if we've already read\n            // this result using the other boolean value.\n            peekArgs[3] = !canonizeResults;\n            var other = (_a = _this.executeSelectionSet).peek.apply(_a, peekArgs);\n            if (other) {\n                if (canonizeResults) {\n                    return __assign(__assign({}, other), { \n                        // If we previously read this result without canonizing it, we can\n                        // reuse that result simply by canonizing it now.\n                        result: _this.canon.admit(other.result) });\n                }\n                // If we previously read this result with canonization enabled, we can\n                // return that canonized result as-is.\n                return other;\n            }\n            maybeDependOnExistenceOfEntity(options.context.store, options.enclosingRef.__ref);\n            // Finally, if we didn't find any useful previous results, run the real\n            // execSelectionSetImpl method with the given options.\n            return _this.execSelectionSetImpl(options);\n        }, {\n            max: this.config.resultCacheMaxSize ||\n                cacheSizes[\"inMemoryCache.executeSelectionSet\"] ||\n                50000 /* defaultCacheSizes[\"inMemoryCache.executeSelectionSet\"] */,\n            keyArgs: execSelectionSetKeyArgs,\n            // Note that the parameters of makeCacheKey are determined by the\n            // array returned by keyArgs.\n            makeCacheKey: function (selectionSet, parent, context, canonizeResults) {\n                if (supportsResultCaching(context.store)) {\n                    return context.store.makeCacheKey(selectionSet, isReference(parent) ? parent.__ref : parent, context.varString, canonizeResults);\n                }\n            },\n        });\n        this.executeSubSelectedArray = wrap(function (options) {\n            maybeDependOnExistenceOfEntity(options.context.store, options.enclosingRef.__ref);\n            return _this.execSubSelectedArrayImpl(options);\n        }, {\n            max: this.config.resultCacheMaxSize ||\n                cacheSizes[\"inMemoryCache.executeSubSelectedArray\"] ||\n                10000 /* defaultCacheSizes[\"inMemoryCache.executeSubSelectedArray\"] */,\n            makeCacheKey: function (_a) {\n                var field = _a.field, array = _a.array, context = _a.context;\n                if (supportsResultCaching(context.store)) {\n                    return context.store.makeCacheKey(field, array, context.varString);\n                }\n            },\n        });\n    }\n    StoreReader.prototype.resetCanon = function () {\n        this.canon = new ObjectCanon();\n    };\n    /**\n     * Given a store and a query, return as much of the result as possible and\n     * identify if any data was missing from the store.\n     */\n    StoreReader.prototype.diffQueryAgainstStore = function (_a) {\n        var store = _a.store, query = _a.query, _b = _a.rootId, rootId = _b === void 0 ? \"ROOT_QUERY\" : _b, variables = _a.variables, _c = _a.returnPartialData, returnPartialData = _c === void 0 ? true : _c, _d = _a.canonizeResults, canonizeResults = _d === void 0 ? this.config.canonizeResults : _d;\n        var policies = this.config.cache.policies;\n        variables = __assign(__assign({}, getDefaultValues(getQueryDefinition(query))), variables);\n        var rootRef = makeReference(rootId);\n        var execResult = this.executeSelectionSet({\n            selectionSet: getMainDefinition(query).selectionSet,\n            objectOrReference: rootRef,\n            enclosingRef: rootRef,\n            context: __assign({ store: store, query: query, policies: policies, variables: variables, varString: canonicalStringify(variables), canonizeResults: canonizeResults }, extractFragmentContext(query, this.config.fragments)),\n        });\n        var missing;\n        if (execResult.missing) {\n            // For backwards compatibility we still report an array of\n            // MissingFieldError objects, even though there will only ever be at most\n            // one of them, now that all missing field error messages are grouped\n            // together in the execResult.missing tree.\n            missing = [\n                new MissingFieldError(firstMissing(execResult.missing), execResult.missing, query, variables),\n            ];\n            if (!returnPartialData) {\n                throw missing[0];\n            }\n        }\n        return {\n            result: execResult.result,\n            complete: !missing,\n            missing: missing,\n        };\n    };\n    StoreReader.prototype.isFresh = function (result, parent, selectionSet, context) {\n        if (supportsResultCaching(context.store) &&\n            this.knownResults.get(result) === selectionSet) {\n            var latest = this.executeSelectionSet.peek(selectionSet, parent, context, \n            // If result is canonical, then it could only have been previously\n            // cached by the canonizing version of executeSelectionSet, so we can\n            // avoid checking both possibilities here.\n            this.canon.isKnown(result));\n            if (latest && result === latest.result) {\n                return true;\n            }\n        }\n        return false;\n    };\n    // Uncached version of executeSelectionSet.\n    StoreReader.prototype.execSelectionSetImpl = function (_a) {\n        var _this = this;\n        var selectionSet = _a.selectionSet, objectOrReference = _a.objectOrReference, enclosingRef = _a.enclosingRef, context = _a.context;\n        if (isReference(objectOrReference) &&\n            !context.policies.rootTypenamesById[objectOrReference.__ref] &&\n            !context.store.has(objectOrReference.__ref)) {\n            return {\n                result: this.canon.empty,\n                missing: \"Dangling reference to missing \".concat(objectOrReference.__ref, \" object\"),\n            };\n        }\n        var variables = context.variables, policies = context.policies, store = context.store;\n        var typename = store.getFieldValue(objectOrReference, \"__typename\");\n        var objectsToMerge = [];\n        var missing;\n        var missingMerger = new DeepMerger();\n        if (this.config.addTypename &&\n            typeof typename === \"string\" &&\n            !policies.rootIdsByTypename[typename]) {\n            // Ensure we always include a default value for the __typename\n            // field, if we have one, and this.config.addTypename is true. Note\n            // that this field can be overridden by other merged objects.\n            objectsToMerge.push({ __typename: typename });\n        }\n        function handleMissing(result, resultName) {\n            var _a;\n            if (result.missing) {\n                missing = missingMerger.merge(missing, (_a = {},\n                    _a[resultName] = result.missing,\n                    _a));\n            }\n            return result.result;\n        }\n        var workSet = new Set(selectionSet.selections);\n        workSet.forEach(function (selection) {\n            var _a, _b;\n            // Omit fields with directives @skip(if: <truthy value>) or\n            // @include(if: <falsy value>).\n            if (!shouldInclude(selection, variables))\n                return;\n            if (isField(selection)) {\n                var fieldValue = policies.readField({\n                    fieldName: selection.name.value,\n                    field: selection,\n                    variables: context.variables,\n                    from: objectOrReference,\n                }, context);\n                var resultName = resultKeyNameFromField(selection);\n                if (fieldValue === void 0) {\n                    if (!addTypenameToDocument.added(selection)) {\n                        missing = missingMerger.merge(missing, (_a = {},\n                            _a[resultName] = \"Can't find field '\".concat(selection.name.value, \"' on \").concat(isReference(objectOrReference) ?\n                                objectOrReference.__ref + \" object\"\n                                : \"object \" + JSON.stringify(objectOrReference, null, 2)),\n                            _a));\n                    }\n                }\n                else if (isArray(fieldValue)) {\n                    if (fieldValue.length > 0) {\n                        fieldValue = handleMissing(_this.executeSubSelectedArray({\n                            field: selection,\n                            array: fieldValue,\n                            enclosingRef: enclosingRef,\n                            context: context,\n                        }), resultName);\n                    }\n                }\n                else if (!selection.selectionSet) {\n                    // If the field does not have a selection set, then we handle it\n                    // as a scalar value. To keep this.canon from canonicalizing\n                    // this value, we use this.canon.pass to wrap fieldValue in a\n                    // Pass object that this.canon.admit will later unwrap as-is.\n                    if (context.canonizeResults) {\n                        fieldValue = _this.canon.pass(fieldValue);\n                    }\n                }\n                else if (fieldValue != null) {\n                    // In this case, because we know the field has a selection set,\n                    // it must be trying to query a GraphQLObjectType, which is why\n                    // fieldValue must be != null.\n                    fieldValue = handleMissing(_this.executeSelectionSet({\n                        selectionSet: selection.selectionSet,\n                        objectOrReference: fieldValue,\n                        enclosingRef: isReference(fieldValue) ? fieldValue : enclosingRef,\n                        context: context,\n                    }), resultName);\n                }\n                if (fieldValue !== void 0) {\n                    objectsToMerge.push((_b = {}, _b[resultName] = fieldValue, _b));\n                }\n            }\n            else {\n                var fragment = getFragmentFromSelection(selection, context.lookupFragment);\n                if (!fragment && selection.kind === Kind.FRAGMENT_SPREAD) {\n                    throw newInvariantError(9, selection.name.value);\n                }\n                if (fragment && policies.fragmentMatches(fragment, typename)) {\n                    fragment.selectionSet.selections.forEach(workSet.add, workSet);\n                }\n            }\n        });\n        var result = mergeDeepArray(objectsToMerge);\n        var finalResult = { result: result, missing: missing };\n        var frozen = context.canonizeResults ?\n            this.canon.admit(finalResult)\n            // Since this.canon is normally responsible for freezing results (only in\n            // development), freeze them manually if canonization is disabled.\n            : maybeDeepFreeze(finalResult);\n        // Store this result with its selection set so that we can quickly\n        // recognize it again in the StoreReader#isFresh method.\n        if (frozen.result) {\n            this.knownResults.set(frozen.result, selectionSet);\n        }\n        return frozen;\n    };\n    // Uncached version of executeSubSelectedArray.\n    StoreReader.prototype.execSubSelectedArrayImpl = function (_a) {\n        var _this = this;\n        var field = _a.field, array = _a.array, enclosingRef = _a.enclosingRef, context = _a.context;\n        var missing;\n        var missingMerger = new DeepMerger();\n        function handleMissing(childResult, i) {\n            var _a;\n            if (childResult.missing) {\n                missing = missingMerger.merge(missing, (_a = {}, _a[i] = childResult.missing, _a));\n            }\n            return childResult.result;\n        }\n        if (field.selectionSet) {\n            array = array.filter(context.store.canRead);\n        }\n        array = array.map(function (item, i) {\n            // null value in array\n            if (item === null) {\n                return null;\n            }\n            // This is a nested array, recurse\n            if (isArray(item)) {\n                return handleMissing(_this.executeSubSelectedArray({\n                    field: field,\n                    array: item,\n                    enclosingRef: enclosingRef,\n                    context: context,\n                }), i);\n            }\n            // This is an object, run the selection set on it\n            if (field.selectionSet) {\n                return handleMissing(_this.executeSelectionSet({\n                    selectionSet: field.selectionSet,\n                    objectOrReference: item,\n                    enclosingRef: isReference(item) ? item : enclosingRef,\n                    context: context,\n                }), i);\n            }\n            if (globalThis.__DEV__ !== false) {\n                assertSelectionSetForIdValue(context.store, field, item);\n            }\n            return item;\n        });\n        return {\n            result: context.canonizeResults ? this.canon.admit(array) : array,\n            missing: missing,\n        };\n    };\n    return StoreReader;\n}());\nexport { StoreReader };\nfunction firstMissing(tree) {\n    try {\n        JSON.stringify(tree, function (_, value) {\n            if (typeof value === \"string\")\n                throw value;\n            return value;\n        });\n    }\n    catch (result) {\n        return result;\n    }\n}\nfunction assertSelectionSetForIdValue(store, field, fieldValue) {\n    if (!field.selectionSet) {\n        var workSet_1 = new Set([fieldValue]);\n        workSet_1.forEach(function (value) {\n            if (isNonNullObject(value)) {\n                invariant(\n                    !isReference(value),\n                    10,\n                    getTypenameFromStoreObject(store, value),\n                    field.name.value\n                );\n                Object.values(value).forEach(workSet_1.add, workSet_1);\n            }\n        });\n    }\n}\n//# sourceMappingURL=readFromStore.js.map","import { invariant } from \"../../utilities/globals/index.js\";\nimport { argumentsObjectFromField, DeepMerger, isNonEmptyArray, isNonNullObject, } from \"../../utilities/index.js\";\nimport { hasOwn, isArray } from \"./helpers.js\";\n// Mapping from JSON-encoded KeySpecifier strings to associated information.\nvar specifierInfoCache = Object.create(null);\nfunction lookupSpecifierInfo(spec) {\n    // It's safe to encode KeySpecifier arrays with JSON.stringify, since they're\n    // just arrays of strings or nested KeySpecifier arrays, and the order of the\n    // array elements is important (and suitably preserved by JSON.stringify).\n    var cacheKey = JSON.stringify(spec);\n    return (specifierInfoCache[cacheKey] ||\n        (specifierInfoCache[cacheKey] = Object.create(null)));\n}\nexport function keyFieldsFnFromSpecifier(specifier) {\n    var info = lookupSpecifierInfo(specifier);\n    return (info.keyFieldsFn || (info.keyFieldsFn = function (object, context) {\n            var extract = function (from, key) {\n                return context.readField(key, from);\n            };\n            var keyObject = (context.keyObject = collectSpecifierPaths(specifier, function (schemaKeyPath) {\n                var extracted = extractKeyPath(context.storeObject, schemaKeyPath, \n                // Using context.readField to extract paths from context.storeObject\n                // allows the extraction to see through Reference objects and respect\n                // custom read functions.\n                extract);\n                if (extracted === void 0 &&\n                    object !== context.storeObject &&\n                    hasOwn.call(object, schemaKeyPath[0])) {\n                    // If context.storeObject fails to provide a value for the requested\n                    // path, fall back to the raw result object, if it has a top-level key\n                    // matching the first key in the path (schemaKeyPath[0]). This allows\n                    // key fields included in the written data to be saved in the cache\n                    // even if they are not selected explicitly in context.selectionSet.\n                    // Not being mentioned by context.selectionSet is convenient here,\n                    // since it means these extra fields cannot be affected by field\n                    // aliasing, which is why we can use extractKey instead of\n                    // context.readField for this extraction.\n                    extracted = extractKeyPath(object, schemaKeyPath, extractKey);\n                }\n                invariant(extracted !== void 0, 4, schemaKeyPath.join(\".\"), object);\n                return extracted;\n            }));\n            return \"\".concat(context.typename, \":\").concat(JSON.stringify(keyObject));\n        }));\n}\n// The keyArgs extraction process is roughly analogous to keyFields extraction,\n// but there are no aliases involved, missing fields are tolerated (by merely\n// omitting them from the key), and drawing from field.directives or variables\n// is allowed (in addition to drawing from the field's arguments object).\n// Concretely, these differences mean passing a different key path extractor\n// function to collectSpecifierPaths, reusing the shared extractKeyPath helper\n// wherever possible.\nexport function keyArgsFnFromSpecifier(specifier) {\n    var info = lookupSpecifierInfo(specifier);\n    return (info.keyArgsFn ||\n        (info.keyArgsFn = function (args, _a) {\n            var field = _a.field, variables = _a.variables, fieldName = _a.fieldName;\n            var collected = collectSpecifierPaths(specifier, function (keyPath) {\n                var firstKey = keyPath[0];\n                var firstChar = firstKey.charAt(0);\n                if (firstChar === \"@\") {\n                    if (field && isNonEmptyArray(field.directives)) {\n                        var directiveName_1 = firstKey.slice(1);\n                        // If the directive appears multiple times, only the first\n                        // occurrence's arguments will be used. TODO Allow repetition?\n                        // TODO Cache this work somehow, a la aliasMap?\n                        var d = field.directives.find(function (d) { return d.name.value === directiveName_1; });\n                        // Fortunately argumentsObjectFromField works for DirectiveNode!\n                        var directiveArgs = d && argumentsObjectFromField(d, variables);\n                        // For directives without arguments (d defined, but directiveArgs ===\n                        // null), the presence or absence of the directive still counts as\n                        // part of the field key, so we return null in those cases. If no\n                        // directive with this name was found for this field (d undefined and\n                        // thus directiveArgs undefined), we return undefined, which causes\n                        // this value to be omitted from the key object returned by\n                        // collectSpecifierPaths.\n                        return (directiveArgs &&\n                            extractKeyPath(directiveArgs, \n                            // If keyPath.length === 1, this code calls extractKeyPath with an\n                            // empty path, which works because it uses directiveArgs as the\n                            // extracted value.\n                            keyPath.slice(1)));\n                    }\n                    // If the key started with @ but there was no corresponding directive,\n                    // we want to omit this value from the key object, not fall through to\n                    // treating @whatever as a normal argument name.\n                    return;\n                }\n                if (firstChar === \"$\") {\n                    var variableName = firstKey.slice(1);\n                    if (variables && hasOwn.call(variables, variableName)) {\n                        var varKeyPath = keyPath.slice(0);\n                        varKeyPath[0] = variableName;\n                        return extractKeyPath(variables, varKeyPath);\n                    }\n                    // If the key started with $ but there was no corresponding variable, we\n                    // want to omit this value from the key object, not fall through to\n                    // treating $whatever as a normal argument name.\n                    return;\n                }\n                if (args) {\n                    return extractKeyPath(args, keyPath);\n                }\n            });\n            var suffix = JSON.stringify(collected);\n            // If no arguments were passed to this field, and it didn't have any other\n            // field key contributions from directives or variables, hide the empty\n            // :{} suffix from the field key. However, a field passed no arguments can\n            // still end up with a non-empty :{...} suffix if its key configuration\n            // refers to directives or variables.\n            if (args || suffix !== \"{}\") {\n                fieldName += \":\" + suffix;\n            }\n            return fieldName;\n        }));\n}\nexport function collectSpecifierPaths(specifier, extractor) {\n    // For each path specified by specifier, invoke the extractor, and repeatedly\n    // merge the results together, with appropriate ancestor context.\n    var merger = new DeepMerger();\n    return getSpecifierPaths(specifier).reduce(function (collected, path) {\n        var _a;\n        var toMerge = extractor(path);\n        if (toMerge !== void 0) {\n            // This path is not expected to contain array indexes, so the toMerge\n            // reconstruction will not contain arrays. TODO Fix this?\n            for (var i = path.length - 1; i >= 0; --i) {\n                toMerge = (_a = {}, _a[path[i]] = toMerge, _a);\n            }\n            collected = merger.merge(collected, toMerge);\n        }\n        return collected;\n    }, Object.create(null));\n}\nexport function getSpecifierPaths(spec) {\n    var info = lookupSpecifierInfo(spec);\n    if (!info.paths) {\n        var paths_1 = (info.paths = []);\n        var currentPath_1 = [];\n        spec.forEach(function (s, i) {\n            if (isArray(s)) {\n                getSpecifierPaths(s).forEach(function (p) { return paths_1.push(currentPath_1.concat(p)); });\n                currentPath_1.length = 0;\n            }\n            else {\n                currentPath_1.push(s);\n                if (!isArray(spec[i + 1])) {\n                    paths_1.push(currentPath_1.slice(0));\n                    currentPath_1.length = 0;\n                }\n            }\n        });\n    }\n    return info.paths;\n}\nfunction extractKey(object, key) {\n    return object[key];\n}\nexport function extractKeyPath(object, path, extract) {\n    // For each key in path, extract the corresponding child property from obj,\n    // flattening arrays if encountered (uncommon for keyFields and keyArgs, but\n    // possible). The final result of path.reduce is normalized so unexpected leaf\n    // objects have their keys safely sorted. That final result is difficult to\n    // type as anything other than any. You're welcome to try to improve the\n    // return type, but keep in mind extractKeyPath is not a public function\n    // (exported only for testing), so the effort may not be worthwhile unless the\n    // limited set of actual callers (see above) pass arguments that TypeScript\n    // can statically type. If we know only that path is some array of strings\n    // (and not, say, a specific tuple of statically known strings), any (or\n    // possibly unknown) is the honest answer.\n    extract = extract || extractKey;\n    return normalize(path.reduce(function reducer(obj, key) {\n        return isArray(obj) ?\n            obj.map(function (child) { return reducer(child, key); })\n            : obj && extract(obj, key);\n    }, object));\n}\nfunction normalize(value) {\n    // Usually the extracted value will be a scalar value, since most primary\n    // key fields are scalar, but just in case we get an object or an array, we\n    // need to do some normalization of the order of (nested) keys.\n    if (isNonNullObject(value)) {\n        if (isArray(value)) {\n            return value.map(normalize);\n        }\n        return collectSpecifierPaths(Object.keys(value).sort(), function (path) {\n            return extractKeyPath(value, path);\n        });\n    }\n    return value;\n}\n//# sourceMappingURL=key-extractor.js.map","import { __assign, __rest } from \"tslib\";\nimport { invariant, newInvariantError } from \"../../utilities/globals/index.js\";\nimport { storeKeyNameFromField, argumentsObjectFromField, isReference, getStoreKeyName, isNonNullObject, stringifyForDisplay, } from \"../../utilities/index.js\";\nimport { hasOwn, fieldNameFromStoreName, storeValueIsStoreObject, selectionSetMatchesResult, TypeOrFieldNameRegExp, defaultDataIdFromObject, isArray, } from \"./helpers.js\";\nimport { cacheSlot } from \"./reactiveVars.js\";\nimport { keyArgsFnFromSpecifier, keyFieldsFnFromSpecifier, } from \"./key-extractor.js\";\nfunction argsFromFieldSpecifier(spec) {\n    return (spec.args !== void 0 ? spec.args\n        : spec.field ? argumentsObjectFromField(spec.field, spec.variables)\n            : null);\n}\nvar nullKeyFieldsFn = function () { return void 0; };\nvar simpleKeyArgsFn = function (_args, context) { return context.fieldName; };\n// These merge functions can be selected by specifying merge:true or\n// merge:false in a field policy.\nvar mergeTrueFn = function (existing, incoming, _a) {\n    var mergeObjects = _a.mergeObjects;\n    return mergeObjects(existing, incoming);\n};\nvar mergeFalseFn = function (_, incoming) { return incoming; };\nvar Policies = /** @class */ (function () {\n    function Policies(config) {\n        this.config = config;\n        this.typePolicies = Object.create(null);\n        this.toBeAdded = Object.create(null);\n        // Map from subtype names to sets of supertype names. Note that this\n        // representation inverts the structure of possibleTypes (whose keys are\n        // supertypes and whose values are arrays of subtypes) because it tends\n        // to be much more efficient to search upwards than downwards.\n        this.supertypeMap = new Map();\n        // Any fuzzy subtypes specified by possibleTypes will be converted to\n        // RegExp objects and recorded here. Every key of this map can also be\n        // found in supertypeMap. In many cases this Map will be empty, which\n        // means no fuzzy subtype checking will happen in fragmentMatches.\n        this.fuzzySubtypes = new Map();\n        this.rootIdsByTypename = Object.create(null);\n        this.rootTypenamesById = Object.create(null);\n        this.usingPossibleTypes = false;\n        this.config = __assign({ dataIdFromObject: defaultDataIdFromObject }, config);\n        this.cache = this.config.cache;\n        this.setRootTypename(\"Query\");\n        this.setRootTypename(\"Mutation\");\n        this.setRootTypename(\"Subscription\");\n        if (config.possibleTypes) {\n            this.addPossibleTypes(config.possibleTypes);\n        }\n        if (config.typePolicies) {\n            this.addTypePolicies(config.typePolicies);\n        }\n    }\n    Policies.prototype.identify = function (object, partialContext) {\n        var _a;\n        var policies = this;\n        var typename = (partialContext &&\n            (partialContext.typename || ((_a = partialContext.storeObject) === null || _a === void 0 ? void 0 : _a.__typename))) ||\n            object.__typename;\n        // It should be possible to write root Query fields with writeFragment,\n        // using { __typename: \"Query\", ... } as the data, but it does not make\n        // sense to allow the same identification behavior for the Mutation and\n        // Subscription types, since application code should never be writing\n        // directly to (or reading directly from) those root objects.\n        if (typename === this.rootTypenamesById.ROOT_QUERY) {\n            return [\"ROOT_QUERY\"];\n        }\n        // Default context.storeObject to object if not otherwise provided.\n        var storeObject = (partialContext && partialContext.storeObject) || object;\n        var context = __assign(__assign({}, partialContext), { typename: typename, storeObject: storeObject, readField: (partialContext && partialContext.readField) ||\n                function () {\n                    var options = normalizeReadFieldOptions(arguments, storeObject);\n                    return policies.readField(options, {\n                        store: policies.cache[\"data\"],\n                        variables: options.variables,\n                    });\n                } });\n        var id;\n        var policy = typename && this.getTypePolicy(typename);\n        var keyFn = (policy && policy.keyFn) || this.config.dataIdFromObject;\n        while (keyFn) {\n            var specifierOrId = keyFn(__assign(__assign({}, object), storeObject), context);\n            if (isArray(specifierOrId)) {\n                keyFn = keyFieldsFnFromSpecifier(specifierOrId);\n            }\n            else {\n                id = specifierOrId;\n                break;\n            }\n        }\n        id = id ? String(id) : void 0;\n        return context.keyObject ? [id, context.keyObject] : [id];\n    };\n    Policies.prototype.addTypePolicies = function (typePolicies) {\n        var _this = this;\n        Object.keys(typePolicies).forEach(function (typename) {\n            var _a = typePolicies[typename], queryType = _a.queryType, mutationType = _a.mutationType, subscriptionType = _a.subscriptionType, incoming = __rest(_a, [\"queryType\", \"mutationType\", \"subscriptionType\"]);\n            // Though {query,mutation,subscription}Type configurations are rare,\n            // it's important to call setRootTypename as early as possible,\n            // since these configurations should apply consistently for the\n            // entire lifetime of the cache. Also, since only one __typename can\n            // qualify as one of these root types, these three properties cannot\n            // be inherited, unlike the rest of the incoming properties. That\n            // restriction is convenient, because the purpose of this.toBeAdded\n            // is to delay the processing of type/field policies until the first\n            // time they're used, allowing policies to be added in any order as\n            // long as all relevant policies (including policies for supertypes)\n            // have been added by the time a given policy is used for the first\n            // time. In other words, since inheritance doesn't matter for these\n            // properties, there's also no need to delay their processing using\n            // the this.toBeAdded queue.\n            if (queryType)\n                _this.setRootTypename(\"Query\", typename);\n            if (mutationType)\n                _this.setRootTypename(\"Mutation\", typename);\n            if (subscriptionType)\n                _this.setRootTypename(\"Subscription\", typename);\n            if (hasOwn.call(_this.toBeAdded, typename)) {\n                _this.toBeAdded[typename].push(incoming);\n            }\n            else {\n                _this.toBeAdded[typename] = [incoming];\n            }\n        });\n    };\n    Policies.prototype.updateTypePolicy = function (typename, incoming) {\n        var _this = this;\n        var existing = this.getTypePolicy(typename);\n        var keyFields = incoming.keyFields, fields = incoming.fields;\n        function setMerge(existing, merge) {\n            existing.merge =\n                typeof merge === \"function\" ? merge\n                    // Pass merge:true as a shorthand for a merge implementation\n                    // that returns options.mergeObjects(existing, incoming).\n                    : merge === true ? mergeTrueFn\n                        // Pass merge:false to make incoming always replace existing\n                        // without any warnings about data clobbering.\n                        : merge === false ? mergeFalseFn\n                            : existing.merge;\n        }\n        // Type policies can define merge functions, as an alternative to\n        // using field policies to merge child objects.\n        setMerge(existing, incoming.merge);\n        existing.keyFn =\n            // Pass false to disable normalization for this typename.\n            keyFields === false ? nullKeyFieldsFn\n                // Pass an array of strings to use those fields to compute a\n                // composite ID for objects of this typename.\n                : isArray(keyFields) ? keyFieldsFnFromSpecifier(keyFields)\n                    // Pass a function to take full control over identification.\n                    : typeof keyFields === \"function\" ? keyFields\n                        // Leave existing.keyFn unchanged if above cases fail.\n                        : existing.keyFn;\n        if (fields) {\n            Object.keys(fields).forEach(function (fieldName) {\n                var existing = _this.getFieldPolicy(typename, fieldName, true);\n                var incoming = fields[fieldName];\n                if (typeof incoming === \"function\") {\n                    existing.read = incoming;\n                }\n                else {\n                    var keyArgs = incoming.keyArgs, read = incoming.read, merge = incoming.merge;\n                    existing.keyFn =\n                        // Pass false to disable argument-based differentiation of\n                        // field identities.\n                        keyArgs === false ? simpleKeyArgsFn\n                            // Pass an array of strings to use named arguments to\n                            // compute a composite identity for the field.\n                            : isArray(keyArgs) ? keyArgsFnFromSpecifier(keyArgs)\n                                // Pass a function to take full control over field identity.\n                                : typeof keyArgs === \"function\" ? keyArgs\n                                    // Leave existing.keyFn unchanged if above cases fail.\n                                    : existing.keyFn;\n                    if (typeof read === \"function\") {\n                        existing.read = read;\n                    }\n                    setMerge(existing, merge);\n                }\n                if (existing.read && existing.merge) {\n                    // If we have both a read and a merge function, assume\n                    // keyArgs:false, because read and merge together can take\n                    // responsibility for interpreting arguments in and out. This\n                    // default assumption can always be overridden by specifying\n                    // keyArgs explicitly in the FieldPolicy.\n                    existing.keyFn = existing.keyFn || simpleKeyArgsFn;\n                }\n            });\n        }\n    };\n    Policies.prototype.setRootTypename = function (which, typename) {\n        if (typename === void 0) { typename = which; }\n        var rootId = \"ROOT_\" + which.toUpperCase();\n        var old = this.rootTypenamesById[rootId];\n        if (typename !== old) {\n            invariant(!old || old === which, 5, which);\n            // First, delete any old __typename associated with this rootId from\n            // rootIdsByTypename.\n            if (old)\n                delete this.rootIdsByTypename[old];\n            // Now make this the only __typename that maps to this rootId.\n            this.rootIdsByTypename[typename] = rootId;\n            // Finally, update the __typename associated with this rootId.\n            this.rootTypenamesById[rootId] = typename;\n        }\n    };\n    Policies.prototype.addPossibleTypes = function (possibleTypes) {\n        var _this = this;\n        this.usingPossibleTypes = true;\n        Object.keys(possibleTypes).forEach(function (supertype) {\n            // Make sure all types have an entry in this.supertypeMap, even if\n            // their supertype set is empty, so we can return false immediately\n            // from policies.fragmentMatches for unknown supertypes.\n            _this.getSupertypeSet(supertype, true);\n            possibleTypes[supertype].forEach(function (subtype) {\n                _this.getSupertypeSet(subtype, true).add(supertype);\n                var match = subtype.match(TypeOrFieldNameRegExp);\n                if (!match || match[0] !== subtype) {\n                    // TODO Don't interpret just any invalid typename as a RegExp.\n                    _this.fuzzySubtypes.set(subtype, new RegExp(subtype));\n                }\n            });\n        });\n    };\n    Policies.prototype.getTypePolicy = function (typename) {\n        var _this = this;\n        if (!hasOwn.call(this.typePolicies, typename)) {\n            var policy_1 = (this.typePolicies[typename] = Object.create(null));\n            policy_1.fields = Object.create(null);\n            // When the TypePolicy for typename is first accessed, instead of\n            // starting with an empty policy object, inherit any properties or\n            // fields from the type policies of the supertypes of typename.\n            //\n            // Any properties or fields defined explicitly within the TypePolicy\n            // for typename will take precedence, and if there are multiple\n            // supertypes, the properties of policies whose types were added\n            // later via addPossibleTypes will take precedence over those of\n            // earlier supertypes. TODO Perhaps we should warn about these\n            // conflicts in development, and recommend defining the property\n            // explicitly in the subtype policy?\n            //\n            // Field policy inheritance is atomic/shallow: you can't inherit a\n            // field policy and then override just its read function, since read\n            // and merge functions often need to cooperate, so changing only one\n            // of them would be a recipe for inconsistency.\n            //\n            // Once the TypePolicy for typename has been accessed, its properties can\n            // still be updated directly using addTypePolicies, but future changes to\n            // inherited supertype policies will not be reflected in this subtype\n            // policy, because this code runs at most once per typename.\n            var supertypes_1 = this.supertypeMap.get(typename);\n            if (!supertypes_1 && this.fuzzySubtypes.size) {\n                // To make the inheritance logic work for unknown typename strings that\n                // may have fuzzy supertypes, we give this typename an empty supertype\n                // set and then populate it with any fuzzy supertypes that match.\n                supertypes_1 = this.getSupertypeSet(typename, true);\n                // This only works for typenames that are directly matched by a fuzzy\n                // supertype. What if there is an intermediate chain of supertypes?\n                // While possible, that situation can only be solved effectively by\n                // specifying the intermediate relationships via possibleTypes, manually\n                // and in a non-fuzzy way.\n                this.fuzzySubtypes.forEach(function (regExp, fuzzy) {\n                    if (regExp.test(typename)) {\n                        // The fuzzy parameter is just the original string version of regExp\n                        // (not a valid __typename string), but we can look up the\n                        // associated supertype(s) in this.supertypeMap.\n                        var fuzzySupertypes = _this.supertypeMap.get(fuzzy);\n                        if (fuzzySupertypes) {\n                            fuzzySupertypes.forEach(function (supertype) {\n                                return supertypes_1.add(supertype);\n                            });\n                        }\n                    }\n                });\n            }\n            if (supertypes_1 && supertypes_1.size) {\n                supertypes_1.forEach(function (supertype) {\n                    var _a = _this.getTypePolicy(supertype), fields = _a.fields, rest = __rest(_a, [\"fields\"]);\n                    Object.assign(policy_1, rest);\n                    Object.assign(policy_1.fields, fields);\n                });\n            }\n        }\n        var inbox = this.toBeAdded[typename];\n        if (inbox && inbox.length) {\n            // Merge the pending policies into this.typePolicies, in the order they\n            // were originally passed to addTypePolicy.\n            inbox.splice(0).forEach(function (policy) {\n                _this.updateTypePolicy(typename, policy);\n            });\n        }\n        return this.typePolicies[typename];\n    };\n    Policies.prototype.getFieldPolicy = function (typename, fieldName, createIfMissing) {\n        if (typename) {\n            var fieldPolicies = this.getTypePolicy(typename).fields;\n            return (fieldPolicies[fieldName] ||\n                (createIfMissing && (fieldPolicies[fieldName] = Object.create(null))));\n        }\n    };\n    Policies.prototype.getSupertypeSet = function (subtype, createIfMissing) {\n        var supertypeSet = this.supertypeMap.get(subtype);\n        if (!supertypeSet && createIfMissing) {\n            this.supertypeMap.set(subtype, (supertypeSet = new Set()));\n        }\n        return supertypeSet;\n    };\n    Policies.prototype.fragmentMatches = function (fragment, typename, result, variables) {\n        var _this = this;\n        if (!fragment.typeCondition)\n            return true;\n        // If the fragment has a type condition but the object we're matching\n        // against does not have a __typename, the fragment cannot match.\n        if (!typename)\n            return false;\n        var supertype = fragment.typeCondition.name.value;\n        // Common case: fragment type condition and __typename are the same.\n        if (typename === supertype)\n            return true;\n        if (this.usingPossibleTypes && this.supertypeMap.has(supertype)) {\n            var typenameSupertypeSet = this.getSupertypeSet(typename, true);\n            var workQueue_1 = [typenameSupertypeSet];\n            var maybeEnqueue_1 = function (subtype) {\n                var supertypeSet = _this.getSupertypeSet(subtype, false);\n                if (supertypeSet &&\n                    supertypeSet.size &&\n                    workQueue_1.indexOf(supertypeSet) < 0) {\n                    workQueue_1.push(supertypeSet);\n                }\n            };\n            // We need to check fuzzy subtypes only if we encountered fuzzy\n            // subtype strings in addPossibleTypes, and only while writing to\n            // the cache, since that's when selectionSetMatchesResult gives a\n            // strong signal of fragment matching. The StoreReader class calls\n            // policies.fragmentMatches without passing a result object, so\n            // needToCheckFuzzySubtypes is always false while reading.\n            var needToCheckFuzzySubtypes = !!(result && this.fuzzySubtypes.size);\n            var checkingFuzzySubtypes = false;\n            // It's important to keep evaluating workQueue.length each time through\n            // the loop, because the queue can grow while we're iterating over it.\n            for (var i = 0; i < workQueue_1.length; ++i) {\n                var supertypeSet = workQueue_1[i];\n                if (supertypeSet.has(supertype)) {\n                    if (!typenameSupertypeSet.has(supertype)) {\n                        if (checkingFuzzySubtypes) {\n                            globalThis.__DEV__ !== false && invariant.warn(6, typename, supertype);\n                        }\n                        // Record positive results for faster future lookup.\n                        // Unfortunately, we cannot safely cache negative results,\n                        // because new possibleTypes data could always be added to the\n                        // Policies class.\n                        typenameSupertypeSet.add(supertype);\n                    }\n                    return true;\n                }\n                supertypeSet.forEach(maybeEnqueue_1);\n                if (needToCheckFuzzySubtypes &&\n                    // Start checking fuzzy subtypes only after exhausting all\n                    // non-fuzzy subtypes (after the final iteration of the loop).\n                    i === workQueue_1.length - 1 &&\n                    // We could wait to compare fragment.selectionSet to result\n                    // after we verify the supertype, but this check is often less\n                    // expensive than that search, and we will have to do the\n                    // comparison anyway whenever we find a potential match.\n                    selectionSetMatchesResult(fragment.selectionSet, result, variables)) {\n                    // We don't always need to check fuzzy subtypes (if no result\n                    // was provided, or !this.fuzzySubtypes.size), but, when we do,\n                    // we only want to check them once.\n                    needToCheckFuzzySubtypes = false;\n                    checkingFuzzySubtypes = true;\n                    // If we find any fuzzy subtypes that match typename, extend the\n                    // workQueue to search through the supertypes of those fuzzy\n                    // subtypes. Otherwise the for-loop will terminate and we'll\n                    // return false below.\n                    this.fuzzySubtypes.forEach(function (regExp, fuzzyString) {\n                        var match = typename.match(regExp);\n                        if (match && match[0] === typename) {\n                            maybeEnqueue_1(fuzzyString);\n                        }\n                    });\n                }\n            }\n        }\n        return false;\n    };\n    Policies.prototype.hasKeyArgs = function (typename, fieldName) {\n        var policy = this.getFieldPolicy(typename, fieldName, false);\n        return !!(policy && policy.keyFn);\n    };\n    Policies.prototype.getStoreFieldName = function (fieldSpec) {\n        var typename = fieldSpec.typename, fieldName = fieldSpec.fieldName;\n        var policy = this.getFieldPolicy(typename, fieldName, false);\n        var storeFieldName;\n        var keyFn = policy && policy.keyFn;\n        if (keyFn && typename) {\n            var context = {\n                typename: typename,\n                fieldName: fieldName,\n                field: fieldSpec.field || null,\n                variables: fieldSpec.variables,\n            };\n            var args = argsFromFieldSpecifier(fieldSpec);\n            while (keyFn) {\n                var specifierOrString = keyFn(args, context);\n                if (isArray(specifierOrString)) {\n                    keyFn = keyArgsFnFromSpecifier(specifierOrString);\n                }\n                else {\n                    // If the custom keyFn returns a falsy value, fall back to\n                    // fieldName instead.\n                    storeFieldName = specifierOrString || fieldName;\n                    break;\n                }\n            }\n        }\n        if (storeFieldName === void 0) {\n            storeFieldName =\n                fieldSpec.field ?\n                    storeKeyNameFromField(fieldSpec.field, fieldSpec.variables)\n                    : getStoreKeyName(fieldName, argsFromFieldSpecifier(fieldSpec));\n        }\n        // Returning false from a keyArgs function is like configuring\n        // keyArgs: false, but more dynamic.\n        if (storeFieldName === false) {\n            return fieldName;\n        }\n        // Make sure custom field names start with the actual field.name.value\n        // of the field, so we can always figure out which properties of a\n        // StoreObject correspond to which original field names.\n        return fieldName === fieldNameFromStoreName(storeFieldName) ? storeFieldName\n            : fieldName + \":\" + storeFieldName;\n    };\n    Policies.prototype.readField = function (options, context) {\n        var objectOrReference = options.from;\n        if (!objectOrReference)\n            return;\n        var nameOrField = options.field || options.fieldName;\n        if (!nameOrField)\n            return;\n        if (options.typename === void 0) {\n            var typename = context.store.getFieldValue(objectOrReference, \"__typename\");\n            if (typename)\n                options.typename = typename;\n        }\n        var storeFieldName = this.getStoreFieldName(options);\n        var fieldName = fieldNameFromStoreName(storeFieldName);\n        var existing = context.store.getFieldValue(objectOrReference, storeFieldName);\n        var policy = this.getFieldPolicy(options.typename, fieldName, false);\n        var read = policy && policy.read;\n        if (read) {\n            var readOptions = makeFieldFunctionOptions(this, objectOrReference, options, context, context.store.getStorage(isReference(objectOrReference) ?\n                objectOrReference.__ref\n                : objectOrReference, storeFieldName));\n            // Call read(existing, readOptions) with cacheSlot holding this.cache.\n            return cacheSlot.withValue(this.cache, read, [\n                existing,\n                readOptions,\n            ]);\n        }\n        return existing;\n    };\n    Policies.prototype.getReadFunction = function (typename, fieldName) {\n        var policy = this.getFieldPolicy(typename, fieldName, false);\n        return policy && policy.read;\n    };\n    Policies.prototype.getMergeFunction = function (parentTypename, fieldName, childTypename) {\n        var policy = this.getFieldPolicy(parentTypename, fieldName, false);\n        var merge = policy && policy.merge;\n        if (!merge && childTypename) {\n            policy = this.getTypePolicy(childTypename);\n            merge = policy && policy.merge;\n        }\n        return merge;\n    };\n    Policies.prototype.runMergeFunction = function (existing, incoming, _a, context, storage) {\n        var field = _a.field, typename = _a.typename, merge = _a.merge;\n        if (merge === mergeTrueFn) {\n            // Instead of going to the trouble of creating a full\n            // FieldFunctionOptions object and calling mergeTrueFn, we can\n            // simply call mergeObjects, as mergeTrueFn would.\n            return makeMergeObjectsFunction(context.store)(existing, incoming);\n        }\n        if (merge === mergeFalseFn) {\n            // Likewise for mergeFalseFn, whose implementation is even simpler.\n            return incoming;\n        }\n        // If cache.writeQuery or cache.writeFragment was called with\n        // options.overwrite set to true, we still call merge functions, but\n        // the existing data is always undefined, so the merge function will\n        // not attempt to combine the incoming data with the existing data.\n        if (context.overwrite) {\n            existing = void 0;\n        }\n        return merge(existing, incoming, makeFieldFunctionOptions(this, \n        // Unlike options.readField for read functions, we do not fall\n        // back to the current object if no foreignObjOrRef is provided,\n        // because it's not clear what the current object should be for\n        // merge functions: the (possibly undefined) existing object, or\n        // the incoming object? If you think your merge function needs\n        // to read sibling fields in order to produce a new value for\n        // the current field, you might want to rethink your strategy,\n        // because that's a recipe for making merge behavior sensitive\n        // to the order in which fields are written into the cache.\n        // However, readField(name, ref) is useful for merge functions\n        // that need to deduplicate child objects and references.\n        void 0, {\n            typename: typename,\n            fieldName: field.name.value,\n            field: field,\n            variables: context.variables,\n        }, context, storage || Object.create(null)));\n    };\n    return Policies;\n}());\nexport { Policies };\nfunction makeFieldFunctionOptions(policies, objectOrReference, fieldSpec, context, storage) {\n    var storeFieldName = policies.getStoreFieldName(fieldSpec);\n    var fieldName = fieldNameFromStoreName(storeFieldName);\n    var variables = fieldSpec.variables || context.variables;\n    var _a = context.store, toReference = _a.toReference, canRead = _a.canRead;\n    return {\n        args: argsFromFieldSpecifier(fieldSpec),\n        field: fieldSpec.field || null,\n        fieldName: fieldName,\n        storeFieldName: storeFieldName,\n        variables: variables,\n        isReference: isReference,\n        toReference: toReference,\n        storage: storage,\n        cache: policies.cache,\n        canRead: canRead,\n        readField: function () {\n            return policies.readField(normalizeReadFieldOptions(arguments, objectOrReference, variables), context);\n        },\n        mergeObjects: makeMergeObjectsFunction(context.store),\n    };\n}\nexport function normalizeReadFieldOptions(readFieldArgs, objectOrReference, variables) {\n    var fieldNameOrOptions = readFieldArgs[0], from = readFieldArgs[1], argc = readFieldArgs.length;\n    var options;\n    if (typeof fieldNameOrOptions === \"string\") {\n        options = {\n            fieldName: fieldNameOrOptions,\n            // Default to objectOrReference only when no second argument was\n            // passed for the from parameter, not when undefined is explicitly\n            // passed as the second argument.\n            from: argc > 1 ? from : objectOrReference,\n        };\n    }\n    else {\n        options = __assign({}, fieldNameOrOptions);\n        // Default to objectOrReference only when fieldNameOrOptions.from is\n        // actually omitted, rather than just undefined.\n        if (!hasOwn.call(options, \"from\")) {\n            options.from = objectOrReference;\n        }\n    }\n    if (globalThis.__DEV__ !== false && options.from === void 0) {\n        globalThis.__DEV__ !== false && invariant.warn(7, stringifyForDisplay(Array.from(readFieldArgs)));\n    }\n    if (void 0 === options.variables) {\n        options.variables = variables;\n    }\n    return options;\n}\nfunction makeMergeObjectsFunction(store) {\n    return function mergeObjects(existing, incoming) {\n        if (isArray(existing) || isArray(incoming)) {\n            throw newInvariantError(8);\n        }\n        // These dynamic checks are necessary because the parameters of a\n        // custom merge function can easily have the any type, so the type\n        // system cannot always enforce the StoreObject | Reference parameter\n        // types of options.mergeObjects.\n        if (isNonNullObject(existing) && isNonNullObject(incoming)) {\n            var eType = store.getFieldValue(existing, \"__typename\");\n            var iType = store.getFieldValue(incoming, \"__typename\");\n            var typesDiffer = eType && iType && eType !== iType;\n            if (typesDiffer) {\n                return incoming;\n            }\n            if (isReference(existing) && storeValueIsStoreObject(incoming)) {\n                // Update the normalized EntityStore for the entity identified by\n                // existing.__ref, preferring/overwriting any fields contributed by the\n                // newer incoming StoreObject.\n                store.merge(existing.__ref, incoming);\n                return existing;\n            }\n            if (storeValueIsStoreObject(existing) && isReference(incoming)) {\n                // Update the normalized EntityStore for the entity identified by\n                // incoming.__ref, taking fields from the older existing object only if\n                // those fields are not already present in the newer StoreObject\n                // identified by incoming.__ref.\n                store.merge(existing, incoming.__ref);\n                return incoming;\n            }\n            if (storeValueIsStoreObject(existing) &&\n                storeValueIsStoreObject(incoming)) {\n                return __assign(__assign({}, existing), incoming);\n            }\n        }\n        return incoming;\n    };\n}\n//# sourceMappingURL=policies.js.map","import { __assign } from \"tslib\";\nimport { invariant, newInvariantError } from \"../../utilities/globals/index.js\";\nimport { equal } from \"@wry/equality\";\nimport { Trie } from \"@wry/trie\";\nimport { Kind } from \"graphql\";\nimport { getFragmentFromSelection, getDefaultValues, getOperationDefinition, getTypenameFromResult, makeReference, isField, resultKeyNameFromField, isReference, shouldInclude, cloneDeep, addTypenameToDocument, isNonEmptyArray, argumentsObjectFromField, canonicalStringify, } from \"../../utilities/index.js\";\nimport { isArray, makeProcessedFieldsMerger, fieldNameFromStoreName, storeValueIsStoreObject, extractFragmentContext, } from \"./helpers.js\";\nimport { normalizeReadFieldOptions } from \"./policies.js\";\n// Since there are only four possible combinations of context.clientOnly and\n// context.deferred values, we should need at most four \"flavors\" of any given\n// WriteContext. To avoid creating multiple copies of the same context, we cache\n// the contexts in the context.flavors Map (shared by all flavors) according to\n// their clientOnly and deferred values (always in that order).\nfunction getContextFlavor(context, clientOnly, deferred) {\n    var key = \"\".concat(clientOnly).concat(deferred);\n    var flavored = context.flavors.get(key);\n    if (!flavored) {\n        context.flavors.set(key, (flavored =\n            context.clientOnly === clientOnly && context.deferred === deferred ?\n                context\n                : __assign(__assign({}, context), { clientOnly: clientOnly, deferred: deferred })));\n    }\n    return flavored;\n}\nvar StoreWriter = /** @class */ (function () {\n    function StoreWriter(cache, reader, fragments) {\n        this.cache = cache;\n        this.reader = reader;\n        this.fragments = fragments;\n    }\n    StoreWriter.prototype.writeToStore = function (store, _a) {\n        var _this = this;\n        var query = _a.query, result = _a.result, dataId = _a.dataId, variables = _a.variables, overwrite = _a.overwrite;\n        var operationDefinition = getOperationDefinition(query);\n        var merger = makeProcessedFieldsMerger();\n        variables = __assign(__assign({}, getDefaultValues(operationDefinition)), variables);\n        var context = __assign(__assign({ store: store, written: Object.create(null), merge: function (existing, incoming) {\n                return merger.merge(existing, incoming);\n            }, variables: variables, varString: canonicalStringify(variables) }, extractFragmentContext(query, this.fragments)), { overwrite: !!overwrite, incomingById: new Map(), clientOnly: false, deferred: false, flavors: new Map() });\n        var ref = this.processSelectionSet({\n            result: result || Object.create(null),\n            dataId: dataId,\n            selectionSet: operationDefinition.selectionSet,\n            mergeTree: { map: new Map() },\n            context: context,\n        });\n        if (!isReference(ref)) {\n            throw newInvariantError(11, result);\n        }\n        // So far, the store has not been modified, so now it's time to process\n        // context.incomingById and merge those incoming fields into context.store.\n        context.incomingById.forEach(function (_a, dataId) {\n            var storeObject = _a.storeObject, mergeTree = _a.mergeTree, fieldNodeSet = _a.fieldNodeSet;\n            var entityRef = makeReference(dataId);\n            if (mergeTree && mergeTree.map.size) {\n                var applied = _this.applyMerges(mergeTree, entityRef, storeObject, context);\n                if (isReference(applied)) {\n                    // Assume References returned by applyMerges have already been merged\n                    // into the store. See makeMergeObjectsFunction in policies.ts for an\n                    // example of how this can happen.\n                    return;\n                }\n                // Otherwise, applyMerges returned a StoreObject, whose fields we should\n                // merge into the store (see store.merge statement below).\n                storeObject = applied;\n            }\n            if (globalThis.__DEV__ !== false && !context.overwrite) {\n                var fieldsWithSelectionSets_1 = Object.create(null);\n                fieldNodeSet.forEach(function (field) {\n                    if (field.selectionSet) {\n                        fieldsWithSelectionSets_1[field.name.value] = true;\n                    }\n                });\n                var hasSelectionSet_1 = function (storeFieldName) {\n                    return fieldsWithSelectionSets_1[fieldNameFromStoreName(storeFieldName)] ===\n                        true;\n                };\n                var hasMergeFunction_1 = function (storeFieldName) {\n                    var childTree = mergeTree && mergeTree.map.get(storeFieldName);\n                    return Boolean(childTree && childTree.info && childTree.info.merge);\n                };\n                Object.keys(storeObject).forEach(function (storeFieldName) {\n                    // If a merge function was defined for this field, trust that it\n                    // did the right thing about (not) clobbering data. If the field\n                    // has no selection set, it's a scalar field, so it doesn't need\n                    // a merge function (even if it's an object, like JSON data).\n                    if (hasSelectionSet_1(storeFieldName) &&\n                        !hasMergeFunction_1(storeFieldName)) {\n                        warnAboutDataLoss(entityRef, storeObject, storeFieldName, context.store);\n                    }\n                });\n            }\n            store.merge(dataId, storeObject);\n        });\n        // Any IDs written explicitly to the cache will be retained as\n        // reachable root IDs for garbage collection purposes. Although this\n        // logic includes root IDs like ROOT_QUERY and ROOT_MUTATION, their\n        // retainment counts are effectively ignored because cache.gc() always\n        // includes them in its root ID set.\n        store.retain(ref.__ref);\n        return ref;\n    };\n    StoreWriter.prototype.processSelectionSet = function (_a) {\n        var _this = this;\n        var dataId = _a.dataId, result = _a.result, selectionSet = _a.selectionSet, context = _a.context, \n        // This object allows processSelectionSet to report useful information\n        // to its callers without explicitly returning that information.\n        mergeTree = _a.mergeTree;\n        var policies = this.cache.policies;\n        // This variable will be repeatedly updated using context.merge to\n        // accumulate all fields that need to be written into the store.\n        var incoming = Object.create(null);\n        // If typename was not passed in, infer it. Note that typename is\n        // always passed in for tricky-to-infer cases such as \"Query\" for\n        // ROOT_QUERY.\n        var typename = (dataId && policies.rootTypenamesById[dataId]) ||\n            getTypenameFromResult(result, selectionSet, context.fragmentMap) ||\n            (dataId && context.store.get(dataId, \"__typename\"));\n        if (\"string\" === typeof typename) {\n            incoming.__typename = typename;\n        }\n        // This readField function will be passed as context.readField in the\n        // KeyFieldsContext object created within policies.identify (called below).\n        // In addition to reading from the existing context.store (thanks to the\n        // policies.readField(options, context) line at the very bottom), this\n        // version of readField can read from Reference objects that are currently\n        // pending in context.incomingById, which is important whenever keyFields\n        // need to be extracted from a child object that processSelectionSet has\n        // turned into a Reference.\n        var readField = function () {\n            var options = normalizeReadFieldOptions(arguments, incoming, context.variables);\n            if (isReference(options.from)) {\n                var info = context.incomingById.get(options.from.__ref);\n                if (info) {\n                    var result_1 = policies.readField(__assign(__assign({}, options), { from: info.storeObject }), context);\n                    if (result_1 !== void 0) {\n                        return result_1;\n                    }\n                }\n            }\n            return policies.readField(options, context);\n        };\n        var fieldNodeSet = new Set();\n        this.flattenFields(selectionSet, result, \n        // This WriteContext will be the default context value for fields returned\n        // by the flattenFields method, but some fields may be assigned a modified\n        // context, depending on the presence of @client and other directives.\n        context, typename).forEach(function (context, field) {\n            var _a;\n            var resultFieldKey = resultKeyNameFromField(field);\n            var value = result[resultFieldKey];\n            fieldNodeSet.add(field);\n            if (value !== void 0) {\n                var storeFieldName = policies.getStoreFieldName({\n                    typename: typename,\n                    fieldName: field.name.value,\n                    field: field,\n                    variables: context.variables,\n                });\n                var childTree = getChildMergeTree(mergeTree, storeFieldName);\n                var incomingValue = _this.processFieldValue(value, field, \n                // Reset context.clientOnly and context.deferred to their default\n                // values before processing nested selection sets.\n                field.selectionSet ?\n                    getContextFlavor(context, false, false)\n                    : context, childTree);\n                // To determine if this field holds a child object with a merge function\n                // defined in its type policy (see PR #7070), we need to figure out the\n                // child object's __typename.\n                var childTypename = void 0;\n                // The field's value can be an object that has a __typename only if the\n                // field has a selection set. Otherwise incomingValue is scalar.\n                if (field.selectionSet &&\n                    (isReference(incomingValue) || storeValueIsStoreObject(incomingValue))) {\n                    childTypename = readField(\"__typename\", incomingValue);\n                }\n                var merge = policies.getMergeFunction(typename, field.name.value, childTypename);\n                if (merge) {\n                    childTree.info = {\n                        // TODO Check compatibility against any existing childTree.field?\n                        field: field,\n                        typename: typename,\n                        merge: merge,\n                    };\n                }\n                else {\n                    maybeRecycleChildMergeTree(mergeTree, storeFieldName);\n                }\n                incoming = context.merge(incoming, (_a = {},\n                    _a[storeFieldName] = incomingValue,\n                    _a));\n            }\n            else if (globalThis.__DEV__ !== false &&\n                !context.clientOnly &&\n                !context.deferred &&\n                !addTypenameToDocument.added(field) &&\n                // If the field has a read function, it may be a synthetic field or\n                // provide a default value, so its absence from the written data should\n                // not be cause for alarm.\n                !policies.getReadFunction(typename, field.name.value)) {\n                globalThis.__DEV__ !== false && invariant.error(12, resultKeyNameFromField(field), result);\n            }\n        });\n        // Identify the result object, even if dataId was already provided,\n        // since we always need keyObject below.\n        try {\n            var _b = policies.identify(result, {\n                typename: typename,\n                selectionSet: selectionSet,\n                fragmentMap: context.fragmentMap,\n                storeObject: incoming,\n                readField: readField,\n            }), id = _b[0], keyObject = _b[1];\n            // If dataId was not provided, fall back to the id just generated by\n            // policies.identify.\n            dataId = dataId || id;\n            // Write any key fields that were used during identification, even if\n            // they were not mentioned in the original query.\n            if (keyObject) {\n                // TODO Reverse the order of the arguments?\n                incoming = context.merge(incoming, keyObject);\n            }\n        }\n        catch (e) {\n            // If dataId was provided, tolerate failure of policies.identify.\n            if (!dataId)\n                throw e;\n        }\n        if (\"string\" === typeof dataId) {\n            var dataRef = makeReference(dataId);\n            // Avoid processing the same entity object using the same selection\n            // set more than once. We use an array instead of a Set since most\n            // entity IDs will be written using only one selection set, so the\n            // size of this array is likely to be very small, meaning indexOf is\n            // likely to be faster than Set.prototype.has.\n            var sets = context.written[dataId] || (context.written[dataId] = []);\n            if (sets.indexOf(selectionSet) >= 0)\n                return dataRef;\n            sets.push(selectionSet);\n            // If we're about to write a result object into the store, but we\n            // happen to know that the exact same (===) result object would be\n            // returned if we were to reread the result with the same inputs,\n            // then we can skip the rest of the processSelectionSet work for\n            // this object, and immediately return a Reference to it.\n            if (this.reader &&\n                this.reader.isFresh(result, dataRef, selectionSet, context)) {\n                return dataRef;\n            }\n            var previous_1 = context.incomingById.get(dataId);\n            if (previous_1) {\n                previous_1.storeObject = context.merge(previous_1.storeObject, incoming);\n                previous_1.mergeTree = mergeMergeTrees(previous_1.mergeTree, mergeTree);\n                fieldNodeSet.forEach(function (field) { return previous_1.fieldNodeSet.add(field); });\n            }\n            else {\n                context.incomingById.set(dataId, {\n                    storeObject: incoming,\n                    // Save a reference to mergeTree only if it is not empty, because\n                    // empty MergeTrees may be recycled by maybeRecycleChildMergeTree and\n                    // reused for entirely different parts of the result tree.\n                    mergeTree: mergeTreeIsEmpty(mergeTree) ? void 0 : mergeTree,\n                    fieldNodeSet: fieldNodeSet,\n                });\n            }\n            return dataRef;\n        }\n        return incoming;\n    };\n    StoreWriter.prototype.processFieldValue = function (value, field, context, mergeTree) {\n        var _this = this;\n        if (!field.selectionSet || value === null) {\n            // In development, we need to clone scalar values so that they can be\n            // safely frozen with maybeDeepFreeze in readFromStore.ts. In production,\n            // it's cheaper to store the scalar values directly in the cache.\n            return globalThis.__DEV__ !== false ? cloneDeep(value) : value;\n        }\n        if (isArray(value)) {\n            return value.map(function (item, i) {\n                var value = _this.processFieldValue(item, field, context, getChildMergeTree(mergeTree, i));\n                maybeRecycleChildMergeTree(mergeTree, i);\n                return value;\n            });\n        }\n        return this.processSelectionSet({\n            result: value,\n            selectionSet: field.selectionSet,\n            context: context,\n            mergeTree: mergeTree,\n        });\n    };\n    // Implements https://spec.graphql.org/draft/#sec-Field-Collection, but with\n    // some additions for tracking @client and @defer directives.\n    StoreWriter.prototype.flattenFields = function (selectionSet, result, context, typename) {\n        if (typename === void 0) { typename = getTypenameFromResult(result, selectionSet, context.fragmentMap); }\n        var fieldMap = new Map();\n        var policies = this.cache.policies;\n        var limitingTrie = new Trie(false); // No need for WeakMap, since limitingTrie does not escape.\n        (function flatten(selectionSet, inheritedContext) {\n            var visitedNode = limitingTrie.lookup(selectionSet, \n            // Because we take inheritedClientOnly and inheritedDeferred into\n            // consideration here (in addition to selectionSet), it's possible for\n            // the same selection set to be flattened more than once, if it appears\n            // in the query with different @client and/or @directive configurations.\n            inheritedContext.clientOnly, inheritedContext.deferred);\n            if (visitedNode.visited)\n                return;\n            visitedNode.visited = true;\n            selectionSet.selections.forEach(function (selection) {\n                if (!shouldInclude(selection, context.variables))\n                    return;\n                var clientOnly = inheritedContext.clientOnly, deferred = inheritedContext.deferred;\n                if (\n                // Since the presence of @client or @defer on this field can only\n                // cause clientOnly or deferred to become true, we can skip the\n                // forEach loop if both clientOnly and deferred are already true.\n                !(clientOnly && deferred) &&\n                    isNonEmptyArray(selection.directives)) {\n                    selection.directives.forEach(function (dir) {\n                        var name = dir.name.value;\n                        if (name === \"client\")\n                            clientOnly = true;\n                        if (name === \"defer\") {\n                            var args = argumentsObjectFromField(dir, context.variables);\n                            // The @defer directive takes an optional args.if boolean\n                            // argument, similar to @include(if: boolean). Note that\n                            // @defer(if: false) does not make context.deferred false, but\n                            // instead behaves as if there was no @defer directive.\n                            if (!args || args.if !== false) {\n                                deferred = true;\n                            }\n                            // TODO In the future, we may want to record args.label using\n                            // context.deferred, if a label is specified.\n                        }\n                    });\n                }\n                if (isField(selection)) {\n                    var existing = fieldMap.get(selection);\n                    if (existing) {\n                        // If this field has been visited along another recursive path\n                        // before, the final context should have clientOnly or deferred set\n                        // to true only if *all* paths have the directive (hence the &&).\n                        clientOnly = clientOnly && existing.clientOnly;\n                        deferred = deferred && existing.deferred;\n                    }\n                    fieldMap.set(selection, getContextFlavor(context, clientOnly, deferred));\n                }\n                else {\n                    var fragment = getFragmentFromSelection(selection, context.lookupFragment);\n                    if (!fragment && selection.kind === Kind.FRAGMENT_SPREAD) {\n                        throw newInvariantError(13, selection.name.value);\n                    }\n                    if (fragment &&\n                        policies.fragmentMatches(fragment, typename, result, context.variables)) {\n                        flatten(fragment.selectionSet, getContextFlavor(context, clientOnly, deferred));\n                    }\n                }\n            });\n        })(selectionSet, context);\n        return fieldMap;\n    };\n    StoreWriter.prototype.applyMerges = function (mergeTree, existing, incoming, context, getStorageArgs) {\n        var _a;\n        var _this = this;\n        if (mergeTree.map.size && !isReference(incoming)) {\n            var e_1 = \n            // Items in the same position in different arrays are not\n            // necessarily related to each other, so when incoming is an array\n            // we process its elements as if there was no existing data.\n            (!isArray(incoming) &&\n                // Likewise, existing must be either a Reference or a StoreObject\n                // in order for its fields to be safe to merge with the fields of\n                // the incoming object.\n                (isReference(existing) || storeValueIsStoreObject(existing))) ?\n                existing\n                : void 0;\n            // This narrowing is implied by mergeTree.map.size > 0 and\n            // !isReference(incoming), though TypeScript understandably cannot\n            // hope to infer this type.\n            var i_1 = incoming;\n            // The options.storage objects provided to read and merge functions\n            // are derived from the identity of the parent object plus a\n            // sequence of storeFieldName strings/numbers identifying the nested\n            // field name path of each field value to be merged.\n            if (e_1 && !getStorageArgs) {\n                getStorageArgs = [isReference(e_1) ? e_1.__ref : e_1];\n            }\n            // It's possible that applying merge functions to this subtree will\n            // not change the incoming data, so this variable tracks the fields\n            // that did change, so we can create a new incoming object when (and\n            // only when) at least one incoming field has changed. We use a Map\n            // to preserve the type of numeric keys.\n            var changedFields_1;\n            var getValue_1 = function (from, name) {\n                return (isArray(from) ?\n                    typeof name === \"number\" ?\n                        from[name]\n                        : void 0\n                    : context.store.getFieldValue(from, String(name)));\n            };\n            mergeTree.map.forEach(function (childTree, storeFieldName) {\n                var eVal = getValue_1(e_1, storeFieldName);\n                var iVal = getValue_1(i_1, storeFieldName);\n                // If we have no incoming data, leave any existing data untouched.\n                if (void 0 === iVal)\n                    return;\n                if (getStorageArgs) {\n                    getStorageArgs.push(storeFieldName);\n                }\n                var aVal = _this.applyMerges(childTree, eVal, iVal, context, getStorageArgs);\n                if (aVal !== iVal) {\n                    changedFields_1 = changedFields_1 || new Map();\n                    changedFields_1.set(storeFieldName, aVal);\n                }\n                if (getStorageArgs) {\n                    invariant(getStorageArgs.pop() === storeFieldName);\n                }\n            });\n            if (changedFields_1) {\n                // Shallow clone i so we can add changed fields to it.\n                incoming = (isArray(i_1) ? i_1.slice(0) : __assign({}, i_1));\n                changedFields_1.forEach(function (value, name) {\n                    incoming[name] = value;\n                });\n            }\n        }\n        if (mergeTree.info) {\n            return this.cache.policies.runMergeFunction(existing, incoming, mergeTree.info, context, getStorageArgs && (_a = context.store).getStorage.apply(_a, getStorageArgs));\n        }\n        return incoming;\n    };\n    return StoreWriter;\n}());\nexport { StoreWriter };\nvar emptyMergeTreePool = [];\nfunction getChildMergeTree(_a, name) {\n    var map = _a.map;\n    if (!map.has(name)) {\n        map.set(name, emptyMergeTreePool.pop() || { map: new Map() });\n    }\n    return map.get(name);\n}\nfunction mergeMergeTrees(left, right) {\n    if (left === right || !right || mergeTreeIsEmpty(right))\n        return left;\n    if (!left || mergeTreeIsEmpty(left))\n        return right;\n    var info = left.info && right.info ? __assign(__assign({}, left.info), right.info) : left.info || right.info;\n    var needToMergeMaps = left.map.size && right.map.size;\n    var map = needToMergeMaps ? new Map()\n        : left.map.size ? left.map\n            : right.map;\n    var merged = { info: info, map: map };\n    if (needToMergeMaps) {\n        var remainingRightKeys_1 = new Set(right.map.keys());\n        left.map.forEach(function (leftTree, key) {\n            merged.map.set(key, mergeMergeTrees(leftTree, right.map.get(key)));\n            remainingRightKeys_1.delete(key);\n        });\n        remainingRightKeys_1.forEach(function (key) {\n            merged.map.set(key, mergeMergeTrees(right.map.get(key), left.map.get(key)));\n        });\n    }\n    return merged;\n}\nfunction mergeTreeIsEmpty(tree) {\n    return !tree || !(tree.info || tree.map.size);\n}\nfunction maybeRecycleChildMergeTree(_a, name) {\n    var map = _a.map;\n    var childTree = map.get(name);\n    if (childTree && mergeTreeIsEmpty(childTree)) {\n        emptyMergeTreePool.push(childTree);\n        map.delete(name);\n    }\n}\nvar warnings = new Set();\n// Note that this function is unused in production, and thus should be\n// pruned by any well-configured minifier.\nfunction warnAboutDataLoss(existingRef, incomingObj, storeFieldName, store) {\n    var getChild = function (objOrRef) {\n        var child = store.getFieldValue(objOrRef, storeFieldName);\n        return typeof child === \"object\" && child;\n    };\n    var existing = getChild(existingRef);\n    if (!existing)\n        return;\n    var incoming = getChild(incomingObj);\n    if (!incoming)\n        return;\n    // It's always safe to replace a reference, since it refers to data\n    // safely stored elsewhere.\n    if (isReference(existing))\n        return;\n    // If the values are structurally equivalent, we do not need to worry\n    // about incoming replacing existing.\n    if (equal(existing, incoming))\n        return;\n    // If we're replacing every key of the existing object, then the\n    // existing data would be overwritten even if the objects were\n    // normalized, so warning would not be helpful here.\n    if (Object.keys(existing).every(function (key) { return store.getFieldValue(incoming, key) !== void 0; })) {\n        return;\n    }\n    var parentType = store.getFieldValue(existingRef, \"__typename\") ||\n        store.getFieldValue(incomingObj, \"__typename\");\n    var fieldName = fieldNameFromStoreName(storeFieldName);\n    var typeDotName = \"\".concat(parentType, \".\").concat(fieldName);\n    // Avoid warning more than once for the same type and field name.\n    if (warnings.has(typeDotName))\n        return;\n    warnings.add(typeDotName);\n    var childTypenames = [];\n    // Arrays do not have __typename fields, and always need a custom merge\n    // function, even if their elements are normalized entities.\n    if (!isArray(existing) && !isArray(incoming)) {\n        [existing, incoming].forEach(function (child) {\n            var typename = store.getFieldValue(child, \"__typename\");\n            if (typeof typename === \"string\" && !childTypenames.includes(typename)) {\n                childTypenames.push(typename);\n            }\n        });\n    }\n    globalThis.__DEV__ !== false && invariant.warn(14, fieldName, parentType, childTypenames.length ?\n        \"either ensure all objects of type \" +\n            childTypenames.join(\" and \") +\n            \" have an ID or a custom merge function, or \"\n        : \"\", typeDotName, __assign({}, existing), __assign({}, incoming));\n}\n//# sourceMappingURL=writeToStore.js.map","import { __assign, __extends } from \"tslib\";\nimport { invariant } from \"../../utilities/globals/index.js\";\n// Make builtins like Map and Set safe to use with non-extensible objects.\nimport \"./fixPolyfills.js\";\nimport { wrap } from \"optimism\";\nimport { equal } from \"@wry/equality\";\nimport { ApolloCache } from \"../core/cache.js\";\nimport { MissingFieldError } from \"../core/types/common.js\";\nimport { addTypenameToDocument, isReference, DocumentTransform, canonicalStringify, print, cacheSizes, } from \"../../utilities/index.js\";\nimport { StoreReader } from \"./readFromStore.js\";\nimport { StoreWriter } from \"./writeToStore.js\";\nimport { EntityStore, supportsResultCaching } from \"./entityStore.js\";\nimport { makeVar, forgetCache, recallCache } from \"./reactiveVars.js\";\nimport { Policies } from \"./policies.js\";\nimport { hasOwn, normalizeConfig, shouldCanonizeResults } from \"./helpers.js\";\nimport { getInMemoryCacheMemoryInternals } from \"../../utilities/caching/getMemoryInternals.js\";\nvar InMemoryCache = /** @class */ (function (_super) {\n    __extends(InMemoryCache, _super);\n    function InMemoryCache(config) {\n        if (config === void 0) { config = {}; }\n        var _this = _super.call(this) || this;\n        _this.watches = new Set();\n        _this.addTypenameTransform = new DocumentTransform(addTypenameToDocument);\n        // Override the default value, since InMemoryCache result objects are frozen\n        // in development and expected to remain logically immutable in production.\n        _this.assumeImmutableResults = true;\n        _this.makeVar = makeVar;\n        _this.txCount = 0;\n        _this.config = normalizeConfig(config);\n        _this.addTypename = !!_this.config.addTypename;\n        _this.policies = new Policies({\n            cache: _this,\n            dataIdFromObject: _this.config.dataIdFromObject,\n            possibleTypes: _this.config.possibleTypes,\n            typePolicies: _this.config.typePolicies,\n        });\n        _this.init();\n        return _this;\n    }\n    InMemoryCache.prototype.init = function () {\n        // Passing { resultCaching: false } in the InMemoryCache constructor options\n        // will completely disable dependency tracking, which will improve memory\n        // usage but worsen the performance of repeated reads.\n        var rootStore = (this.data = new EntityStore.Root({\n            policies: this.policies,\n            resultCaching: this.config.resultCaching,\n        }));\n        // When no optimistic writes are currently active, cache.optimisticData ===\n        // cache.data, so there are no additional layers on top of the actual data.\n        // When an optimistic update happens, this.optimisticData will become a\n        // linked list of EntityStore Layer objects that terminates with the\n        // original this.data cache object.\n        this.optimisticData = rootStore.stump;\n        this.resetResultCache();\n    };\n    InMemoryCache.prototype.resetResultCache = function (resetResultIdentities) {\n        var _this = this;\n        var previousReader = this.storeReader;\n        var fragments = this.config.fragments;\n        // The StoreWriter is mostly stateless and so doesn't really need to be\n        // reset, but it does need to have its writer.storeReader reference updated,\n        // so it's simpler to update this.storeWriter as well.\n        this.storeWriter = new StoreWriter(this, (this.storeReader = new StoreReader({\n            cache: this,\n            addTypename: this.addTypename,\n            resultCacheMaxSize: this.config.resultCacheMaxSize,\n            canonizeResults: shouldCanonizeResults(this.config),\n            canon: resetResultIdentities ? void 0 : (previousReader && previousReader.canon),\n            fragments: fragments,\n        })), fragments);\n        this.maybeBroadcastWatch = wrap(function (c, options) {\n            return _this.broadcastWatch(c, options);\n        }, {\n            max: this.config.resultCacheMaxSize ||\n                cacheSizes[\"inMemoryCache.maybeBroadcastWatch\"] ||\n                5000 /* defaultCacheSizes[\"inMemoryCache.maybeBroadcastWatch\"] */,\n            makeCacheKey: function (c) {\n                // Return a cache key (thus enabling result caching) only if we're\n                // currently using a data store that can track cache dependencies.\n                var store = c.optimistic ? _this.optimisticData : _this.data;\n                if (supportsResultCaching(store)) {\n                    var optimistic = c.optimistic, id = c.id, variables = c.variables;\n                    return store.makeCacheKey(c.query, \n                    // Different watches can have the same query, optimistic\n                    // status, rootId, and variables, but if their callbacks are\n                    // different, the (identical) result needs to be delivered to\n                    // each distinct callback. The easiest way to achieve that\n                    // separation is to include c.callback in the cache key for\n                    // maybeBroadcastWatch calls. See issue #5733.\n                    c.callback, canonicalStringify({ optimistic: optimistic, id: id, variables: variables }));\n                }\n            },\n        });\n        // Since we have thrown away all the cached functions that depend on the\n        // CacheGroup dependencies maintained by EntityStore, we should also reset\n        // all CacheGroup dependency information.\n        new Set([this.data.group, this.optimisticData.group]).forEach(function (group) {\n            return group.resetCaching();\n        });\n    };\n    InMemoryCache.prototype.restore = function (data) {\n        this.init();\n        // Since calling this.init() discards/replaces the entire StoreReader, along\n        // with the result caches it maintains, this.data.replace(data) won't have\n        // to bother deleting the old data.\n        if (data)\n            this.data.replace(data);\n        return this;\n    };\n    InMemoryCache.prototype.extract = function (optimistic) {\n        if (optimistic === void 0) { optimistic = false; }\n        return (optimistic ? this.optimisticData : this.data).extract();\n    };\n    InMemoryCache.prototype.read = function (options) {\n        var \n        // Since read returns data or null, without any additional metadata\n        // about whether/where there might have been missing fields, the\n        // default behavior cannot be returnPartialData = true (like it is\n        // for the diff method), since defaulting to true would violate the\n        // integrity of the T in the return type. However, partial data may\n        // be useful in some cases, so returnPartialData:true may be\n        // specified explicitly.\n        _a = options.returnPartialData, \n        // Since read returns data or null, without any additional metadata\n        // about whether/where there might have been missing fields, the\n        // default behavior cannot be returnPartialData = true (like it is\n        // for the diff method), since defaulting to true would violate the\n        // integrity of the T in the return type. However, partial data may\n        // be useful in some cases, so returnPartialData:true may be\n        // specified explicitly.\n        returnPartialData = _a === void 0 ? false : _a;\n        try {\n            return (this.storeReader.diffQueryAgainstStore(__assign(__assign({}, options), { store: options.optimistic ? this.optimisticData : this.data, config: this.config, returnPartialData: returnPartialData })).result || null);\n        }\n        catch (e) {\n            if (e instanceof MissingFieldError) {\n                // Swallow MissingFieldError and return null, so callers do not need to\n                // worry about catching \"normal\" exceptions resulting from incomplete\n                // cache data. Unexpected errors will be re-thrown. If you need more\n                // information about which fields were missing, use cache.diff instead,\n                // and examine diffResult.missing.\n                return null;\n            }\n            throw e;\n        }\n    };\n    InMemoryCache.prototype.write = function (options) {\n        try {\n            ++this.txCount;\n            return this.storeWriter.writeToStore(this.data, options);\n        }\n        finally {\n            if (!--this.txCount && options.broadcast !== false) {\n                this.broadcastWatches();\n            }\n        }\n    };\n    InMemoryCache.prototype.modify = function (options) {\n        if (hasOwn.call(options, \"id\") && !options.id) {\n            // To my knowledge, TypeScript does not currently provide a way to\n            // enforce that an optional property?:type must *not* be undefined\n            // when present. That ability would be useful here, because we want\n            // options.id to default to ROOT_QUERY only when no options.id was\n            // provided. If the caller attempts to pass options.id with a\n            // falsy/undefined value (perhaps because cache.identify failed), we\n            // should not assume the goal was to modify the ROOT_QUERY object.\n            // We could throw, but it seems natural to return false to indicate\n            // that nothing was modified.\n            return false;\n        }\n        var store = ((options.optimistic) // Defaults to false.\n        ) ?\n            this.optimisticData\n            : this.data;\n        try {\n            ++this.txCount;\n            return store.modify(options.id || \"ROOT_QUERY\", options.fields);\n        }\n        finally {\n            if (!--this.txCount && options.broadcast !== false) {\n                this.broadcastWatches();\n            }\n        }\n    };\n    InMemoryCache.prototype.diff = function (options) {\n        return this.storeReader.diffQueryAgainstStore(__assign(__assign({}, options), { store: options.optimistic ? this.optimisticData : this.data, rootId: options.id || \"ROOT_QUERY\", config: this.config }));\n    };\n    InMemoryCache.prototype.watch = function (watch) {\n        var _this = this;\n        if (!this.watches.size) {\n            // In case we previously called forgetCache(this) because\n            // this.watches became empty (see below), reattach this cache to any\n            // reactive variables on which it previously depended. It might seem\n            // paradoxical that we're able to recall something we supposedly\n            // forgot, but the point of calling forgetCache(this) is to silence\n            // useless broadcasts while this.watches is empty, and to allow the\n            // cache to be garbage collected. If, however, we manage to call\n            // recallCache(this) here, this cache object must not have been\n            // garbage collected yet, and should resume receiving updates from\n            // reactive variables, now that it has a watcher to notify.\n            recallCache(this);\n        }\n        this.watches.add(watch);\n        if (watch.immediate) {\n            this.maybeBroadcastWatch(watch);\n        }\n        return function () {\n            // Once we remove the last watch from this.watches, cache.broadcastWatches\n            // no longer does anything, so we preemptively tell the reactive variable\n            // system to exclude this cache from future broadcasts.\n            if (_this.watches.delete(watch) && !_this.watches.size) {\n                forgetCache(_this);\n            }\n            // Remove this watch from the LRU cache managed by the\n            // maybeBroadcastWatch OptimisticWrapperFunction, to prevent memory\n            // leaks involving the closure of watch.callback.\n            _this.maybeBroadcastWatch.forget(watch);\n        };\n    };\n    InMemoryCache.prototype.gc = function (options) {\n        var _a;\n        canonicalStringify.reset();\n        print.reset();\n        this.addTypenameTransform.resetCache();\n        (_a = this.config.fragments) === null || _a === void 0 ? void 0 : _a.resetCaches();\n        var ids = this.optimisticData.gc();\n        if (options && !this.txCount) {\n            if (options.resetResultCache) {\n                this.resetResultCache(options.resetResultIdentities);\n            }\n            else if (options.resetResultIdentities) {\n                this.storeReader.resetCanon();\n            }\n        }\n        return ids;\n    };\n    // Call this method to ensure the given root ID remains in the cache after\n    // garbage collection, along with its transitive child entities. Note that\n    // the cache automatically retains all directly written entities. By default,\n    // the retainment persists after optimistic updates are removed. Pass true\n    // for the optimistic argument if you would prefer for the retainment to be\n    // discarded when the top-most optimistic layer is removed. Returns the\n    // resulting (non-negative) retainment count.\n    InMemoryCache.prototype.retain = function (rootId, optimistic) {\n        return (optimistic ? this.optimisticData : this.data).retain(rootId);\n    };\n    // Call this method to undo the effect of the retain method, above. Once the\n    // retainment count falls to zero, the given ID will no longer be preserved\n    // during garbage collection, though it may still be preserved by other safe\n    // entities that refer to it. Returns the resulting (non-negative) retainment\n    // count, in case that's useful.\n    InMemoryCache.prototype.release = function (rootId, optimistic) {\n        return (optimistic ? this.optimisticData : this.data).release(rootId);\n    };\n    // Returns the canonical ID for a given StoreObject, obeying typePolicies\n    // and keyFields (and dataIdFromObject, if you still use that). At minimum,\n    // the object must contain a __typename and any primary key fields required\n    // to identify entities of that type. If you pass a query result object, be\n    // sure that none of the primary key fields have been renamed by aliasing.\n    // If you pass a Reference object, its __ref ID string will be returned.\n    InMemoryCache.prototype.identify = function (object) {\n        if (isReference(object))\n            return object.__ref;\n        try {\n            return this.policies.identify(object)[0];\n        }\n        catch (e) {\n            globalThis.__DEV__ !== false && invariant.warn(e);\n        }\n    };\n    InMemoryCache.prototype.evict = function (options) {\n        if (!options.id) {\n            if (hasOwn.call(options, \"id\")) {\n                // See comment in modify method about why we return false when\n                // options.id exists but is falsy/undefined.\n                return false;\n            }\n            options = __assign(__assign({}, options), { id: \"ROOT_QUERY\" });\n        }\n        try {\n            // It's unlikely that the eviction will end up invoking any other\n            // cache update operations while it's running, but {in,de}crementing\n            // this.txCount still seems like a good idea, for uniformity with\n            // the other update methods.\n            ++this.txCount;\n            // Pass this.data as a limit on the depth of the eviction, so evictions\n            // during optimistic updates (when this.data is temporarily set equal to\n            // this.optimisticData) do not escape their optimistic Layer.\n            return this.optimisticData.evict(options, this.data);\n        }\n        finally {\n            if (!--this.txCount && options.broadcast !== false) {\n                this.broadcastWatches();\n            }\n        }\n    };\n    InMemoryCache.prototype.reset = function (options) {\n        var _this = this;\n        this.init();\n        canonicalStringify.reset();\n        if (options && options.discardWatches) {\n            // Similar to what happens in the unsubscribe function returned by\n            // cache.watch, applied to all current watches.\n            this.watches.forEach(function (watch) { return _this.maybeBroadcastWatch.forget(watch); });\n            this.watches.clear();\n            forgetCache(this);\n        }\n        else {\n            // Calling this.init() above unblocks all maybeBroadcastWatch caching, so\n            // this.broadcastWatches() triggers a broadcast to every current watcher\n            // (letting them know their data is now missing). This default behavior is\n            // convenient because it means the watches do not have to be manually\n            // reestablished after resetting the cache. To prevent this broadcast and\n            // cancel all watches, pass true for options.discardWatches.\n            this.broadcastWatches();\n        }\n        return Promise.resolve();\n    };\n    InMemoryCache.prototype.removeOptimistic = function (idToRemove) {\n        var newOptimisticData = this.optimisticData.removeLayer(idToRemove);\n        if (newOptimisticData !== this.optimisticData) {\n            this.optimisticData = newOptimisticData;\n            this.broadcastWatches();\n        }\n    };\n    InMemoryCache.prototype.batch = function (options) {\n        var _this = this;\n        var update = options.update, _a = options.optimistic, optimistic = _a === void 0 ? true : _a, removeOptimistic = options.removeOptimistic, onWatchUpdated = options.onWatchUpdated;\n        var updateResult;\n        var perform = function (layer) {\n            var _a = _this, data = _a.data, optimisticData = _a.optimisticData;\n            ++_this.txCount;\n            if (layer) {\n                _this.data = _this.optimisticData = layer;\n            }\n            try {\n                return (updateResult = update(_this));\n            }\n            finally {\n                --_this.txCount;\n                _this.data = data;\n                _this.optimisticData = optimisticData;\n            }\n        };\n        var alreadyDirty = new Set();\n        if (onWatchUpdated && !this.txCount) {\n            // If an options.onWatchUpdated callback is provided, we want to call it\n            // with only the Cache.WatchOptions objects affected by options.update,\n            // but there might be dirty watchers already waiting to be broadcast that\n            // have nothing to do with the update. To prevent including those watchers\n            // in the post-update broadcast, we perform this initial broadcast to\n            // collect the dirty watchers, so we can re-dirty them later, after the\n            // post-update broadcast, allowing them to receive their pending\n            // broadcasts the next time broadcastWatches is called, just as they would\n            // if we never called cache.batch.\n            this.broadcastWatches(__assign(__assign({}, options), { onWatchUpdated: function (watch) {\n                    alreadyDirty.add(watch);\n                    return false;\n                } }));\n        }\n        if (typeof optimistic === \"string\") {\n            // Note that there can be multiple layers with the same optimistic ID.\n            // When removeOptimistic(id) is called for that id, all matching layers\n            // will be removed, and the remaining layers will be reapplied.\n            this.optimisticData = this.optimisticData.addLayer(optimistic, perform);\n        }\n        else if (optimistic === false) {\n            // Ensure both this.data and this.optimisticData refer to the root\n            // (non-optimistic) layer of the cache during the update. Note that\n            // this.data could be a Layer if we are currently executing an optimistic\n            // update function, but otherwise will always be an EntityStore.Root\n            // instance.\n            perform(this.data);\n        }\n        else {\n            // Otherwise, leave this.data and this.optimisticData unchanged and run\n            // the update with broadcast batching.\n            perform();\n        }\n        if (typeof removeOptimistic === \"string\") {\n            this.optimisticData = this.optimisticData.removeLayer(removeOptimistic);\n        }\n        // Note: if this.txCount > 0, then alreadyDirty.size === 0, so this code\n        // takes the else branch and calls this.broadcastWatches(options), which\n        // does nothing when this.txCount > 0.\n        if (onWatchUpdated && alreadyDirty.size) {\n            this.broadcastWatches(__assign(__assign({}, options), { onWatchUpdated: function (watch, diff) {\n                    var result = onWatchUpdated.call(this, watch, diff);\n                    if (result !== false) {\n                        // Since onWatchUpdated did not return false, this diff is\n                        // about to be broadcast to watch.callback, so we don't need\n                        // to re-dirty it with the other alreadyDirty watches below.\n                        alreadyDirty.delete(watch);\n                    }\n                    return result;\n                } }));\n            // Silently re-dirty any watches that were already dirty before the update\n            // was performed, and were not broadcast just now.\n            if (alreadyDirty.size) {\n                alreadyDirty.forEach(function (watch) { return _this.maybeBroadcastWatch.dirty(watch); });\n            }\n        }\n        else {\n            // If alreadyDirty is empty or we don't have an onWatchUpdated\n            // function, we don't need to go to the trouble of wrapping\n            // options.onWatchUpdated.\n            this.broadcastWatches(options);\n        }\n        return updateResult;\n    };\n    InMemoryCache.prototype.performTransaction = function (update, optimisticId) {\n        return this.batch({\n            update: update,\n            optimistic: optimisticId || optimisticId !== null,\n        });\n    };\n    InMemoryCache.prototype.transformDocument = function (document) {\n        return this.addTypenameToDocument(this.addFragmentsToDocument(document));\n    };\n    InMemoryCache.prototype.broadcastWatches = function (options) {\n        var _this = this;\n        if (!this.txCount) {\n            this.watches.forEach(function (c) { return _this.maybeBroadcastWatch(c, options); });\n        }\n    };\n    InMemoryCache.prototype.addFragmentsToDocument = function (document) {\n        var fragments = this.config.fragments;\n        return fragments ? fragments.transform(document) : document;\n    };\n    InMemoryCache.prototype.addTypenameToDocument = function (document) {\n        if (this.addTypename) {\n            return this.addTypenameTransform.transformDocument(document);\n        }\n        return document;\n    };\n    // This method is wrapped by maybeBroadcastWatch, which is called by\n    // broadcastWatches, so that we compute and broadcast results only when\n    // the data that would be broadcast might have changed. It would be\n    // simpler to check for changes after recomputing a result but before\n    // broadcasting it, but this wrapping approach allows us to skip both\n    // the recomputation and the broadcast, in most cases.\n    InMemoryCache.prototype.broadcastWatch = function (c, options) {\n        var lastDiff = c.lastDiff;\n        // Both WatchOptions and DiffOptions extend ReadOptions, and DiffOptions\n        // currently requires no additional properties, so we can use c (a\n        // WatchOptions object) as DiffOptions, without having to allocate a new\n        // object, and without having to enumerate the relevant properties (query,\n        // variables, etc.) explicitly. There will be some additional properties\n        // (lastDiff, callback, etc.), but cache.diff ignores them.\n        var diff = this.diff(c);\n        if (options) {\n            if (c.optimistic && typeof options.optimistic === \"string\") {\n                diff.fromOptimisticTransaction = true;\n            }\n            if (options.onWatchUpdated &&\n                options.onWatchUpdated.call(this, c, diff, lastDiff) === false) {\n                // Returning false from the onWatchUpdated callback will prevent\n                // calling c.callback(diff) for this watcher.\n                return;\n            }\n        }\n        if (!lastDiff || !equal(lastDiff.result, diff.result)) {\n            c.callback((c.lastDiff = diff), lastDiff);\n        }\n    };\n    return InMemoryCache;\n}(ApolloCache));\nexport { InMemoryCache };\nif (globalThis.__DEV__ !== false) {\n    InMemoryCache.prototype.getMemoryInternals = getInMemoryCacheMemoryInternals;\n}\n//# sourceMappingURL=inMemoryCache.js.map","import { dep, Slot } from \"optimism\";\n// Contextual Slot that acquires its value when custom read functions are\n// called in Policies#readField.\nexport var cacheSlot = new Slot();\nvar cacheInfoMap = new WeakMap();\nfunction getCacheInfo(cache) {\n    var info = cacheInfoMap.get(cache);\n    if (!info) {\n        cacheInfoMap.set(cache, (info = {\n            vars: new Set(),\n            dep: dep(),\n        }));\n    }\n    return info;\n}\nexport function forgetCache(cache) {\n    getCacheInfo(cache).vars.forEach(function (rv) { return rv.forgetCache(cache); });\n}\n// Calling forgetCache(cache) serves to silence broadcasts and allows the\n// cache to be garbage collected. However, the varsByCache WeakMap\n// preserves the set of reactive variables that were previously associated\n// with this cache, which makes it possible to \"recall\" the cache at a\n// later time, by reattaching it to those variables. If the cache has been\n// garbage collected in the meantime, because it is no longer reachable,\n// you won't be able to call recallCache(cache), and the cache will\n// automatically disappear from the varsByCache WeakMap.\nexport function recallCache(cache) {\n    getCacheInfo(cache).vars.forEach(function (rv) { return rv.attachCache(cache); });\n}\nexport function makeVar(value) {\n    var caches = new Set();\n    var listeners = new Set();\n    var rv = function (newValue) {\n        if (arguments.length > 0) {\n            if (value !== newValue) {\n                value = newValue;\n                caches.forEach(function (cache) {\n                    // Invalidate any fields with custom read functions that\n                    // consumed this variable, so query results involving those\n                    // fields will be recomputed the next time we read them.\n                    getCacheInfo(cache).dep.dirty(rv);\n                    // Broadcast changes to any caches that have previously read\n                    // from this variable.\n                    broadcast(cache);\n                });\n                // Finally, notify any listeners added via rv.onNextChange.\n                var oldListeners = Array.from(listeners);\n                listeners.clear();\n                oldListeners.forEach(function (listener) { return listener(value); });\n            }\n        }\n        else {\n            // When reading from the variable, obtain the current cache from\n            // context via cacheSlot. This isn't entirely foolproof, but it's\n            // the same system that powers varDep.\n            var cache = cacheSlot.getValue();\n            if (cache) {\n                attach(cache);\n                getCacheInfo(cache).dep(rv);\n            }\n        }\n        return value;\n    };\n    rv.onNextChange = function (listener) {\n        listeners.add(listener);\n        return function () {\n            listeners.delete(listener);\n        };\n    };\n    var attach = (rv.attachCache = function (cache) {\n        caches.add(cache);\n        getCacheInfo(cache).vars.add(rv);\n        return rv;\n    });\n    rv.forgetCache = function (cache) { return caches.delete(cache); };\n    return rv;\n}\nfunction broadcast(cache) {\n    if (cache.broadcastWatches) {\n        cache.broadcastWatches();\n    }\n}\n//# sourceMappingURL=reactiveVars.js.map","import { ApolloLink } from \"./ApolloLink.js\";\nexport var execute = ApolloLink.execute;\n//# sourceMappingURL=execute.js.map","import { Observable } from \"./Observable.js\";\n// Like Observable.prototype.map, except that the mapping function can\n// optionally return a Promise (or be async).\nexport function asyncMap(observable, mapFn, catchFn) {\n    return new Observable(function (observer) {\n        var promiseQueue = {\n            // Normally we would initialize promiseQueue to Promise.resolve(), but\n            // in this case, for backwards compatibility, we need to be careful to\n            // invoke the first callback synchronously.\n            then: function (callback) {\n                return new Promise(function (resolve) { return resolve(callback()); });\n            },\n        };\n        function makeCallback(examiner, key) {\n            return function (arg) {\n                if (examiner) {\n                    var both = function () {\n                        // If the observer is closed, we don't want to continue calling the\n                        // mapping function - it's result will be swallowed anyways.\n                        return observer.closed ?\n                            /* will be swallowed */ 0\n                            : examiner(arg);\n                    };\n                    promiseQueue = promiseQueue.then(both, both).then(function (result) { return observer.next(result); }, function (error) { return observer.error(error); });\n                }\n                else {\n                    observer[key](arg);\n                }\n            };\n        }\n        var handler = {\n            next: makeCallback(mapFn, \"next\"),\n            error: makeCallback(catchFn, \"error\"),\n            complete: function () {\n                // no need to reassign `promiseQueue`, after `observer.complete`,\n                // the observer will be closed and short-circuit everything anyways\n                /*promiseQueue = */ promiseQueue.then(function () { return observer.complete(); });\n            },\n        };\n        var sub = observable.subscribe(handler);\n        return function () { return sub.unsubscribe(); };\n    });\n}\n//# sourceMappingURL=asyncMap.js.map","import { isNonEmptyArray } from \"./arrays.js\";\nimport { isExecutionPatchIncrementalResult } from \"./incrementalResult.js\";\nexport function graphQLResultHasError(result) {\n    var errors = getGraphQLErrorsFromResult(result);\n    return isNonEmptyArray(errors);\n}\nexport function getGraphQLErrorsFromResult(result) {\n    var graphQLErrors = isNonEmptyArray(result.errors) ? result.errors.slice(0) : [];\n    if (isExecutionPatchIncrementalResult(result) &&\n        isNonEmptyArray(result.incremental)) {\n        result.incremental.forEach(function (incrementalResult) {\n            if (incrementalResult.errors) {\n                graphQLErrors.push.apply(graphQLErrors, incrementalResult.errors);\n            }\n        });\n    }\n    return graphQLErrors;\n}\n//# sourceMappingURL=errorHandling.js.map","export function iterateObserversSafely(observers, method, argument) {\n    // In case observers is modified during iteration, we need to commit to the\n    // original elements, which also provides an opportunity to filter them down\n    // to just the observers with the given method.\n    var observersWithMethod = [];\n    observers.forEach(function (obs) { return obs[method] && observersWithMethod.push(obs); });\n    observersWithMethod.forEach(function (obs) { return obs[method](argument); });\n}\n//# sourceMappingURL=iteration.js.map","import { Observable } from \"./Observable.js\";\nimport { canUseSymbol } from \"../common/canUse.js\";\n// Generic implementations of Observable.prototype methods like map and\n// filter need to know how to create a new Observable from an Observable\n// subclass (like Concast or ObservableQuery). Those methods assume\n// (perhaps unwisely?) that they can call the subtype's constructor with a\n// Subscriber function, even though the subclass constructor might expect\n// different parameters. Defining this static Symbol.species property on\n// the subclass is a hint to generic Observable code to use the default\n// constructor instead of trying to do `new Subclass(observer => ...)`.\nexport function fixObservableSubclass(subclass) {\n    function set(key) {\n        // Object.defineProperty is necessary because the Symbol.species\n        // property is a getter by default in modern JS environments, so we\n        // can't assign to it with a normal assignment expression.\n        Object.defineProperty(subclass, key, { value: Observable });\n    }\n    if (canUseSymbol && Symbol.species) {\n        set(Symbol.species);\n    }\n    // The \"@@species\" string is used as a fake Symbol.species value in some\n    // polyfill systems (including the SymbolSpecies variable used by\n    // zen-observable), so we should set it as well, to be safe.\n    set(\"@@species\");\n    return subclass;\n}\n//# sourceMappingURL=subclassing.js.map","import { __extends } from \"tslib\";\nimport { Observable } from \"./Observable.js\";\nimport { iterateObserversSafely } from \"./iteration.js\";\nimport { fixObservableSubclass } from \"./subclassing.js\";\nfunction isPromiseLike(value) {\n    return value && typeof value.then === \"function\";\n}\n// A Concast<T> observable concatenates the given sources into a single\n// non-overlapping sequence of Ts, automatically unwrapping any promises,\n// and broadcasts the T elements of that sequence to any number of\n// subscribers, all without creating a bunch of intermediary Observable\n// wrapper objects.\n//\n// Even though any number of observers can subscribe to the Concast, each\n// source observable is guaranteed to receive at most one subscribe call,\n// and the results are multicast to all observers.\n//\n// In addition to broadcasting every next/error message to this.observers,\n// the Concast stores the most recent message using this.latest, so any\n// new observers can immediately receive the latest message, even if it\n// was originally delivered in the past. This behavior means we can assume\n// every active observer in this.observers has received the same most\n// recent message.\n//\n// With the exception of this.latest replay, a Concast is a \"hot\"\n// observable in the sense that it does not replay past results from the\n// beginning of time for each new observer.\n//\n// Could we have used some existing RxJS class instead? Concast<T> is\n// similar to a BehaviorSubject<T>, because it is multicast and redelivers\n// the latest next/error message to new subscribers. Unlike Subject<T>,\n// Concast<T> does not expose an Observer<T> interface (this.handlers is\n// intentionally private), since Concast<T> gets its inputs from the\n// concatenated sources. If we ever switch to RxJS, there may be some\n// value in reusing their code, but for now we use zen-observable, which\n// does not contain any Subject implementations.\nvar Concast = /** @class */ (function (_super) {\n    __extends(Concast, _super);\n    // Not only can the individual elements of the iterable be promises, but\n    // also the iterable itself can be wrapped in a promise.\n    function Concast(sources) {\n        var _this = _super.call(this, function (observer) {\n            _this.addObserver(observer);\n            return function () { return _this.removeObserver(observer); };\n        }) || this;\n        // Active observers receiving broadcast messages. Thanks to this.latest,\n        // we can assume all observers in this Set have received the same most\n        // recent message, though possibly at different times in the past.\n        _this.observers = new Set();\n        _this.promise = new Promise(function (resolve, reject) {\n            _this.resolve = resolve;\n            _this.reject = reject;\n        });\n        // Bound handler functions that can be reused for every internal\n        // subscription.\n        _this.handlers = {\n            next: function (result) {\n                if (_this.sub !== null) {\n                    _this.latest = [\"next\", result];\n                    _this.notify(\"next\", result);\n                    iterateObserversSafely(_this.observers, \"next\", result);\n                }\n            },\n            error: function (error) {\n                var sub = _this.sub;\n                if (sub !== null) {\n                    // Delay unsubscribing from the underlying subscription slightly,\n                    // so that immediately subscribing another observer can keep the\n                    // subscription active.\n                    if (sub)\n                        setTimeout(function () { return sub.unsubscribe(); });\n                    _this.sub = null;\n                    _this.latest = [\"error\", error];\n                    _this.reject(error);\n                    _this.notify(\"error\", error);\n                    iterateObserversSafely(_this.observers, \"error\", error);\n                }\n            },\n            complete: function () {\n                var _a = _this, sub = _a.sub, _b = _a.sources, sources = _b === void 0 ? [] : _b;\n                if (sub !== null) {\n                    // If complete is called before concast.start, this.sources may be\n                    // undefined, so we use a default value of [] for sources. That works\n                    // here because it falls into the if (!value) {...} block, which\n                    // appropriately terminates the Concast, even if this.sources might\n                    // eventually have been initialized to a non-empty array.\n                    var value = sources.shift();\n                    if (!value) {\n                        if (sub)\n                            setTimeout(function () { return sub.unsubscribe(); });\n                        _this.sub = null;\n                        if (_this.latest && _this.latest[0] === \"next\") {\n                            _this.resolve(_this.latest[1]);\n                        }\n                        else {\n                            _this.resolve();\n                        }\n                        _this.notify(\"complete\");\n                        // We do not store this.latest = [\"complete\"], because doing so\n                        // discards useful information about the previous next (or\n                        // error) message. Instead, if new observers subscribe after\n                        // this Concast has completed, they will receive the final\n                        // 'next' message (unless there was an error) immediately\n                        // followed by a 'complete' message (see addObserver).\n                        iterateObserversSafely(_this.observers, \"complete\");\n                    }\n                    else if (isPromiseLike(value)) {\n                        value.then(function (obs) { return (_this.sub = obs.subscribe(_this.handlers)); }, _this.handlers.error);\n                    }\n                    else {\n                        _this.sub = value.subscribe(_this.handlers);\n                    }\n                }\n            },\n        };\n        _this.nextResultListeners = new Set();\n        // A public way to abort observation and broadcast.\n        _this.cancel = function (reason) {\n            _this.reject(reason);\n            _this.sources = [];\n            _this.handlers.error(reason);\n        };\n        // Suppress rejection warnings for this.promise, since it's perfectly\n        // acceptable to pay no attention to this.promise if you're consuming\n        // the results through the normal observable API.\n        _this.promise.catch(function (_) { });\n        // If someone accidentally tries to create a Concast using a subscriber\n        // function, recover by creating an Observable from that subscriber and\n        // using it as the source.\n        if (typeof sources === \"function\") {\n            sources = [new Observable(sources)];\n        }\n        if (isPromiseLike(sources)) {\n            sources.then(function (iterable) { return _this.start(iterable); }, _this.handlers.error);\n        }\n        else {\n            _this.start(sources);\n        }\n        return _this;\n    }\n    Concast.prototype.start = function (sources) {\n        if (this.sub !== void 0)\n            return;\n        // In practice, sources is most often simply an Array of observables.\n        // TODO Consider using sources[Symbol.iterator]() to take advantage\n        // of the laziness of non-Array iterables.\n        this.sources = Array.from(sources);\n        // Calling this.handlers.complete() kicks off consumption of the first\n        // source observable. It's tempting to do this step lazily in\n        // addObserver, but this.promise can be accessed without calling\n        // addObserver, so consumption needs to begin eagerly.\n        this.handlers.complete();\n    };\n    Concast.prototype.deliverLastMessage = function (observer) {\n        if (this.latest) {\n            var nextOrError = this.latest[0];\n            var method = observer[nextOrError];\n            if (method) {\n                method.call(observer, this.latest[1]);\n            }\n            // If the subscription is already closed, and the last message was\n            // a 'next' message, simulate delivery of the final 'complete'\n            // message again.\n            if (this.sub === null && nextOrError === \"next\" && observer.complete) {\n                observer.complete();\n            }\n        }\n    };\n    Concast.prototype.addObserver = function (observer) {\n        if (!this.observers.has(observer)) {\n            // Immediately deliver the most recent message, so we can always\n            // be sure all observers have the latest information.\n            this.deliverLastMessage(observer);\n            this.observers.add(observer);\n        }\n    };\n    Concast.prototype.removeObserver = function (observer) {\n        if (this.observers.delete(observer) && this.observers.size < 1) {\n            // In case there are still any listeners in this.nextResultListeners, and\n            // no error or completion has been broadcast yet, make sure those\n            // observers have a chance to run and then remove themselves from\n            // this.observers.\n            this.handlers.complete();\n        }\n    };\n    Concast.prototype.notify = function (method, arg) {\n        var nextResultListeners = this.nextResultListeners;\n        if (nextResultListeners.size) {\n            // Replacing this.nextResultListeners first ensures it does not grow while\n            // we are iterating over it, potentially leading to infinite loops.\n            this.nextResultListeners = new Set();\n            nextResultListeners.forEach(function (listener) { return listener(method, arg); });\n        }\n    };\n    // We need a way to run callbacks just *before* the next result (or error or\n    // completion) is delivered by this Concast, so we can be sure any code that\n    // runs as a result of delivering that result/error observes the effects of\n    // running the callback(s). It was tempting to reuse the Observer type instead\n    // of introducing NextResultListener, but that messes with the sizing and\n    // maintenance of this.observers, and ends up being more code overall.\n    Concast.prototype.beforeNext = function (callback) {\n        var called = false;\n        this.nextResultListeners.add(function (method, arg) {\n            if (!called) {\n                called = true;\n                callback(method, arg);\n            }\n        });\n    };\n    return Concast;\n}(Observable));\nexport { Concast };\n// Necessary because the Concast constructor has a different signature\n// than the Observable constructor.\nfixObservableSubclass(Concast);\n//# sourceMappingURL=Concast.js.map","import { __assign, __extends } from \"tslib\";\nimport { invariant } from \"../utilities/globals/index.js\";\nimport { equal } from \"@wry/equality\";\nimport { NetworkStatus, isNetworkRequestInFlight } from \"./networkStatus.js\";\nimport { cloneDeep, compact, getOperationDefinition, Observable, iterateObserversSafely, fixObservableSubclass, getQueryDefinition, } from \"../utilities/index.js\";\nimport { ApolloError, isApolloError } from \"../errors/index.js\";\nimport { equalByQuery } from \"./equalByQuery.js\";\nvar assign = Object.assign, hasOwnProperty = Object.hasOwnProperty;\nvar ObservableQuery = /** @class */ (function (_super) {\n    __extends(ObservableQuery, _super);\n    function ObservableQuery(_a) {\n        var queryManager = _a.queryManager, queryInfo = _a.queryInfo, options = _a.options;\n        var _this = _super.call(this, function (observer) {\n            // Zen Observable has its own error function, so in order to log correctly\n            // we need to provide a custom error callback.\n            try {\n                var subObserver = observer._subscription._observer;\n                if (subObserver && !subObserver.error) {\n                    subObserver.error = defaultSubscriptionObserverErrorCallback;\n                }\n            }\n            catch (_a) { }\n            var first = !_this.observers.size;\n            _this.observers.add(observer);\n            // Deliver most recent error or result.\n            var last = _this.last;\n            if (last && last.error) {\n                observer.error && observer.error(last.error);\n            }\n            else if (last && last.result) {\n                observer.next && observer.next(last.result);\n            }\n            // Initiate observation of this query if it hasn't been reported to\n            // the QueryManager yet.\n            if (first) {\n                // Blindly catching here prevents unhandled promise rejections,\n                // and is safe because the ObservableQuery handles this error with\n                // this.observer.error, so we're not just swallowing the error by\n                // ignoring it here.\n                _this.reobserve().catch(function () { });\n            }\n            return function () {\n                if (_this.observers.delete(observer) && !_this.observers.size) {\n                    _this.tearDownQuery();\n                }\n            };\n        }) || this;\n        _this.observers = new Set();\n        _this.subscriptions = new Set();\n        // related classes\n        _this.queryInfo = queryInfo;\n        _this.queryManager = queryManager;\n        // active state\n        _this.waitForOwnResult = skipCacheDataFor(options.fetchPolicy);\n        _this.isTornDown = false;\n        _this.subscribeToMore = _this.subscribeToMore.bind(_this);\n        var _b = queryManager.defaultOptions.watchQuery, _c = _b === void 0 ? {} : _b, _d = _c.fetchPolicy, defaultFetchPolicy = _d === void 0 ? \"cache-first\" : _d;\n        var _e = options.fetchPolicy, fetchPolicy = _e === void 0 ? defaultFetchPolicy : _e, \n        // Make sure we don't store \"standby\" as the initialFetchPolicy.\n        _f = options.initialFetchPolicy, \n        // Make sure we don't store \"standby\" as the initialFetchPolicy.\n        initialFetchPolicy = _f === void 0 ? fetchPolicy === \"standby\" ? defaultFetchPolicy : (fetchPolicy) : _f;\n        _this.options = __assign(__assign({}, options), { \n            // Remember the initial options.fetchPolicy so we can revert back to this\n            // policy when variables change. This information can also be specified\n            // (or overridden) by providing options.initialFetchPolicy explicitly.\n            initialFetchPolicy: initialFetchPolicy, \n            // This ensures this.options.fetchPolicy always has a string value, in\n            // case options.fetchPolicy was not provided.\n            fetchPolicy: fetchPolicy });\n        _this.queryId = queryInfo.queryId || queryManager.generateQueryId();\n        var opDef = getOperationDefinition(_this.query);\n        _this.queryName = opDef && opDef.name && opDef.name.value;\n        return _this;\n    }\n    Object.defineProperty(ObservableQuery.prototype, \"query\", {\n        // The `query` computed property will always reflect the document transformed\n        // by the last run query. `this.options.query` will always reflect the raw\n        // untransformed query to ensure document transforms with runtime conditionals\n        // are run on the original document.\n        get: function () {\n            return this.lastQuery || this.options.query;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(ObservableQuery.prototype, \"variables\", {\n        // Computed shorthand for this.options.variables, preserved for\n        // backwards compatibility.\n        /**\n         * An object containing the variables that were provided for the query.\n         */\n        get: function () {\n            return this.options.variables;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    ObservableQuery.prototype.result = function () {\n        var _this = this;\n        return new Promise(function (resolve, reject) {\n            // TODO: this code doesn’t actually make sense insofar as the observer\n            // will never exist in this.observers due how zen-observable wraps observables.\n            // https://github.com/zenparsing/zen-observable/blob/master/src/Observable.js#L169\n            var observer = {\n                next: function (result) {\n                    resolve(result);\n                    // Stop the query within the QueryManager if we can before\n                    // this function returns.\n                    //\n                    // We do this in order to prevent observers piling up within\n                    // the QueryManager. Notice that we only fully unsubscribe\n                    // from the subscription in a setTimeout(..., 0)  call. This call can\n                    // actually be handled by the browser at a much later time. If queries\n                    // are fired in the meantime, observers that should have been removed\n                    // from the QueryManager will continue to fire, causing an unnecessary\n                    // performance hit.\n                    _this.observers.delete(observer);\n                    if (!_this.observers.size) {\n                        _this.queryManager.removeQuery(_this.queryId);\n                    }\n                    setTimeout(function () {\n                        subscription.unsubscribe();\n                    }, 0);\n                },\n                error: reject,\n            };\n            var subscription = _this.subscribe(observer);\n        });\n    };\n    /** @internal */\n    ObservableQuery.prototype.resetDiff = function () {\n        this.queryInfo.resetDiff();\n    };\n    ObservableQuery.prototype.getCurrentResult = function (saveAsLastResult) {\n        if (saveAsLastResult === void 0) { saveAsLastResult = true; }\n        // Use the last result as long as the variables match this.variables.\n        var lastResult = this.getLastResult(true);\n        var networkStatus = this.queryInfo.networkStatus ||\n            (lastResult && lastResult.networkStatus) ||\n            NetworkStatus.ready;\n        var result = __assign(__assign({}, lastResult), { loading: isNetworkRequestInFlight(networkStatus), networkStatus: networkStatus });\n        var _a = this.options.fetchPolicy, fetchPolicy = _a === void 0 ? \"cache-first\" : _a;\n        if (\n        // These fetch policies should never deliver data from the cache, unless\n        // redelivering a previously delivered result.\n        skipCacheDataFor(fetchPolicy) ||\n            // If this.options.query has @client(always: true) fields, we cannot\n            // trust diff.result, since it was read from the cache without running\n            // local resolvers (and it's too late to run resolvers now, since we must\n            // return a result synchronously).\n            this.queryManager.getDocumentInfo(this.query).hasForcedResolvers) {\n            // Fall through.\n        }\n        else if (this.waitForOwnResult) {\n            // This would usually be a part of `QueryInfo.getDiff()`.\n            // which we skip in the waitForOwnResult case since we are not\n            // interested in the diff.\n            this.queryInfo[\"updateWatch\"]();\n        }\n        else {\n            var diff = this.queryInfo.getDiff();\n            if (diff.complete || this.options.returnPartialData) {\n                result.data = diff.result;\n            }\n            if (equal(result.data, {})) {\n                result.data = void 0;\n            }\n            if (diff.complete) {\n                // Similar to setting result.partial to false, but taking advantage of the\n                // falsiness of missing fields.\n                delete result.partial;\n                // If the diff is complete, and we're using a FetchPolicy that\n                // terminates after a complete cache read, we can assume the next result\n                // we receive will have NetworkStatus.ready and !loading.\n                if (diff.complete &&\n                    result.networkStatus === NetworkStatus.loading &&\n                    (fetchPolicy === \"cache-first\" || fetchPolicy === \"cache-only\")) {\n                    result.networkStatus = NetworkStatus.ready;\n                    result.loading = false;\n                }\n            }\n            else {\n                result.partial = true;\n            }\n            if (globalThis.__DEV__ !== false &&\n                !diff.complete &&\n                !this.options.partialRefetch &&\n                !result.loading &&\n                !result.data &&\n                !result.error) {\n                logMissingFieldErrors(diff.missing);\n            }\n        }\n        if (saveAsLastResult) {\n            this.updateLastResult(result);\n        }\n        return result;\n    };\n    // Compares newResult to the snapshot we took of this.lastResult when it was\n    // first received.\n    ObservableQuery.prototype.isDifferentFromLastResult = function (newResult, variables) {\n        if (!this.last) {\n            return true;\n        }\n        var resultIsDifferent = this.queryManager.getDocumentInfo(this.query).hasNonreactiveDirective ?\n            !equalByQuery(this.query, this.last.result, newResult, this.variables)\n            : !equal(this.last.result, newResult);\n        return (resultIsDifferent || (variables && !equal(this.last.variables, variables)));\n    };\n    ObservableQuery.prototype.getLast = function (key, variablesMustMatch) {\n        var last = this.last;\n        if (last &&\n            last[key] &&\n            (!variablesMustMatch || equal(last.variables, this.variables))) {\n            return last[key];\n        }\n    };\n    ObservableQuery.prototype.getLastResult = function (variablesMustMatch) {\n        return this.getLast(\"result\", variablesMustMatch);\n    };\n    ObservableQuery.prototype.getLastError = function (variablesMustMatch) {\n        return this.getLast(\"error\", variablesMustMatch);\n    };\n    ObservableQuery.prototype.resetLastResults = function () {\n        delete this.last;\n        this.isTornDown = false;\n    };\n    ObservableQuery.prototype.resetQueryStoreErrors = function () {\n        this.queryManager.resetErrors(this.queryId);\n    };\n    /**\n     * Update the variables of this observable query, and fetch the new results.\n     * This method should be preferred over `setVariables` in most use cases.\n     *\n     * @param variables - The new set of variables. If there are missing variables,\n     * the previous values of those variables will be used.\n     */\n    ObservableQuery.prototype.refetch = function (variables) {\n        var _a;\n        var reobserveOptions = {\n            // Always disable polling for refetches.\n            pollInterval: 0,\n        };\n        // Unless the provided fetchPolicy always consults the network\n        // (no-cache, network-only, or cache-and-network), override it with\n        // network-only to force the refetch for this fetchQuery call.\n        var fetchPolicy = this.options.fetchPolicy;\n        if (fetchPolicy === \"cache-and-network\") {\n            reobserveOptions.fetchPolicy = fetchPolicy;\n        }\n        else if (fetchPolicy === \"no-cache\") {\n            reobserveOptions.fetchPolicy = \"no-cache\";\n        }\n        else {\n            reobserveOptions.fetchPolicy = \"network-only\";\n        }\n        if (globalThis.__DEV__ !== false && variables && hasOwnProperty.call(variables, \"variables\")) {\n            var queryDef = getQueryDefinition(this.query);\n            var vars = queryDef.variableDefinitions;\n            if (!vars || !vars.some(function (v) { return v.variable.name.value === \"variables\"; })) {\n                globalThis.__DEV__ !== false && invariant.warn(\n                    20,\n                    variables,\n                    ((_a = queryDef.name) === null || _a === void 0 ? void 0 : _a.value) || queryDef\n                );\n            }\n        }\n        if (variables && !equal(this.options.variables, variables)) {\n            // Update the existing options with new variables\n            reobserveOptions.variables = this.options.variables = __assign(__assign({}, this.options.variables), variables);\n        }\n        this.queryInfo.resetLastWrite();\n        return this.reobserve(reobserveOptions, NetworkStatus.refetch);\n    };\n    /**\n     * A function that helps you fetch the next set of results for a [paginated list field](https://www.apollographql.com/docs/react/pagination/core-api/).\n     */\n    ObservableQuery.prototype.fetchMore = function (fetchMoreOptions) {\n        var _this = this;\n        var combinedOptions = __assign(__assign({}, (fetchMoreOptions.query ? fetchMoreOptions : (__assign(__assign(__assign(__assign({}, this.options), { query: this.options.query }), fetchMoreOptions), { variables: __assign(__assign({}, this.options.variables), fetchMoreOptions.variables) })))), { \n            // The fetchMore request goes immediately to the network and does\n            // not automatically write its result to the cache (hence no-cache\n            // instead of network-only), because we allow the caller of\n            // fetchMore to provide an updateQuery callback that determines how\n            // the data gets written to the cache.\n            fetchPolicy: \"no-cache\" });\n        combinedOptions.query = this.transformDocument(combinedOptions.query);\n        var qid = this.queryManager.generateQueryId();\n        // If a temporary query is passed to `fetchMore`, we don't want to store\n        // it as the last query result since it may be an optimized query for\n        // pagination. We will however run the transforms on the original document\n        // as well as the document passed in `fetchMoreOptions` to ensure the cache\n        // uses the most up-to-date document which may rely on runtime conditionals.\n        this.lastQuery =\n            fetchMoreOptions.query ?\n                this.transformDocument(this.options.query)\n                : combinedOptions.query;\n        // Simulate a loading result for the original query with\n        // result.networkStatus === NetworkStatus.fetchMore.\n        var queryInfo = this.queryInfo;\n        var originalNetworkStatus = queryInfo.networkStatus;\n        queryInfo.networkStatus = NetworkStatus.fetchMore;\n        if (combinedOptions.notifyOnNetworkStatusChange) {\n            this.observe();\n        }\n        var updatedQuerySet = new Set();\n        var updateQuery = fetchMoreOptions === null || fetchMoreOptions === void 0 ? void 0 : fetchMoreOptions.updateQuery;\n        var isCached = this.options.fetchPolicy !== \"no-cache\";\n        if (!isCached) {\n            invariant(updateQuery, 21);\n        }\n        return this.queryManager\n            .fetchQuery(qid, combinedOptions, NetworkStatus.fetchMore)\n            .then(function (fetchMoreResult) {\n            _this.queryManager.removeQuery(qid);\n            if (queryInfo.networkStatus === NetworkStatus.fetchMore) {\n                queryInfo.networkStatus = originalNetworkStatus;\n            }\n            if (isCached) {\n                // Performing this cache update inside a cache.batch transaction ensures\n                // any affected cache.watch watchers are notified at most once about any\n                // updates. Most watchers will be using the QueryInfo class, which\n                // responds to notifications by calling reobserveCacheFirst to deliver\n                // fetchMore cache results back to this ObservableQuery.\n                _this.queryManager.cache.batch({\n                    update: function (cache) {\n                        var updateQuery = fetchMoreOptions.updateQuery;\n                        if (updateQuery) {\n                            cache.updateQuery({\n                                query: _this.query,\n                                variables: _this.variables,\n                                returnPartialData: true,\n                                optimistic: false,\n                            }, function (previous) {\n                                return updateQuery(previous, {\n                                    fetchMoreResult: fetchMoreResult.data,\n                                    variables: combinedOptions.variables,\n                                });\n                            });\n                        }\n                        else {\n                            // If we're using a field policy instead of updateQuery, the only\n                            // thing we need to do is write the new data to the cache using\n                            // combinedOptions.variables (instead of this.variables, which is\n                            // what this.updateQuery uses, because it works by abusing the\n                            // original field value, keyed by the original variables).\n                            cache.writeQuery({\n                                query: combinedOptions.query,\n                                variables: combinedOptions.variables,\n                                data: fetchMoreResult.data,\n                            });\n                        }\n                    },\n                    onWatchUpdated: function (watch) {\n                        // Record the DocumentNode associated with any watched query whose\n                        // data were updated by the cache writes above.\n                        updatedQuerySet.add(watch.query);\n                    },\n                });\n            }\n            else {\n                // There is a possibility `lastResult` may not be set when\n                // `fetchMore` is called which would cause this to crash. This should\n                // only happen if we haven't previously reported a result. We don't\n                // quite know what the right behavior should be here since this block\n                // of code runs after the fetch result has executed on the network.\n                // We plan to let it crash in the meantime.\n                //\n                // If we get bug reports due to the `data` property access on\n                // undefined, this should give us a real-world scenario that we can\n                // use to test against and determine the right behavior. If we do end\n                // up changing this behavior, this may require, for example, an\n                // adjustment to the types on `updateQuery` since that function\n                // expects that the first argument always contains previous result\n                // data, but not `undefined`.\n                var lastResult = _this.getLast(\"result\");\n                var data = updateQuery(lastResult.data, {\n                    fetchMoreResult: fetchMoreResult.data,\n                    variables: combinedOptions.variables,\n                });\n                _this.reportResult(__assign(__assign({}, lastResult), { data: data }), _this.variables);\n            }\n            return fetchMoreResult;\n        })\n            .finally(function () {\n            // In case the cache writes above did not generate a broadcast\n            // notification (which would have been intercepted by onWatchUpdated),\n            // likely because the written data were the same as what was already in\n            // the cache, we still want fetchMore to deliver its final loading:false\n            // result with the unchanged data.\n            if (isCached && !updatedQuerySet.has(_this.query)) {\n                reobserveCacheFirst(_this);\n            }\n        });\n    };\n    // XXX the subscription variables are separate from the query variables.\n    // if you want to update subscription variables, right now you have to do that separately,\n    // and you can only do it by stopping the subscription and then subscribing again with new variables.\n    /**\n     * A function that enables you to execute a [subscription](https://www.apollographql.com/docs/react/data/subscriptions/), usually to subscribe to specific fields that were included in the query.\n     *\n     * This function returns _another_ function that you can call to terminate the subscription.\n     */\n    ObservableQuery.prototype.subscribeToMore = function (options) {\n        var _this = this;\n        var subscription = this.queryManager\n            .startGraphQLSubscription({\n            query: options.document,\n            variables: options.variables,\n            context: options.context,\n        })\n            .subscribe({\n            next: function (subscriptionData) {\n                var updateQuery = options.updateQuery;\n                if (updateQuery) {\n                    _this.updateQuery(function (previous, _a) {\n                        var variables = _a.variables;\n                        return updateQuery(previous, {\n                            subscriptionData: subscriptionData,\n                            variables: variables,\n                        });\n                    });\n                }\n            },\n            error: function (err) {\n                if (options.onError) {\n                    options.onError(err);\n                    return;\n                }\n                globalThis.__DEV__ !== false && invariant.error(22, err);\n            },\n        });\n        this.subscriptions.add(subscription);\n        return function () {\n            if (_this.subscriptions.delete(subscription)) {\n                subscription.unsubscribe();\n            }\n        };\n    };\n    ObservableQuery.prototype.setOptions = function (newOptions) {\n        return this.reobserve(newOptions);\n    };\n    ObservableQuery.prototype.silentSetOptions = function (newOptions) {\n        var mergedOptions = compact(this.options, newOptions || {});\n        assign(this.options, mergedOptions);\n    };\n    /**\n     * Update the variables of this observable query, and fetch the new results\n     * if they've changed. Most users should prefer `refetch` instead of\n     * `setVariables` in order to to be properly notified of results even when\n     * they come from the cache.\n     *\n     * Note: the `next` callback will *not* fire if the variables have not changed\n     * or if the result is coming from cache.\n     *\n     * Note: the promise will return the old results immediately if the variables\n     * have not changed.\n     *\n     * Note: the promise will return null immediately if the query is not active\n     * (there are no subscribers).\n     *\n     * @param variables - The new set of variables. If there are missing variables,\n     * the previous values of those variables will be used.\n     */\n    ObservableQuery.prototype.setVariables = function (variables) {\n        if (equal(this.variables, variables)) {\n            // If we have no observers, then we don't actually want to make a network\n            // request. As soon as someone observes the query, the request will kick\n            // off. For now, we just store any changes. (See #1077)\n            return this.observers.size ? this.result() : Promise.resolve();\n        }\n        this.options.variables = variables;\n        // See comment above\n        if (!this.observers.size) {\n            return Promise.resolve();\n        }\n        return this.reobserve({\n            // Reset options.fetchPolicy to its original value.\n            fetchPolicy: this.options.initialFetchPolicy,\n            variables: variables,\n        }, NetworkStatus.setVariables);\n    };\n    /**\n     * A function that enables you to update the query's cached result without executing a followup GraphQL operation.\n     *\n     * See [using updateQuery and updateFragment](https://www.apollographql.com/docs/react/caching/cache-interaction/#using-updatequery-and-updatefragment) for additional information.\n     */\n    ObservableQuery.prototype.updateQuery = function (mapFn) {\n        var queryManager = this.queryManager;\n        var result = queryManager.cache.diff({\n            query: this.options.query,\n            variables: this.variables,\n            returnPartialData: true,\n            optimistic: false,\n        }).result;\n        var newResult = mapFn(result, {\n            variables: this.variables,\n        });\n        if (newResult) {\n            queryManager.cache.writeQuery({\n                query: this.options.query,\n                data: newResult,\n                variables: this.variables,\n            });\n            queryManager.broadcastQueries();\n        }\n    };\n    /**\n     * A function that instructs the query to begin re-executing at a specified interval (in milliseconds).\n     */\n    ObservableQuery.prototype.startPolling = function (pollInterval) {\n        this.options.pollInterval = pollInterval;\n        this.updatePolling();\n    };\n    /**\n     * A function that instructs the query to stop polling after a previous call to `startPolling`.\n     */\n    ObservableQuery.prototype.stopPolling = function () {\n        this.options.pollInterval = 0;\n        this.updatePolling();\n    };\n    // Update options.fetchPolicy according to options.nextFetchPolicy.\n    ObservableQuery.prototype.applyNextFetchPolicy = function (reason, \n    // It's possible to use this method to apply options.nextFetchPolicy to\n    // options.fetchPolicy even if options !== this.options, though that happens\n    // most often when the options are temporary, used for only one request and\n    // then thrown away, so nextFetchPolicy may not end up mattering.\n    options) {\n        if (options.nextFetchPolicy) {\n            var _a = options.fetchPolicy, fetchPolicy = _a === void 0 ? \"cache-first\" : _a, _b = options.initialFetchPolicy, initialFetchPolicy = _b === void 0 ? fetchPolicy : _b;\n            if (fetchPolicy === \"standby\") {\n                // Do nothing, leaving options.fetchPolicy unchanged.\n            }\n            else if (typeof options.nextFetchPolicy === \"function\") {\n                // When someone chooses \"cache-and-network\" or \"network-only\" as their\n                // initial FetchPolicy, they often do not want future cache updates to\n                // trigger unconditional network requests, which is what repeatedly\n                // applying the \"cache-and-network\" or \"network-only\" policies would\n                // seem to imply. Instead, when the cache reports an update after the\n                // initial network request, it may be desirable for subsequent network\n                // requests to be triggered only if the cache result is incomplete. To\n                // that end, the options.nextFetchPolicy option provides an easy way to\n                // update options.fetchPolicy after the initial network request, without\n                // having to call observableQuery.setOptions.\n                options.fetchPolicy = options.nextFetchPolicy(fetchPolicy, {\n                    reason: reason,\n                    options: options,\n                    observable: this,\n                    initialFetchPolicy: initialFetchPolicy,\n                });\n            }\n            else if (reason === \"variables-changed\") {\n                options.fetchPolicy = initialFetchPolicy;\n            }\n            else {\n                options.fetchPolicy = options.nextFetchPolicy;\n            }\n        }\n        return options.fetchPolicy;\n    };\n    ObservableQuery.prototype.fetch = function (options, newNetworkStatus, query) {\n        // TODO Make sure we update the networkStatus (and infer fetchVariables)\n        // before actually committing to the fetch.\n        this.queryManager.setObservableQuery(this);\n        return this.queryManager[\"fetchConcastWithInfo\"](this.queryId, options, newNetworkStatus, query);\n    };\n    // Turns polling on or off based on this.options.pollInterval.\n    ObservableQuery.prototype.updatePolling = function () {\n        var _this = this;\n        // Avoid polling in SSR mode\n        if (this.queryManager.ssrMode) {\n            return;\n        }\n        var _a = this, pollingInfo = _a.pollingInfo, pollInterval = _a.options.pollInterval;\n        if (!pollInterval || !this.hasObservers()) {\n            if (pollingInfo) {\n                clearTimeout(pollingInfo.timeout);\n                delete this.pollingInfo;\n            }\n            return;\n        }\n        if (pollingInfo && pollingInfo.interval === pollInterval) {\n            return;\n        }\n        invariant(pollInterval, 23);\n        var info = pollingInfo || (this.pollingInfo = {});\n        info.interval = pollInterval;\n        var maybeFetch = function () {\n            var _a, _b;\n            if (_this.pollingInfo) {\n                if (!isNetworkRequestInFlight(_this.queryInfo.networkStatus) &&\n                    !((_b = (_a = _this.options).skipPollAttempt) === null || _b === void 0 ? void 0 : _b.call(_a))) {\n                    _this.reobserve({\n                        // Most fetchPolicy options don't make sense to use in a polling context, as\n                        // users wouldn't want to be polling the cache directly. However, network-only and\n                        // no-cache are both useful for when the user wants to control whether or not the\n                        // polled results are written to the cache.\n                        fetchPolicy: _this.options.initialFetchPolicy === \"no-cache\" ?\n                            \"no-cache\"\n                            : \"network-only\",\n                    }, NetworkStatus.poll).then(poll, poll);\n                }\n                else {\n                    poll();\n                }\n            }\n        };\n        var poll = function () {\n            var info = _this.pollingInfo;\n            if (info) {\n                clearTimeout(info.timeout);\n                info.timeout = setTimeout(maybeFetch, info.interval);\n            }\n        };\n        poll();\n    };\n    ObservableQuery.prototype.updateLastResult = function (newResult, variables) {\n        if (variables === void 0) { variables = this.variables; }\n        var error = this.getLastError();\n        // Preserve this.last.error unless the variables have changed.\n        if (error && this.last && !equal(variables, this.last.variables)) {\n            error = void 0;\n        }\n        return (this.last = __assign({ result: this.queryManager.assumeImmutableResults ?\n                newResult\n                : cloneDeep(newResult), variables: variables }, (error ? { error: error } : null)));\n    };\n    ObservableQuery.prototype.reobserveAsConcast = function (newOptions, newNetworkStatus) {\n        var _this = this;\n        this.isTornDown = false;\n        var useDisposableConcast = \n        // Refetching uses a disposable Concast to allow refetches using different\n        // options/variables, without permanently altering the options of the\n        // original ObservableQuery.\n        newNetworkStatus === NetworkStatus.refetch ||\n            // The fetchMore method does not actually call the reobserve method, but,\n            // if it did, it would definitely use a disposable Concast.\n            newNetworkStatus === NetworkStatus.fetchMore ||\n            // Polling uses a disposable Concast so the polling options (which force\n            // fetchPolicy to be \"network-only\" or \"no-cache\") won't override the original options.\n            newNetworkStatus === NetworkStatus.poll;\n        // Save the old variables, since Object.assign may modify them below.\n        var oldVariables = this.options.variables;\n        var oldFetchPolicy = this.options.fetchPolicy;\n        var mergedOptions = compact(this.options, newOptions || {});\n        var options = useDisposableConcast ?\n            // Disposable Concast fetches receive a shallow copy of this.options\n            // (merged with newOptions), leaving this.options unmodified.\n            mergedOptions\n            : assign(this.options, mergedOptions);\n        // Don't update options.query with the transformed query to avoid\n        // overwriting this.options.query when we aren't using a disposable concast.\n        // We want to ensure we can re-run the custom document transforms the next\n        // time a request is made against the original query.\n        var query = this.transformDocument(options.query);\n        this.lastQuery = query;\n        if (!useDisposableConcast) {\n            // We can skip calling updatePolling if we're not changing this.options.\n            this.updatePolling();\n            // Reset options.fetchPolicy to its original value when variables change,\n            // unless a new fetchPolicy was provided by newOptions.\n            if (newOptions &&\n                newOptions.variables &&\n                !equal(newOptions.variables, oldVariables) &&\n                // Don't mess with the fetchPolicy if it's currently \"standby\".\n                options.fetchPolicy !== \"standby\" &&\n                // If we're changing the fetchPolicy anyway, don't try to change it here\n                // using applyNextFetchPolicy. The explicit options.fetchPolicy wins.\n                (options.fetchPolicy === oldFetchPolicy ||\n                    // A `nextFetchPolicy` function has even higher priority, though,\n                    // so in that case `applyNextFetchPolicy` must be called.\n                    typeof options.nextFetchPolicy === \"function\")) {\n                this.applyNextFetchPolicy(\"variables-changed\", options);\n                if (newNetworkStatus === void 0) {\n                    newNetworkStatus = NetworkStatus.setVariables;\n                }\n            }\n        }\n        this.waitForOwnResult && (this.waitForOwnResult = skipCacheDataFor(options.fetchPolicy));\n        var finishWaitingForOwnResult = function () {\n            if (_this.concast === concast) {\n                _this.waitForOwnResult = false;\n            }\n        };\n        var variables = options.variables && __assign({}, options.variables);\n        var _a = this.fetch(options, newNetworkStatus, query), concast = _a.concast, fromLink = _a.fromLink;\n        var observer = {\n            next: function (result) {\n                if (equal(_this.variables, variables)) {\n                    finishWaitingForOwnResult();\n                    _this.reportResult(result, variables);\n                }\n            },\n            error: function (error) {\n                if (equal(_this.variables, variables)) {\n                    // Coming from `getResultsFromLink`, `error` here should always be an `ApolloError`.\n                    // However, calling `concast.cancel` can inject another type of error, so we have to\n                    // wrap it again here.\n                    if (!isApolloError(error)) {\n                        error = new ApolloError({ networkError: error });\n                    }\n                    finishWaitingForOwnResult();\n                    _this.reportError(error, variables);\n                }\n            },\n        };\n        if (!useDisposableConcast && (fromLink || !this.concast)) {\n            // We use the {add,remove}Observer methods directly to avoid wrapping\n            // observer with an unnecessary SubscriptionObserver object.\n            if (this.concast && this.observer) {\n                this.concast.removeObserver(this.observer);\n            }\n            this.concast = concast;\n            this.observer = observer;\n        }\n        concast.addObserver(observer);\n        return concast;\n    };\n    ObservableQuery.prototype.reobserve = function (newOptions, newNetworkStatus) {\n        return this.reobserveAsConcast(newOptions, newNetworkStatus)\n            .promise;\n    };\n    ObservableQuery.prototype.resubscribeAfterError = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        // If `lastError` is set in the current when the subscription is re-created,\n        // the subscription will immediately receive the error, which will\n        // cause it to terminate again. To avoid this, we first clear\n        // the last error/result from the `observableQuery` before re-starting\n        // the subscription, and restore the last value afterwards so that the\n        // subscription has a chance to stay open.\n        var last = this.last;\n        this.resetLastResults();\n        var subscription = this.subscribe.apply(this, args);\n        this.last = last;\n        return subscription;\n    };\n    // (Re)deliver the current result to this.observers without applying fetch\n    // policies or making network requests.\n    ObservableQuery.prototype.observe = function () {\n        this.reportResult(\n        // Passing false is important so that this.getCurrentResult doesn't\n        // save the fetchMore result as this.lastResult, causing it to be\n        // ignored due to the this.isDifferentFromLastResult check in\n        // this.reportResult.\n        this.getCurrentResult(false), this.variables);\n    };\n    ObservableQuery.prototype.reportResult = function (result, variables) {\n        var lastError = this.getLastError();\n        var isDifferent = this.isDifferentFromLastResult(result, variables);\n        // Update the last result even when isDifferentFromLastResult returns false,\n        // because the query may be using the @nonreactive directive, and we want to\n        // save the the latest version of any nonreactive subtrees (in case\n        // getCurrentResult is called), even though we skip broadcasting changes.\n        if (lastError || !result.partial || this.options.returnPartialData) {\n            this.updateLastResult(result, variables);\n        }\n        if (lastError || isDifferent) {\n            iterateObserversSafely(this.observers, \"next\", result);\n        }\n    };\n    ObservableQuery.prototype.reportError = function (error, variables) {\n        // Since we don't get the current result on errors, only the error, we\n        // must mirror the updates that occur in QueryStore.markQueryError here\n        var errorResult = __assign(__assign({}, this.getLastResult()), { error: error, errors: error.graphQLErrors, networkStatus: NetworkStatus.error, loading: false });\n        this.updateLastResult(errorResult, variables);\n        iterateObserversSafely(this.observers, \"error\", (this.last.error = error));\n    };\n    ObservableQuery.prototype.hasObservers = function () {\n        return this.observers.size > 0;\n    };\n    ObservableQuery.prototype.tearDownQuery = function () {\n        if (this.isTornDown)\n            return;\n        if (this.concast && this.observer) {\n            this.concast.removeObserver(this.observer);\n            delete this.concast;\n            delete this.observer;\n        }\n        this.stopPolling();\n        // stop all active GraphQL subscriptions\n        this.subscriptions.forEach(function (sub) { return sub.unsubscribe(); });\n        this.subscriptions.clear();\n        this.queryManager.stopQuery(this.queryId);\n        this.observers.clear();\n        this.isTornDown = true;\n    };\n    ObservableQuery.prototype.transformDocument = function (document) {\n        return this.queryManager.transform(document);\n    };\n    return ObservableQuery;\n}(Observable));\nexport { ObservableQuery };\n// Necessary because the ObservableQuery constructor has a different\n// signature than the Observable constructor.\nfixObservableSubclass(ObservableQuery);\n// Reobserve with fetchPolicy effectively set to \"cache-first\", triggering\n// delivery of any new data from the cache, possibly falling back to the network\n// if any cache data are missing. This allows _complete_ cache results to be\n// delivered without also kicking off unnecessary network requests when\n// this.options.fetchPolicy is \"cache-and-network\" or \"network-only\". When\n// this.options.fetchPolicy is any other policy (\"cache-first\", \"cache-only\",\n// \"standby\", or \"no-cache\"), we call this.reobserve() as usual.\nexport function reobserveCacheFirst(obsQuery) {\n    var _a = obsQuery.options, fetchPolicy = _a.fetchPolicy, nextFetchPolicy = _a.nextFetchPolicy;\n    if (fetchPolicy === \"cache-and-network\" || fetchPolicy === \"network-only\") {\n        return obsQuery.reobserve({\n            fetchPolicy: \"cache-first\",\n            // Use a temporary nextFetchPolicy function that replaces itself with the\n            // previous nextFetchPolicy value and returns the original fetchPolicy.\n            nextFetchPolicy: function (currentFetchPolicy, context) {\n                // Replace this nextFetchPolicy function in the options object with the\n                // original this.options.nextFetchPolicy value.\n                this.nextFetchPolicy = nextFetchPolicy;\n                // If the original nextFetchPolicy value was a function, give it a\n                // chance to decide what happens here.\n                if (typeof this.nextFetchPolicy === \"function\") {\n                    return this.nextFetchPolicy(currentFetchPolicy, context);\n                }\n                // Otherwise go back to the original this.options.fetchPolicy.\n                return fetchPolicy;\n            },\n        });\n    }\n    return obsQuery.reobserve();\n}\nfunction defaultSubscriptionObserverErrorCallback(error) {\n    globalThis.__DEV__ !== false && invariant.error(24, error.message, error.stack);\n}\nexport function logMissingFieldErrors(missing) {\n    if (globalThis.__DEV__ !== false && missing) {\n        globalThis.__DEV__ !== false && invariant.debug(25, missing);\n    }\n}\nfunction skipCacheDataFor(fetchPolicy /* `undefined` would mean `\"cache-first\"` */) {\n    return (fetchPolicy === \"network-only\" ||\n        fetchPolicy === \"no-cache\" ||\n        fetchPolicy === \"standby\");\n}\n//# sourceMappingURL=ObservableQuery.js.map","import { __assign } from \"tslib\";\nimport { equal } from \"@wry/equality\";\nimport { DeepMerger } from \"../utilities/index.js\";\nimport { mergeIncrementalData } from \"../utilities/index.js\";\nimport { reobserveCacheFirst } from \"./ObservableQuery.js\";\nimport { isNonEmptyArray, graphQLResultHasError, canUseWeakMap, } from \"../utilities/index.js\";\nimport { NetworkStatus, isNetworkRequestInFlight } from \"./networkStatus.js\";\nvar destructiveMethodCounts = new (canUseWeakMap ? WeakMap : Map)();\nfunction wrapDestructiveCacheMethod(cache, methodName) {\n    var original = cache[methodName];\n    if (typeof original === \"function\") {\n        // @ts-expect-error this is just too generic to be typed correctly\n        cache[methodName] = function () {\n            destructiveMethodCounts.set(cache, \n            // The %1e15 allows the count to wrap around to 0 safely every\n            // quadrillion evictions, so there's no risk of overflow. To be\n            // clear, this is more of a pedantic principle than something\n            // that matters in any conceivable practical scenario.\n            (destructiveMethodCounts.get(cache) + 1) % 1e15);\n            // @ts-expect-error this is just too generic to be typed correctly\n            return original.apply(this, arguments);\n        };\n    }\n}\nfunction cancelNotifyTimeout(info) {\n    if (info[\"notifyTimeout\"]) {\n        clearTimeout(info[\"notifyTimeout\"]);\n        info[\"notifyTimeout\"] = void 0;\n    }\n}\n// A QueryInfo object represents a single query managed by the\n// QueryManager, which tracks all QueryInfo objects by queryId in its\n// this.queries Map. QueryInfo objects store the latest results and errors\n// for the given query, and are responsible for reporting those results to\n// the corresponding ObservableQuery, via the QueryInfo.notify method.\n// Results are reported asynchronously whenever setDiff marks the\n// QueryInfo object as dirty, though a call to the QueryManager's\n// broadcastQueries method may trigger the notification before it happens\n// automatically. This class used to be a simple interface type without\n// any field privacy or meaningful methods, which is why it still has so\n// many public fields. The effort to lock down and simplify the QueryInfo\n// interface is ongoing, and further improvements are welcome.\nvar QueryInfo = /** @class */ (function () {\n    function QueryInfo(queryManager, queryId) {\n        if (queryId === void 0) { queryId = queryManager.generateQueryId(); }\n        this.queryId = queryId;\n        this.listeners = new Set();\n        this.document = null;\n        this.lastRequestId = 1;\n        this.stopped = false;\n        this.dirty = false;\n        this.observableQuery = null;\n        var cache = (this.cache = queryManager.cache);\n        // Track how often cache.evict is called, since we want eviction to\n        // override the feud-stopping logic in the markResult method, by\n        // causing shouldWrite to return true. Wrapping the cache.evict method\n        // is a bit of a hack, but it saves us from having to make eviction\n        // counting an official part of the ApolloCache API.\n        if (!destructiveMethodCounts.has(cache)) {\n            destructiveMethodCounts.set(cache, 0);\n            wrapDestructiveCacheMethod(cache, \"evict\");\n            wrapDestructiveCacheMethod(cache, \"modify\");\n            wrapDestructiveCacheMethod(cache, \"reset\");\n        }\n    }\n    QueryInfo.prototype.init = function (query) {\n        var networkStatus = query.networkStatus || NetworkStatus.loading;\n        if (this.variables &&\n            this.networkStatus !== NetworkStatus.loading &&\n            !equal(this.variables, query.variables)) {\n            networkStatus = NetworkStatus.setVariables;\n        }\n        if (!equal(query.variables, this.variables)) {\n            this.lastDiff = void 0;\n        }\n        Object.assign(this, {\n            document: query.document,\n            variables: query.variables,\n            networkError: null,\n            graphQLErrors: this.graphQLErrors || [],\n            networkStatus: networkStatus,\n        });\n        if (query.observableQuery) {\n            this.setObservableQuery(query.observableQuery);\n        }\n        if (query.lastRequestId) {\n            this.lastRequestId = query.lastRequestId;\n        }\n        return this;\n    };\n    QueryInfo.prototype.reset = function () {\n        cancelNotifyTimeout(this);\n        this.dirty = false;\n    };\n    QueryInfo.prototype.resetDiff = function () {\n        this.lastDiff = void 0;\n    };\n    QueryInfo.prototype.getDiff = function () {\n        var options = this.getDiffOptions();\n        if (this.lastDiff && equal(options, this.lastDiff.options)) {\n            return this.lastDiff.diff;\n        }\n        this.updateWatch(this.variables);\n        var oq = this.observableQuery;\n        if (oq && oq.options.fetchPolicy === \"no-cache\") {\n            return { complete: false };\n        }\n        var diff = this.cache.diff(options);\n        this.updateLastDiff(diff, options);\n        return diff;\n    };\n    QueryInfo.prototype.updateLastDiff = function (diff, options) {\n        this.lastDiff =\n            diff ?\n                {\n                    diff: diff,\n                    options: options || this.getDiffOptions(),\n                }\n                : void 0;\n    };\n    QueryInfo.prototype.getDiffOptions = function (variables) {\n        var _a;\n        if (variables === void 0) { variables = this.variables; }\n        return {\n            query: this.document,\n            variables: variables,\n            returnPartialData: true,\n            optimistic: true,\n            canonizeResults: (_a = this.observableQuery) === null || _a === void 0 ? void 0 : _a.options.canonizeResults,\n        };\n    };\n    QueryInfo.prototype.setDiff = function (diff) {\n        var _this = this;\n        var _a;\n        var oldDiff = this.lastDiff && this.lastDiff.diff;\n        // If we are trying to deliver an incomplete cache result, we avoid\n        // reporting it if the query has errored, otherwise we let the broadcast try\n        // and repair the partial result by refetching the query. This check avoids\n        // a situation where a query that errors and another succeeds with\n        // overlapping data does not report the partial data result to the errored\n        // query.\n        //\n        // See https://github.com/apollographql/apollo-client/issues/11400 for more\n        // information on this issue.\n        if (diff && !diff.complete && ((_a = this.observableQuery) === null || _a === void 0 ? void 0 : _a.getLastError())) {\n            return;\n        }\n        this.updateLastDiff(diff);\n        if (!this.dirty && !equal(oldDiff && oldDiff.result, diff && diff.result)) {\n            this.dirty = true;\n            if (!this.notifyTimeout) {\n                this.notifyTimeout = setTimeout(function () { return _this.notify(); }, 0);\n            }\n        }\n    };\n    QueryInfo.prototype.setObservableQuery = function (oq) {\n        var _this = this;\n        if (oq === this.observableQuery)\n            return;\n        if (this.oqListener) {\n            this.listeners.delete(this.oqListener);\n        }\n        this.observableQuery = oq;\n        if (oq) {\n            oq[\"queryInfo\"] = this;\n            this.listeners.add((this.oqListener = function () {\n                var diff = _this.getDiff();\n                if (diff.fromOptimisticTransaction) {\n                    // If this diff came from an optimistic transaction, deliver the\n                    // current cache data to the ObservableQuery, but don't perform a\n                    // reobservation, since oq.reobserveCacheFirst might make a network\n                    // request, and we never want to trigger network requests in the\n                    // middle of optimistic updates.\n                    oq[\"observe\"]();\n                }\n                else {\n                    // Otherwise, make the ObservableQuery \"reobserve\" the latest data\n                    // using a temporary fetch policy of \"cache-first\", so complete cache\n                    // results have a chance to be delivered without triggering additional\n                    // network requests, even when options.fetchPolicy is \"network-only\"\n                    // or \"cache-and-network\". All other fetch policies are preserved by\n                    // this method, and are handled by calling oq.reobserve(). If this\n                    // reobservation is spurious, isDifferentFromLastResult still has a\n                    // chance to catch it before delivery to ObservableQuery subscribers.\n                    reobserveCacheFirst(oq);\n                }\n            }));\n        }\n        else {\n            delete this.oqListener;\n        }\n    };\n    QueryInfo.prototype.notify = function () {\n        var _this = this;\n        cancelNotifyTimeout(this);\n        if (this.shouldNotify()) {\n            this.listeners.forEach(function (listener) { return listener(_this); });\n        }\n        this.dirty = false;\n    };\n    QueryInfo.prototype.shouldNotify = function () {\n        if (!this.dirty || !this.listeners.size) {\n            return false;\n        }\n        if (isNetworkRequestInFlight(this.networkStatus) && this.observableQuery) {\n            var fetchPolicy = this.observableQuery.options.fetchPolicy;\n            if (fetchPolicy !== \"cache-only\" && fetchPolicy !== \"cache-and-network\") {\n                return false;\n            }\n        }\n        return true;\n    };\n    QueryInfo.prototype.stop = function () {\n        if (!this.stopped) {\n            this.stopped = true;\n            // Cancel the pending notify timeout\n            this.reset();\n            this.cancel();\n            // Revert back to the no-op version of cancel inherited from\n            // QueryInfo.prototype.\n            this.cancel = QueryInfo.prototype.cancel;\n            var oq = this.observableQuery;\n            if (oq)\n                oq.stopPolling();\n        }\n    };\n    // This method is a no-op by default, until/unless overridden by the\n    // updateWatch method.\n    QueryInfo.prototype.cancel = function () { };\n    QueryInfo.prototype.updateWatch = function (variables) {\n        var _this = this;\n        if (variables === void 0) { variables = this.variables; }\n        var oq = this.observableQuery;\n        if (oq && oq.options.fetchPolicy === \"no-cache\") {\n            return;\n        }\n        var watchOptions = __assign(__assign({}, this.getDiffOptions(variables)), { watcher: this, callback: function (diff) { return _this.setDiff(diff); } });\n        if (!this.lastWatch || !equal(watchOptions, this.lastWatch)) {\n            this.cancel();\n            this.cancel = this.cache.watch((this.lastWatch = watchOptions));\n        }\n    };\n    QueryInfo.prototype.resetLastWrite = function () {\n        this.lastWrite = void 0;\n    };\n    QueryInfo.prototype.shouldWrite = function (result, variables) {\n        var lastWrite = this.lastWrite;\n        return !(lastWrite &&\n            // If cache.evict has been called since the last time we wrote this\n            // data into the cache, there's a chance writing this result into\n            // the cache will repair what was evicted.\n            lastWrite.dmCount === destructiveMethodCounts.get(this.cache) &&\n            equal(variables, lastWrite.variables) &&\n            equal(result.data, lastWrite.result.data));\n    };\n    QueryInfo.prototype.markResult = function (result, document, options, cacheWriteBehavior) {\n        var _this = this;\n        var merger = new DeepMerger();\n        var graphQLErrors = isNonEmptyArray(result.errors) ? result.errors.slice(0) : [];\n        // Cancel the pending notify timeout (if it exists) to prevent extraneous network\n        // requests. To allow future notify timeouts, diff and dirty are reset as well.\n        this.reset();\n        if (\"incremental\" in result && isNonEmptyArray(result.incremental)) {\n            var mergedData = mergeIncrementalData(this.getDiff().result, result);\n            result.data = mergedData;\n            // Detect the first chunk of a deferred query and merge it with existing\n            // cache data. This ensures a `cache-first` fetch policy that returns\n            // partial cache data or a `cache-and-network` fetch policy that already\n            // has full data in the cache does not complain when trying to merge the\n            // initial deferred server data with existing cache data.\n        }\n        else if (\"hasNext\" in result && result.hasNext) {\n            var diff = this.getDiff();\n            result.data = merger.merge(diff.result, result.data);\n        }\n        this.graphQLErrors = graphQLErrors;\n        if (options.fetchPolicy === \"no-cache\") {\n            this.updateLastDiff({ result: result.data, complete: true }, this.getDiffOptions(options.variables));\n        }\n        else if (cacheWriteBehavior !== 0 /* CacheWriteBehavior.FORBID */) {\n            if (shouldWriteResult(result, options.errorPolicy)) {\n                // Using a transaction here so we have a chance to read the result\n                // back from the cache before the watch callback fires as a result\n                // of writeQuery, so we can store the new diff quietly and ignore\n                // it when we receive it redundantly from the watch callback.\n                this.cache.performTransaction(function (cache) {\n                    if (_this.shouldWrite(result, options.variables)) {\n                        cache.writeQuery({\n                            query: document,\n                            data: result.data,\n                            variables: options.variables,\n                            overwrite: cacheWriteBehavior === 1 /* CacheWriteBehavior.OVERWRITE */,\n                        });\n                        _this.lastWrite = {\n                            result: result,\n                            variables: options.variables,\n                            dmCount: destructiveMethodCounts.get(_this.cache),\n                        };\n                    }\n                    else {\n                        // If result is the same as the last result we received from\n                        // the network (and the variables match too), avoid writing\n                        // result into the cache again. The wisdom of skipping this\n                        // cache write is far from obvious, since any cache write\n                        // could be the one that puts the cache back into a desired\n                        // state, fixing corruption or missing data. However, if we\n                        // always write every network result into the cache, we enable\n                        // feuds between queries competing to update the same data in\n                        // incompatible ways, which can lead to an endless cycle of\n                        // cache broadcasts and useless network requests. As with any\n                        // feud, eventually one side must step back from the brink,\n                        // letting the other side(s) have the last word(s). There may\n                        // be other points where we could break this cycle, such as\n                        // silencing the broadcast for cache.writeQuery (not a good\n                        // idea, since it just delays the feud a bit) or somehow\n                        // avoiding the network request that just happened (also bad,\n                        // because the server could return useful new data). All\n                        // options considered, skipping this cache write seems to be\n                        // the least damaging place to break the cycle, because it\n                        // reflects the intuition that we recently wrote this exact\n                        // result into the cache, so the cache *should* already/still\n                        // contain this data. If some other query has clobbered that\n                        // data in the meantime, that's too bad, but there will be no\n                        // winners if every query blindly reverts to its own version\n                        // of the data. This approach also gives the network a chance\n                        // to return new data, which will be written into the cache as\n                        // usual, notifying only those queries that are directly\n                        // affected by the cache updates, as usual. In the future, an\n                        // even more sophisticated cache could perhaps prevent or\n                        // mitigate the clobbering somehow, but that would make this\n                        // particular cache write even less important, and thus\n                        // skipping it would be even safer than it is today.\n                        if (_this.lastDiff && _this.lastDiff.diff.complete) {\n                            // Reuse data from the last good (complete) diff that we\n                            // received, when possible.\n                            result.data = _this.lastDiff.diff.result;\n                            return;\n                        }\n                        // If the previous this.diff was incomplete, fall through to\n                        // re-reading the latest data with cache.diff, below.\n                    }\n                    var diffOptions = _this.getDiffOptions(options.variables);\n                    var diff = cache.diff(diffOptions);\n                    // In case the QueryManager stops this QueryInfo before its\n                    // results are delivered, it's important to avoid restarting the\n                    // cache watch when markResult is called. We also avoid updating\n                    // the watch if we are writing a result that doesn't match the current\n                    // variables to avoid race conditions from broadcasting the wrong\n                    // result.\n                    if (!_this.stopped && equal(_this.variables, options.variables)) {\n                        // Any time we're about to update this.diff, we need to make\n                        // sure we've started watching the cache.\n                        _this.updateWatch(options.variables);\n                    }\n                    // If we're allowed to write to the cache, and we can read a\n                    // complete result from the cache, update result.data to be the\n                    // result from the cache, rather than the raw network result.\n                    // Set without setDiff to avoid triggering a notify call, since\n                    // we have other ways of notifying for this result.\n                    _this.updateLastDiff(diff, diffOptions);\n                    if (diff.complete) {\n                        result.data = diff.result;\n                    }\n                });\n            }\n            else {\n                this.lastWrite = void 0;\n            }\n        }\n    };\n    QueryInfo.prototype.markReady = function () {\n        this.networkError = null;\n        return (this.networkStatus = NetworkStatus.ready);\n    };\n    QueryInfo.prototype.markError = function (error) {\n        this.networkStatus = NetworkStatus.error;\n        this.lastWrite = void 0;\n        this.reset();\n        if (error.graphQLErrors) {\n            this.graphQLErrors = error.graphQLErrors;\n        }\n        if (error.networkError) {\n            this.networkError = error.networkError;\n        }\n        return error;\n    };\n    return QueryInfo;\n}());\nexport { QueryInfo };\nexport function shouldWriteResult(result, errorPolicy) {\n    if (errorPolicy === void 0) { errorPolicy = \"none\"; }\n    var ignoreErrors = errorPolicy === \"ignore\" || errorPolicy === \"all\";\n    var writeWithErrors = !graphQLResultHasError(result);\n    if (!writeWithErrors && ignoreErrors && result.data) {\n        writeWithErrors = true;\n    }\n    return writeWithErrors;\n}\n//# sourceMappingURL=QueryInfo.js.map","import { __assign, __awaiter, __generator } from \"tslib\";\nimport { invariant, newInvariantError } from \"../utilities/globals/index.js\";\nimport { equal } from \"@wry/equality\";\nimport { execute } from \"../link/core/index.js\";\nimport { hasDirectives, isExecutionPatchIncrementalResult, isExecutionPatchResult, removeDirectivesFromDocument, } from \"../utilities/index.js\";\nimport { canonicalStringify } from \"../cache/index.js\";\nimport { getDefaultValues, getOperationDefinition, getOperationName, hasClientExports, graphQLResultHasError, getGraphQLErrorsFromResult, Observable, asyncMap, isNonEmptyArray, Concast, makeUniqueId, isDocumentNode, isNonNullObject, DocumentTransform, } from \"../utilities/index.js\";\nimport { mergeIncrementalData } from \"../utilities/common/incrementalResult.js\";\nimport { ApolloError, isApolloError, graphQLResultHasProtocolErrors, } from \"../errors/index.js\";\nimport { ObservableQuery, logMissingFieldErrors } from \"./ObservableQuery.js\";\nimport { NetworkStatus, isNetworkRequestInFlight } from \"./networkStatus.js\";\nimport { QueryInfo, shouldWriteResult, } from \"./QueryInfo.js\";\nimport { PROTOCOL_ERRORS_SYMBOL } from \"../errors/index.js\";\nimport { print } from \"../utilities/index.js\";\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nvar IGNORE = Object.create(null);\nimport { Trie } from \"@wry/trie\";\nimport { AutoCleanedWeakCache, cacheSizes } from \"../utilities/index.js\";\nvar QueryManager = /** @class */ (function () {\n    function QueryManager(options) {\n        var _this = this;\n        this.clientAwareness = {};\n        // All the queries that the QueryManager is currently managing (not\n        // including mutations and subscriptions).\n        this.queries = new Map();\n        // Maps from queryId strings to Promise rejection functions for\n        // currently active queries and fetches.\n        // Use protected instead of private field so\n        // @apollo/experimental-nextjs-app-support can access type info.\n        this.fetchCancelFns = new Map();\n        this.transformCache = new AutoCleanedWeakCache(cacheSizes[\"queryManager.getDocumentInfo\"] ||\n            2000 /* defaultCacheSizes[\"queryManager.getDocumentInfo\"] */);\n        this.queryIdCounter = 1;\n        this.requestIdCounter = 1;\n        this.mutationIdCounter = 1;\n        // Use protected instead of private field so\n        // @apollo/experimental-nextjs-app-support can access type info.\n        this.inFlightLinkObservables = new Trie(false);\n        var defaultDocumentTransform = new DocumentTransform(function (document) { return _this.cache.transformDocument(document); }, \n        // Allow the apollo cache to manage its own transform caches\n        { cache: false });\n        this.cache = options.cache;\n        this.link = options.link;\n        this.defaultOptions = options.defaultOptions;\n        this.queryDeduplication = options.queryDeduplication;\n        this.clientAwareness = options.clientAwareness;\n        this.localState = options.localState;\n        this.ssrMode = options.ssrMode;\n        this.assumeImmutableResults = options.assumeImmutableResults;\n        var documentTransform = options.documentTransform;\n        this.documentTransform =\n            documentTransform ?\n                defaultDocumentTransform\n                    .concat(documentTransform)\n                    // The custom document transform may add new fragment spreads or new\n                    // field selections, so we want to give the cache a chance to run\n                    // again. For example, the InMemoryCache adds __typename to field\n                    // selections and fragments from the fragment registry.\n                    .concat(defaultDocumentTransform)\n                : defaultDocumentTransform;\n        this.defaultContext = options.defaultContext || Object.create(null);\n        if ((this.onBroadcast = options.onBroadcast)) {\n            this.mutationStore = Object.create(null);\n        }\n    }\n    /**\n     * Call this method to terminate any active query processes, making it safe\n     * to dispose of this QueryManager instance.\n     */\n    QueryManager.prototype.stop = function () {\n        var _this = this;\n        this.queries.forEach(function (_info, queryId) {\n            _this.stopQueryNoBroadcast(queryId);\n        });\n        this.cancelPendingFetches(newInvariantError(26));\n    };\n    QueryManager.prototype.cancelPendingFetches = function (error) {\n        this.fetchCancelFns.forEach(function (cancel) { return cancel(error); });\n        this.fetchCancelFns.clear();\n    };\n    QueryManager.prototype.mutate = function (_a) {\n        return __awaiter(this, arguments, void 0, function (_b) {\n            var mutationId, hasClientExports, mutationStoreValue, isOptimistic, self;\n            var _c, _d;\n            var mutation = _b.mutation, variables = _b.variables, optimisticResponse = _b.optimisticResponse, updateQueries = _b.updateQueries, _e = _b.refetchQueries, refetchQueries = _e === void 0 ? [] : _e, _f = _b.awaitRefetchQueries, awaitRefetchQueries = _f === void 0 ? false : _f, updateWithProxyFn = _b.update, onQueryUpdated = _b.onQueryUpdated, _g = _b.fetchPolicy, fetchPolicy = _g === void 0 ? ((_c = this.defaultOptions.mutate) === null || _c === void 0 ? void 0 : _c.fetchPolicy) || \"network-only\" : _g, _h = _b.errorPolicy, errorPolicy = _h === void 0 ? ((_d = this.defaultOptions.mutate) === null || _d === void 0 ? void 0 : _d.errorPolicy) || \"none\" : _h, keepRootFields = _b.keepRootFields, context = _b.context;\n            return __generator(this, function (_j) {\n                switch (_j.label) {\n                    case 0:\n                        invariant(mutation, 27);\n                        invariant(fetchPolicy === \"network-only\" || fetchPolicy === \"no-cache\", 28);\n                        mutationId = this.generateMutationId();\n                        mutation = this.cache.transformForLink(this.transform(mutation));\n                        hasClientExports = this.getDocumentInfo(mutation).hasClientExports;\n                        variables = this.getVariables(mutation, variables);\n                        if (!hasClientExports) return [3 /*break*/, 2];\n                        return [4 /*yield*/, this.localState.addExportedVariables(mutation, variables, context)];\n                    case 1:\n                        variables = (_j.sent());\n                        _j.label = 2;\n                    case 2:\n                        mutationStoreValue = this.mutationStore &&\n                            (this.mutationStore[mutationId] = {\n                                mutation: mutation,\n                                variables: variables,\n                                loading: true,\n                                error: null,\n                            });\n                        isOptimistic = optimisticResponse &&\n                            this.markMutationOptimistic(optimisticResponse, {\n                                mutationId: mutationId,\n                                document: mutation,\n                                variables: variables,\n                                fetchPolicy: fetchPolicy,\n                                errorPolicy: errorPolicy,\n                                context: context,\n                                updateQueries: updateQueries,\n                                update: updateWithProxyFn,\n                                keepRootFields: keepRootFields,\n                            });\n                        this.broadcastQueries();\n                        self = this;\n                        return [2 /*return*/, new Promise(function (resolve, reject) {\n                                return asyncMap(self.getObservableFromLink(mutation, __assign(__assign({}, context), { optimisticResponse: isOptimistic ? optimisticResponse : void 0 }), variables, {}, false), function (result) {\n                                    if (graphQLResultHasError(result) && errorPolicy === \"none\") {\n                                        throw new ApolloError({\n                                            graphQLErrors: getGraphQLErrorsFromResult(result),\n                                        });\n                                    }\n                                    if (mutationStoreValue) {\n                                        mutationStoreValue.loading = false;\n                                        mutationStoreValue.error = null;\n                                    }\n                                    var storeResult = __assign({}, result);\n                                    if (typeof refetchQueries === \"function\") {\n                                        refetchQueries = refetchQueries(storeResult);\n                                    }\n                                    if (errorPolicy === \"ignore\" && graphQLResultHasError(storeResult)) {\n                                        delete storeResult.errors;\n                                    }\n                                    return self.markMutationResult({\n                                        mutationId: mutationId,\n                                        result: storeResult,\n                                        document: mutation,\n                                        variables: variables,\n                                        fetchPolicy: fetchPolicy,\n                                        errorPolicy: errorPolicy,\n                                        context: context,\n                                        update: updateWithProxyFn,\n                                        updateQueries: updateQueries,\n                                        awaitRefetchQueries: awaitRefetchQueries,\n                                        refetchQueries: refetchQueries,\n                                        removeOptimistic: isOptimistic ? mutationId : void 0,\n                                        onQueryUpdated: onQueryUpdated,\n                                        keepRootFields: keepRootFields,\n                                    });\n                                }).subscribe({\n                                    next: function (storeResult) {\n                                        self.broadcastQueries();\n                                        // Since mutations might receive multiple payloads from the\n                                        // ApolloLink chain (e.g. when used with @defer),\n                                        // we resolve with a SingleExecutionResult or after the final\n                                        // ExecutionPatchResult has arrived and we have assembled the\n                                        // multipart response into a single result.\n                                        if (!(\"hasNext\" in storeResult) || storeResult.hasNext === false) {\n                                            resolve(storeResult);\n                                        }\n                                    },\n                                    error: function (err) {\n                                        if (mutationStoreValue) {\n                                            mutationStoreValue.loading = false;\n                                            mutationStoreValue.error = err;\n                                        }\n                                        if (isOptimistic) {\n                                            self.cache.removeOptimistic(mutationId);\n                                        }\n                                        self.broadcastQueries();\n                                        reject(err instanceof ApolloError ? err : (new ApolloError({\n                                            networkError: err,\n                                        })));\n                                    },\n                                });\n                            })];\n                }\n            });\n        });\n    };\n    QueryManager.prototype.markMutationResult = function (mutation, cache) {\n        var _this = this;\n        if (cache === void 0) { cache = this.cache; }\n        var result = mutation.result;\n        var cacheWrites = [];\n        var skipCache = mutation.fetchPolicy === \"no-cache\";\n        if (!skipCache && shouldWriteResult(result, mutation.errorPolicy)) {\n            if (!isExecutionPatchIncrementalResult(result)) {\n                cacheWrites.push({\n                    result: result.data,\n                    dataId: \"ROOT_MUTATION\",\n                    query: mutation.document,\n                    variables: mutation.variables,\n                });\n            }\n            if (isExecutionPatchIncrementalResult(result) &&\n                isNonEmptyArray(result.incremental)) {\n                var diff = cache.diff({\n                    id: \"ROOT_MUTATION\",\n                    // The cache complains if passed a mutation where it expects a\n                    // query, so we transform mutations and subscriptions to queries\n                    // (only once, thanks to this.transformCache).\n                    query: this.getDocumentInfo(mutation.document).asQuery,\n                    variables: mutation.variables,\n                    optimistic: false,\n                    returnPartialData: true,\n                });\n                var mergedData = void 0;\n                if (diff.result) {\n                    mergedData = mergeIncrementalData(diff.result, result);\n                }\n                if (typeof mergedData !== \"undefined\") {\n                    // cast the ExecutionPatchResult to FetchResult here since\n                    // ExecutionPatchResult never has `data` when returned from the server\n                    result.data = mergedData;\n                    cacheWrites.push({\n                        result: mergedData,\n                        dataId: \"ROOT_MUTATION\",\n                        query: mutation.document,\n                        variables: mutation.variables,\n                    });\n                }\n            }\n            var updateQueries_1 = mutation.updateQueries;\n            if (updateQueries_1) {\n                this.queries.forEach(function (_a, queryId) {\n                    var observableQuery = _a.observableQuery;\n                    var queryName = observableQuery && observableQuery.queryName;\n                    if (!queryName || !hasOwnProperty.call(updateQueries_1, queryName)) {\n                        return;\n                    }\n                    var updater = updateQueries_1[queryName];\n                    var _b = _this.queries.get(queryId), document = _b.document, variables = _b.variables;\n                    // Read the current query result from the store.\n                    var _c = cache.diff({\n                        query: document,\n                        variables: variables,\n                        returnPartialData: true,\n                        optimistic: false,\n                    }), currentQueryResult = _c.result, complete = _c.complete;\n                    if (complete && currentQueryResult) {\n                        // Run our reducer using the current query result and the mutation result.\n                        var nextQueryResult = updater(currentQueryResult, {\n                            mutationResult: result,\n                            queryName: (document && getOperationName(document)) || void 0,\n                            queryVariables: variables,\n                        });\n                        // Write the modified result back into the store if we got a new result.\n                        if (nextQueryResult) {\n                            cacheWrites.push({\n                                result: nextQueryResult,\n                                dataId: \"ROOT_QUERY\",\n                                query: document,\n                                variables: variables,\n                            });\n                        }\n                    }\n                });\n            }\n        }\n        if (cacheWrites.length > 0 ||\n            (mutation.refetchQueries || \"\").length > 0 ||\n            mutation.update ||\n            mutation.onQueryUpdated ||\n            mutation.removeOptimistic) {\n            var results_1 = [];\n            this.refetchQueries({\n                updateCache: function (cache) {\n                    if (!skipCache) {\n                        cacheWrites.forEach(function (write) { return cache.write(write); });\n                    }\n                    // If the mutation has some writes associated with it then we need to\n                    // apply those writes to the store by running this reducer again with\n                    // a write action.\n                    var update = mutation.update;\n                    // Determine whether result is a SingleExecutionResult,\n                    // or the final ExecutionPatchResult.\n                    var isFinalResult = !isExecutionPatchResult(result) ||\n                        (isExecutionPatchIncrementalResult(result) && !result.hasNext);\n                    if (update) {\n                        if (!skipCache) {\n                            // Re-read the ROOT_MUTATION data we just wrote into the cache\n                            // (the first cache.write call in the cacheWrites.forEach loop\n                            // above), so field read functions have a chance to run for\n                            // fields within mutation result objects.\n                            var diff = cache.diff({\n                                id: \"ROOT_MUTATION\",\n                                // The cache complains if passed a mutation where it expects a\n                                // query, so we transform mutations and subscriptions to queries\n                                // (only once, thanks to this.transformCache).\n                                query: _this.getDocumentInfo(mutation.document).asQuery,\n                                variables: mutation.variables,\n                                optimistic: false,\n                                returnPartialData: true,\n                            });\n                            if (diff.complete) {\n                                result = __assign(__assign({}, result), { data: diff.result });\n                                if (\"incremental\" in result) {\n                                    delete result.incremental;\n                                }\n                                if (\"hasNext\" in result) {\n                                    delete result.hasNext;\n                                }\n                            }\n                        }\n                        // If we've received the whole response,\n                        // either a SingleExecutionResult or the final ExecutionPatchResult,\n                        // call the update function.\n                        if (isFinalResult) {\n                            update(cache, result, {\n                                context: mutation.context,\n                                variables: mutation.variables,\n                            });\n                        }\n                    }\n                    // TODO Do this with cache.evict({ id: 'ROOT_MUTATION' }) but make it\n                    // shallow to allow rolling back optimistic evictions.\n                    if (!skipCache && !mutation.keepRootFields && isFinalResult) {\n                        cache.modify({\n                            id: \"ROOT_MUTATION\",\n                            fields: function (value, _a) {\n                                var fieldName = _a.fieldName, DELETE = _a.DELETE;\n                                return fieldName === \"__typename\" ? value : DELETE;\n                            },\n                        });\n                    }\n                },\n                include: mutation.refetchQueries,\n                // Write the final mutation.result to the root layer of the cache.\n                optimistic: false,\n                // Remove the corresponding optimistic layer at the same time as we\n                // write the final non-optimistic result.\n                removeOptimistic: mutation.removeOptimistic,\n                // Let the caller of client.mutate optionally determine the refetching\n                // behavior for watched queries after the mutation.update function runs.\n                // If no onQueryUpdated function was provided for this mutation, pass\n                // null instead of undefined to disable the default refetching behavior.\n                onQueryUpdated: mutation.onQueryUpdated || null,\n            }).forEach(function (result) { return results_1.push(result); });\n            if (mutation.awaitRefetchQueries || mutation.onQueryUpdated) {\n                // Returning a promise here makes the mutation await that promise, so we\n                // include results in that promise's work if awaitRefetchQueries or an\n                // onQueryUpdated function was specified.\n                return Promise.all(results_1).then(function () { return result; });\n            }\n        }\n        return Promise.resolve(result);\n    };\n    QueryManager.prototype.markMutationOptimistic = function (optimisticResponse, mutation) {\n        var _this = this;\n        var data = typeof optimisticResponse === \"function\" ?\n            optimisticResponse(mutation.variables, { IGNORE: IGNORE })\n            : optimisticResponse;\n        if (data === IGNORE) {\n            return false;\n        }\n        this.cache.recordOptimisticTransaction(function (cache) {\n            try {\n                _this.markMutationResult(__assign(__assign({}, mutation), { result: { data: data } }), cache);\n            }\n            catch (error) {\n                globalThis.__DEV__ !== false && invariant.error(error);\n            }\n        }, mutation.mutationId);\n        return true;\n    };\n    QueryManager.prototype.fetchQuery = function (queryId, options, networkStatus) {\n        return this.fetchConcastWithInfo(queryId, options, networkStatus).concast\n            .promise;\n    };\n    QueryManager.prototype.getQueryStore = function () {\n        var store = Object.create(null);\n        this.queries.forEach(function (info, queryId) {\n            store[queryId] = {\n                variables: info.variables,\n                networkStatus: info.networkStatus,\n                networkError: info.networkError,\n                graphQLErrors: info.graphQLErrors,\n            };\n        });\n        return store;\n    };\n    QueryManager.prototype.resetErrors = function (queryId) {\n        var queryInfo = this.queries.get(queryId);\n        if (queryInfo) {\n            queryInfo.networkError = undefined;\n            queryInfo.graphQLErrors = [];\n        }\n    };\n    QueryManager.prototype.transform = function (document) {\n        return this.documentTransform.transformDocument(document);\n    };\n    QueryManager.prototype.getDocumentInfo = function (document) {\n        var transformCache = this.transformCache;\n        if (!transformCache.has(document)) {\n            var cacheEntry = {\n                // TODO These three calls (hasClientExports, shouldForceResolvers, and\n                // usesNonreactiveDirective) are performing independent full traversals\n                // of the transformed document. We should consider merging these\n                // traversals into a single pass in the future, though the work is\n                // cached after the first time.\n                hasClientExports: hasClientExports(document),\n                hasForcedResolvers: this.localState.shouldForceResolvers(document),\n                hasNonreactiveDirective: hasDirectives([\"nonreactive\"], document),\n                clientQuery: this.localState.clientQuery(document),\n                serverQuery: removeDirectivesFromDocument([\n                    { name: \"client\", remove: true },\n                    { name: \"connection\" },\n                    { name: \"nonreactive\" },\n                ], document),\n                defaultVars: getDefaultValues(getOperationDefinition(document)),\n                // Transform any mutation or subscription operations to query operations\n                // so we can read/write them from/to the cache.\n                asQuery: __assign(__assign({}, document), { definitions: document.definitions.map(function (def) {\n                        if (def.kind === \"OperationDefinition\" &&\n                            def.operation !== \"query\") {\n                            return __assign(__assign({}, def), { operation: \"query\" });\n                        }\n                        return def;\n                    }) }),\n            };\n            transformCache.set(document, cacheEntry);\n        }\n        return transformCache.get(document);\n    };\n    QueryManager.prototype.getVariables = function (document, variables) {\n        return __assign(__assign({}, this.getDocumentInfo(document).defaultVars), variables);\n    };\n    QueryManager.prototype.watchQuery = function (options) {\n        var query = this.transform(options.query);\n        // assign variable default values if supplied\n        // NOTE: We don't modify options.query here with the transformed query to\n        // ensure observable.options.query is set to the raw untransformed query.\n        options = __assign(__assign({}, options), { variables: this.getVariables(query, options.variables) });\n        if (typeof options.notifyOnNetworkStatusChange === \"undefined\") {\n            options.notifyOnNetworkStatusChange = false;\n        }\n        var queryInfo = new QueryInfo(this);\n        var observable = new ObservableQuery({\n            queryManager: this,\n            queryInfo: queryInfo,\n            options: options,\n        });\n        observable[\"lastQuery\"] = query;\n        this.queries.set(observable.queryId, queryInfo);\n        // We give queryInfo the transformed query to ensure the first cache diff\n        // uses the transformed query instead of the raw query\n        queryInfo.init({\n            document: query,\n            observableQuery: observable,\n            variables: observable.variables,\n        });\n        return observable;\n    };\n    QueryManager.prototype.query = function (options, queryId) {\n        var _this = this;\n        if (queryId === void 0) { queryId = this.generateQueryId(); }\n        invariant(options.query, 29);\n        invariant(options.query.kind === \"Document\", 30);\n        invariant(!options.returnPartialData, 31);\n        invariant(!options.pollInterval, 32);\n        return this.fetchQuery(queryId, __assign(__assign({}, options), { query: this.transform(options.query) })).finally(function () { return _this.stopQuery(queryId); });\n    };\n    QueryManager.prototype.generateQueryId = function () {\n        return String(this.queryIdCounter++);\n    };\n    QueryManager.prototype.generateRequestId = function () {\n        return this.requestIdCounter++;\n    };\n    QueryManager.prototype.generateMutationId = function () {\n        return String(this.mutationIdCounter++);\n    };\n    QueryManager.prototype.stopQueryInStore = function (queryId) {\n        this.stopQueryInStoreNoBroadcast(queryId);\n        this.broadcastQueries();\n    };\n    QueryManager.prototype.stopQueryInStoreNoBroadcast = function (queryId) {\n        var queryInfo = this.queries.get(queryId);\n        if (queryInfo)\n            queryInfo.stop();\n    };\n    QueryManager.prototype.clearStore = function (options) {\n        if (options === void 0) { options = {\n            discardWatches: true,\n        }; }\n        // Before we have sent the reset action to the store, we can no longer\n        // rely on the results returned by in-flight requests since these may\n        // depend on values that previously existed in the data portion of the\n        // store. So, we cancel the promises and observers that we have issued\n        // so far and not yet resolved (in the case of queries).\n        this.cancelPendingFetches(newInvariantError(33));\n        this.queries.forEach(function (queryInfo) {\n            if (queryInfo.observableQuery) {\n                // Set loading to true so listeners don't trigger unless they want\n                // results with partial data.\n                queryInfo.networkStatus = NetworkStatus.loading;\n            }\n            else {\n                queryInfo.stop();\n            }\n        });\n        if (this.mutationStore) {\n            this.mutationStore = Object.create(null);\n        }\n        // begin removing data from the store\n        return this.cache.reset(options);\n    };\n    QueryManager.prototype.getObservableQueries = function (include) {\n        var _this = this;\n        if (include === void 0) { include = \"active\"; }\n        var queries = new Map();\n        var queryNamesAndDocs = new Map();\n        var legacyQueryOptions = new Set();\n        if (Array.isArray(include)) {\n            include.forEach(function (desc) {\n                if (typeof desc === \"string\") {\n                    queryNamesAndDocs.set(desc, false);\n                }\n                else if (isDocumentNode(desc)) {\n                    queryNamesAndDocs.set(_this.transform(desc), false);\n                }\n                else if (isNonNullObject(desc) && desc.query) {\n                    legacyQueryOptions.add(desc);\n                }\n            });\n        }\n        this.queries.forEach(function (_a, queryId) {\n            var oq = _a.observableQuery, document = _a.document;\n            if (oq) {\n                if (include === \"all\") {\n                    queries.set(queryId, oq);\n                    return;\n                }\n                var queryName = oq.queryName, fetchPolicy = oq.options.fetchPolicy;\n                if (fetchPolicy === \"standby\" ||\n                    (include === \"active\" && !oq.hasObservers())) {\n                    return;\n                }\n                if (include === \"active\" ||\n                    (queryName && queryNamesAndDocs.has(queryName)) ||\n                    (document && queryNamesAndDocs.has(document))) {\n                    queries.set(queryId, oq);\n                    if (queryName)\n                        queryNamesAndDocs.set(queryName, true);\n                    if (document)\n                        queryNamesAndDocs.set(document, true);\n                }\n            }\n        });\n        if (legacyQueryOptions.size) {\n            legacyQueryOptions.forEach(function (options) {\n                // We will be issuing a fresh network request for this query, so we\n                // pre-allocate a new query ID here, using a special prefix to enable\n                // cleaning up these temporary queries later, after fetching.\n                var queryId = makeUniqueId(\"legacyOneTimeQuery\");\n                var queryInfo = _this.getQuery(queryId).init({\n                    document: options.query,\n                    variables: options.variables,\n                });\n                var oq = new ObservableQuery({\n                    queryManager: _this,\n                    queryInfo: queryInfo,\n                    options: __assign(__assign({}, options), { fetchPolicy: \"network-only\" }),\n                });\n                invariant(oq.queryId === queryId);\n                queryInfo.setObservableQuery(oq);\n                queries.set(queryId, oq);\n            });\n        }\n        if (globalThis.__DEV__ !== false && queryNamesAndDocs.size) {\n            queryNamesAndDocs.forEach(function (included, nameOrDoc) {\n                if (!included) {\n                    globalThis.__DEV__ !== false && invariant.warn(typeof nameOrDoc === \"string\" ? 34 : 35, nameOrDoc);\n                }\n            });\n        }\n        return queries;\n    };\n    QueryManager.prototype.reFetchObservableQueries = function (includeStandby) {\n        var _this = this;\n        if (includeStandby === void 0) { includeStandby = false; }\n        var observableQueryPromises = [];\n        this.getObservableQueries(includeStandby ? \"all\" : \"active\").forEach(function (observableQuery, queryId) {\n            var fetchPolicy = observableQuery.options.fetchPolicy;\n            observableQuery.resetLastResults();\n            if (includeStandby ||\n                (fetchPolicy !== \"standby\" && fetchPolicy !== \"cache-only\")) {\n                observableQueryPromises.push(observableQuery.refetch());\n            }\n            _this.getQuery(queryId).setDiff(null);\n        });\n        this.broadcastQueries();\n        return Promise.all(observableQueryPromises);\n    };\n    QueryManager.prototype.setObservableQuery = function (observableQuery) {\n        this.getQuery(observableQuery.queryId).setObservableQuery(observableQuery);\n    };\n    QueryManager.prototype.startGraphQLSubscription = function (_a) {\n        var _this = this;\n        var query = _a.query, fetchPolicy = _a.fetchPolicy, _b = _a.errorPolicy, errorPolicy = _b === void 0 ? \"none\" : _b, variables = _a.variables, _c = _a.context, context = _c === void 0 ? {} : _c, _d = _a.extensions, extensions = _d === void 0 ? {} : _d;\n        query = this.transform(query);\n        variables = this.getVariables(query, variables);\n        var makeObservable = function (variables) {\n            return _this.getObservableFromLink(query, context, variables, extensions).map(function (result) {\n                if (fetchPolicy !== \"no-cache\") {\n                    // the subscription interface should handle not sending us results we no longer subscribe to.\n                    // XXX I don't think we ever send in an object with errors, but we might in the future...\n                    if (shouldWriteResult(result, errorPolicy)) {\n                        _this.cache.write({\n                            query: query,\n                            result: result.data,\n                            dataId: \"ROOT_SUBSCRIPTION\",\n                            variables: variables,\n                        });\n                    }\n                    _this.broadcastQueries();\n                }\n                var hasErrors = graphQLResultHasError(result);\n                var hasProtocolErrors = graphQLResultHasProtocolErrors(result);\n                if (hasErrors || hasProtocolErrors) {\n                    var errors = {};\n                    if (hasErrors) {\n                        errors.graphQLErrors = result.errors;\n                    }\n                    if (hasProtocolErrors) {\n                        errors.protocolErrors = result.extensions[PROTOCOL_ERRORS_SYMBOL];\n                    }\n                    // `errorPolicy` is a mechanism for handling GraphQL errors, according\n                    // to our documentation, so we throw protocol errors regardless of the\n                    // set error policy.\n                    if (errorPolicy === \"none\" || hasProtocolErrors) {\n                        throw new ApolloError(errors);\n                    }\n                }\n                if (errorPolicy === \"ignore\") {\n                    delete result.errors;\n                }\n                return result;\n            });\n        };\n        if (this.getDocumentInfo(query).hasClientExports) {\n            var observablePromise_1 = this.localState\n                .addExportedVariables(query, variables, context)\n                .then(makeObservable);\n            return new Observable(function (observer) {\n                var sub = null;\n                observablePromise_1.then(function (observable) { return (sub = observable.subscribe(observer)); }, observer.error);\n                return function () { return sub && sub.unsubscribe(); };\n            });\n        }\n        return makeObservable(variables);\n    };\n    QueryManager.prototype.stopQuery = function (queryId) {\n        this.stopQueryNoBroadcast(queryId);\n        this.broadcastQueries();\n    };\n    QueryManager.prototype.stopQueryNoBroadcast = function (queryId) {\n        this.stopQueryInStoreNoBroadcast(queryId);\n        this.removeQuery(queryId);\n    };\n    QueryManager.prototype.removeQuery = function (queryId) {\n        // teardown all links\n        // Both `QueryManager.fetchRequest` and `QueryManager.query` create separate promises\n        // that each add their reject functions to fetchCancelFns.\n        // A query created with `QueryManager.query()` could trigger a `QueryManager.fetchRequest`.\n        // The same queryId could have two rejection fns for two promises\n        this.fetchCancelFns.delete(queryId);\n        if (this.queries.has(queryId)) {\n            this.getQuery(queryId).stop();\n            this.queries.delete(queryId);\n        }\n    };\n    QueryManager.prototype.broadcastQueries = function () {\n        if (this.onBroadcast)\n            this.onBroadcast();\n        this.queries.forEach(function (info) { return info.notify(); });\n    };\n    QueryManager.prototype.getLocalState = function () {\n        return this.localState;\n    };\n    QueryManager.prototype.getObservableFromLink = function (query, context, variables, extensions, \n    // Prefer context.queryDeduplication if specified.\n    deduplication) {\n        var _this = this;\n        var _a;\n        if (deduplication === void 0) { deduplication = (_a = context === null || context === void 0 ? void 0 : context.queryDeduplication) !== null && _a !== void 0 ? _a : this.queryDeduplication; }\n        var observable;\n        var _b = this.getDocumentInfo(query), serverQuery = _b.serverQuery, clientQuery = _b.clientQuery;\n        if (serverQuery) {\n            var _c = this, inFlightLinkObservables_1 = _c.inFlightLinkObservables, link = _c.link;\n            var operation = {\n                query: serverQuery,\n                variables: variables,\n                operationName: getOperationName(serverQuery) || void 0,\n                context: this.prepareContext(__assign(__assign({}, context), { forceFetch: !deduplication })),\n                extensions: extensions,\n            };\n            context = operation.context;\n            if (deduplication) {\n                var printedServerQuery_1 = print(serverQuery);\n                var varJson_1 = canonicalStringify(variables);\n                var entry = inFlightLinkObservables_1.lookup(printedServerQuery_1, varJson_1);\n                observable = entry.observable;\n                if (!observable) {\n                    var concast = new Concast([\n                        execute(link, operation),\n                    ]);\n                    observable = entry.observable = concast;\n                    concast.beforeNext(function () {\n                        inFlightLinkObservables_1.remove(printedServerQuery_1, varJson_1);\n                    });\n                }\n            }\n            else {\n                observable = new Concast([\n                    execute(link, operation),\n                ]);\n            }\n        }\n        else {\n            observable = new Concast([Observable.of({ data: {} })]);\n            context = this.prepareContext(context);\n        }\n        if (clientQuery) {\n            observable = asyncMap(observable, function (result) {\n                return _this.localState.runResolvers({\n                    document: clientQuery,\n                    remoteResult: result,\n                    context: context,\n                    variables: variables,\n                });\n            });\n        }\n        return observable;\n    };\n    QueryManager.prototype.getResultsFromLink = function (queryInfo, cacheWriteBehavior, options) {\n        var requestId = (queryInfo.lastRequestId = this.generateRequestId());\n        // Performing transformForLink here gives this.cache a chance to fill in\n        // missing fragment definitions (for example) before sending this document\n        // through the link chain.\n        var linkDocument = this.cache.transformForLink(options.query);\n        return asyncMap(this.getObservableFromLink(linkDocument, options.context, options.variables), function (result) {\n            var graphQLErrors = getGraphQLErrorsFromResult(result);\n            var hasErrors = graphQLErrors.length > 0;\n            var errorPolicy = options.errorPolicy;\n            // If we interrupted this request by calling getResultsFromLink again\n            // with the same QueryInfo object, we ignore the old results.\n            if (requestId >= queryInfo.lastRequestId) {\n                if (hasErrors && errorPolicy === \"none\") {\n                    // Throwing here effectively calls observer.error.\n                    throw queryInfo.markError(new ApolloError({\n                        graphQLErrors: graphQLErrors,\n                    }));\n                }\n                // Use linkDocument rather than queryInfo.document so the\n                // operation/fragments used to write the result are the same as the\n                // ones used to obtain it from the link.\n                queryInfo.markResult(result, linkDocument, options, cacheWriteBehavior);\n                queryInfo.markReady();\n            }\n            var aqr = {\n                data: result.data,\n                loading: false,\n                networkStatus: NetworkStatus.ready,\n            };\n            // In the case we start multiple network requests simulatenously, we\n            // want to ensure we properly set `data` if we're reporting on an old\n            // result which will not be caught by the conditional above that ends up\n            // throwing the markError result.\n            if (hasErrors && errorPolicy === \"none\") {\n                aqr.data = void 0;\n            }\n            if (hasErrors && errorPolicy !== \"ignore\") {\n                aqr.errors = graphQLErrors;\n                aqr.networkStatus = NetworkStatus.error;\n            }\n            return aqr;\n        }, function (networkError) {\n            var error = isApolloError(networkError) ? networkError : (new ApolloError({ networkError: networkError }));\n            // Avoid storing errors from older interrupted queries.\n            if (requestId >= queryInfo.lastRequestId) {\n                queryInfo.markError(error);\n            }\n            throw error;\n        });\n    };\n    QueryManager.prototype.fetchConcastWithInfo = function (queryId, options, \n    // The initial networkStatus for this fetch, most often\n    // NetworkStatus.loading, but also possibly fetchMore, poll, refetch,\n    // or setVariables.\n    networkStatus, query) {\n        var _this = this;\n        if (networkStatus === void 0) { networkStatus = NetworkStatus.loading; }\n        if (query === void 0) { query = options.query; }\n        var variables = this.getVariables(query, options.variables);\n        var queryInfo = this.getQuery(queryId);\n        var defaults = this.defaultOptions.watchQuery;\n        var _a = options.fetchPolicy, fetchPolicy = _a === void 0 ? (defaults && defaults.fetchPolicy) || \"cache-first\" : _a, _b = options.errorPolicy, errorPolicy = _b === void 0 ? (defaults && defaults.errorPolicy) || \"none\" : _b, _c = options.returnPartialData, returnPartialData = _c === void 0 ? false : _c, _d = options.notifyOnNetworkStatusChange, notifyOnNetworkStatusChange = _d === void 0 ? false : _d, _e = options.context, context = _e === void 0 ? {} : _e;\n        var normalized = Object.assign({}, options, {\n            query: query,\n            variables: variables,\n            fetchPolicy: fetchPolicy,\n            errorPolicy: errorPolicy,\n            returnPartialData: returnPartialData,\n            notifyOnNetworkStatusChange: notifyOnNetworkStatusChange,\n            context: context,\n        });\n        var fromVariables = function (variables) {\n            // Since normalized is always a fresh copy of options, it's safe to\n            // modify its properties here, rather than creating yet another new\n            // WatchQueryOptions object.\n            normalized.variables = variables;\n            var sourcesWithInfo = _this.fetchQueryByPolicy(queryInfo, normalized, networkStatus);\n            if (\n            // If we're in standby, postpone advancing options.fetchPolicy using\n            // applyNextFetchPolicy.\n            normalized.fetchPolicy !== \"standby\" &&\n                // The \"standby\" policy currently returns [] from fetchQueryByPolicy, so\n                // this is another way to detect when nothing was done/fetched.\n                sourcesWithInfo.sources.length > 0 &&\n                queryInfo.observableQuery) {\n                queryInfo.observableQuery[\"applyNextFetchPolicy\"](\"after-fetch\", options);\n            }\n            return sourcesWithInfo;\n        };\n        // This cancel function needs to be set before the concast is created,\n        // in case concast creation synchronously cancels the request.\n        var cleanupCancelFn = function () { return _this.fetchCancelFns.delete(queryId); };\n        this.fetchCancelFns.set(queryId, function (reason) {\n            cleanupCancelFn();\n            // This delay ensures the concast variable has been initialized.\n            setTimeout(function () { return concast.cancel(reason); });\n        });\n        var concast, containsDataFromLink;\n        // If the query has @export(as: ...) directives, then we need to\n        // process those directives asynchronously. When there are no\n        // @export directives (the common case), we deliberately avoid\n        // wrapping the result of this.fetchQueryByPolicy in a Promise,\n        // since the timing of result delivery is (unfortunately) important\n        // for backwards compatibility. TODO This code could be simpler if\n        // we deprecated and removed LocalState.\n        if (this.getDocumentInfo(normalized.query).hasClientExports) {\n            concast = new Concast(this.localState\n                .addExportedVariables(normalized.query, normalized.variables, normalized.context)\n                .then(fromVariables)\n                .then(function (sourcesWithInfo) { return sourcesWithInfo.sources; }));\n            // there is just no way we can synchronously get the *right* value here,\n            // so we will assume `true`, which is the behaviour before the bug fix in\n            // #10597. This means that bug is not fixed in that case, and is probably\n            // un-fixable with reasonable effort for the edge case of @export as\n            // directives.\n            containsDataFromLink = true;\n        }\n        else {\n            var sourcesWithInfo = fromVariables(normalized.variables);\n            containsDataFromLink = sourcesWithInfo.fromLink;\n            concast = new Concast(sourcesWithInfo.sources);\n        }\n        concast.promise.then(cleanupCancelFn, cleanupCancelFn);\n        return {\n            concast: concast,\n            fromLink: containsDataFromLink,\n        };\n    };\n    QueryManager.prototype.refetchQueries = function (_a) {\n        var _this = this;\n        var updateCache = _a.updateCache, include = _a.include, _b = _a.optimistic, optimistic = _b === void 0 ? false : _b, _c = _a.removeOptimistic, removeOptimistic = _c === void 0 ? optimistic ? makeUniqueId(\"refetchQueries\") : void 0 : _c, onQueryUpdated = _a.onQueryUpdated;\n        var includedQueriesById = new Map();\n        if (include) {\n            this.getObservableQueries(include).forEach(function (oq, queryId) {\n                includedQueriesById.set(queryId, {\n                    oq: oq,\n                    lastDiff: _this.getQuery(queryId).getDiff(),\n                });\n            });\n        }\n        var results = new Map();\n        if (updateCache) {\n            this.cache.batch({\n                update: updateCache,\n                // Since you can perform any combination of cache reads and/or writes in\n                // the cache.batch update function, its optimistic option can be either\n                // a boolean or a string, representing three distinct modes of\n                // operation:\n                //\n                // * false: read/write only the root layer\n                // * true: read/write the topmost layer\n                // * string: read/write a fresh optimistic layer with that ID string\n                //\n                // When typeof optimistic === \"string\", a new optimistic layer will be\n                // temporarily created within cache.batch with that string as its ID. If\n                // we then pass that same string as the removeOptimistic option, we can\n                // make cache.batch immediately remove the optimistic layer after\n                // running the updateCache function, triggering only one broadcast.\n                //\n                // However, the refetchQueries method accepts only true or false for its\n                // optimistic option (not string). We interpret true to mean a temporary\n                // optimistic layer should be created, to allow efficiently rolling back\n                // the effect of the updateCache function, which involves passing a\n                // string instead of true as the optimistic option to cache.batch, when\n                // refetchQueries receives optimistic: true.\n                //\n                // In other words, we are deliberately not supporting the use case of\n                // writing to an *existing* optimistic layer (using the refetchQueries\n                // updateCache function), since that would potentially interfere with\n                // other optimistic updates in progress. Instead, you can read/write\n                // only the root layer by passing optimistic: false to refetchQueries,\n                // or you can read/write a brand new optimistic layer that will be\n                // automatically removed by passing optimistic: true.\n                optimistic: (optimistic && removeOptimistic) || false,\n                // The removeOptimistic option can also be provided by itself, even if\n                // optimistic === false, to remove some previously-added optimistic\n                // layer safely and efficiently, like we do in markMutationResult.\n                //\n                // If an explicit removeOptimistic string is provided with optimistic:\n                // true, the removeOptimistic string will determine the ID of the\n                // temporary optimistic layer, in case that ever matters.\n                removeOptimistic: removeOptimistic,\n                onWatchUpdated: function (watch, diff, lastDiff) {\n                    var oq = watch.watcher instanceof QueryInfo && watch.watcher.observableQuery;\n                    if (oq) {\n                        if (onQueryUpdated) {\n                            // Since we're about to handle this query now, remove it from\n                            // includedQueriesById, in case it was added earlier because of\n                            // options.include.\n                            includedQueriesById.delete(oq.queryId);\n                            var result = onQueryUpdated(oq, diff, lastDiff);\n                            if (result === true) {\n                                // The onQueryUpdated function requested the default refetching\n                                // behavior by returning true.\n                                result = oq.refetch();\n                            }\n                            // Record the result in the results Map, as long as onQueryUpdated\n                            // did not return false to skip/ignore this result.\n                            if (result !== false) {\n                                results.set(oq, result);\n                            }\n                            // Allow the default cache broadcast to happen, except when\n                            // onQueryUpdated returns false.\n                            return result;\n                        }\n                        if (onQueryUpdated !== null) {\n                            // If we don't have an onQueryUpdated function, and onQueryUpdated\n                            // was not disabled by passing null, make sure this query is\n                            // \"included\" like any other options.include-specified query.\n                            includedQueriesById.set(oq.queryId, { oq: oq, lastDiff: lastDiff, diff: diff });\n                        }\n                    }\n                },\n            });\n        }\n        if (includedQueriesById.size) {\n            includedQueriesById.forEach(function (_a, queryId) {\n                var oq = _a.oq, lastDiff = _a.lastDiff, diff = _a.diff;\n                var result;\n                // If onQueryUpdated is provided, we want to use it for all included\n                // queries, even the QueryOptions ones.\n                if (onQueryUpdated) {\n                    if (!diff) {\n                        var info = oq[\"queryInfo\"];\n                        info.reset(); // Force info.getDiff() to read from cache.\n                        diff = info.getDiff();\n                    }\n                    result = onQueryUpdated(oq, diff, lastDiff);\n                }\n                // Otherwise, we fall back to refetching.\n                if (!onQueryUpdated || result === true) {\n                    result = oq.refetch();\n                }\n                if (result !== false) {\n                    results.set(oq, result);\n                }\n                if (queryId.indexOf(\"legacyOneTimeQuery\") >= 0) {\n                    _this.stopQueryNoBroadcast(queryId);\n                }\n            });\n        }\n        if (removeOptimistic) {\n            // In case no updateCache callback was provided (so cache.batch was not\n            // called above, and thus did not already remove the optimistic layer),\n            // remove it here. Since this is a no-op when the layer has already been\n            // removed, we do it even if we called cache.batch above, since it's\n            // possible this.cache is an instance of some ApolloCache subclass other\n            // than InMemoryCache, and does not fully support the removeOptimistic\n            // option for cache.batch.\n            this.cache.removeOptimistic(removeOptimistic);\n        }\n        return results;\n    };\n    QueryManager.prototype.fetchQueryByPolicy = function (queryInfo, _a, \n    // The initial networkStatus for this fetch, most often\n    // NetworkStatus.loading, but also possibly fetchMore, poll, refetch,\n    // or setVariables.\n    networkStatus) {\n        var _this = this;\n        var query = _a.query, variables = _a.variables, fetchPolicy = _a.fetchPolicy, refetchWritePolicy = _a.refetchWritePolicy, errorPolicy = _a.errorPolicy, returnPartialData = _a.returnPartialData, context = _a.context, notifyOnNetworkStatusChange = _a.notifyOnNetworkStatusChange;\n        var oldNetworkStatus = queryInfo.networkStatus;\n        queryInfo.init({\n            document: query,\n            variables: variables,\n            networkStatus: networkStatus,\n        });\n        var readCache = function () { return queryInfo.getDiff(); };\n        var resultsFromCache = function (diff, networkStatus) {\n            if (networkStatus === void 0) { networkStatus = queryInfo.networkStatus || NetworkStatus.loading; }\n            var data = diff.result;\n            if (globalThis.__DEV__ !== false && !returnPartialData && !equal(data, {})) {\n                logMissingFieldErrors(diff.missing);\n            }\n            var fromData = function (data) {\n                return Observable.of(__assign({ data: data, loading: isNetworkRequestInFlight(networkStatus), networkStatus: networkStatus }, (diff.complete ? null : { partial: true })));\n            };\n            if (data && _this.getDocumentInfo(query).hasForcedResolvers) {\n                return _this.localState\n                    .runResolvers({\n                    document: query,\n                    remoteResult: { data: data },\n                    context: context,\n                    variables: variables,\n                    onlyRunForcedResolvers: true,\n                })\n                    .then(function (resolved) { return fromData(resolved.data || void 0); });\n            }\n            // Resolves https://github.com/apollographql/apollo-client/issues/10317.\n            // If errorPolicy is 'none' and notifyOnNetworkStatusChange is true,\n            // data was incorrectly returned from the cache on refetch:\n            // if diff.missing exists, we should not return cache data.\n            if (errorPolicy === \"none\" &&\n                networkStatus === NetworkStatus.refetch &&\n                Array.isArray(diff.missing)) {\n                return fromData(void 0);\n            }\n            return fromData(data);\n        };\n        var cacheWriteBehavior = fetchPolicy === \"no-cache\" ? 0 /* CacheWriteBehavior.FORBID */\n            // Watched queries must opt into overwriting existing data on refetch,\n            // by passing refetchWritePolicy: \"overwrite\" in their WatchQueryOptions.\n            : (networkStatus === NetworkStatus.refetch &&\n                refetchWritePolicy !== \"merge\") ?\n                1 /* CacheWriteBehavior.OVERWRITE */\n                : 2 /* CacheWriteBehavior.MERGE */;\n        var resultsFromLink = function () {\n            return _this.getResultsFromLink(queryInfo, cacheWriteBehavior, {\n                query: query,\n                variables: variables,\n                context: context,\n                fetchPolicy: fetchPolicy,\n                errorPolicy: errorPolicy,\n            });\n        };\n        var shouldNotify = notifyOnNetworkStatusChange &&\n            typeof oldNetworkStatus === \"number\" &&\n            oldNetworkStatus !== networkStatus &&\n            isNetworkRequestInFlight(networkStatus);\n        switch (fetchPolicy) {\n            default:\n            case \"cache-first\": {\n                var diff = readCache();\n                if (diff.complete) {\n                    return {\n                        fromLink: false,\n                        sources: [resultsFromCache(diff, queryInfo.markReady())],\n                    };\n                }\n                if (returnPartialData || shouldNotify) {\n                    return {\n                        fromLink: true,\n                        sources: [resultsFromCache(diff), resultsFromLink()],\n                    };\n                }\n                return { fromLink: true, sources: [resultsFromLink()] };\n            }\n            case \"cache-and-network\": {\n                var diff = readCache();\n                if (diff.complete || returnPartialData || shouldNotify) {\n                    return {\n                        fromLink: true,\n                        sources: [resultsFromCache(diff), resultsFromLink()],\n                    };\n                }\n                return { fromLink: true, sources: [resultsFromLink()] };\n            }\n            case \"cache-only\":\n                return {\n                    fromLink: false,\n                    sources: [resultsFromCache(readCache(), queryInfo.markReady())],\n                };\n            case \"network-only\":\n                if (shouldNotify) {\n                    return {\n                        fromLink: true,\n                        sources: [resultsFromCache(readCache()), resultsFromLink()],\n                    };\n                }\n                return { fromLink: true, sources: [resultsFromLink()] };\n            case \"no-cache\":\n                if (shouldNotify) {\n                    return {\n                        fromLink: true,\n                        // Note that queryInfo.getDiff() for no-cache queries does not call\n                        // cache.diff, but instead returns a { complete: false } stub result\n                        // when there is no queryInfo.diff already defined.\n                        sources: [resultsFromCache(queryInfo.getDiff()), resultsFromLink()],\n                    };\n                }\n                return { fromLink: true, sources: [resultsFromLink()] };\n            case \"standby\":\n                return { fromLink: false, sources: [] };\n        }\n    };\n    QueryManager.prototype.getQuery = function (queryId) {\n        if (queryId && !this.queries.has(queryId)) {\n            this.queries.set(queryId, new QueryInfo(this, queryId));\n        }\n        return this.queries.get(queryId);\n    };\n    QueryManager.prototype.prepareContext = function (context) {\n        if (context === void 0) { context = {}; }\n        var newContext = this.localState.prepareContext(context);\n        return __assign(__assign(__assign({}, this.defaultContext), newContext), { clientAwareness: this.clientAwareness });\n    };\n    return QueryManager;\n}());\nexport { QueryManager };\n//# sourceMappingURL=QueryManager.js.map","import { Kind } from './kinds.mjs';\nexport function isDefinitionNode(node) {\n  return (\n    isExecutableDefinitionNode(node) ||\n    isTypeSystemDefinitionNode(node) ||\n    isTypeSystemExtensionNode(node)\n  );\n}\nexport function isExecutableDefinitionNode(node) {\n  return (\n    node.kind === Kind.OPERATION_DEFINITION ||\n    node.kind === Kind.FRAGMENT_DEFINITION\n  );\n}\nexport function isSelectionNode(node) {\n  return (\n    node.kind === Kind.FIELD ||\n    node.kind === Kind.FRAGMENT_SPREAD ||\n    node.kind === Kind.INLINE_FRAGMENT\n  );\n}\nexport function isValueNode(node) {\n  return (\n    node.kind === Kind.VARIABLE ||\n    node.kind === Kind.INT ||\n    node.kind === Kind.FLOAT ||\n    node.kind === Kind.STRING ||\n    node.kind === Kind.BOOLEAN ||\n    node.kind === Kind.NULL ||\n    node.kind === Kind.ENUM ||\n    node.kind === Kind.LIST ||\n    node.kind === Kind.OBJECT\n  );\n}\nexport function isConstValueNode(node) {\n  return (\n    isValueNode(node) &&\n    (node.kind === Kind.LIST\n      ? node.values.some(isConstValueNode)\n      : node.kind === Kind.OBJECT\n      ? node.fields.some((field) => isConstValueNode(field.value))\n      : node.kind !== Kind.VARIABLE)\n  );\n}\nexport function isTypeNode(node) {\n  return (\n    node.kind === Kind.NAMED_TYPE ||\n    node.kind === Kind.LIST_TYPE ||\n    node.kind === Kind.NON_NULL_TYPE\n  );\n}\nexport function isTypeSystemDefinitionNode(node) {\n  return (\n    node.kind === Kind.SCHEMA_DEFINITION ||\n    isTypeDefinitionNode(node) ||\n    node.kind === Kind.DIRECTIVE_DEFINITION\n  );\n}\nexport function isTypeDefinitionNode(node) {\n  return (\n    node.kind === Kind.SCALAR_TYPE_DEFINITION ||\n    node.kind === Kind.OBJECT_TYPE_DEFINITION ||\n    node.kind === Kind.INTERFACE_TYPE_DEFINITION ||\n    node.kind === Kind.UNION_TYPE_DEFINITION ||\n    node.kind === Kind.ENUM_TYPE_DEFINITION ||\n    node.kind === Kind.INPUT_OBJECT_TYPE_DEFINITION\n  );\n}\nexport function isTypeSystemExtensionNode(node) {\n  return node.kind === Kind.SCHEMA_EXTENSION || isTypeExtensionNode(node);\n}\nexport function isTypeExtensionNode(node) {\n  return (\n    node.kind === Kind.SCALAR_TYPE_EXTENSION ||\n    node.kind === Kind.OBJECT_TYPE_EXTENSION ||\n    node.kind === Kind.INTERFACE_TYPE_EXTENSION ||\n    node.kind === Kind.UNION_TYPE_EXTENSION ||\n    node.kind === Kind.ENUM_TYPE_EXTENSION ||\n    node.kind === Kind.INPUT_OBJECT_TYPE_EXTENSION\n  );\n}\n","import { __assign, __awaiter, __generator } from \"tslib\";\nimport { invariant } from \"../utilities/globals/index.js\";\nimport { visit, BREAK, isSelectionNode } from \"graphql\";\nimport { argumentsObjectFromField, buildQueryFromSelectionSet, createFragmentMap, getFragmentDefinitions, getMainDefinition, hasDirectives, isField, isInlineFragment, mergeDeep, mergeDeepArray, removeClientSetsFromDocument, resultKeyNameFromField, shouldInclude, } from \"../utilities/index.js\";\nimport { cacheSlot } from \"../cache/index.js\";\nvar LocalState = /** @class */ (function () {\n    function LocalState(_a) {\n        var cache = _a.cache, client = _a.client, resolvers = _a.resolvers, fragmentMatcher = _a.fragmentMatcher;\n        this.selectionsToResolveCache = new WeakMap();\n        this.cache = cache;\n        if (client) {\n            this.client = client;\n        }\n        if (resolvers) {\n            this.addResolvers(resolvers);\n        }\n        if (fragmentMatcher) {\n            this.setFragmentMatcher(fragmentMatcher);\n        }\n    }\n    LocalState.prototype.addResolvers = function (resolvers) {\n        var _this = this;\n        this.resolvers = this.resolvers || {};\n        if (Array.isArray(resolvers)) {\n            resolvers.forEach(function (resolverGroup) {\n                _this.resolvers = mergeDeep(_this.resolvers, resolverGroup);\n            });\n        }\n        else {\n            this.resolvers = mergeDeep(this.resolvers, resolvers);\n        }\n    };\n    LocalState.prototype.setResolvers = function (resolvers) {\n        this.resolvers = {};\n        this.addResolvers(resolvers);\n    };\n    LocalState.prototype.getResolvers = function () {\n        return this.resolvers || {};\n    };\n    // Run local client resolvers against the incoming query and remote data.\n    // Locally resolved field values are merged with the incoming remote data,\n    // and returned. Note that locally resolved fields will overwrite\n    // remote data using the same field name.\n    LocalState.prototype.runResolvers = function (_a) {\n        return __awaiter(this, arguments, void 0, function (_b) {\n            var document = _b.document, remoteResult = _b.remoteResult, context = _b.context, variables = _b.variables, _c = _b.onlyRunForcedResolvers, onlyRunForcedResolvers = _c === void 0 ? false : _c;\n            return __generator(this, function (_d) {\n                if (document) {\n                    return [2 /*return*/, this.resolveDocument(document, remoteResult.data, context, variables, this.fragmentMatcher, onlyRunForcedResolvers).then(function (localResult) { return (__assign(__assign({}, remoteResult), { data: localResult.result })); })];\n                }\n                return [2 /*return*/, remoteResult];\n            });\n        });\n    };\n    LocalState.prototype.setFragmentMatcher = function (fragmentMatcher) {\n        this.fragmentMatcher = fragmentMatcher;\n    };\n    LocalState.prototype.getFragmentMatcher = function () {\n        return this.fragmentMatcher;\n    };\n    // Client queries contain everything in the incoming document (if a @client\n    // directive is found).\n    LocalState.prototype.clientQuery = function (document) {\n        if (hasDirectives([\"client\"], document)) {\n            if (this.resolvers) {\n                return document;\n            }\n        }\n        return null;\n    };\n    // Server queries are stripped of all @client based selection sets.\n    LocalState.prototype.serverQuery = function (document) {\n        return removeClientSetsFromDocument(document);\n    };\n    LocalState.prototype.prepareContext = function (context) {\n        var cache = this.cache;\n        return __assign(__assign({}, context), { cache: cache, \n            // Getting an entry's cache key is useful for local state resolvers.\n            getCacheKey: function (obj) {\n                return cache.identify(obj);\n            } });\n    };\n    // To support `@client @export(as: \"someVar\")` syntax, we'll first resolve\n    // @client @export fields locally, then pass the resolved values back to be\n    // used alongside the original operation variables.\n    LocalState.prototype.addExportedVariables = function (document_1) {\n        return __awaiter(this, arguments, void 0, function (document, variables, context) {\n            if (variables === void 0) { variables = {}; }\n            if (context === void 0) { context = {}; }\n            return __generator(this, function (_a) {\n                if (document) {\n                    return [2 /*return*/, this.resolveDocument(document, this.buildRootValueFromCache(document, variables) || {}, this.prepareContext(context), variables).then(function (data) { return (__assign(__assign({}, variables), data.exportedVariables)); })];\n                }\n                return [2 /*return*/, __assign({}, variables)];\n            });\n        });\n    };\n    LocalState.prototype.shouldForceResolvers = function (document) {\n        var forceResolvers = false;\n        visit(document, {\n            Directive: {\n                enter: function (node) {\n                    if (node.name.value === \"client\" && node.arguments) {\n                        forceResolvers = node.arguments.some(function (arg) {\n                            return arg.name.value === \"always\" &&\n                                arg.value.kind === \"BooleanValue\" &&\n                                arg.value.value === true;\n                        });\n                        if (forceResolvers) {\n                            return BREAK;\n                        }\n                    }\n                },\n            },\n        });\n        return forceResolvers;\n    };\n    // Query the cache and return matching data.\n    LocalState.prototype.buildRootValueFromCache = function (document, variables) {\n        return this.cache.diff({\n            query: buildQueryFromSelectionSet(document),\n            variables: variables,\n            returnPartialData: true,\n            optimistic: false,\n        }).result;\n    };\n    LocalState.prototype.resolveDocument = function (document_1, rootValue_1) {\n        return __awaiter(this, arguments, void 0, function (document, rootValue, context, variables, fragmentMatcher, onlyRunForcedResolvers) {\n            var mainDefinition, fragments, fragmentMap, selectionsToResolve, definitionOperation, defaultOperationType, _a, cache, client, execContext, isClientFieldDescendant;\n            if (context === void 0) { context = {}; }\n            if (variables === void 0) { variables = {}; }\n            if (fragmentMatcher === void 0) { fragmentMatcher = function () { return true; }; }\n            if (onlyRunForcedResolvers === void 0) { onlyRunForcedResolvers = false; }\n            return __generator(this, function (_b) {\n                mainDefinition = getMainDefinition(document);\n                fragments = getFragmentDefinitions(document);\n                fragmentMap = createFragmentMap(fragments);\n                selectionsToResolve = this.collectSelectionsToResolve(mainDefinition, fragmentMap);\n                definitionOperation = mainDefinition.operation;\n                defaultOperationType = definitionOperation ?\n                    definitionOperation.charAt(0).toUpperCase() +\n                        definitionOperation.slice(1)\n                    : \"Query\";\n                _a = this, cache = _a.cache, client = _a.client;\n                execContext = {\n                    fragmentMap: fragmentMap,\n                    context: __assign(__assign({}, context), { cache: cache, client: client }),\n                    variables: variables,\n                    fragmentMatcher: fragmentMatcher,\n                    defaultOperationType: defaultOperationType,\n                    exportedVariables: {},\n                    selectionsToResolve: selectionsToResolve,\n                    onlyRunForcedResolvers: onlyRunForcedResolvers,\n                };\n                isClientFieldDescendant = false;\n                return [2 /*return*/, this.resolveSelectionSet(mainDefinition.selectionSet, isClientFieldDescendant, rootValue, execContext).then(function (result) { return ({\n                        result: result,\n                        exportedVariables: execContext.exportedVariables,\n                    }); })];\n            });\n        });\n    };\n    LocalState.prototype.resolveSelectionSet = function (selectionSet, isClientFieldDescendant, rootValue, execContext) {\n        return __awaiter(this, void 0, void 0, function () {\n            var fragmentMap, context, variables, resultsToMerge, execute;\n            var _this = this;\n            return __generator(this, function (_a) {\n                fragmentMap = execContext.fragmentMap, context = execContext.context, variables = execContext.variables;\n                resultsToMerge = [rootValue];\n                execute = function (selection) { return __awaiter(_this, void 0, void 0, function () {\n                    var fragment, typeCondition;\n                    return __generator(this, function (_a) {\n                        if (!isClientFieldDescendant &&\n                            !execContext.selectionsToResolve.has(selection)) {\n                            // Skip selections without @client directives\n                            // (still processing if one of the ancestors or one of the child fields has @client directive)\n                            return [2 /*return*/];\n                        }\n                        if (!shouldInclude(selection, variables)) {\n                            // Skip this entirely.\n                            return [2 /*return*/];\n                        }\n                        if (isField(selection)) {\n                            return [2 /*return*/, this.resolveField(selection, isClientFieldDescendant, rootValue, execContext).then(function (fieldResult) {\n                                    var _a;\n                                    if (typeof fieldResult !== \"undefined\") {\n                                        resultsToMerge.push((_a = {},\n                                            _a[resultKeyNameFromField(selection)] = fieldResult,\n                                            _a));\n                                    }\n                                })];\n                        }\n                        if (isInlineFragment(selection)) {\n                            fragment = selection;\n                        }\n                        else {\n                            // This is a named fragment.\n                            fragment = fragmentMap[selection.name.value];\n                            invariant(fragment, 18, selection.name.value);\n                        }\n                        if (fragment && fragment.typeCondition) {\n                            typeCondition = fragment.typeCondition.name.value;\n                            if (execContext.fragmentMatcher(rootValue, typeCondition, context)) {\n                                return [2 /*return*/, this.resolveSelectionSet(fragment.selectionSet, isClientFieldDescendant, rootValue, execContext).then(function (fragmentResult) {\n                                        resultsToMerge.push(fragmentResult);\n                                    })];\n                            }\n                        }\n                        return [2 /*return*/];\n                    });\n                }); };\n                return [2 /*return*/, Promise.all(selectionSet.selections.map(execute)).then(function () {\n                        return mergeDeepArray(resultsToMerge);\n                    })];\n            });\n        });\n    };\n    LocalState.prototype.resolveField = function (field, isClientFieldDescendant, rootValue, execContext) {\n        return __awaiter(this, void 0, void 0, function () {\n            var variables, fieldName, aliasedFieldName, aliasUsed, defaultResult, resultPromise, resolverType, resolverMap, resolve;\n            var _this = this;\n            return __generator(this, function (_a) {\n                if (!rootValue) {\n                    return [2 /*return*/, null];\n                }\n                variables = execContext.variables;\n                fieldName = field.name.value;\n                aliasedFieldName = resultKeyNameFromField(field);\n                aliasUsed = fieldName !== aliasedFieldName;\n                defaultResult = rootValue[aliasedFieldName] || rootValue[fieldName];\n                resultPromise = Promise.resolve(defaultResult);\n                // Usually all local resolvers are run when passing through here, but\n                // if we've specifically identified that we only want to run forced\n                // resolvers (that is, resolvers for fields marked with\n                // `@client(always: true)`), then we'll skip running non-forced resolvers.\n                if (!execContext.onlyRunForcedResolvers ||\n                    this.shouldForceResolvers(field)) {\n                    resolverType = rootValue.__typename || execContext.defaultOperationType;\n                    resolverMap = this.resolvers && this.resolvers[resolverType];\n                    if (resolverMap) {\n                        resolve = resolverMap[aliasUsed ? fieldName : aliasedFieldName];\n                        if (resolve) {\n                            resultPromise = Promise.resolve(\n                            // In case the resolve function accesses reactive variables,\n                            // set cacheSlot to the current cache instance.\n                            cacheSlot.withValue(this.cache, resolve, [\n                                rootValue,\n                                argumentsObjectFromField(field, variables),\n                                execContext.context,\n                                { field: field, fragmentMap: execContext.fragmentMap },\n                            ]));\n                        }\n                    }\n                }\n                return [2 /*return*/, resultPromise.then(function (result) {\n                        var _a, _b;\n                        if (result === void 0) { result = defaultResult; }\n                        // If an @export directive is associated with the current field, store\n                        // the `as` export variable name and current result for later use.\n                        if (field.directives) {\n                            field.directives.forEach(function (directive) {\n                                if (directive.name.value === \"export\" && directive.arguments) {\n                                    directive.arguments.forEach(function (arg) {\n                                        if (arg.name.value === \"as\" && arg.value.kind === \"StringValue\") {\n                                            execContext.exportedVariables[arg.value.value] = result;\n                                        }\n                                    });\n                                }\n                            });\n                        }\n                        // Handle all scalar types here.\n                        if (!field.selectionSet) {\n                            return result;\n                        }\n                        // From here down, the field has a selection set, which means it's trying\n                        // to query a GraphQLObjectType.\n                        if (result == null) {\n                            // Basically any field in a GraphQL response can be null, or missing\n                            return result;\n                        }\n                        var isClientField = (_b = (_a = field.directives) === null || _a === void 0 ? void 0 : _a.some(function (d) { return d.name.value === \"client\"; })) !== null && _b !== void 0 ? _b : false;\n                        if (Array.isArray(result)) {\n                            return _this.resolveSubSelectedArray(field, isClientFieldDescendant || isClientField, result, execContext);\n                        }\n                        // Returned value is an object, and the query has a sub-selection. Recurse.\n                        if (field.selectionSet) {\n                            return _this.resolveSelectionSet(field.selectionSet, isClientFieldDescendant || isClientField, result, execContext);\n                        }\n                    })];\n            });\n        });\n    };\n    LocalState.prototype.resolveSubSelectedArray = function (field, isClientFieldDescendant, result, execContext) {\n        var _this = this;\n        return Promise.all(result.map(function (item) {\n            if (item === null) {\n                return null;\n            }\n            // This is a nested array, recurse.\n            if (Array.isArray(item)) {\n                return _this.resolveSubSelectedArray(field, isClientFieldDescendant, item, execContext);\n            }\n            // This is an object, run the selection set on it.\n            if (field.selectionSet) {\n                return _this.resolveSelectionSet(field.selectionSet, isClientFieldDescendant, item, execContext);\n            }\n        }));\n    };\n    // Collect selection nodes on paths from document root down to all @client directives.\n    // This function takes into account transitive fragment spreads.\n    // Complexity equals to a single `visit` over the full document.\n    LocalState.prototype.collectSelectionsToResolve = function (mainDefinition, fragmentMap) {\n        var isSingleASTNode = function (node) { return !Array.isArray(node); };\n        var selectionsToResolveCache = this.selectionsToResolveCache;\n        function collectByDefinition(definitionNode) {\n            if (!selectionsToResolveCache.has(definitionNode)) {\n                var matches_1 = new Set();\n                selectionsToResolveCache.set(definitionNode, matches_1);\n                visit(definitionNode, {\n                    Directive: function (node, _, __, ___, ancestors) {\n                        if (node.name.value === \"client\") {\n                            ancestors.forEach(function (node) {\n                                if (isSingleASTNode(node) && isSelectionNode(node)) {\n                                    matches_1.add(node);\n                                }\n                            });\n                        }\n                    },\n                    FragmentSpread: function (spread, _, __, ___, ancestors) {\n                        var fragment = fragmentMap[spread.name.value];\n                        invariant(fragment, 19, spread.name.value);\n                        var fragmentSelections = collectByDefinition(fragment);\n                        if (fragmentSelections.size > 0) {\n                            // Fragment for this spread contains @client directive (either directly or transitively)\n                            // Collect selection nodes on paths from the root down to fields with the @client directive\n                            ancestors.forEach(function (node) {\n                                if (isSingleASTNode(node) && isSelectionNode(node)) {\n                                    matches_1.add(node);\n                                }\n                            });\n                            matches_1.add(spread);\n                            fragmentSelections.forEach(function (selection) {\n                                matches_1.add(selection);\n                            });\n                        }\n                    },\n                });\n            }\n            return selectionsToResolveCache.get(definitionNode);\n        }\n        return collectByDefinition(mainDefinition);\n    };\n    return LocalState;\n}());\nexport { LocalState };\n//# sourceMappingURL=LocalState.js.map","import { __assign } from \"tslib\";\nimport { invariant, newInvariantError } from \"../utilities/globals/index.js\";\nimport { ApolloLink, execute } from \"../link/core/index.js\";\nimport { version } from \"../version.js\";\nimport { HttpLink } from \"../link/http/index.js\";\nimport { QueryManager } from \"./QueryManager.js\";\nimport { LocalState } from \"./LocalState.js\";\nvar hasSuggestedDevtools = false;\n// Though mergeOptions now resides in @apollo/client/utilities, it was\n// previously declared and exported from this module, and then reexported from\n// @apollo/client/core. Since we need to preserve that API anyway, the easiest\n// solution is to reexport mergeOptions where it was previously declared (here).\nimport { mergeOptions } from \"../utilities/index.js\";\nimport { getApolloClientMemoryInternals } from \"../utilities/caching/getMemoryInternals.js\";\nexport { mergeOptions };\n/**\n * This is the primary Apollo Client class. It is used to send GraphQL documents (i.e. queries\n * and mutations) to a GraphQL spec-compliant server over an `ApolloLink` instance,\n * receive results from the server and cache the results in a store. It also delivers updates\n * to GraphQL queries through `Observable` instances.\n */\nvar ApolloClient = /** @class */ (function () {\n    /**\n     * Constructs an instance of `ApolloClient`.\n     *\n     * @example\n     * ```js\n     * import { ApolloClient, InMemoryCache } from '@apollo/client';\n     *\n     * const cache = new InMemoryCache();\n     *\n     * const client = new ApolloClient({\n     *   // Provide required constructor fields\n     *   cache: cache,\n     *   uri: 'http://localhost:4000/',\n     *\n     *   // Provide some optional constructor fields\n     *   name: 'react-web-client',\n     *   version: '1.3',\n     *   queryDeduplication: false,\n     *   defaultOptions: {\n     *     watchQuery: {\n     *       fetchPolicy: 'cache-and-network',\n     *     },\n     *   },\n     * });\n     * ```\n     */\n    function ApolloClient(options) {\n        var _this = this;\n        this.resetStoreCallbacks = [];\n        this.clearStoreCallbacks = [];\n        if (!options.cache) {\n            throw newInvariantError(15);\n        }\n        var uri = options.uri, credentials = options.credentials, headers = options.headers, cache = options.cache, documentTransform = options.documentTransform, _a = options.ssrMode, ssrMode = _a === void 0 ? false : _a, _b = options.ssrForceFetchDelay, ssrForceFetchDelay = _b === void 0 ? 0 : _b, \n        // Expose the client instance as window.__APOLLO_CLIENT__ and call\n        // onBroadcast in queryManager.broadcastQueries to enable browser\n        // devtools, but disable them by default in production.\n        connectToDevTools = options.connectToDevTools, _c = options.queryDeduplication, queryDeduplication = _c === void 0 ? true : _c, defaultOptions = options.defaultOptions, defaultContext = options.defaultContext, _d = options.assumeImmutableResults, assumeImmutableResults = _d === void 0 ? cache.assumeImmutableResults : _d, resolvers = options.resolvers, typeDefs = options.typeDefs, fragmentMatcher = options.fragmentMatcher, clientAwarenessName = options.name, clientAwarenessVersion = options.version, devtools = options.devtools;\n        var link = options.link;\n        if (!link) {\n            link =\n                uri ? new HttpLink({ uri: uri, credentials: credentials, headers: headers }) : ApolloLink.empty();\n        }\n        this.link = link;\n        this.cache = cache;\n        this.disableNetworkFetches = ssrMode || ssrForceFetchDelay > 0;\n        this.queryDeduplication = queryDeduplication;\n        this.defaultOptions = defaultOptions || Object.create(null);\n        this.typeDefs = typeDefs;\n        this.devtoolsConfig = __assign(__assign({}, devtools), { enabled: (devtools === null || devtools === void 0 ? void 0 : devtools.enabled) || connectToDevTools });\n        if (this.devtoolsConfig.enabled === undefined) {\n            this.devtoolsConfig.enabled = globalThis.__DEV__ !== false;\n        }\n        if (ssrForceFetchDelay) {\n            setTimeout(function () { return (_this.disableNetworkFetches = false); }, ssrForceFetchDelay);\n        }\n        this.watchQuery = this.watchQuery.bind(this);\n        this.query = this.query.bind(this);\n        this.mutate = this.mutate.bind(this);\n        this.watchFragment = this.watchFragment.bind(this);\n        this.resetStore = this.resetStore.bind(this);\n        this.reFetchObservableQueries = this.reFetchObservableQueries.bind(this);\n        this.version = version;\n        this.localState = new LocalState({\n            cache: cache,\n            client: this,\n            resolvers: resolvers,\n            fragmentMatcher: fragmentMatcher,\n        });\n        this.queryManager = new QueryManager({\n            cache: this.cache,\n            link: this.link,\n            defaultOptions: this.defaultOptions,\n            defaultContext: defaultContext,\n            documentTransform: documentTransform,\n            queryDeduplication: queryDeduplication,\n            ssrMode: ssrMode,\n            clientAwareness: {\n                name: clientAwarenessName,\n                version: clientAwarenessVersion,\n            },\n            localState: this.localState,\n            assumeImmutableResults: assumeImmutableResults,\n            onBroadcast: this.devtoolsConfig.enabled ?\n                function () {\n                    if (_this.devToolsHookCb) {\n                        _this.devToolsHookCb({\n                            action: {},\n                            state: {\n                                queries: _this.queryManager.getQueryStore(),\n                                mutations: _this.queryManager.mutationStore || {},\n                            },\n                            dataWithOptimisticResults: _this.cache.extract(true),\n                        });\n                    }\n                }\n                : void 0,\n        });\n        if (this.devtoolsConfig.enabled)\n            this.connectToDevTools();\n    }\n    ApolloClient.prototype.connectToDevTools = function () {\n        if (typeof window === \"undefined\") {\n            return;\n        }\n        var windowWithDevTools = window;\n        var devtoolsSymbol = Symbol.for(\"apollo.devtools\");\n        (windowWithDevTools[devtoolsSymbol] =\n            windowWithDevTools[devtoolsSymbol] || []).push(this);\n        windowWithDevTools.__APOLLO_CLIENT__ = this;\n        /**\n         * Suggest installing the devtools for developers who don't have them\n         */\n        if (!hasSuggestedDevtools && globalThis.__DEV__ !== false) {\n            hasSuggestedDevtools = true;\n            if (window.document &&\n                window.top === window.self &&\n                /^(https?|file):$/.test(window.location.protocol)) {\n                setTimeout(function () {\n                    if (!window.__APOLLO_DEVTOOLS_GLOBAL_HOOK__) {\n                        var nav = window.navigator;\n                        var ua = nav && nav.userAgent;\n                        var url = void 0;\n                        if (typeof ua === \"string\") {\n                            if (ua.indexOf(\"Chrome/\") > -1) {\n                                url =\n                                    \"https://chrome.google.com/webstore/detail/\" +\n                                        \"apollo-client-developer-t/jdkknkkbebbapilgoeccciglkfbmbnfm\";\n                            }\n                            else if (ua.indexOf(\"Firefox/\") > -1) {\n                                url =\n                                    \"https://addons.mozilla.org/en-US/firefox/addon/apollo-developer-tools/\";\n                            }\n                        }\n                        if (url) {\n                            globalThis.__DEV__ !== false && invariant.log(\"Download the Apollo DevTools for a better development \" +\n                                \"experience: %s\", url);\n                        }\n                    }\n                }, 10000);\n            }\n        }\n    };\n    Object.defineProperty(ApolloClient.prototype, \"documentTransform\", {\n        /**\n         * The `DocumentTransform` used to modify GraphQL documents before a request\n         * is made. If a custom `DocumentTransform` is not provided, this will be the\n         * default document transform.\n         */\n        get: function () {\n            return this.queryManager.documentTransform;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    /**\n     * Call this method to terminate any active client processes, making it safe\n     * to dispose of this `ApolloClient` instance.\n     */\n    ApolloClient.prototype.stop = function () {\n        this.queryManager.stop();\n    };\n    /**\n     * This watches the cache store of the query according to the options specified and\n     * returns an `ObservableQuery`. We can subscribe to this `ObservableQuery` and\n     * receive updated results through an observer when the cache store changes.\n     *\n     * Note that this method is not an implementation of GraphQL subscriptions. Rather,\n     * it uses Apollo's store in order to reactively deliver updates to your query results.\n     *\n     * For example, suppose you call watchQuery on a GraphQL query that fetches a person's\n     * first and last name and this person has a particular object identifier, provided by\n     * dataIdFromObject. Later, a different query fetches that same person's\n     * first and last name and the first name has now changed. Then, any observers associated\n     * with the results of the first query will be updated with a new result object.\n     *\n     * Note that if the cache does not change, the subscriber will *not* be notified.\n     *\n     * See [here](https://medium.com/apollo-stack/the-concepts-of-graphql-bc68bd819be3#.3mb0cbcmc) for\n     * a description of store reactivity.\n     */\n    ApolloClient.prototype.watchQuery = function (options) {\n        if (this.defaultOptions.watchQuery) {\n            options = mergeOptions(this.defaultOptions.watchQuery, options);\n        }\n        // XXX Overwriting options is probably not the best way to do this long term...\n        if (this.disableNetworkFetches &&\n            (options.fetchPolicy === \"network-only\" ||\n                options.fetchPolicy === \"cache-and-network\")) {\n            options = __assign(__assign({}, options), { fetchPolicy: \"cache-first\" });\n        }\n        return this.queryManager.watchQuery(options);\n    };\n    /**\n     * This resolves a single query according to the options specified and\n     * returns a `Promise` which is either resolved with the resulting data\n     * or rejected with an error.\n     *\n     * @param options - An object of type `QueryOptions` that allows us to\n     * describe how this query should be treated e.g. whether it should hit the\n     * server at all or just resolve from the cache, etc.\n     */\n    ApolloClient.prototype.query = function (options) {\n        if (this.defaultOptions.query) {\n            options = mergeOptions(this.defaultOptions.query, options);\n        }\n        invariant(options.fetchPolicy !== \"cache-and-network\", 16);\n        if (this.disableNetworkFetches && options.fetchPolicy === \"network-only\") {\n            options = __assign(__assign({}, options), { fetchPolicy: \"cache-first\" });\n        }\n        return this.queryManager.query(options);\n    };\n    /**\n     * This resolves a single mutation according to the options specified and returns a\n     * Promise which is either resolved with the resulting data or rejected with an\n     * error. In some cases both `data` and `errors` might be undefined, for example\n     * when `errorPolicy` is set to `'ignore'`.\n     *\n     * It takes options as an object with the following keys and values:\n     */\n    ApolloClient.prototype.mutate = function (options) {\n        if (this.defaultOptions.mutate) {\n            options = mergeOptions(this.defaultOptions.mutate, options);\n        }\n        return this.queryManager.mutate(options);\n    };\n    /**\n     * This subscribes to a graphql subscription according to the options specified and returns an\n     * `Observable` which either emits received data or an error.\n     */\n    ApolloClient.prototype.subscribe = function (options) {\n        return this.queryManager.startGraphQLSubscription(options);\n    };\n    /**\n     * Tries to read some data from the store in the shape of the provided\n     * GraphQL query without making a network request. This method will start at\n     * the root query. To start at a specific id returned by `dataIdFromObject`\n     * use `readFragment`.\n     *\n     * @param optimistic - Set to `true` to allow `readQuery` to return\n     * optimistic results. Is `false` by default.\n     */\n    ApolloClient.prototype.readQuery = function (options, optimistic) {\n        if (optimistic === void 0) { optimistic = false; }\n        return this.cache.readQuery(options, optimistic);\n    };\n    /**\n     * Watches the cache store of the fragment according to the options specified\n     * and returns an `Observable`. We can subscribe to this\n     * `Observable` and receive updated results through an\n     * observer when the cache store changes.\n     *\n     * You must pass in a GraphQL document with a single fragment or a document\n     * with multiple fragments that represent what you are reading. If you pass\n     * in a document with multiple fragments then you must also specify a\n     * `fragmentName`.\n     *\n     * @since 3.10.0\n     * @param options - An object of type `WatchFragmentOptions` that allows\n     * the cache to identify the fragment and optionally specify whether to react\n     * to optimistic updates.\n     */\n    ApolloClient.prototype.watchFragment = function (options) {\n        return this.cache.watchFragment(options);\n    };\n    /**\n     * Tries to read some data from the store in the shape of the provided\n     * GraphQL fragment without making a network request. This method will read a\n     * GraphQL fragment from any arbitrary id that is currently cached, unlike\n     * `readQuery` which will only read from the root query.\n     *\n     * You must pass in a GraphQL document with a single fragment or a document\n     * with multiple fragments that represent what you are reading. If you pass\n     * in a document with multiple fragments then you must also specify a\n     * `fragmentName`.\n     *\n     * @param optimistic - Set to `true` to allow `readFragment` to return\n     * optimistic results. Is `false` by default.\n     */\n    ApolloClient.prototype.readFragment = function (options, optimistic) {\n        if (optimistic === void 0) { optimistic = false; }\n        return this.cache.readFragment(options, optimistic);\n    };\n    /**\n     * Writes some data in the shape of the provided GraphQL query directly to\n     * the store. This method will start at the root query. To start at a\n     * specific id returned by `dataIdFromObject` then use `writeFragment`.\n     */\n    ApolloClient.prototype.writeQuery = function (options) {\n        var ref = this.cache.writeQuery(options);\n        if (options.broadcast !== false) {\n            this.queryManager.broadcastQueries();\n        }\n        return ref;\n    };\n    /**\n     * Writes some data in the shape of the provided GraphQL fragment directly to\n     * the store. This method will write to a GraphQL fragment from any arbitrary\n     * id that is currently cached, unlike `writeQuery` which will only write\n     * from the root query.\n     *\n     * You must pass in a GraphQL document with a single fragment or a document\n     * with multiple fragments that represent what you are writing. If you pass\n     * in a document with multiple fragments then you must also specify a\n     * `fragmentName`.\n     */\n    ApolloClient.prototype.writeFragment = function (options) {\n        var ref = this.cache.writeFragment(options);\n        if (options.broadcast !== false) {\n            this.queryManager.broadcastQueries();\n        }\n        return ref;\n    };\n    ApolloClient.prototype.__actionHookForDevTools = function (cb) {\n        this.devToolsHookCb = cb;\n    };\n    ApolloClient.prototype.__requestRaw = function (payload) {\n        return execute(this.link, payload);\n    };\n    /**\n     * Resets your entire store by clearing out your cache and then re-executing\n     * all of your active queries. This makes it so that you may guarantee that\n     * there is no data left in your store from a time before you called this\n     * method.\n     *\n     * `resetStore()` is useful when your user just logged out. You’ve removed the\n     * user session, and you now want to make sure that any references to data you\n     * might have fetched while the user session was active is gone.\n     *\n     * It is important to remember that `resetStore()` *will* refetch any active\n     * queries. This means that any components that might be mounted will execute\n     * their queries again using your network interface. If you do not want to\n     * re-execute any queries then you should make sure to stop watching any\n     * active queries.\n     */\n    ApolloClient.prototype.resetStore = function () {\n        var _this = this;\n        return Promise.resolve()\n            .then(function () {\n            return _this.queryManager.clearStore({\n                discardWatches: false,\n            });\n        })\n            .then(function () { return Promise.all(_this.resetStoreCallbacks.map(function (fn) { return fn(); })); })\n            .then(function () { return _this.reFetchObservableQueries(); });\n    };\n    /**\n     * Remove all data from the store. Unlike `resetStore`, `clearStore` will\n     * not refetch any active queries.\n     */\n    ApolloClient.prototype.clearStore = function () {\n        var _this = this;\n        return Promise.resolve()\n            .then(function () {\n            return _this.queryManager.clearStore({\n                discardWatches: true,\n            });\n        })\n            .then(function () { return Promise.all(_this.clearStoreCallbacks.map(function (fn) { return fn(); })); });\n    };\n    /**\n     * Allows callbacks to be registered that are executed when the store is\n     * reset. `onResetStore` returns an unsubscribe function that can be used\n     * to remove registered callbacks.\n     */\n    ApolloClient.prototype.onResetStore = function (cb) {\n        var _this = this;\n        this.resetStoreCallbacks.push(cb);\n        return function () {\n            _this.resetStoreCallbacks = _this.resetStoreCallbacks.filter(function (c) { return c !== cb; });\n        };\n    };\n    /**\n     * Allows callbacks to be registered that are executed when the store is\n     * cleared. `onClearStore` returns an unsubscribe function that can be used\n     * to remove registered callbacks.\n     */\n    ApolloClient.prototype.onClearStore = function (cb) {\n        var _this = this;\n        this.clearStoreCallbacks.push(cb);\n        return function () {\n            _this.clearStoreCallbacks = _this.clearStoreCallbacks.filter(function (c) { return c !== cb; });\n        };\n    };\n    /**\n     * Refetches all of your active queries.\n     *\n     * `reFetchObservableQueries()` is useful if you want to bring the client back to proper state in case of a network outage\n     *\n     * It is important to remember that `reFetchObservableQueries()` *will* refetch any active\n     * queries. This means that any components that might be mounted will execute\n     * their queries again using your network interface. If you do not want to\n     * re-execute any queries then you should make sure to stop watching any\n     * active queries.\n     * Takes optional parameter `includeStandby` which will include queries in standby-mode when refetching.\n     */\n    ApolloClient.prototype.reFetchObservableQueries = function (includeStandby) {\n        return this.queryManager.reFetchObservableQueries(includeStandby);\n    };\n    /**\n     * Refetches specified active queries. Similar to \"reFetchObservableQueries()\" but with a specific list of queries.\n     *\n     * `refetchQueries()` is useful for use cases to imperatively refresh a selection of queries.\n     *\n     * It is important to remember that `refetchQueries()` *will* refetch specified active\n     * queries. This means that any components that might be mounted will execute\n     * their queries again using your network interface. If you do not want to\n     * re-execute any queries then you should make sure to stop watching any\n     * active queries.\n     */\n    ApolloClient.prototype.refetchQueries = function (options) {\n        var map = this.queryManager.refetchQueries(options);\n        var queries = [];\n        var results = [];\n        map.forEach(function (result, obsQuery) {\n            queries.push(obsQuery);\n            results.push(result);\n        });\n        var result = Promise.all(results);\n        // In case you need the raw results immediately, without awaiting\n        // Promise.all(results):\n        result.queries = queries;\n        result.results = results;\n        // If you decide to ignore the result Promise because you're using\n        // result.queries and result.results instead, you shouldn't have to worry\n        // about preventing uncaught rejections for the Promise.all result.\n        result.catch(function (error) {\n            globalThis.__DEV__ !== false && invariant.debug(17, error);\n        });\n        return result;\n    };\n    /**\n     * Get all currently active `ObservableQuery` objects, in a `Map` keyed by\n     * query ID strings.\n     *\n     * An \"active\" query is one that has observers and a `fetchPolicy` other than\n     * \"standby\" or \"cache-only\".\n     *\n     * You can include all `ObservableQuery` objects (including the inactive ones)\n     * by passing \"all\" instead of \"active\", or you can include just a subset of\n     * active queries by passing an array of query names or DocumentNode objects.\n     */\n    ApolloClient.prototype.getObservableQueries = function (include) {\n        if (include === void 0) { include = \"active\"; }\n        return this.queryManager.getObservableQueries(include);\n    };\n    /**\n     * Exposes the cache's complete state, in a serializable format for later restoration.\n     */\n    ApolloClient.prototype.extract = function (optimistic) {\n        return this.cache.extract(optimistic);\n    };\n    /**\n     * Replaces existing state in the cache (if any) with the values expressed by\n     * `serializedState`.\n     *\n     * Called when hydrating a cache (server side rendering, or offline storage),\n     * and also (potentially) during hot reloads.\n     */\n    ApolloClient.prototype.restore = function (serializedState) {\n        return this.cache.restore(serializedState);\n    };\n    /**\n     * Add additional local resolvers.\n     */\n    ApolloClient.prototype.addResolvers = function (resolvers) {\n        this.localState.addResolvers(resolvers);\n    };\n    /**\n     * Set (override existing) local resolvers.\n     */\n    ApolloClient.prototype.setResolvers = function (resolvers) {\n        this.localState.setResolvers(resolvers);\n    };\n    /**\n     * Get all registered local resolvers.\n     */\n    ApolloClient.prototype.getResolvers = function () {\n        return this.localState.getResolvers();\n    };\n    /**\n     * Set a custom local state fragment matcher.\n     */\n    ApolloClient.prototype.setLocalStateFragmentMatcher = function (fragmentMatcher) {\n        this.localState.setFragmentMatcher(fragmentMatcher);\n    };\n    /**\n     * Define a new ApolloLink (or link chain) that Apollo Client will use.\n     */\n    ApolloClient.prototype.setLink = function (newLink) {\n        this.link = this.queryManager.link = newLink;\n    };\n    Object.defineProperty(ApolloClient.prototype, \"defaultContext\", {\n        get: function () {\n            return this.queryManager.defaultContext;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    return ApolloClient;\n}());\nexport { ApolloClient };\nif (globalThis.__DEV__ !== false) {\n    ApolloClient.prototype.getMemoryInternals = getApolloClientMemoryInternals;\n}\n//# sourceMappingURL=ApolloClient.js.map","import { __rest } from \"tslib\";\nimport equal from \"@wry/equality\";\nimport { createFragmentMap, getFragmentDefinitions, getFragmentFromSelection, getMainDefinition, isField, resultKeyNameFromField, shouldInclude, } from \"../utilities/index.js\";\n// Returns true if aResult and bResult are deeply equal according to the fields\n// selected by the given query, ignoring any fields marked as @nonreactive.\nexport function equalByQuery(query, _a, _b, variables) {\n    var aData = _a.data, aRest = __rest(_a, [\"data\"]);\n    var bData = _b.data, bRest = __rest(_b, [\"data\"]);\n    return (equal(aRest, bRest) &&\n        equalBySelectionSet(getMainDefinition(query).selectionSet, aData, bData, {\n            fragmentMap: createFragmentMap(getFragmentDefinitions(query)),\n            variables: variables,\n        }));\n}\nfunction equalBySelectionSet(selectionSet, aResult, bResult, context) {\n    if (aResult === bResult) {\n        return true;\n    }\n    var seenSelections = new Set();\n    // Returning true from this Array.prototype.every callback function skips the\n    // current field/subtree. Returning false aborts the entire traversal\n    // immediately, causing equalBySelectionSet to return false.\n    return selectionSet.selections.every(function (selection) {\n        // Avoid re-processing the same selection at the same level of recursion, in\n        // case the same field gets included via multiple indirect fragment spreads.\n        if (seenSelections.has(selection))\n            return true;\n        seenSelections.add(selection);\n        // Ignore @skip(if: true) and @include(if: false) fields.\n        if (!shouldInclude(selection, context.variables))\n            return true;\n        // If the field or (named) fragment spread has a @nonreactive directive on\n        // it, we don't care if it's different, so we pretend it's the same.\n        if (selectionHasNonreactiveDirective(selection))\n            return true;\n        if (isField(selection)) {\n            var resultKey = resultKeyNameFromField(selection);\n            var aResultChild = aResult && aResult[resultKey];\n            var bResultChild = bResult && bResult[resultKey];\n            var childSelectionSet = selection.selectionSet;\n            if (!childSelectionSet) {\n                // These are scalar values, so we can compare them with deep equal\n                // without redoing the main recursive work.\n                return equal(aResultChild, bResultChild);\n            }\n            var aChildIsArray = Array.isArray(aResultChild);\n            var bChildIsArray = Array.isArray(bResultChild);\n            if (aChildIsArray !== bChildIsArray)\n                return false;\n            if (aChildIsArray && bChildIsArray) {\n                var length_1 = aResultChild.length;\n                if (bResultChild.length !== length_1) {\n                    return false;\n                }\n                for (var i = 0; i < length_1; ++i) {\n                    if (!equalBySelectionSet(childSelectionSet, aResultChild[i], bResultChild[i], context)) {\n                        return false;\n                    }\n                }\n                return true;\n            }\n            return equalBySelectionSet(childSelectionSet, aResultChild, bResultChild, context);\n        }\n        else {\n            var fragment = getFragmentFromSelection(selection, context.fragmentMap);\n            if (fragment) {\n                // The fragment might === selection if it's an inline fragment, but\n                // could be !== if it's a named fragment ...spread.\n                if (selectionHasNonreactiveDirective(fragment))\n                    return true;\n                return equalBySelectionSet(fragment.selectionSet, \n                // Notice that we reuse the same aResult and bResult values here,\n                // since the fragment ...spread does not specify a field name, but\n                // consists of multiple fields (within the fragment's selection set)\n                // that should be applied to the current result value(s).\n                aResult, bResult, context);\n            }\n        }\n    });\n}\nfunction selectionHasNonreactiveDirective(selection) {\n    return (!!selection.directives && selection.directives.some(directiveIsNonreactive));\n}\nfunction directiveIsNonreactive(dir) {\n    return dir.name.value === \"nonreactive\";\n}\n//# sourceMappingURL=equalByQuery.js.map","import { __assign } from \"tslib\";\nexport function createOperation(starting, operation) {\n    var context = __assign({}, starting);\n    var setContext = function (next) {\n        if (typeof next === \"function\") {\n            context = __assign(__assign({}, context), next(context));\n        }\n        else {\n            context = __assign(__assign({}, context), next);\n        }\n    };\n    var getContext = function () { return (__assign({}, context)); };\n    Object.defineProperty(operation, \"setContext\", {\n        enumerable: false,\n        value: setContext,\n    });\n    Object.defineProperty(operation, \"getContext\", {\n        enumerable: false,\n        value: getContext,\n    });\n    return operation;\n}\n//# sourceMappingURL=createOperation.js.map","import { getOperationName } from \"../../utilities/index.js\";\nexport function transformOperation(operation) {\n    var transformedOperation = {\n        variables: operation.variables || {},\n        extensions: operation.extensions || {},\n        operationName: operation.operationName,\n        query: operation.query,\n    };\n    // Best guess at an operation name\n    if (!transformedOperation.operationName) {\n        transformedOperation.operationName =\n            typeof transformedOperation.query !== \"string\" ?\n                getOperationName(transformedOperation.query) || undefined\n                : \"\";\n    }\n    return transformedOperation;\n}\n//# sourceMappingURL=transformOperation.js.map","import { newInvariantError } from \"../../utilities/globals/index.js\";\nexport function validateOperation(operation) {\n    var OPERATION_FIELDS = [\n        \"query\",\n        \"operationName\",\n        \"variables\",\n        \"extensions\",\n        \"context\",\n    ];\n    for (var _i = 0, _a = Object.keys(operation); _i < _a.length; _i++) {\n        var key = _a[_i];\n        if (OPERATION_FIELDS.indexOf(key) < 0) {\n            throw newInvariantError(44, key);\n        }\n    }\n    return operation;\n}\n//# sourceMappingURL=validateOperation.js.map","import { newInvariantError, invariant } from \"../../utilities/globals/index.js\";\nimport { Observable } from \"../../utilities/index.js\";\nimport { validateOperation, createOperation, transformOperation, } from \"../utils/index.js\";\nfunction passthrough(op, forward) {\n    return (forward ? forward(op) : Observable.of());\n}\nfunction toLink(handler) {\n    return typeof handler === \"function\" ? new ApolloLink(handler) : handler;\n}\nfunction isTerminating(link) {\n    return link.request.length <= 1;\n}\nvar ApolloLink = /** @class */ (function () {\n    function ApolloLink(request) {\n        if (request)\n            this.request = request;\n    }\n    ApolloLink.empty = function () {\n        return new ApolloLink(function () { return Observable.of(); });\n    };\n    ApolloLink.from = function (links) {\n        if (links.length === 0)\n            return ApolloLink.empty();\n        return links.map(toLink).reduce(function (x, y) { return x.concat(y); });\n    };\n    ApolloLink.split = function (test, left, right) {\n        var leftLink = toLink(left);\n        var rightLink = toLink(right || new ApolloLink(passthrough));\n        var ret;\n        if (isTerminating(leftLink) && isTerminating(rightLink)) {\n            ret = new ApolloLink(function (operation) {\n                return test(operation) ?\n                    leftLink.request(operation) || Observable.of()\n                    : rightLink.request(operation) || Observable.of();\n            });\n        }\n        else {\n            ret = new ApolloLink(function (operation, forward) {\n                return test(operation) ?\n                    leftLink.request(operation, forward) || Observable.of()\n                    : rightLink.request(operation, forward) || Observable.of();\n            });\n        }\n        return Object.assign(ret, { left: leftLink, right: rightLink });\n    };\n    ApolloLink.execute = function (link, operation) {\n        return (link.request(createOperation(operation.context, transformOperation(validateOperation(operation)))) || Observable.of());\n    };\n    ApolloLink.concat = function (first, second) {\n        var firstLink = toLink(first);\n        if (isTerminating(firstLink)) {\n            globalThis.__DEV__ !== false && invariant.warn(36, firstLink);\n            return firstLink;\n        }\n        var nextLink = toLink(second);\n        var ret;\n        if (isTerminating(nextLink)) {\n            ret = new ApolloLink(function (operation) {\n                return firstLink.request(operation, function (op) { return nextLink.request(op) || Observable.of(); }) || Observable.of();\n            });\n        }\n        else {\n            ret = new ApolloLink(function (operation, forward) {\n                return (firstLink.request(operation, function (op) {\n                    return nextLink.request(op, forward) || Observable.of();\n                }) || Observable.of());\n            });\n        }\n        return Object.assign(ret, { left: firstLink, right: nextLink });\n    };\n    ApolloLink.prototype.split = function (test, left, right) {\n        return this.concat(ApolloLink.split(test, left, right || new ApolloLink(passthrough)));\n    };\n    ApolloLink.prototype.concat = function (next) {\n        return ApolloLink.concat(this, next);\n    };\n    ApolloLink.prototype.request = function (operation, forward) {\n        throw newInvariantError(37);\n    };\n    ApolloLink.prototype.onError = function (error, observer) {\n        if (observer && observer.error) {\n            observer.error(error);\n            // Returning false indicates that observer.error does not need to be\n            // called again, since it was already called (on the previous line).\n            // Calling observer.error again would not cause any real problems,\n            // since only the first call matters, but custom onError functions\n            // might have other reasons for wanting to prevent the default\n            // behavior by returning false.\n            return false;\n        }\n        // Throw errors will be passed to observer.error.\n        throw error;\n    };\n    ApolloLink.prototype.setOnError = function (fn) {\n        this.onError = fn;\n        return this;\n    };\n    return ApolloLink;\n}());\nexport { ApolloLink };\n//# sourceMappingURL=ApolloLink.js.map","import { ApolloLink } from \"./ApolloLink.js\";\nexport var from = ApolloLink.from;\n//# sourceMappingURL=from.js.map","import { __extends } from \"tslib\";\nimport { Observable } from \"../../utilities/index.js\";\nimport { ApolloLink } from \"../core/index.js\";\nexport function onError(errorHandler) {\n    return new ApolloLink(function (operation, forward) {\n        return new Observable(function (observer) {\n            var sub;\n            var retriedSub;\n            var retriedResult;\n            try {\n                sub = forward(operation).subscribe({\n                    next: function (result) {\n                        if (result.errors) {\n                            retriedResult = errorHandler({\n                                graphQLErrors: result.errors,\n                                response: result,\n                                operation: operation,\n                                forward: forward,\n                            });\n                            if (retriedResult) {\n                                retriedSub = retriedResult.subscribe({\n                                    next: observer.next.bind(observer),\n                                    error: observer.error.bind(observer),\n                                    complete: observer.complete.bind(observer),\n                                });\n                                return;\n                            }\n                        }\n                        observer.next(result);\n                    },\n                    error: function (networkError) {\n                        retriedResult = errorHandler({\n                            operation: operation,\n                            networkError: networkError,\n                            //Network errors can return GraphQL errors on for example a 403\n                            graphQLErrors: (networkError &&\n                                networkError.result &&\n                                networkError.result.errors) ||\n                                void 0,\n                            forward: forward,\n                        });\n                        if (retriedResult) {\n                            retriedSub = retriedResult.subscribe({\n                                next: observer.next.bind(observer),\n                                error: observer.error.bind(observer),\n                                complete: observer.complete.bind(observer),\n                            });\n                            return;\n                        }\n                        observer.error(networkError);\n                    },\n                    complete: function () {\n                        // disable the previous sub from calling complete on observable\n                        // if retry is in flight.\n                        if (!retriedResult) {\n                            observer.complete.bind(observer)();\n                        }\n                    },\n                });\n            }\n            catch (e) {\n                errorHandler({ networkError: e, operation: operation, forward: forward });\n                observer.error(e);\n            }\n            return function () {\n                if (sub)\n                    sub.unsubscribe();\n                if (retriedSub)\n                    sub.unsubscribe();\n            };\n        });\n    });\n}\nvar ErrorLink = /** @class */ (function (_super) {\n    __extends(ErrorLink, _super);\n    function ErrorLink(errorHandler) {\n        var _this = _super.call(this) || this;\n        _this.link = onError(errorHandler);\n        return _this;\n    }\n    ErrorLink.prototype.request = function (operation, forward) {\n        return this.link.request(operation, forward);\n    };\n    return ErrorLink;\n}(ApolloLink));\nexport { ErrorLink };\n//# sourceMappingURL=index.js.map","import { newInvariantError } from \"../../utilities/globals/index.js\";\nexport var serializeFetchParameter = function (p, label) {\n    var serialized;\n    try {\n        serialized = JSON.stringify(p);\n    }\n    catch (e) {\n        var parseError = newInvariantError(40, label, e.message);\n        parseError.parseError = e;\n        throw parseError;\n    }\n    return serialized;\n};\n//# sourceMappingURL=serializeFetchParameter.js.map","export var selectURI = function (operation, fallbackURI) {\n    var context = operation.getContext();\n    var contextURI = context.uri;\n    if (contextURI) {\n        return contextURI;\n    }\n    else if (typeof fallbackURI === \"function\") {\n        return fallbackURI(operation);\n    }\n    else {\n        return fallbackURI || \"/graphql\";\n    }\n};\n//# sourceMappingURL=selectURI.js.map","/**\n * Original source:\n * https://github.com/kmalakoff/response-iterator/blob/master/src/iterators/async.ts\n */\nexport default function asyncIterator(source) {\n    var _a;\n    var iterator = source[Symbol.asyncIterator]();\n    return _a = {\n            next: function () {\n                return iterator.next();\n            }\n        },\n        _a[Symbol.asyncIterator] = function () {\n            return this;\n        },\n        _a;\n}\n//# sourceMappingURL=async.js.map","/**\n * Original source:\n * https://github.com/kmalakoff/response-iterator/blob/master/src/iterators/nodeStream.ts\n */\nimport { canUseAsyncIteratorSymbol } from \"../../../utilities/index.js\";\nexport default function nodeStreamIterator(stream) {\n    var cleanup = null;\n    var error = null;\n    var done = false;\n    var data = [];\n    var waiting = [];\n    function onData(chunk) {\n        if (error)\n            return;\n        if (waiting.length) {\n            var shiftedArr = waiting.shift();\n            if (Array.isArray(shiftedArr) && shiftedArr[0]) {\n                return shiftedArr[0]({ value: chunk, done: false });\n            }\n        }\n        data.push(chunk);\n    }\n    function onError(err) {\n        error = err;\n        var all = waiting.slice();\n        all.forEach(function (pair) {\n            pair[1](err);\n        });\n        !cleanup || cleanup();\n    }\n    function onEnd() {\n        done = true;\n        var all = waiting.slice();\n        all.forEach(function (pair) {\n            pair[0]({ value: undefined, done: true });\n        });\n        !cleanup || cleanup();\n    }\n    cleanup = function () {\n        cleanup = null;\n        stream.removeListener(\"data\", onData);\n        stream.removeListener(\"error\", onError);\n        stream.removeListener(\"end\", onEnd);\n        stream.removeListener(\"finish\", onEnd);\n        stream.removeListener(\"close\", onEnd);\n    };\n    stream.on(\"data\", onData);\n    stream.on(\"error\", onError);\n    stream.on(\"end\", onEnd);\n    stream.on(\"finish\", onEnd);\n    stream.on(\"close\", onEnd);\n    function getNext() {\n        return new Promise(function (resolve, reject) {\n            if (error)\n                return reject(error);\n            if (data.length)\n                return resolve({ value: data.shift(), done: false });\n            if (done)\n                return resolve({ value: undefined, done: true });\n            waiting.push([resolve, reject]);\n        });\n    }\n    var iterator = {\n        next: function () {\n            return getNext();\n        },\n    };\n    if (canUseAsyncIteratorSymbol) {\n        iterator[Symbol.asyncIterator] = function () {\n            return this;\n        };\n    }\n    return iterator;\n}\n//# sourceMappingURL=nodeStream.js.map","/**\n * Original source:\n * https://github.com/kmalakoff/response-iterator/blob/master/src/iterators/promise.ts\n */\nimport { canUseAsyncIteratorSymbol } from \"../../../utilities/index.js\";\nexport default function promiseIterator(promise) {\n    var resolved = false;\n    var iterator = {\n        next: function () {\n            if (resolved)\n                return Promise.resolve({\n                    value: undefined,\n                    done: true,\n                });\n            resolved = true;\n            return new Promise(function (resolve, reject) {\n                promise\n                    .then(function (value) {\n                    resolve({ value: value, done: false });\n                })\n                    .catch(reject);\n            });\n        },\n    };\n    if (canUseAsyncIteratorSymbol) {\n        iterator[Symbol.asyncIterator] = function () {\n            return this;\n        };\n    }\n    return iterator;\n}\n//# sourceMappingURL=promise.js.map","/**\n * Original source:\n * https://github.com/kmalakoff/response-iterator/blob/master/src/iterators/reader.ts\n */\nimport { canUseAsyncIteratorSymbol } from \"../../../utilities/index.js\";\nexport default function readerIterator(reader) {\n    var iterator = {\n        next: function () {\n            return reader.read();\n        },\n    };\n    if (canUseAsyncIteratorSymbol) {\n        iterator[Symbol.asyncIterator] = function () {\n            return this;\n        };\n    }\n    return iterator;\n}\n//# sourceMappingURL=reader.js.map","/**\n * Original source:\n * https://github.com/kmalakoff/response-iterator/blob/master/src/index.ts\n */\nimport { canUseAsyncIteratorSymbol } from \"../../utilities/index.js\";\nimport asyncIterator from \"./iterators/async.js\";\nimport nodeStreamIterator from \"./iterators/nodeStream.js\";\nimport promiseIterator from \"./iterators/promise.js\";\nimport readerIterator from \"./iterators/reader.js\";\nfunction isNodeResponse(value) {\n    return !!value.body;\n}\nfunction isReadableStream(value) {\n    return !!value.getReader;\n}\nfunction isAsyncIterableIterator(value) {\n    return !!(canUseAsyncIteratorSymbol &&\n        value[Symbol.asyncIterator]);\n}\nfunction isStreamableBlob(value) {\n    return !!value.stream;\n}\nfunction isBlob(value) {\n    return !!value.arrayBuffer;\n}\nfunction isNodeReadableStream(value) {\n    return !!value.pipe;\n}\nexport function responseIterator(response) {\n    var body = response;\n    if (isNodeResponse(response))\n        body = response.body;\n    if (isAsyncIterableIterator(body))\n        return asyncIterator(body);\n    if (isReadableStream(body))\n        return readerIterator(body.getReader());\n    // this errors without casting to ReadableStream<T>\n    // because Blob.stream() returns a NodeJS ReadableStream\n    if (isStreamableBlob(body)) {\n        return readerIterator(body.stream().getReader());\n    }\n    if (isBlob(body))\n        return promiseIterator(body.arrayBuffer());\n    if (isNodeReadableStream(body))\n        return nodeStreamIterator(body);\n    throw new Error(\"Unknown body type for responseIterator. Please pass a streamable response.\");\n}\n//# sourceMappingURL=responseIterator.js.map","export var throwServerError = function (response, result, message) {\n    var error = new Error(message);\n    error.name = \"ServerError\";\n    error.response = response;\n    error.statusCode = response.status;\n    error.result = result;\n    throw error;\n};\n//# sourceMappingURL=throwServerError.js.map","import { __assign, __awaiter, __generator } from \"tslib\";\nimport { responseIterator } from \"./responseIterator.js\";\nimport { throwServerError } from \"../utils/index.js\";\nimport { PROTOCOL_ERRORS_SYMBOL } from \"../../errors/index.js\";\nimport { isApolloPayloadResult } from \"../../utilities/common/incrementalResult.js\";\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nexport function readMultipartBody(response, nextValue) {\n    return __awaiter(this, void 0, void 0, function () {\n        var decoder, contentType, delimiter, boundaryVal, boundary, buffer, iterator, running, _a, value, done, chunk, searchFrom, bi, message, i, headers, contentType_1, body, result, next;\n        var _b, _c;\n        var _d;\n        return __generator(this, function (_e) {\n            switch (_e.label) {\n                case 0:\n                    if (TextDecoder === undefined) {\n                        throw new Error(\"TextDecoder must be defined in the environment: please import a polyfill.\");\n                    }\n                    decoder = new TextDecoder(\"utf-8\");\n                    contentType = (_d = response.headers) === null || _d === void 0 ? void 0 : _d.get(\"content-type\");\n                    delimiter = \"boundary=\";\n                    boundaryVal = (contentType === null || contentType === void 0 ? void 0 : contentType.includes(delimiter)) ?\n                        contentType === null || contentType === void 0 ? void 0 : contentType.substring((contentType === null || contentType === void 0 ? void 0 : contentType.indexOf(delimiter)) + delimiter.length).replace(/['\"]/g, \"\").replace(/\\;(.*)/gm, \"\").trim()\n                        : \"-\";\n                    boundary = \"\\r\\n--\".concat(boundaryVal);\n                    buffer = \"\";\n                    iterator = responseIterator(response);\n                    running = true;\n                    _e.label = 1;\n                case 1:\n                    if (!running) return [3 /*break*/, 3];\n                    return [4 /*yield*/, iterator.next()];\n                case 2:\n                    _a = _e.sent(), value = _a.value, done = _a.done;\n                    chunk = typeof value === \"string\" ? value : decoder.decode(value);\n                    searchFrom = buffer.length - boundary.length + 1;\n                    running = !done;\n                    buffer += chunk;\n                    bi = buffer.indexOf(boundary, searchFrom);\n                    while (bi > -1) {\n                        message = void 0;\n                        _b = [\n                            buffer.slice(0, bi),\n                            buffer.slice(bi + boundary.length),\n                        ], message = _b[0], buffer = _b[1];\n                        i = message.indexOf(\"\\r\\n\\r\\n\");\n                        headers = parseHeaders(message.slice(0, i));\n                        contentType_1 = headers[\"content-type\"];\n                        if (contentType_1 &&\n                            contentType_1.toLowerCase().indexOf(\"application/json\") === -1) {\n                            throw new Error(\"Unsupported patch content type: application/json is required.\");\n                        }\n                        body = message.slice(i);\n                        if (body) {\n                            result = parseJsonBody(response, body);\n                            if (Object.keys(result).length > 1 ||\n                                \"data\" in result ||\n                                \"incremental\" in result ||\n                                \"errors\" in result ||\n                                \"payload\" in result) {\n                                if (isApolloPayloadResult(result)) {\n                                    next = {};\n                                    if (\"payload\" in result) {\n                                        if (Object.keys(result).length === 1 && result.payload === null) {\n                                            return [2 /*return*/];\n                                        }\n                                        next = __assign({}, result.payload);\n                                    }\n                                    if (\"errors\" in result) {\n                                        next = __assign(__assign({}, next), { extensions: __assign(__assign({}, (\"extensions\" in next ? next.extensions : null)), (_c = {}, _c[PROTOCOL_ERRORS_SYMBOL] = result.errors, _c)) });\n                                    }\n                                    nextValue(next);\n                                }\n                                else {\n                                    // for the last chunk with only `hasNext: false`\n                                    // we don't need to call observer.next as there is no data/errors\n                                    nextValue(result);\n                                }\n                            }\n                            else if (\n                            // If the chunk contains only a \"hasNext: false\", we can call\n                            // observer.complete() immediately.\n                            Object.keys(result).length === 1 &&\n                                \"hasNext\" in result &&\n                                !result.hasNext) {\n                                return [2 /*return*/];\n                            }\n                        }\n                        bi = buffer.indexOf(boundary);\n                    }\n                    return [3 /*break*/, 1];\n                case 3: return [2 /*return*/];\n            }\n        });\n    });\n}\nexport function parseHeaders(headerText) {\n    var headersInit = {};\n    headerText.split(\"\\n\").forEach(function (line) {\n        var i = line.indexOf(\":\");\n        if (i > -1) {\n            // normalize headers to lowercase\n            var name_1 = line.slice(0, i).trim().toLowerCase();\n            var value = line.slice(i + 1).trim();\n            headersInit[name_1] = value;\n        }\n    });\n    return headersInit;\n}\nexport function parseJsonBody(response, bodyText) {\n    if (response.status >= 300) {\n        // Network error\n        var getResult = function () {\n            try {\n                return JSON.parse(bodyText);\n            }\n            catch (err) {\n                return bodyText;\n            }\n        };\n        throwServerError(response, getResult(), \"Response not successful: Received status code \".concat(response.status));\n    }\n    try {\n        return JSON.parse(bodyText);\n    }\n    catch (err) {\n        var parseError = err;\n        parseError.name = \"ServerParseError\";\n        parseError.response = response;\n        parseError.statusCode = response.status;\n        parseError.bodyText = bodyText;\n        throw parseError;\n    }\n}\nexport function handleError(err, observer) {\n    // if it is a network error, BUT there is graphql result info fire\n    // the next observer before calling error this gives apollo-client\n    // (and react-apollo) the `graphqlErrors` and `networkErrors` to\n    // pass to UI this should only happen if we *also* have data as\n    // part of the response key per the spec\n    if (err.result && err.result.errors && err.result.data) {\n        // if we don't call next, the UI can only show networkError\n        // because AC didn't get any graphqlErrors this is graphql\n        // execution result info (i.e errors and possibly data) this is\n        // because there is no formal spec how errors should translate to\n        // http status codes. So an auth error (401) could have both data\n        // from a public field, errors from a private field, and a status\n        // of 401\n        // {\n        //  user { // this will have errors\n        //    firstName\n        //  }\n        //  products { // this is public so will have data\n        //    cost\n        //  }\n        // }\n        //\n        // the result of above *could* look like this:\n        // {\n        //   data: { products: [{ cost: \"$10\" }] },\n        //   errors: [{\n        //      message: 'your session has timed out',\n        //      path: []\n        //   }]\n        // }\n        // status code of above would be a 401\n        // in the UI you want to show data where you can, errors as data where you can\n        // and use correct http status codes\n        observer.next(err.result);\n    }\n    observer.error(err);\n}\nexport function parseAndCheckHttpResponse(operations) {\n    return function (response) {\n        return response\n            .text()\n            .then(function (bodyText) { return parseJsonBody(response, bodyText); })\n            .then(function (result) {\n            if (!Array.isArray(result) &&\n                !hasOwnProperty.call(result, \"data\") &&\n                !hasOwnProperty.call(result, \"errors\")) {\n                // Data error\n                throwServerError(response, result, \"Server response was missing for query '\".concat(Array.isArray(operations) ?\n                    operations.map(function (op) { return op.operationName; })\n                    : operations.operationName, \"'.\"));\n            }\n            return result;\n        });\n    };\n}\n//# sourceMappingURL=parseAndCheckHttpResponse.js.map","import { newInvariantError } from \"../../utilities/globals/index.js\";\nexport var checkFetcher = function (fetcher) {\n    if (!fetcher && typeof fetch === \"undefined\") {\n        throw newInvariantError(38);\n    }\n};\n//# sourceMappingURL=checkFetcher.js.map","import { __assign, __spreadArray } from \"tslib\";\nimport { print } from \"../../utilities/index.js\";\nvar defaultHttpOptions = {\n    includeQuery: true,\n    includeExtensions: false,\n    preserveHeaderCase: false,\n};\nvar defaultHeaders = {\n    // headers are case insensitive (https://stackoverflow.com/a/5259004)\n    accept: \"*/*\",\n    // The content-type header describes the type of the body of the request, and\n    // so it typically only is sent with requests that actually have bodies. One\n    // could imagine that Apollo Client would remove this header when constructing\n    // a GET request (which has no body), but we historically have not done that.\n    // This means that browsers will preflight all Apollo Client requests (even\n    // GET requests). Apollo Server's CSRF prevention feature (introduced in\n    // AS3.7) takes advantage of this fact and does not block requests with this\n    // header. If you want to drop this header from GET requests, then you should\n    // probably replace it with a `apollo-require-preflight` header, or servers\n    // with CSRF prevention enabled might block your GET request. See\n    // https://www.apollographql.com/docs/apollo-server/security/cors/#preventing-cross-site-request-forgery-csrf\n    // for more details.\n    \"content-type\": \"application/json\",\n};\nvar defaultOptions = {\n    method: \"POST\",\n};\nexport var fallbackHttpConfig = {\n    http: defaultHttpOptions,\n    headers: defaultHeaders,\n    options: defaultOptions,\n};\nexport var defaultPrinter = function (ast, printer) { return printer(ast); };\nexport function selectHttpOptionsAndBody(operation, fallbackConfig) {\n    var configs = [];\n    for (var _i = 2; _i < arguments.length; _i++) {\n        configs[_i - 2] = arguments[_i];\n    }\n    configs.unshift(fallbackConfig);\n    return selectHttpOptionsAndBodyInternal.apply(void 0, __spreadArray([operation,\n        defaultPrinter], configs, false));\n}\nexport function selectHttpOptionsAndBodyInternal(operation, printer) {\n    var configs = [];\n    for (var _i = 2; _i < arguments.length; _i++) {\n        configs[_i - 2] = arguments[_i];\n    }\n    var options = {};\n    var http = {};\n    configs.forEach(function (config) {\n        options = __assign(__assign(__assign({}, options), config.options), { headers: __assign(__assign({}, options.headers), config.headers) });\n        if (config.credentials) {\n            options.credentials = config.credentials;\n        }\n        http = __assign(__assign({}, http), config.http);\n    });\n    if (options.headers) {\n        options.headers = removeDuplicateHeaders(options.headers, http.preserveHeaderCase);\n    }\n    //The body depends on the http options\n    var operationName = operation.operationName, extensions = operation.extensions, variables = operation.variables, query = operation.query;\n    var body = { operationName: operationName, variables: variables };\n    if (http.includeExtensions)\n        body.extensions = extensions;\n    // not sending the query (i.e persisted queries)\n    if (http.includeQuery)\n        body.query = printer(query, print);\n    return {\n        options: options,\n        body: body,\n    };\n}\n// Remove potential duplicate header names, preserving last (by insertion order).\n// This is done to prevent unintentionally duplicating a header instead of\n// overwriting it (See #8447 and #8449).\nfunction removeDuplicateHeaders(headers, preserveHeaderCase) {\n    // If we're not preserving the case, just remove duplicates w/ normalization.\n    if (!preserveHeaderCase) {\n        var normalizedHeaders_1 = {};\n        Object.keys(Object(headers)).forEach(function (name) {\n            normalizedHeaders_1[name.toLowerCase()] = headers[name];\n        });\n        return normalizedHeaders_1;\n    }\n    // If we are preserving the case, remove duplicates w/ normalization,\n    // preserving the original name.\n    // This allows for non-http-spec-compliant servers that expect intentionally\n    // capitalized header names (See #6741).\n    var headerData = {};\n    Object.keys(Object(headers)).forEach(function (name) {\n        headerData[name.toLowerCase()] = {\n            originalName: name,\n            value: headers[name],\n        };\n    });\n    var normalizedHeaders = {};\n    Object.keys(headerData).forEach(function (name) {\n        normalizedHeaders[headerData[name].originalName] = headerData[name].value;\n    });\n    return normalizedHeaders;\n}\n//# sourceMappingURL=selectHttpOptionsAndBody.js.map","import { serializeFetchParameter } from \"./serializeFetchParameter.js\";\n// For GET operations, returns the given URI rewritten with parameters, or a\n// parse error.\nexport function rewriteURIForGET(chosenURI, body) {\n    // Implement the standard HTTP GET serialization, plus 'extensions'. Note\n    // the extra level of JSON serialization!\n    var queryParams = [];\n    var addQueryParam = function (key, value) {\n        queryParams.push(\"\".concat(key, \"=\").concat(encodeURIComponent(value)));\n    };\n    if (\"query\" in body) {\n        addQueryParam(\"query\", body.query);\n    }\n    if (body.operationName) {\n        addQueryParam(\"operationName\", body.operationName);\n    }\n    if (body.variables) {\n        var serializedVariables = void 0;\n        try {\n            serializedVariables = serializeFetchParameter(body.variables, \"Variables map\");\n        }\n        catch (parseError) {\n            return { parseError: parseError };\n        }\n        addQueryParam(\"variables\", serializedVariables);\n    }\n    if (body.extensions) {\n        var serializedExtensions = void 0;\n        try {\n            serializedExtensions = serializeFetchParameter(body.extensions, \"Extensions map\");\n        }\n        catch (parseError) {\n            return { parseError: parseError };\n        }\n        addQueryParam(\"extensions\", serializedExtensions);\n    }\n    // Reconstruct the URI with added query params.\n    // XXX This assumes that the URI is well-formed and that it doesn't\n    //     already contain any of these query params. We could instead use the\n    //     URL API and take a polyfill (whatwg-url@6) for older browsers that\n    //     don't support URLSearchParams. Note that some browsers (and\n    //     versions of whatwg-url) support URL but not URLSearchParams!\n    var fragment = \"\", preFragment = chosenURI;\n    var fragmentStart = chosenURI.indexOf(\"#\");\n    if (fragmentStart !== -1) {\n        fragment = chosenURI.substr(fragmentStart);\n        preFragment = chosenURI.substr(0, fragmentStart);\n    }\n    var queryParamsPrefix = preFragment.indexOf(\"?\") === -1 ? \"?\" : \"&\";\n    var newURI = preFragment + queryParamsPrefix + queryParams.join(\"&\") + fragment;\n    return { newURI: newURI };\n}\n//# sourceMappingURL=rewriteURIForGET.js.map","import { Observable } from \"../../utilities/index.js\";\nexport function fromError(errorValue) {\n    return new Observable(function (observer) {\n        observer.error(errorValue);\n    });\n}\n//# sourceMappingURL=fromError.js.map","import { __assign } from \"tslib\";\nimport { visit } from \"graphql\";\nexport function filterOperationVariables(variables, query) {\n    var result = __assign({}, variables);\n    var unusedNames = new Set(Object.keys(variables));\n    visit(query, {\n        Variable: function (node, _key, parent) {\n            // A variable type definition at the top level of a query is not\n            // enough to silence server-side errors about the variable being\n            // unused, so variable definitions do not count as usage.\n            // https://spec.graphql.org/draft/#sec-All-Variables-Used\n            if (parent &&\n                parent.kind !== \"VariableDefinition\") {\n                unusedNames.delete(node.name.value);\n            }\n        },\n    });\n    unusedNames.forEach(function (name) {\n        delete result[name];\n    });\n    return result;\n}\n//# sourceMappingURL=filterOperationVariables.js.map","import { __assign, __rest } from \"tslib\";\nimport { invariant } from \"../../utilities/globals/index.js\";\nimport { ApolloLink } from \"../core/index.js\";\nimport { Observable, hasDirectives } from \"../../utilities/index.js\";\nimport { serializeFetchParameter } from \"./serializeFetchParameter.js\";\nimport { selectURI } from \"./selectURI.js\";\nimport { handleError, readMultipartBody, parseAndCheckHttpResponse, } from \"./parseAndCheckHttpResponse.js\";\nimport { checkFetcher } from \"./checkFetcher.js\";\nimport { selectHttpOptionsAndBodyInternal, defaultPrinter, fallbackHttpConfig, } from \"./selectHttpOptionsAndBody.js\";\nimport { rewriteURIForGET } from \"./rewriteURIForGET.js\";\nimport { fromError, filterOperationVariables } from \"../utils/index.js\";\nimport { maybe, getMainDefinition, removeClientSetsFromDocument, } from \"../../utilities/index.js\";\nvar backupFetch = maybe(function () { return fetch; });\nexport var createHttpLink = function (linkOptions) {\n    if (linkOptions === void 0) { linkOptions = {}; }\n    var _a = linkOptions.uri, uri = _a === void 0 ? \"/graphql\" : _a, \n    // use default global fetch if nothing passed in\n    preferredFetch = linkOptions.fetch, _b = linkOptions.print, print = _b === void 0 ? defaultPrinter : _b, includeExtensions = linkOptions.includeExtensions, preserveHeaderCase = linkOptions.preserveHeaderCase, useGETForQueries = linkOptions.useGETForQueries, _c = linkOptions.includeUnusedVariables, includeUnusedVariables = _c === void 0 ? false : _c, requestOptions = __rest(linkOptions, [\"uri\", \"fetch\", \"print\", \"includeExtensions\", \"preserveHeaderCase\", \"useGETForQueries\", \"includeUnusedVariables\"]);\n    if (globalThis.__DEV__ !== false) {\n        // Make sure at least one of preferredFetch, window.fetch, or backupFetch is\n        // defined, so requests won't fail at runtime.\n        checkFetcher(preferredFetch || backupFetch);\n    }\n    var linkConfig = {\n        http: { includeExtensions: includeExtensions, preserveHeaderCase: preserveHeaderCase },\n        options: requestOptions.fetchOptions,\n        credentials: requestOptions.credentials,\n        headers: requestOptions.headers,\n    };\n    return new ApolloLink(function (operation) {\n        var chosenURI = selectURI(operation, uri);\n        var context = operation.getContext();\n        // `apollographql-client-*` headers are automatically set if a\n        // `clientAwareness` object is found in the context. These headers are\n        // set first, followed by the rest of the headers pulled from\n        // `context.headers`. If desired, `apollographql-client-*` headers set by\n        // the `clientAwareness` object can be overridden by\n        // `apollographql-client-*` headers set in `context.headers`.\n        var clientAwarenessHeaders = {};\n        if (context.clientAwareness) {\n            var _a = context.clientAwareness, name_1 = _a.name, version = _a.version;\n            if (name_1) {\n                clientAwarenessHeaders[\"apollographql-client-name\"] = name_1;\n            }\n            if (version) {\n                clientAwarenessHeaders[\"apollographql-client-version\"] = version;\n            }\n        }\n        var contextHeaders = __assign(__assign({}, clientAwarenessHeaders), context.headers);\n        var contextConfig = {\n            http: context.http,\n            options: context.fetchOptions,\n            credentials: context.credentials,\n            headers: contextHeaders,\n        };\n        if (hasDirectives([\"client\"], operation.query)) {\n            var transformedQuery = removeClientSetsFromDocument(operation.query);\n            if (!transformedQuery) {\n                return fromError(new Error(\"HttpLink: Trying to send a client-only query to the server. To send to the server, ensure a non-client field is added to the query or set the `transformOptions.removeClientFields` option to `true`.\"));\n            }\n            operation.query = transformedQuery;\n        }\n        //uses fallback, link, and then context to build options\n        var _b = selectHttpOptionsAndBodyInternal(operation, print, fallbackHttpConfig, linkConfig, contextConfig), options = _b.options, body = _b.body;\n        if (body.variables && !includeUnusedVariables) {\n            body.variables = filterOperationVariables(body.variables, operation.query);\n        }\n        var controller;\n        if (!options.signal && typeof AbortController !== \"undefined\") {\n            controller = new AbortController();\n            options.signal = controller.signal;\n        }\n        // If requested, set method to GET if there are no mutations.\n        var definitionIsMutation = function (d) {\n            return d.kind === \"OperationDefinition\" && d.operation === \"mutation\";\n        };\n        var definitionIsSubscription = function (d) {\n            return d.kind === \"OperationDefinition\" && d.operation === \"subscription\";\n        };\n        var isSubscription = definitionIsSubscription(getMainDefinition(operation.query));\n        // does not match custom directives beginning with @defer\n        var hasDefer = hasDirectives([\"defer\"], operation.query);\n        if (useGETForQueries &&\n            !operation.query.definitions.some(definitionIsMutation)) {\n            options.method = \"GET\";\n        }\n        if (hasDefer || isSubscription) {\n            options.headers = options.headers || {};\n            var acceptHeader = \"multipart/mixed;\";\n            // Omit defer-specific headers if the user attempts to defer a selection\n            // set on a subscription and log a warning.\n            if (isSubscription && hasDefer) {\n                globalThis.__DEV__ !== false && invariant.warn(39);\n            }\n            if (isSubscription) {\n                acceptHeader +=\n                    \"boundary=graphql;subscriptionSpec=1.0,application/json\";\n            }\n            else if (hasDefer) {\n                acceptHeader += \"deferSpec=20220824,application/json\";\n            }\n            options.headers.accept = acceptHeader;\n        }\n        if (options.method === \"GET\") {\n            var _c = rewriteURIForGET(chosenURI, body), newURI = _c.newURI, parseError = _c.parseError;\n            if (parseError) {\n                return fromError(parseError);\n            }\n            chosenURI = newURI;\n        }\n        else {\n            try {\n                options.body = serializeFetchParameter(body, \"Payload\");\n            }\n            catch (parseError) {\n                return fromError(parseError);\n            }\n        }\n        return new Observable(function (observer) {\n            // Prefer linkOptions.fetch (preferredFetch) if provided, and otherwise\n            // fall back to the *current* global window.fetch function (see issue\n            // #7832), or (if all else fails) the backupFetch function we saved when\n            // this module was first evaluated. This last option protects against the\n            // removal of window.fetch, which is unlikely but not impossible.\n            var currentFetch = preferredFetch || maybe(function () { return fetch; }) || backupFetch;\n            var observerNext = observer.next.bind(observer);\n            currentFetch(chosenURI, options)\n                .then(function (response) {\n                var _a;\n                operation.setContext({ response: response });\n                var ctype = (_a = response.headers) === null || _a === void 0 ? void 0 : _a.get(\"content-type\");\n                if (ctype !== null && /^multipart\\/mixed/i.test(ctype)) {\n                    return readMultipartBody(response, observerNext);\n                }\n                else {\n                    return parseAndCheckHttpResponse(operation)(response).then(observerNext);\n                }\n            })\n                .then(function () {\n                controller = undefined;\n                observer.complete();\n            })\n                .catch(function (err) {\n                controller = undefined;\n                handleError(err, observer);\n            });\n            return function () {\n                // XXX support canceling this request\n                // https://developers.google.com/web/updates/2017/09/abortable-fetch\n                if (controller)\n                    controller.abort();\n            };\n        });\n    });\n};\n//# sourceMappingURL=createHttpLink.js.map","import { __extends } from \"tslib\";\nimport { ApolloLink } from \"../core/index.js\";\nimport { createHttpLink } from \"./createHttpLink.js\";\nvar HttpLink = /** @class */ (function (_super) {\n    __extends(HttpLink, _super);\n    function HttpLink(options) {\n        if (options === void 0) { options = {}; }\n        var _this = _super.call(this, createHttpLink(options).request) || this;\n        _this.options = options;\n        return _this;\n    }\n    return HttpLink;\n}(ApolloLink));\nexport { HttpLink };\n//# sourceMappingURL=HttpLink.js.map","import { AutoCleanedStrongCache, cacheSizes, } from \"../../utilities/caching/index.js\";\nimport { registerGlobalCache } from \"../caching/getMemoryInternals.js\";\n/**\n * Like JSON.stringify, but with object keys always sorted in the same order.\n *\n * To achieve performant sorting, this function uses a Map from JSON-serialized\n * arrays of keys (in any order) to sorted arrays of the same keys, with a\n * single sorted array reference shared by all permutations of the keys.\n *\n * As a drawback, this function will add a little bit more memory for every\n * object encountered that has different (more, less, a different order of) keys\n * than in the past.\n *\n * In a typical application, this extra memory usage should not play a\n * significant role, as `canonicalStringify` will be called for only a limited\n * number of object shapes, and the cache will not grow beyond a certain point.\n * But in some edge cases, this could be a problem, so we provide\n * canonicalStringify.reset() as a way of clearing the cache.\n * */\nexport var canonicalStringify = Object.assign(function canonicalStringify(value) {\n    return JSON.stringify(value, stableObjectReplacer);\n}, {\n    reset: function () {\n        // Clearing the sortingMap will reclaim all cached memory, without\n        // affecting the logical results of canonicalStringify, but potentially\n        // sacrificing performance until the cache is refilled.\n        sortingMap = new AutoCleanedStrongCache(cacheSizes.canonicalStringify || 1000 /* defaultCacheSizes.canonicalStringify */);\n    },\n});\nif (globalThis.__DEV__ !== false) {\n    registerGlobalCache(\"canonicalStringify\", function () { return sortingMap.size; });\n}\n// Values are JSON-serialized arrays of object keys (in any order), and values\n// are sorted arrays of the same keys.\nvar sortingMap;\ncanonicalStringify.reset();\n// The JSON.stringify function takes an optional second argument called a\n// replacer function. This function is called for each key-value pair in the\n// object being stringified, and its return value is used instead of the\n// original value. If the replacer function returns a new value, that value is\n// stringified as JSON instead of the original value of the property.\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#the_replacer_parameter\nfunction stableObjectReplacer(key, value) {\n    if (value && typeof value === \"object\") {\n        var proto = Object.getPrototypeOf(value);\n        // We don't want to mess with objects that are not \"plain\" objects, which\n        // means their prototype is either Object.prototype or null. This check also\n        // prevents needlessly rearranging the indices of arrays.\n        if (proto === Object.prototype || proto === null) {\n            var keys = Object.keys(value);\n            // If keys is already sorted, let JSON.stringify serialize the original\n            // value instead of creating a new object with keys in the same order.\n            if (keys.every(everyKeyInOrder))\n                return value;\n            var unsortedKey = JSON.stringify(keys);\n            var sortedKeys = sortingMap.get(unsortedKey);\n            if (!sortedKeys) {\n                keys.sort();\n                var sortedKey = JSON.stringify(keys);\n                // Checking for sortedKey in the sortingMap allows us to share the same\n                // sorted array reference for all permutations of the same set of keys.\n                sortedKeys = sortingMap.get(sortedKey) || keys;\n                sortingMap.set(unsortedKey, sortedKeys);\n                sortingMap.set(sortedKey, sortedKeys);\n            }\n            var sortedObject_1 = Object.create(proto);\n            // Reassigning the keys in sorted order will cause JSON.stringify to\n            // serialize them in sorted order.\n            sortedKeys.forEach(function (key) {\n                sortedObject_1[key] = value[key];\n            });\n            return sortedObject_1;\n        }\n    }\n    return value;\n}\n// Since everything that happens in stableObjectReplacer benefits from being as\n// efficient as possible, we use a static function as the callback for\n// keys.every in order to test if the provided keys are already sorted without\n// allocating extra memory for a callback.\nfunction everyKeyInOrder(key, i, keys) {\n    return i === 0 || keys[i - 1] <= key;\n}\n//# sourceMappingURL=canonicalStringify.js.map","var toString = Object.prototype.toString;\n/**\n * Deeply clones a value to create a new instance.\n */\nexport function cloneDeep(value) {\n    return cloneDeepHelper(value);\n}\nfunction cloneDeepHelper(val, seen) {\n    switch (toString.call(val)) {\n        case \"[object Array]\": {\n            seen = seen || new Map();\n            if (seen.has(val))\n                return seen.get(val);\n            var copy_1 = val.slice(0);\n            seen.set(val, copy_1);\n            copy_1.forEach(function (child, i) {\n                copy_1[i] = cloneDeepHelper(child, seen);\n            });\n            return copy_1;\n        }\n        case \"[object Object]\": {\n            seen = seen || new Map();\n            if (seen.has(val))\n                return seen.get(val);\n            // High fidelity polyfills of Object.create and Object.getPrototypeOf are\n            // possible in all JS environments, so we will assume they exist/work.\n            var copy_2 = Object.create(Object.getPrototypeOf(val));\n            seen.set(val, copy_2);\n            Object.keys(val).forEach(function (key) {\n                copy_2[key] = cloneDeepHelper(val[key], seen);\n            });\n            return copy_2;\n        }\n        default:\n            return val;\n    }\n}\n//# sourceMappingURL=cloneDeep.js.map","import { isNonNullObject } from \"./objects.js\";\nimport { isNonEmptyArray } from \"./arrays.js\";\nimport { DeepMerger } from \"./mergeDeep.js\";\nexport function isExecutionPatchIncrementalResult(value) {\n    return \"incremental\" in value;\n}\nexport function isExecutionPatchInitialResult(value) {\n    return \"hasNext\" in value && \"data\" in value;\n}\nexport function isExecutionPatchResult(value) {\n    return (isExecutionPatchIncrementalResult(value) ||\n        isExecutionPatchInitialResult(value));\n}\n// This function detects an Apollo payload result before it is transformed\n// into a FetchResult via HttpLink; it cannot detect an ApolloPayloadResult\n// once it leaves the link chain.\nexport function isApolloPayloadResult(value) {\n    return isNonNullObject(value) && \"payload\" in value;\n}\nexport function mergeIncrementalData(prevResult, result) {\n    var mergedData = prevResult;\n    var merger = new DeepMerger();\n    if (isExecutionPatchIncrementalResult(result) &&\n        isNonEmptyArray(result.incremental)) {\n        result.incremental.forEach(function (_a) {\n            var data = _a.data, path = _a.path;\n            for (var i = path.length - 1; i >= 0; --i) {\n                var key = path[i];\n                var isNumericKey = !isNaN(+key);\n                var parent_1 = isNumericKey ? [] : {};\n                parent_1[key] = data;\n                data = parent_1;\n            }\n            mergedData = merger.merge(mergedData, data);\n        });\n    }\n    return mergedData;\n}\n//# sourceMappingURL=incrementalResult.js.map","import { __assign, __spreadArray } from \"tslib\";\nimport { isNonNullObject } from \"./objects.js\";\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nexport function mergeDeep() {\n    var sources = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        sources[_i] = arguments[_i];\n    }\n    return mergeDeepArray(sources);\n}\n// In almost any situation where you could succeed in getting the\n// TypeScript compiler to infer a tuple type for the sources array, you\n// could just use mergeDeep instead of mergeDeepArray, so instead of\n// trying to convert T[] to an intersection type we just infer the array\n// element type, which works perfectly when the sources array has a\n// consistent element type.\nexport function mergeDeepArray(sources) {\n    var target = sources[0] || {};\n    var count = sources.length;\n    if (count > 1) {\n        var merger = new DeepMerger();\n        for (var i = 1; i < count; ++i) {\n            target = merger.merge(target, sources[i]);\n        }\n    }\n    return target;\n}\nvar defaultReconciler = function (target, source, property) {\n    return this.merge(target[property], source[property]);\n};\nvar DeepMerger = /** @class */ (function () {\n    function DeepMerger(reconciler) {\n        if (reconciler === void 0) { reconciler = defaultReconciler; }\n        this.reconciler = reconciler;\n        this.isObject = isNonNullObject;\n        this.pastCopies = new Set();\n    }\n    DeepMerger.prototype.merge = function (target, source) {\n        var _this = this;\n        var context = [];\n        for (var _i = 2; _i < arguments.length; _i++) {\n            context[_i - 2] = arguments[_i];\n        }\n        if (isNonNullObject(source) && isNonNullObject(target)) {\n            Object.keys(source).forEach(function (sourceKey) {\n                if (hasOwnProperty.call(target, sourceKey)) {\n                    var targetValue = target[sourceKey];\n                    if (source[sourceKey] !== targetValue) {\n                        var result = _this.reconciler.apply(_this, __spreadArray([target,\n                            source,\n                            sourceKey], context, false));\n                        // A well-implemented reconciler may return targetValue to indicate\n                        // the merge changed nothing about the structure of the target.\n                        if (result !== targetValue) {\n                            target = _this.shallowCopyForMerge(target);\n                            target[sourceKey] = result;\n                        }\n                    }\n                }\n                else {\n                    // If there is no collision, the target can safely share memory with\n                    // the source, and the recursion can terminate here.\n                    target = _this.shallowCopyForMerge(target);\n                    target[sourceKey] = source[sourceKey];\n                }\n            });\n            return target;\n        }\n        // If source (or target) is not an object, let source replace target.\n        return source;\n    };\n    DeepMerger.prototype.shallowCopyForMerge = function (value) {\n        if (isNonNullObject(value)) {\n            if (!this.pastCopies.has(value)) {\n                if (Array.isArray(value)) {\n                    value = value.slice(0);\n                }\n                else {\n                    value = __assign({ __proto__: Object.getPrototypeOf(value) }, value);\n                }\n                this.pastCopies.add(value);\n            }\n        }\n        return value;\n    };\n    return DeepMerger;\n}());\nexport { DeepMerger };\n//# sourceMappingURL=mergeDeep.js.map","import { Trie } from \"@wry/trie\";\nimport { canUseWeakMap, canUseWeakSet } from \"../common/canUse.js\";\nimport { checkDocument } from \"./getFromAST.js\";\nimport { invariant } from \"../globals/index.js\";\nimport { WeakCache } from \"@wry/caches\";\nimport { wrap } from \"optimism\";\nimport { cacheSizes } from \"../caching/index.js\";\nfunction identity(document) {\n    return document;\n}\nvar DocumentTransform = /** @class */ (function () {\n    function DocumentTransform(transform, options) {\n        if (options === void 0) { options = Object.create(null); }\n        this.resultCache = canUseWeakSet ? new WeakSet() : new Set();\n        this.transform = transform;\n        if (options.getCacheKey) {\n            // Override default `getCacheKey` function, which returns [document].\n            this.getCacheKey = options.getCacheKey;\n        }\n        this.cached = options.cache !== false;\n        this.resetCache();\n    }\n    // This default implementation of getCacheKey can be overridden by providing\n    // options.getCacheKey to the DocumentTransform constructor. In general, a\n    // getCacheKey function may either return an array of keys (often including\n    // the document) to be used as a cache key, or undefined to indicate the\n    // transform for this document should not be cached.\n    DocumentTransform.prototype.getCacheKey = function (document) {\n        return [document];\n    };\n    DocumentTransform.identity = function () {\n        // No need to cache this transform since it just returns the document\n        // unchanged. This should save a bit of memory that would otherwise be\n        // needed to populate the `documentCache` of this transform.\n        return new DocumentTransform(identity, { cache: false });\n    };\n    DocumentTransform.split = function (predicate, left, right) {\n        if (right === void 0) { right = DocumentTransform.identity(); }\n        return Object.assign(new DocumentTransform(function (document) {\n            var documentTransform = predicate(document) ? left : right;\n            return documentTransform.transformDocument(document);\n        }, \n        // Reasonably assume both `left` and `right` transforms handle their own caching\n        { cache: false }), { left: left, right: right });\n    };\n    /**\n     * Resets the internal cache of this transform, if it has one.\n     */\n    DocumentTransform.prototype.resetCache = function () {\n        var _this = this;\n        if (this.cached) {\n            var stableCacheKeys_1 = new Trie(canUseWeakMap);\n            this.performWork = wrap(DocumentTransform.prototype.performWork.bind(this), {\n                makeCacheKey: function (document) {\n                    var cacheKeys = _this.getCacheKey(document);\n                    if (cacheKeys) {\n                        invariant(Array.isArray(cacheKeys), 69);\n                        return stableCacheKeys_1.lookupArray(cacheKeys);\n                    }\n                },\n                max: cacheSizes[\"documentTransform.cache\"],\n                cache: (WeakCache),\n            });\n        }\n    };\n    DocumentTransform.prototype.performWork = function (document) {\n        checkDocument(document);\n        return this.transform(document);\n    };\n    DocumentTransform.prototype.transformDocument = function (document) {\n        // If a user passes an already transformed result back to this function,\n        // immediately return it.\n        if (this.resultCache.has(document)) {\n            return document;\n        }\n        var transformedDocument = this.performWork(document);\n        this.resultCache.add(transformedDocument);\n        return transformedDocument;\n    };\n    DocumentTransform.prototype.concat = function (otherTransform) {\n        var _this = this;\n        return Object.assign(new DocumentTransform(function (document) {\n            return otherTransform.transformDocument(_this.transformDocument(document));\n        }, \n        // Reasonably assume both transforms handle their own caching\n        { cache: false }), {\n            left: this,\n            right: otherTransform,\n        });\n    };\n    return DocumentTransform;\n}());\nexport { DocumentTransform };\n//# sourceMappingURL=DocumentTransform.js.map","import { invariant } from \"../globals/index.js\";\nimport { visit, BREAK } from \"graphql\";\nexport function shouldInclude(_a, variables) {\n    var directives = _a.directives;\n    if (!directives || !directives.length) {\n        return true;\n    }\n    return getInclusionDirectives(directives).every(function (_a) {\n        var directive = _a.directive, ifArgument = _a.ifArgument;\n        var evaledValue = false;\n        if (ifArgument.value.kind === \"Variable\") {\n            evaledValue =\n                variables && variables[ifArgument.value.name.value];\n            invariant(evaledValue !== void 0, 70, directive.name.value);\n        }\n        else {\n            evaledValue = ifArgument.value.value;\n        }\n        return directive.name.value === \"skip\" ? !evaledValue : evaledValue;\n    });\n}\nexport function getDirectiveNames(root) {\n    var names = [];\n    visit(root, {\n        Directive: function (node) {\n            names.push(node.name.value);\n        },\n    });\n    return names;\n}\nexport var hasAnyDirectives = function (names, root) {\n    return hasDirectives(names, root, false);\n};\nexport var hasAllDirectives = function (names, root) {\n    return hasDirectives(names, root, true);\n};\nexport function hasDirectives(names, root, all) {\n    var nameSet = new Set(names);\n    var uniqueCount = nameSet.size;\n    visit(root, {\n        Directive: function (node) {\n            if (nameSet.delete(node.name.value) && (!all || !nameSet.size)) {\n                return BREAK;\n            }\n        },\n    });\n    // If we found all the names, nameSet will be empty. If we only care about\n    // finding some of them, the < condition is sufficient.\n    return all ? !nameSet.size : nameSet.size < uniqueCount;\n}\nexport function hasClientExports(document) {\n    return document && hasDirectives([\"client\", \"export\"], document, true);\n}\nfunction isInclusionDirective(_a) {\n    var value = _a.name.value;\n    return value === \"skip\" || value === \"include\";\n}\nexport function getInclusionDirectives(directives) {\n    var result = [];\n    if (directives && directives.length) {\n        directives.forEach(function (directive) {\n            if (!isInclusionDirective(directive))\n                return;\n            var directiveArguments = directive.arguments;\n            var directiveName = directive.name.value;\n            invariant(directiveArguments && directiveArguments.length === 1, 71, directiveName);\n            var ifArgument = directiveArguments[0];\n            invariant(ifArgument.name && ifArgument.name.value === \"if\", 72, directiveName);\n            var ifValue = ifArgument.value;\n            // means it has to be a variable value if this is a valid @skip or @include directive\n            invariant(ifValue &&\n                (ifValue.kind === \"Variable\" || ifValue.kind === \"BooleanValue\"), 73, directiveName);\n            result.push({ directive: directive, ifArgument: ifArgument });\n        });\n    }\n    return result;\n}\n//# sourceMappingURL=directives.js.map","import { __assign, __spreadArray } from \"tslib\";\nimport { invariant, newInvariantError } from \"../globals/index.js\";\n/**\n * Returns a query document which adds a single query operation that only\n * spreads the target fragment inside of it.\n *\n * So for example a document of:\n *\n * ```graphql\n * fragment foo on Foo { a b c }\n * ```\n *\n * Turns into:\n *\n * ```graphql\n * { ...foo }\n *\n * fragment foo on Foo { a b c }\n * ```\n *\n * The target fragment will either be the only fragment in the document, or a\n * fragment specified by the provided `fragmentName`. If there is more than one\n * fragment, but a `fragmentName` was not defined then an error will be thrown.\n */\nexport function getFragmentQueryDocument(document, fragmentName) {\n    var actualFragmentName = fragmentName;\n    // Build an array of all our fragment definitions that will be used for\n    // validations. We also do some validations on the other definitions in the\n    // document while building this list.\n    var fragments = [];\n    document.definitions.forEach(function (definition) {\n        // Throw an error if we encounter an operation definition because we will\n        // define our own operation definition later on.\n        if (definition.kind === \"OperationDefinition\") {\n            throw newInvariantError(\n                74,\n                definition.operation,\n                definition.name ? \" named '\".concat(definition.name.value, \"'\") : \"\"\n            );\n        }\n        // Add our definition to the fragments array if it is a fragment\n        // definition.\n        if (definition.kind === \"FragmentDefinition\") {\n            fragments.push(definition);\n        }\n    });\n    // If the user did not give us a fragment name then let us try to get a\n    // name from a single fragment in the definition.\n    if (typeof actualFragmentName === \"undefined\") {\n        invariant(fragments.length === 1, 75, fragments.length);\n        actualFragmentName = fragments[0].name.value;\n    }\n    // Generate a query document with an operation that simply spreads the\n    // fragment inside of it.\n    var query = __assign(__assign({}, document), { definitions: __spreadArray([\n            {\n                kind: \"OperationDefinition\",\n                // OperationTypeNode is an enum\n                operation: \"query\",\n                selectionSet: {\n                    kind: \"SelectionSet\",\n                    selections: [\n                        {\n                            kind: \"FragmentSpread\",\n                            name: {\n                                kind: \"Name\",\n                                value: actualFragmentName,\n                            },\n                        },\n                    ],\n                },\n            }\n        ], document.definitions, true) });\n    return query;\n}\n// Utility function that takes a list of fragment definitions and makes a hash out of them\n// that maps the name of the fragment to the fragment definition.\nexport function createFragmentMap(fragments) {\n    if (fragments === void 0) { fragments = []; }\n    var symTable = {};\n    fragments.forEach(function (fragment) {\n        symTable[fragment.name.value] = fragment;\n    });\n    return symTable;\n}\nexport function getFragmentFromSelection(selection, fragmentMap) {\n    switch (selection.kind) {\n        case \"InlineFragment\":\n            return selection;\n        case \"FragmentSpread\": {\n            var fragmentName = selection.name.value;\n            if (typeof fragmentMap === \"function\") {\n                return fragmentMap(fragmentName);\n            }\n            var fragment = fragmentMap && fragmentMap[fragmentName];\n            invariant(fragment, 76, fragmentName);\n            return fragment || null;\n        }\n        default:\n            return null;\n    }\n}\n//# sourceMappingURL=fragments.js.map","import { invariant, newInvariantError } from \"../globals/index.js\";\nimport { valueToObjectRepresentation } from \"./storeUtils.js\";\n// Checks the document for errors and throws an exception if there is an error.\nexport function checkDocument(doc) {\n    invariant(doc && doc.kind === \"Document\", 77);\n    var operations = doc.definitions\n        .filter(function (d) { return d.kind !== \"FragmentDefinition\"; })\n        .map(function (definition) {\n        if (definition.kind !== \"OperationDefinition\") {\n            throw newInvariantError(78, definition.kind);\n        }\n        return definition;\n    });\n    invariant(operations.length <= 1, 79, operations.length);\n    return doc;\n}\nexport function getOperationDefinition(doc) {\n    checkDocument(doc);\n    return doc.definitions.filter(function (definition) {\n        return definition.kind === \"OperationDefinition\";\n    })[0];\n}\nexport function getOperationName(doc) {\n    return (doc.definitions\n        .filter(function (definition) {\n        return definition.kind === \"OperationDefinition\" && !!definition.name;\n    })\n        .map(function (x) { return x.name.value; })[0] || null);\n}\n// Returns the FragmentDefinitions from a particular document as an array\nexport function getFragmentDefinitions(doc) {\n    return doc.definitions.filter(function (definition) {\n        return definition.kind === \"FragmentDefinition\";\n    });\n}\nexport function getQueryDefinition(doc) {\n    var queryDef = getOperationDefinition(doc);\n    invariant(queryDef && queryDef.operation === \"query\", 80);\n    return queryDef;\n}\nexport function getFragmentDefinition(doc) {\n    invariant(doc.kind === \"Document\", 81);\n    invariant(doc.definitions.length <= 1, 82);\n    var fragmentDef = doc.definitions[0];\n    invariant(fragmentDef.kind === \"FragmentDefinition\", 83);\n    return fragmentDef;\n}\n/**\n * Returns the first operation definition found in this document.\n * If no operation definition is found, the first fragment definition will be returned.\n * If no definitions are found, an error will be thrown.\n */\nexport function getMainDefinition(queryDoc) {\n    checkDocument(queryDoc);\n    var fragmentDefinition;\n    for (var _i = 0, _a = queryDoc.definitions; _i < _a.length; _i++) {\n        var definition = _a[_i];\n        if (definition.kind === \"OperationDefinition\") {\n            var operation = definition.operation;\n            if (operation === \"query\" ||\n                operation === \"mutation\" ||\n                operation === \"subscription\") {\n                return definition;\n            }\n        }\n        if (definition.kind === \"FragmentDefinition\" && !fragmentDefinition) {\n            // we do this because we want to allow multiple fragment definitions\n            // to precede an operation definition.\n            fragmentDefinition = definition;\n        }\n    }\n    if (fragmentDefinition) {\n        return fragmentDefinition;\n    }\n    throw newInvariantError(84);\n}\nexport function getDefaultValues(definition) {\n    var defaultValues = Object.create(null);\n    var defs = definition && definition.variableDefinitions;\n    if (defs && defs.length) {\n        defs.forEach(function (def) {\n            if (def.defaultValue) {\n                valueToObjectRepresentation(defaultValues, def.variable.name, def.defaultValue);\n            }\n        });\n    }\n    return defaultValues;\n}\n//# sourceMappingURL=getFromAST.js.map","/**\n * Prints a string as a GraphQL StringValue literal. Replaces control characters\n * and excluded characters (\" U+0022 and \\\\ U+005C) with escape sequences.\n */\nexport function printString(str) {\n  return `\"${str.replace(escapedRegExp, escapedReplacer)}\"`;\n} // eslint-disable-next-line no-control-regex\n\nconst escapedRegExp = /[\\x00-\\x1f\\x22\\x5c\\x7f-\\x9f]/g;\n\nfunction escapedReplacer(str) {\n  return escapeSequences[str.charCodeAt(0)];\n} // prettier-ignore\n\nconst escapeSequences = [\n  '\\\\u0000',\n  '\\\\u0001',\n  '\\\\u0002',\n  '\\\\u0003',\n  '\\\\u0004',\n  '\\\\u0005',\n  '\\\\u0006',\n  '\\\\u0007',\n  '\\\\b',\n  '\\\\t',\n  '\\\\n',\n  '\\\\u000B',\n  '\\\\f',\n  '\\\\r',\n  '\\\\u000E',\n  '\\\\u000F',\n  '\\\\u0010',\n  '\\\\u0011',\n  '\\\\u0012',\n  '\\\\u0013',\n  '\\\\u0014',\n  '\\\\u0015',\n  '\\\\u0016',\n  '\\\\u0017',\n  '\\\\u0018',\n  '\\\\u0019',\n  '\\\\u001A',\n  '\\\\u001B',\n  '\\\\u001C',\n  '\\\\u001D',\n  '\\\\u001E',\n  '\\\\u001F',\n  '',\n  '',\n  '\\\\\"',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '', // 2F\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '', // 3F\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '', // 4F\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '\\\\\\\\',\n  '',\n  '',\n  '', // 5F\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '', // 6F\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '\\\\u007F',\n  '\\\\u0080',\n  '\\\\u0081',\n  '\\\\u0082',\n  '\\\\u0083',\n  '\\\\u0084',\n  '\\\\u0085',\n  '\\\\u0086',\n  '\\\\u0087',\n  '\\\\u0088',\n  '\\\\u0089',\n  '\\\\u008A',\n  '\\\\u008B',\n  '\\\\u008C',\n  '\\\\u008D',\n  '\\\\u008E',\n  '\\\\u008F',\n  '\\\\u0090',\n  '\\\\u0091',\n  '\\\\u0092',\n  '\\\\u0093',\n  '\\\\u0094',\n  '\\\\u0095',\n  '\\\\u0096',\n  '\\\\u0097',\n  '\\\\u0098',\n  '\\\\u0099',\n  '\\\\u009A',\n  '\\\\u009B',\n  '\\\\u009C',\n  '\\\\u009D',\n  '\\\\u009E',\n  '\\\\u009F',\n];\n","import { printBlockString } from './blockString.mjs';\nimport { printString } from './printString.mjs';\nimport { visit } from './visitor.mjs';\n/**\n * Converts an AST into a string, using one set of reasonable\n * formatting rules.\n */\n\nexport function print(ast) {\n  return visit(ast, printDocASTReducer);\n}\nconst MAX_LINE_LENGTH = 80;\nconst printDocASTReducer = {\n  Name: {\n    leave: (node) => node.value,\n  },\n  Variable: {\n    leave: (node) => '$' + node.name,\n  },\n  // Document\n  Document: {\n    leave: (node) => join(node.definitions, '\\n\\n'),\n  },\n  OperationDefinition: {\n    leave(node) {\n      const varDefs = wrap('(', join(node.variableDefinitions, ', '), ')');\n      const prefix = join(\n        [\n          node.operation,\n          join([node.name, varDefs]),\n          join(node.directives, ' '),\n        ],\n        ' ',\n      ); // Anonymous queries with no directives or variable definitions can use\n      // the query short form.\n\n      return (prefix === 'query' ? '' : prefix + ' ') + node.selectionSet;\n    },\n  },\n  VariableDefinition: {\n    leave: ({ variable, type, defaultValue, directives }) =>\n      variable +\n      ': ' +\n      type +\n      wrap(' = ', defaultValue) +\n      wrap(' ', join(directives, ' ')),\n  },\n  SelectionSet: {\n    leave: ({ selections }) => block(selections),\n  },\n  Field: {\n    leave({ alias, name, arguments: args, directives, selectionSet }) {\n      const prefix = wrap('', alias, ': ') + name;\n      let argsLine = prefix + wrap('(', join(args, ', '), ')');\n\n      if (argsLine.length > MAX_LINE_LENGTH) {\n        argsLine = prefix + wrap('(\\n', indent(join(args, '\\n')), '\\n)');\n      }\n\n      return join([argsLine, join(directives, ' '), selectionSet], ' ');\n    },\n  },\n  Argument: {\n    leave: ({ name, value }) => name + ': ' + value,\n  },\n  // Fragments\n  FragmentSpread: {\n    leave: ({ name, directives }) =>\n      '...' + name + wrap(' ', join(directives, ' ')),\n  },\n  InlineFragment: {\n    leave: ({ typeCondition, directives, selectionSet }) =>\n      join(\n        [\n          '...',\n          wrap('on ', typeCondition),\n          join(directives, ' '),\n          selectionSet,\n        ],\n        ' ',\n      ),\n  },\n  FragmentDefinition: {\n    leave: (\n      { name, typeCondition, variableDefinitions, directives, selectionSet }, // Note: fragment variable definitions are experimental and may be changed\n    ) =>\n      // or removed in the future.\n      `fragment ${name}${wrap('(', join(variableDefinitions, ', '), ')')} ` +\n      `on ${typeCondition} ${wrap('', join(directives, ' '), ' ')}` +\n      selectionSet,\n  },\n  // Value\n  IntValue: {\n    leave: ({ value }) => value,\n  },\n  FloatValue: {\n    leave: ({ value }) => value,\n  },\n  StringValue: {\n    leave: ({ value, block: isBlockString }) =>\n      isBlockString ? printBlockString(value) : printString(value),\n  },\n  BooleanValue: {\n    leave: ({ value }) => (value ? 'true' : 'false'),\n  },\n  NullValue: {\n    leave: () => 'null',\n  },\n  EnumValue: {\n    leave: ({ value }) => value,\n  },\n  ListValue: {\n    leave: ({ values }) => '[' + join(values, ', ') + ']',\n  },\n  ObjectValue: {\n    leave: ({ fields }) => '{' + join(fields, ', ') + '}',\n  },\n  ObjectField: {\n    leave: ({ name, value }) => name + ': ' + value,\n  },\n  // Directive\n  Directive: {\n    leave: ({ name, arguments: args }) =>\n      '@' + name + wrap('(', join(args, ', '), ')'),\n  },\n  // Type\n  NamedType: {\n    leave: ({ name }) => name,\n  },\n  ListType: {\n    leave: ({ type }) => '[' + type + ']',\n  },\n  NonNullType: {\n    leave: ({ type }) => type + '!',\n  },\n  // Type System Definitions\n  SchemaDefinition: {\n    leave: ({ description, directives, operationTypes }) =>\n      wrap('', description, '\\n') +\n      join(['schema', join(directives, ' '), block(operationTypes)], ' '),\n  },\n  OperationTypeDefinition: {\n    leave: ({ operation, type }) => operation + ': ' + type,\n  },\n  ScalarTypeDefinition: {\n    leave: ({ description, name, directives }) =>\n      wrap('', description, '\\n') +\n      join(['scalar', name, join(directives, ' ')], ' '),\n  },\n  ObjectTypeDefinition: {\n    leave: ({ description, name, interfaces, directives, fields }) =>\n      wrap('', description, '\\n') +\n      join(\n        [\n          'type',\n          name,\n          wrap('implements ', join(interfaces, ' & ')),\n          join(directives, ' '),\n          block(fields),\n        ],\n        ' ',\n      ),\n  },\n  FieldDefinition: {\n    leave: ({ description, name, arguments: args, type, directives }) =>\n      wrap('', description, '\\n') +\n      name +\n      (hasMultilineItems(args)\n        ? wrap('(\\n', indent(join(args, '\\n')), '\\n)')\n        : wrap('(', join(args, ', '), ')')) +\n      ': ' +\n      type +\n      wrap(' ', join(directives, ' ')),\n  },\n  InputValueDefinition: {\n    leave: ({ description, name, type, defaultValue, directives }) =>\n      wrap('', description, '\\n') +\n      join(\n        [name + ': ' + type, wrap('= ', defaultValue), join(directives, ' ')],\n        ' ',\n      ),\n  },\n  InterfaceTypeDefinition: {\n    leave: ({ description, name, interfaces, directives, fields }) =>\n      wrap('', description, '\\n') +\n      join(\n        [\n          'interface',\n          name,\n          wrap('implements ', join(interfaces, ' & ')),\n          join(directives, ' '),\n          block(fields),\n        ],\n        ' ',\n      ),\n  },\n  UnionTypeDefinition: {\n    leave: ({ description, name, directives, types }) =>\n      wrap('', description, '\\n') +\n      join(\n        ['union', name, join(directives, ' '), wrap('= ', join(types, ' | '))],\n        ' ',\n      ),\n  },\n  EnumTypeDefinition: {\n    leave: ({ description, name, directives, values }) =>\n      wrap('', description, '\\n') +\n      join(['enum', name, join(directives, ' '), block(values)], ' '),\n  },\n  EnumValueDefinition: {\n    leave: ({ description, name, directives }) =>\n      wrap('', description, '\\n') + join([name, join(directives, ' ')], ' '),\n  },\n  InputObjectTypeDefinition: {\n    leave: ({ description, name, directives, fields }) =>\n      wrap('', description, '\\n') +\n      join(['input', name, join(directives, ' '), block(fields)], ' '),\n  },\n  DirectiveDefinition: {\n    leave: ({ description, name, arguments: args, repeatable, locations }) =>\n      wrap('', description, '\\n') +\n      'directive @' +\n      name +\n      (hasMultilineItems(args)\n        ? wrap('(\\n', indent(join(args, '\\n')), '\\n)')\n        : wrap('(', join(args, ', '), ')')) +\n      (repeatable ? ' repeatable' : '') +\n      ' on ' +\n      join(locations, ' | '),\n  },\n  SchemaExtension: {\n    leave: ({ directives, operationTypes }) =>\n      join(\n        ['extend schema', join(directives, ' '), block(operationTypes)],\n        ' ',\n      ),\n  },\n  ScalarTypeExtension: {\n    leave: ({ name, directives }) =>\n      join(['extend scalar', name, join(directives, ' ')], ' '),\n  },\n  ObjectTypeExtension: {\n    leave: ({ name, interfaces, directives, fields }) =>\n      join(\n        [\n          'extend type',\n          name,\n          wrap('implements ', join(interfaces, ' & ')),\n          join(directives, ' '),\n          block(fields),\n        ],\n        ' ',\n      ),\n  },\n  InterfaceTypeExtension: {\n    leave: ({ name, interfaces, directives, fields }) =>\n      join(\n        [\n          'extend interface',\n          name,\n          wrap('implements ', join(interfaces, ' & ')),\n          join(directives, ' '),\n          block(fields),\n        ],\n        ' ',\n      ),\n  },\n  UnionTypeExtension: {\n    leave: ({ name, directives, types }) =>\n      join(\n        [\n          'extend union',\n          name,\n          join(directives, ' '),\n          wrap('= ', join(types, ' | ')),\n        ],\n        ' ',\n      ),\n  },\n  EnumTypeExtension: {\n    leave: ({ name, directives, values }) =>\n      join(['extend enum', name, join(directives, ' '), block(values)], ' '),\n  },\n  InputObjectTypeExtension: {\n    leave: ({ name, directives, fields }) =>\n      join(['extend input', name, join(directives, ' '), block(fields)], ' '),\n  },\n};\n/**\n * Given maybeArray, print an empty string if it is null or empty, otherwise\n * print all items together separated by separator if provided\n */\n\nfunction join(maybeArray, separator = '') {\n  var _maybeArray$filter$jo;\n\n  return (_maybeArray$filter$jo =\n    maybeArray === null || maybeArray === void 0\n      ? void 0\n      : maybeArray.filter((x) => x).join(separator)) !== null &&\n    _maybeArray$filter$jo !== void 0\n    ? _maybeArray$filter$jo\n    : '';\n}\n/**\n * Given array, print each item on its own line, wrapped in an indented `{ }` block.\n */\n\nfunction block(array) {\n  return wrap('{\\n', indent(join(array, '\\n')), '\\n}');\n}\n/**\n * If maybeString is not null or empty, then wrap with start and end, otherwise print an empty string.\n */\n\nfunction wrap(start, maybeString, end = '') {\n  return maybeString != null && maybeString !== ''\n    ? start + maybeString + end\n    : '';\n}\n\nfunction indent(str) {\n  return wrap('  ', str.replace(/\\n/g, '\\n  '));\n}\n\nfunction hasMultilineItems(maybeArray) {\n  var _maybeArray$some;\n\n  // FIXME: https://github.com/graphql/graphql-js/issues/2203\n\n  /* c8 ignore next */\n  return (_maybeArray$some =\n    maybeArray === null || maybeArray === void 0\n      ? void 0\n      : maybeArray.some((str) => str.includes('\\n'))) !== null &&\n    _maybeArray$some !== void 0\n    ? _maybeArray$some\n    : false;\n}\n","import { print as origPrint } from \"graphql\";\nimport { AutoCleanedWeakCache, cacheSizes, } from \"../caching/index.js\";\nimport { registerGlobalCache } from \"../caching/getMemoryInternals.js\";\nvar printCache;\nexport var print = Object.assign(function (ast) {\n    var result = printCache.get(ast);\n    if (!result) {\n        result = origPrint(ast);\n        printCache.set(ast, result);\n    }\n    return result;\n}, {\n    reset: function () {\n        printCache = new AutoCleanedWeakCache(cacheSizes.print || 2000 /* defaultCacheSizes.print */);\n    },\n});\nprint.reset();\nif (globalThis.__DEV__ !== false) {\n    registerGlobalCache(\"print\", function () { return (printCache ? printCache.size : 0); });\n}\n//# sourceMappingURL=print.js.map","import { newInvariantError } from \"../globals/index.js\";\nimport { isNonNullObject } from \"../common/objects.js\";\nimport { getFragmentFromSelection } from \"./fragments.js\";\nimport { canonicalStringify } from \"../common/canonicalStringify.js\";\nexport function makeReference(id) {\n    return { __ref: String(id) };\n}\nexport function isReference(obj) {\n    return Boolean(obj && typeof obj === \"object\" && typeof obj.__ref === \"string\");\n}\nexport function isDocumentNode(value) {\n    return (isNonNullObject(value) &&\n        value.kind === \"Document\" &&\n        Array.isArray(value.definitions));\n}\nfunction isStringValue(value) {\n    return value.kind === \"StringValue\";\n}\nfunction isBooleanValue(value) {\n    return value.kind === \"BooleanValue\";\n}\nfunction isIntValue(value) {\n    return value.kind === \"IntValue\";\n}\nfunction isFloatValue(value) {\n    return value.kind === \"FloatValue\";\n}\nfunction isVariable(value) {\n    return value.kind === \"Variable\";\n}\nfunction isObjectValue(value) {\n    return value.kind === \"ObjectValue\";\n}\nfunction isListValue(value) {\n    return value.kind === \"ListValue\";\n}\nfunction isEnumValue(value) {\n    return value.kind === \"EnumValue\";\n}\nfunction isNullValue(value) {\n    return value.kind === \"NullValue\";\n}\nexport function valueToObjectRepresentation(argObj, name, value, variables) {\n    if (isIntValue(value) || isFloatValue(value)) {\n        argObj[name.value] = Number(value.value);\n    }\n    else if (isBooleanValue(value) || isStringValue(value)) {\n        argObj[name.value] = value.value;\n    }\n    else if (isObjectValue(value)) {\n        var nestedArgObj_1 = {};\n        value.fields.map(function (obj) {\n            return valueToObjectRepresentation(nestedArgObj_1, obj.name, obj.value, variables);\n        });\n        argObj[name.value] = nestedArgObj_1;\n    }\n    else if (isVariable(value)) {\n        var variableValue = (variables || {})[value.name.value];\n        argObj[name.value] = variableValue;\n    }\n    else if (isListValue(value)) {\n        argObj[name.value] = value.values.map(function (listValue) {\n            var nestedArgArrayObj = {};\n            valueToObjectRepresentation(nestedArgArrayObj, name, listValue, variables);\n            return nestedArgArrayObj[name.value];\n        });\n    }\n    else if (isEnumValue(value)) {\n        argObj[name.value] = value.value;\n    }\n    else if (isNullValue(value)) {\n        argObj[name.value] = null;\n    }\n    else {\n        throw newInvariantError(85, name.value, value.kind);\n    }\n}\nexport function storeKeyNameFromField(field, variables) {\n    var directivesObj = null;\n    if (field.directives) {\n        directivesObj = {};\n        field.directives.forEach(function (directive) {\n            directivesObj[directive.name.value] = {};\n            if (directive.arguments) {\n                directive.arguments.forEach(function (_a) {\n                    var name = _a.name, value = _a.value;\n                    return valueToObjectRepresentation(directivesObj[directive.name.value], name, value, variables);\n                });\n            }\n        });\n    }\n    var argObj = null;\n    if (field.arguments && field.arguments.length) {\n        argObj = {};\n        field.arguments.forEach(function (_a) {\n            var name = _a.name, value = _a.value;\n            return valueToObjectRepresentation(argObj, name, value, variables);\n        });\n    }\n    return getStoreKeyName(field.name.value, argObj, directivesObj);\n}\nvar KNOWN_DIRECTIVES = [\n    \"connection\",\n    \"include\",\n    \"skip\",\n    \"client\",\n    \"rest\",\n    \"export\",\n    \"nonreactive\",\n];\n// Default stable JSON.stringify implementation used by getStoreKeyName. Can be\n// updated/replaced with something better by calling\n// getStoreKeyName.setStringify(newStringifyFunction).\nvar storeKeyNameStringify = canonicalStringify;\nexport var getStoreKeyName = Object.assign(function (fieldName, args, directives) {\n    if (args &&\n        directives &&\n        directives[\"connection\"] &&\n        directives[\"connection\"][\"key\"]) {\n        if (directives[\"connection\"][\"filter\"] &&\n            directives[\"connection\"][\"filter\"].length > 0) {\n            var filterKeys = directives[\"connection\"][\"filter\"] ?\n                directives[\"connection\"][\"filter\"]\n                : [];\n            filterKeys.sort();\n            var filteredArgs_1 = {};\n            filterKeys.forEach(function (key) {\n                filteredArgs_1[key] = args[key];\n            });\n            return \"\".concat(directives[\"connection\"][\"key\"], \"(\").concat(storeKeyNameStringify(filteredArgs_1), \")\");\n        }\n        else {\n            return directives[\"connection\"][\"key\"];\n        }\n    }\n    var completeFieldName = fieldName;\n    if (args) {\n        // We can't use `JSON.stringify` here since it's non-deterministic,\n        // and can lead to different store key names being created even though\n        // the `args` object used during creation has the same properties/values.\n        var stringifiedArgs = storeKeyNameStringify(args);\n        completeFieldName += \"(\".concat(stringifiedArgs, \")\");\n    }\n    if (directives) {\n        Object.keys(directives).forEach(function (key) {\n            if (KNOWN_DIRECTIVES.indexOf(key) !== -1)\n                return;\n            if (directives[key] && Object.keys(directives[key]).length) {\n                completeFieldName += \"@\".concat(key, \"(\").concat(storeKeyNameStringify(directives[key]), \")\");\n            }\n            else {\n                completeFieldName += \"@\".concat(key);\n            }\n        });\n    }\n    return completeFieldName;\n}, {\n    setStringify: function (s) {\n        var previous = storeKeyNameStringify;\n        storeKeyNameStringify = s;\n        return previous;\n    },\n});\nexport function argumentsObjectFromField(field, variables) {\n    if (field.arguments && field.arguments.length) {\n        var argObj_1 = {};\n        field.arguments.forEach(function (_a) {\n            var name = _a.name, value = _a.value;\n            return valueToObjectRepresentation(argObj_1, name, value, variables);\n        });\n        return argObj_1;\n    }\n    return null;\n}\nexport function resultKeyNameFromField(field) {\n    return field.alias ? field.alias.value : field.name.value;\n}\nexport function getTypenameFromResult(result, selectionSet, fragmentMap) {\n    var fragments;\n    for (var _i = 0, _a = selectionSet.selections; _i < _a.length; _i++) {\n        var selection = _a[_i];\n        if (isField(selection)) {\n            if (selection.name.value === \"__typename\") {\n                return result[resultKeyNameFromField(selection)];\n            }\n        }\n        else if (fragments) {\n            fragments.push(selection);\n        }\n        else {\n            fragments = [selection];\n        }\n    }\n    if (typeof result.__typename === \"string\") {\n        return result.__typename;\n    }\n    if (fragments) {\n        for (var _b = 0, fragments_1 = fragments; _b < fragments_1.length; _b++) {\n            var selection = fragments_1[_b];\n            var typename = getTypenameFromResult(result, getFragmentFromSelection(selection, fragmentMap).selectionSet, fragmentMap);\n            if (typeof typename === \"string\") {\n                return typename;\n            }\n        }\n    }\n}\nexport function isField(selection) {\n    return selection.kind === \"Field\";\n}\nexport function isInlineFragment(selection) {\n    return selection.kind === \"InlineFragment\";\n}\n//# sourceMappingURL=storeUtils.js.map","import { __assign, __spreadArray } from \"tslib\";\nimport { invariant } from \"../globals/index.js\";\nimport { visit, Kind } from \"graphql\";\nimport { checkDocument, getOperationDefinition, getFragmentDefinition, getFragmentDefinitions, getMainDefinition, } from \"./getFromAST.js\";\nimport { isField } from \"./storeUtils.js\";\nimport { createFragmentMap } from \"./fragments.js\";\nimport { isArray, isNonEmptyArray } from \"../common/arrays.js\";\nvar TYPENAME_FIELD = {\n    kind: Kind.FIELD,\n    name: {\n        kind: Kind.NAME,\n        value: \"__typename\",\n    },\n};\nfunction isEmpty(op, fragmentMap) {\n    return (!op ||\n        op.selectionSet.selections.every(function (selection) {\n            return selection.kind === Kind.FRAGMENT_SPREAD &&\n                isEmpty(fragmentMap[selection.name.value], fragmentMap);\n        }));\n}\nfunction nullIfDocIsEmpty(doc) {\n    return (isEmpty(getOperationDefinition(doc) || getFragmentDefinition(doc), createFragmentMap(getFragmentDefinitions(doc)))) ?\n        null\n        : doc;\n}\nfunction getDirectiveMatcher(configs) {\n    var names = new Map();\n    var tests = new Map();\n    configs.forEach(function (directive) {\n        if (directive) {\n            if (directive.name) {\n                names.set(directive.name, directive);\n            }\n            else if (directive.test) {\n                tests.set(directive.test, directive);\n            }\n        }\n    });\n    return function (directive) {\n        var config = names.get(directive.name.value);\n        if (!config && tests.size) {\n            tests.forEach(function (testConfig, test) {\n                if (test(directive)) {\n                    config = testConfig;\n                }\n            });\n        }\n        return config;\n    };\n}\nfunction makeInUseGetterFunction(defaultKey) {\n    var map = new Map();\n    return function inUseGetterFunction(key) {\n        if (key === void 0) { key = defaultKey; }\n        var inUse = map.get(key);\n        if (!inUse) {\n            map.set(key, (inUse = {\n                // Variable and fragment spread names used directly within this\n                // operation or fragment definition, as identified by key. These sets\n                // will be populated during the first traversal of the document in\n                // removeDirectivesFromDocument below.\n                variables: new Set(),\n                fragmentSpreads: new Set(),\n            }));\n        }\n        return inUse;\n    };\n}\nexport function removeDirectivesFromDocument(directives, doc) {\n    checkDocument(doc);\n    // Passing empty strings to makeInUseGetterFunction means we handle anonymous\n    // operations as if their names were \"\". Anonymous fragment definitions are\n    // not supposed to be possible, but the same default naming strategy seems\n    // appropriate for that case as well.\n    var getInUseByOperationName = makeInUseGetterFunction(\"\");\n    var getInUseByFragmentName = makeInUseGetterFunction(\"\");\n    var getInUse = function (ancestors) {\n        for (var p = 0, ancestor = void 0; p < ancestors.length && (ancestor = ancestors[p]); ++p) {\n            if (isArray(ancestor))\n                continue;\n            if (ancestor.kind === Kind.OPERATION_DEFINITION) {\n                // If an operation is anonymous, we use the empty string as its key.\n                return getInUseByOperationName(ancestor.name && ancestor.name.value);\n            }\n            if (ancestor.kind === Kind.FRAGMENT_DEFINITION) {\n                return getInUseByFragmentName(ancestor.name.value);\n            }\n        }\n        globalThis.__DEV__ !== false && invariant.error(86);\n        return null;\n    };\n    var operationCount = 0;\n    for (var i = doc.definitions.length - 1; i >= 0; --i) {\n        if (doc.definitions[i].kind === Kind.OPERATION_DEFINITION) {\n            ++operationCount;\n        }\n    }\n    var directiveMatcher = getDirectiveMatcher(directives);\n    var shouldRemoveField = function (nodeDirectives) {\n        return isNonEmptyArray(nodeDirectives) &&\n            nodeDirectives\n                .map(directiveMatcher)\n                .some(function (config) { return config && config.remove; });\n    };\n    var originalFragmentDefsByPath = new Map();\n    // Any time the first traversal of the document below makes a change like\n    // removing a fragment (by returning null), this variable should be set to\n    // true. Once it becomes true, it should never be set to false again. If this\n    // variable remains false throughout the traversal, then we can return the\n    // original doc immediately without any modifications.\n    var firstVisitMadeChanges = false;\n    var fieldOrInlineFragmentVisitor = {\n        enter: function (node) {\n            if (shouldRemoveField(node.directives)) {\n                firstVisitMadeChanges = true;\n                return null;\n            }\n        },\n    };\n    var docWithoutDirectiveSubtrees = visit(doc, {\n        // These two AST node types share the same implementation, defined above.\n        Field: fieldOrInlineFragmentVisitor,\n        InlineFragment: fieldOrInlineFragmentVisitor,\n        VariableDefinition: {\n            enter: function () {\n                // VariableDefinition nodes do not count as variables in use, though\n                // they do contain Variable nodes that might be visited below. To avoid\n                // counting variable declarations as usages, we skip visiting the\n                // contents of this VariableDefinition node by returning false.\n                return false;\n            },\n        },\n        Variable: {\n            enter: function (node, _key, _parent, _path, ancestors) {\n                var inUse = getInUse(ancestors);\n                if (inUse) {\n                    inUse.variables.add(node.name.value);\n                }\n            },\n        },\n        FragmentSpread: {\n            enter: function (node, _key, _parent, _path, ancestors) {\n                if (shouldRemoveField(node.directives)) {\n                    firstVisitMadeChanges = true;\n                    return null;\n                }\n                var inUse = getInUse(ancestors);\n                if (inUse) {\n                    inUse.fragmentSpreads.add(node.name.value);\n                }\n                // We might like to remove this FragmentSpread by returning null here if\n                // the corresponding FragmentDefinition node is also going to be removed\n                // by the logic below, but we can't control the relative order of those\n                // events, so we have to postpone the removal of dangling FragmentSpread\n                // nodes until after the current visit of the document has finished.\n            },\n        },\n        FragmentDefinition: {\n            enter: function (node, _key, _parent, path) {\n                originalFragmentDefsByPath.set(JSON.stringify(path), node);\n            },\n            leave: function (node, _key, _parent, path) {\n                var originalNode = originalFragmentDefsByPath.get(JSON.stringify(path));\n                if (node === originalNode) {\n                    // If the FragmentNode received by this leave function is identical to\n                    // the one received by the corresponding enter function (above), then\n                    // the visitor must not have made any changes within this\n                    // FragmentDefinition node. This fragment definition may still be\n                    // removed if there are no ...spread references to it, but it won't be\n                    // removed just because it has only a __typename field.\n                    return node;\n                }\n                if (\n                // This logic applies only if the document contains one or more\n                // operations, since removing all fragments from a document containing\n                // only fragments makes the document useless.\n                operationCount > 0 &&\n                    node.selectionSet.selections.every(function (selection) {\n                        return selection.kind === Kind.FIELD &&\n                            selection.name.value === \"__typename\";\n                    })) {\n                    // This is a somewhat opinionated choice: if a FragmentDefinition ends\n                    // up having no fields other than __typename, we remove the whole\n                    // fragment definition, and later prune ...spread references to it.\n                    getInUseByFragmentName(node.name.value).removed = true;\n                    firstVisitMadeChanges = true;\n                    return null;\n                }\n            },\n        },\n        Directive: {\n            leave: function (node) {\n                // If a matching directive is found, remove the directive itself. Note\n                // that this does not remove the target (field, argument, etc) of the\n                // directive, but only the directive itself.\n                if (directiveMatcher(node)) {\n                    firstVisitMadeChanges = true;\n                    return null;\n                }\n            },\n        },\n    });\n    if (!firstVisitMadeChanges) {\n        // If our first pass did not change anything about the document, then there\n        // is no cleanup we need to do, and we can return the original doc.\n        return doc;\n    }\n    // Utility for making sure inUse.transitiveVars is recursively populated.\n    // Because this logic assumes inUse.fragmentSpreads has been completely\n    // populated and inUse.removed has been set if appropriate,\n    // populateTransitiveVars must be called after that information has been\n    // collected by the first traversal of the document.\n    var populateTransitiveVars = function (inUse) {\n        if (!inUse.transitiveVars) {\n            inUse.transitiveVars = new Set(inUse.variables);\n            if (!inUse.removed) {\n                inUse.fragmentSpreads.forEach(function (childFragmentName) {\n                    populateTransitiveVars(getInUseByFragmentName(childFragmentName)).transitiveVars.forEach(function (varName) {\n                        inUse.transitiveVars.add(varName);\n                    });\n                });\n            }\n        }\n        return inUse;\n    };\n    // Since we've been keeping track of fragment spreads used by particular\n    // operations and fragment definitions, we now need to compute the set of all\n    // spreads used (transitively) by any operations in the document.\n    var allFragmentNamesUsed = new Set();\n    docWithoutDirectiveSubtrees.definitions.forEach(function (def) {\n        if (def.kind === Kind.OPERATION_DEFINITION) {\n            populateTransitiveVars(getInUseByOperationName(def.name && def.name.value)).fragmentSpreads.forEach(function (childFragmentName) {\n                allFragmentNamesUsed.add(childFragmentName);\n            });\n        }\n        else if (def.kind === Kind.FRAGMENT_DEFINITION &&\n            // If there are no operations in the document, then all fragment\n            // definitions count as usages of their own fragment names. This heuristic\n            // prevents accidentally removing all fragment definitions from the\n            // document just because it contains no operations that use the fragments.\n            operationCount === 0 &&\n            !getInUseByFragmentName(def.name.value).removed) {\n            allFragmentNamesUsed.add(def.name.value);\n        }\n    });\n    // Now that we have added all fragment spreads used by operations to the\n    // allFragmentNamesUsed set, we can complete the set by transitively adding\n    // all fragment spreads used by those fragments, and so on.\n    allFragmentNamesUsed.forEach(function (fragmentName) {\n        // Once all the childFragmentName strings added here have been seen already,\n        // the top-level allFragmentNamesUsed.forEach loop will terminate.\n        populateTransitiveVars(getInUseByFragmentName(fragmentName)).fragmentSpreads.forEach(function (childFragmentName) {\n            allFragmentNamesUsed.add(childFragmentName);\n        });\n    });\n    var fragmentWillBeRemoved = function (fragmentName) {\n        return !!(\n        // A fragment definition will be removed if there are no spreads that refer\n        // to it, or the fragment was explicitly removed because it had no fields\n        // other than __typename.\n        (!allFragmentNamesUsed.has(fragmentName) ||\n            getInUseByFragmentName(fragmentName).removed));\n    };\n    var enterVisitor = {\n        enter: function (node) {\n            if (fragmentWillBeRemoved(node.name.value)) {\n                return null;\n            }\n        },\n    };\n    return nullIfDocIsEmpty(visit(docWithoutDirectiveSubtrees, {\n        // If the fragment is going to be removed, then leaving any dangling\n        // FragmentSpread nodes with the same name would be a mistake.\n        FragmentSpread: enterVisitor,\n        // This is where the fragment definition is actually removed.\n        FragmentDefinition: enterVisitor,\n        OperationDefinition: {\n            leave: function (node) {\n                // Upon leaving each operation in the depth-first AST traversal, prune\n                // any variables that are declared by the operation but unused within.\n                if (node.variableDefinitions) {\n                    var usedVariableNames_1 = populateTransitiveVars(\n                    // If an operation is anonymous, we use the empty string as its key.\n                    getInUseByOperationName(node.name && node.name.value)).transitiveVars;\n                    // According to the GraphQL spec, all variables declared by an\n                    // operation must either be used by that operation or used by some\n                    // fragment included transitively into that operation:\n                    // https://spec.graphql.org/draft/#sec-All-Variables-Used\n                    //\n                    // To stay on the right side of this validation rule, if/when we\n                    // remove the last $var references from an operation or its fragments,\n                    // we must also remove the corresponding $var declaration from the\n                    // enclosing operation. This pruning applies only to operations and\n                    // not fragment definitions, at the moment. Fragments may be able to\n                    // declare variables eventually, but today they can only consume them.\n                    if (usedVariableNames_1.size < node.variableDefinitions.length) {\n                        return __assign(__assign({}, node), { variableDefinitions: node.variableDefinitions.filter(function (varDef) {\n                                return usedVariableNames_1.has(varDef.variable.name.value);\n                            }) });\n                    }\n                }\n            },\n        },\n    }));\n}\nexport var addTypenameToDocument = Object.assign(function (doc) {\n    return visit(doc, {\n        SelectionSet: {\n            enter: function (node, _key, parent) {\n                // Don't add __typename to OperationDefinitions.\n                if (parent &&\n                    parent.kind ===\n                        Kind.OPERATION_DEFINITION) {\n                    return;\n                }\n                // No changes if no selections.\n                var selections = node.selections;\n                if (!selections) {\n                    return;\n                }\n                // If selections already have a __typename, or are part of an\n                // introspection query, do nothing.\n                var skip = selections.some(function (selection) {\n                    return (isField(selection) &&\n                        (selection.name.value === \"__typename\" ||\n                            selection.name.value.lastIndexOf(\"__\", 0) === 0));\n                });\n                if (skip) {\n                    return;\n                }\n                // If this SelectionSet is @export-ed as an input variable, it should\n                // not have a __typename field (see issue #4691).\n                var field = parent;\n                if (isField(field) &&\n                    field.directives &&\n                    field.directives.some(function (d) { return d.name.value === \"export\"; })) {\n                    return;\n                }\n                // Create and return a new SelectionSet with a __typename Field.\n                return __assign(__assign({}, node), { selections: __spreadArray(__spreadArray([], selections, true), [TYPENAME_FIELD], false) });\n            },\n        },\n    });\n}, {\n    added: function (field) {\n        return field === TYPENAME_FIELD;\n    },\n});\nvar connectionRemoveConfig = {\n    test: function (directive) {\n        var willRemove = directive.name.value === \"connection\";\n        if (willRemove) {\n            if (!directive.arguments ||\n                !directive.arguments.some(function (arg) { return arg.name.value === \"key\"; })) {\n                globalThis.__DEV__ !== false && invariant.warn(87);\n            }\n        }\n        return willRemove;\n    },\n};\nexport function removeConnectionDirectiveFromDocument(doc) {\n    return removeDirectivesFromDocument([connectionRemoveConfig], checkDocument(doc));\n}\nfunction hasDirectivesInSelectionSet(directives, selectionSet, nestedCheck) {\n    if (nestedCheck === void 0) { nestedCheck = true; }\n    return (!!selectionSet &&\n        selectionSet.selections &&\n        selectionSet.selections.some(function (selection) {\n            return hasDirectivesInSelection(directives, selection, nestedCheck);\n        }));\n}\nfunction hasDirectivesInSelection(directives, selection, nestedCheck) {\n    if (nestedCheck === void 0) { nestedCheck = true; }\n    if (!isField(selection)) {\n        return true;\n    }\n    if (!selection.directives) {\n        return false;\n    }\n    return (selection.directives.some(getDirectiveMatcher(directives)) ||\n        (nestedCheck &&\n            hasDirectivesInSelectionSet(directives, selection.selectionSet, nestedCheck)));\n}\nfunction getArgumentMatcher(config) {\n    return function argumentMatcher(argument) {\n        return config.some(function (aConfig) {\n            return argument.value &&\n                argument.value.kind === Kind.VARIABLE &&\n                argument.value.name &&\n                (aConfig.name === argument.value.name.value ||\n                    (aConfig.test && aConfig.test(argument)));\n        });\n    };\n}\nexport function removeArgumentsFromDocument(config, doc) {\n    var argMatcher = getArgumentMatcher(config);\n    return nullIfDocIsEmpty(visit(doc, {\n        OperationDefinition: {\n            enter: function (node) {\n                return __assign(__assign({}, node), { \n                    // Remove matching top level variables definitions.\n                    variableDefinitions: node.variableDefinitions ?\n                        node.variableDefinitions.filter(function (varDef) {\n                            return !config.some(function (arg) { return arg.name === varDef.variable.name.value; });\n                        })\n                        : [] });\n            },\n        },\n        Field: {\n            enter: function (node) {\n                // If `remove` is set to true for an argument, and an argument match\n                // is found for a field, remove the field as well.\n                var shouldRemoveField = config.some(function (argConfig) { return argConfig.remove; });\n                if (shouldRemoveField) {\n                    var argMatchCount_1 = 0;\n                    if (node.arguments) {\n                        node.arguments.forEach(function (arg) {\n                            if (argMatcher(arg)) {\n                                argMatchCount_1 += 1;\n                            }\n                        });\n                    }\n                    if (argMatchCount_1 === 1) {\n                        return null;\n                    }\n                }\n            },\n        },\n        Argument: {\n            enter: function (node) {\n                // Remove all matching arguments.\n                if (argMatcher(node)) {\n                    return null;\n                }\n            },\n        },\n    }));\n}\nexport function removeFragmentSpreadFromDocument(config, doc) {\n    function enter(node) {\n        if (config.some(function (def) { return def.name === node.name.value; })) {\n            return null;\n        }\n    }\n    return nullIfDocIsEmpty(visit(doc, {\n        FragmentSpread: { enter: enter },\n        FragmentDefinition: { enter: enter },\n    }));\n}\n// If the incoming document is a query, return it as is. Otherwise, build a\n// new document containing a query operation based on the selection set\n// of the previous main operation.\nexport function buildQueryFromSelectionSet(document) {\n    var definition = getMainDefinition(document);\n    var definitionOperation = definition.operation;\n    if (definitionOperation === \"query\") {\n        // Already a query, so return the existing document.\n        return document;\n    }\n    // Build a new query using the selection set of the main operation.\n    var modifiedDoc = visit(document, {\n        OperationDefinition: {\n            enter: function (node) {\n                return __assign(__assign({}, node), { operation: \"query\" });\n            },\n        },\n    });\n    return modifiedDoc;\n}\n// Remove fields / selection sets that include an @client directive.\nexport function removeClientSetsFromDocument(document) {\n    checkDocument(document);\n    var modifiedDoc = removeDirectivesFromDocument([\n        {\n            test: function (directive) { return directive.name.value === \"client\"; },\n            remove: true,\n        },\n    ], document);\n    return modifiedDoc;\n}\n//# sourceMappingURL=transform.js.map","// A [trie](https://en.wikipedia.org/wiki/Trie) data structure that holds\n// object keys weakly, yet can also hold non-object keys, unlike the\n// native `WeakMap`.\n// If no makeData function is supplied, the looked-up data will be an empty,\n// null-prototype Object.\nconst defaultMakeData = () => Object.create(null);\n// Useful for processing arguments objects as well as arrays.\nconst { forEach, slice } = Array.prototype;\nconst { hasOwnProperty } = Object.prototype;\nexport class Trie {\n    constructor(weakness = true, makeData = defaultMakeData) {\n        this.weakness = weakness;\n        this.makeData = makeData;\n    }\n    lookup() {\n        return this.lookupArray(arguments);\n    }\n    lookupArray(array) {\n        let node = this;\n        forEach.call(array, key => node = node.getChildTrie(key));\n        return hasOwnProperty.call(node, \"data\")\n            ? node.data\n            : node.data = this.makeData(slice.call(array));\n    }\n    peek() {\n        return this.peekArray(arguments);\n    }\n    peekArray(array) {\n        let node = this;\n        for (let i = 0, len = array.length; node && i < len; ++i) {\n            const map = node.mapFor(array[i], false);\n            node = map && map.get(array[i]);\n        }\n        return node && node.data;\n    }\n    remove() {\n        return this.removeArray(arguments);\n    }\n    removeArray(array) {\n        let data;\n        if (array.length) {\n            const head = array[0];\n            const map = this.mapFor(head, false);\n            const child = map && map.get(head);\n            if (child) {\n                data = child.removeArray(slice.call(array, 1));\n                if (!child.data && !child.weak && !(child.strong && child.strong.size)) {\n                    map.delete(head);\n                }\n            }\n        }\n        else {\n            data = this.data;\n            delete this.data;\n        }\n        return data;\n    }\n    getChildTrie(key) {\n        const map = this.mapFor(key, true);\n        let child = map.get(key);\n        if (!child)\n            map.set(key, child = new Trie(this.weakness, this.makeData));\n        return child;\n    }\n    mapFor(key, create) {\n        return this.weakness && isObjRef(key)\n            ? this.weak || (create ? this.weak = new WeakMap : void 0)\n            : this.strong || (create ? this.strong = new Map : void 0);\n    }\n}\nfunction isObjRef(value) {\n    switch (typeof value) {\n        case \"object\":\n            if (value === null)\n                break;\n        // Fall through to return true...\n        case \"function\":\n            return true;\n    }\n    return false;\n}\n//# sourceMappingURL=index.js.map","import { devAssert } from '../jsutils/devAssert.mjs';\nimport { inspect } from '../jsutils/inspect.mjs';\nimport { isNode, QueryDocumentKeys } from './ast.mjs';\nimport { Kind } from './kinds.mjs';\n/**\n * A visitor is provided to visit, it contains the collection of\n * relevant functions to be called during the visitor's traversal.\n */\n\nexport const BREAK = Object.freeze({});\n/**\n * visit() will walk through an AST using a depth-first traversal, calling\n * the visitor's enter function at each node in the traversal, and calling the\n * leave function after visiting that node and all of its child nodes.\n *\n * By returning different values from the enter and leave functions, the\n * behavior of the visitor can be altered, including skipping over a sub-tree of\n * the AST (by returning false), editing the AST by returning a value or null\n * to remove the value, or to stop the whole traversal by returning BREAK.\n *\n * When using visit() to edit an AST, the original AST will not be modified, and\n * a new version of the AST with the changes applied will be returned from the\n * visit function.\n *\n * ```ts\n * const editedAST = visit(ast, {\n *   enter(node, key, parent, path, ancestors) {\n *     // @return\n *     //   undefined: no action\n *     //   false: skip visiting this node\n *     //   visitor.BREAK: stop visiting altogether\n *     //   null: delete this node\n *     //   any value: replace this node with the returned value\n *   },\n *   leave(node, key, parent, path, ancestors) {\n *     // @return\n *     //   undefined: no action\n *     //   false: no action\n *     //   visitor.BREAK: stop visiting altogether\n *     //   null: delete this node\n *     //   any value: replace this node with the returned value\n *   }\n * });\n * ```\n *\n * Alternatively to providing enter() and leave() functions, a visitor can\n * instead provide functions named the same as the kinds of AST nodes, or\n * enter/leave visitors at a named key, leading to three permutations of the\n * visitor API:\n *\n * 1) Named visitors triggered when entering a node of a specific kind.\n *\n * ```ts\n * visit(ast, {\n *   Kind(node) {\n *     // enter the \"Kind\" node\n *   }\n * })\n * ```\n *\n * 2) Named visitors that trigger upon entering and leaving a node of a specific kind.\n *\n * ```ts\n * visit(ast, {\n *   Kind: {\n *     enter(node) {\n *       // enter the \"Kind\" node\n *     }\n *     leave(node) {\n *       // leave the \"Kind\" node\n *     }\n *   }\n * })\n * ```\n *\n * 3) Generic visitors that trigger upon entering and leaving any node.\n *\n * ```ts\n * visit(ast, {\n *   enter(node) {\n *     // enter any node\n *   },\n *   leave(node) {\n *     // leave any node\n *   }\n * })\n * ```\n */\n\nexport function visit(root, visitor, visitorKeys = QueryDocumentKeys) {\n  const enterLeaveMap = new Map();\n\n  for (const kind of Object.values(Kind)) {\n    enterLeaveMap.set(kind, getEnterLeaveForKind(visitor, kind));\n  }\n  /* eslint-disable no-undef-init */\n\n  let stack = undefined;\n  let inArray = Array.isArray(root);\n  let keys = [root];\n  let index = -1;\n  let edits = [];\n  let node = root;\n  let key = undefined;\n  let parent = undefined;\n  const path = [];\n  const ancestors = [];\n  /* eslint-enable no-undef-init */\n\n  do {\n    index++;\n    const isLeaving = index === keys.length;\n    const isEdited = isLeaving && edits.length !== 0;\n\n    if (isLeaving) {\n      key = ancestors.length === 0 ? undefined : path[path.length - 1];\n      node = parent;\n      parent = ancestors.pop();\n\n      if (isEdited) {\n        if (inArray) {\n          node = node.slice();\n          let editOffset = 0;\n\n          for (const [editKey, editValue] of edits) {\n            const arrayKey = editKey - editOffset;\n\n            if (editValue === null) {\n              node.splice(arrayKey, 1);\n              editOffset++;\n            } else {\n              node[arrayKey] = editValue;\n            }\n          }\n        } else {\n          node = Object.defineProperties(\n            {},\n            Object.getOwnPropertyDescriptors(node),\n          );\n\n          for (const [editKey, editValue] of edits) {\n            node[editKey] = editValue;\n          }\n        }\n      }\n\n      index = stack.index;\n      keys = stack.keys;\n      edits = stack.edits;\n      inArray = stack.inArray;\n      stack = stack.prev;\n    } else if (parent) {\n      key = inArray ? index : keys[index];\n      node = parent[key];\n\n      if (node === null || node === undefined) {\n        continue;\n      }\n\n      path.push(key);\n    }\n\n    let result;\n\n    if (!Array.isArray(node)) {\n      var _enterLeaveMap$get, _enterLeaveMap$get2;\n\n      isNode(node) || devAssert(false, `Invalid AST Node: ${inspect(node)}.`);\n      const visitFn = isLeaving\n        ? (_enterLeaveMap$get = enterLeaveMap.get(node.kind)) === null ||\n          _enterLeaveMap$get === void 0\n          ? void 0\n          : _enterLeaveMap$get.leave\n        : (_enterLeaveMap$get2 = enterLeaveMap.get(node.kind)) === null ||\n          _enterLeaveMap$get2 === void 0\n        ? void 0\n        : _enterLeaveMap$get2.enter;\n      result =\n        visitFn === null || visitFn === void 0\n          ? void 0\n          : visitFn.call(visitor, node, key, parent, path, ancestors);\n\n      if (result === BREAK) {\n        break;\n      }\n\n      if (result === false) {\n        if (!isLeaving) {\n          path.pop();\n          continue;\n        }\n      } else if (result !== undefined) {\n        edits.push([key, result]);\n\n        if (!isLeaving) {\n          if (isNode(result)) {\n            node = result;\n          } else {\n            path.pop();\n            continue;\n          }\n        }\n      }\n    }\n\n    if (result === undefined && isEdited) {\n      edits.push([key, node]);\n    }\n\n    if (isLeaving) {\n      path.pop();\n    } else {\n      var _node$kind;\n\n      stack = {\n        inArray,\n        index,\n        keys,\n        edits,\n        prev: stack,\n      };\n      inArray = Array.isArray(node);\n      keys = inArray\n        ? node\n        : (_node$kind = visitorKeys[node.kind]) !== null &&\n          _node$kind !== void 0\n        ? _node$kind\n        : [];\n      index = -1;\n      edits = [];\n\n      if (parent) {\n        ancestors.push(parent);\n      }\n\n      parent = node;\n    }\n  } while (stack !== undefined);\n\n  if (edits.length !== 0) {\n    // New root\n    return edits[edits.length - 1][1];\n  }\n\n  return root;\n}\n/**\n * Creates a new visitor instance which delegates to many visitors to run in\n * parallel. Each visitor will be visited for each node before moving on.\n *\n * If a prior visitor edits a node, no following visitors will see that node.\n */\n\nexport function visitInParallel(visitors) {\n  const skipping = new Array(visitors.length).fill(null);\n  const mergedVisitor = Object.create(null);\n\n  for (const kind of Object.values(Kind)) {\n    let hasVisitor = false;\n    const enterList = new Array(visitors.length).fill(undefined);\n    const leaveList = new Array(visitors.length).fill(undefined);\n\n    for (let i = 0; i < visitors.length; ++i) {\n      const { enter, leave } = getEnterLeaveForKind(visitors[i], kind);\n      hasVisitor || (hasVisitor = enter != null || leave != null);\n      enterList[i] = enter;\n      leaveList[i] = leave;\n    }\n\n    if (!hasVisitor) {\n      continue;\n    }\n\n    const mergedEnterLeave = {\n      enter(...args) {\n        const node = args[0];\n\n        for (let i = 0; i < visitors.length; i++) {\n          if (skipping[i] === null) {\n            var _enterList$i;\n\n            const result =\n              (_enterList$i = enterList[i]) === null || _enterList$i === void 0\n                ? void 0\n                : _enterList$i.apply(visitors[i], args);\n\n            if (result === false) {\n              skipping[i] = node;\n            } else if (result === BREAK) {\n              skipping[i] = BREAK;\n            } else if (result !== undefined) {\n              return result;\n            }\n          }\n        }\n      },\n\n      leave(...args) {\n        const node = args[0];\n\n        for (let i = 0; i < visitors.length; i++) {\n          if (skipping[i] === null) {\n            var _leaveList$i;\n\n            const result =\n              (_leaveList$i = leaveList[i]) === null || _leaveList$i === void 0\n                ? void 0\n                : _leaveList$i.apply(visitors[i], args);\n\n            if (result === BREAK) {\n              skipping[i] = BREAK;\n            } else if (result !== undefined && result !== false) {\n              return result;\n            }\n          } else if (skipping[i] === node) {\n            skipping[i] = null;\n          }\n        }\n      },\n    };\n    mergedVisitor[kind] = mergedEnterLeave;\n  }\n\n  return mergedVisitor;\n}\n/**\n * Given a visitor instance and a node kind, return EnterLeaveVisitor for that kind.\n */\n\nexport function getEnterLeaveForKind(visitor, kind) {\n  const kindVisitor = visitor[kind];\n\n  if (typeof kindVisitor === 'object') {\n    // { Kind: { enter() {}, leave() {} } }\n    return kindVisitor;\n  } else if (typeof kindVisitor === 'function') {\n    // { Kind() {} }\n    return {\n      enter: kindVisitor,\n      leave: undefined,\n    };\n  } // { enter() {}, leave() {} }\n\n  return {\n    enter: visitor.enter,\n    leave: visitor.leave,\n  };\n}\n/**\n * Given a visitor instance, if it is leaving or not, and a node kind, return\n * the function the visitor runtime should call.\n *\n * @deprecated Please use `getEnterLeaveForKind` instead. Will be removed in v17\n */\n\n/* c8 ignore next 8 */\n\nexport function getVisitFn(visitor, kind, isLeaving) {\n  const { enter, leave } = getEnterLeaveForKind(visitor, kind);\n  return isLeaving ? leave : enter;\n}\n","// A [trie](https://en.wikipedia.org/wiki/Trie) data structure that holds\n// object keys weakly, yet can also hold non-object keys, unlike the\n// native `WeakMap`.\n// If no makeData function is supplied, the looked-up data will be an empty,\n// null-prototype Object.\nconst defaultMakeData = () => Object.create(null);\n// Useful for processing arguments objects as well as arrays.\nconst { forEach, slice } = Array.prototype;\nconst { hasOwnProperty } = Object.prototype;\nexport class Trie {\n    constructor(weakness = true, makeData = defaultMakeData) {\n        this.weakness = weakness;\n        this.makeData = makeData;\n    }\n    lookup(...array) {\n        return this.lookupArray(array);\n    }\n    lookupArray(array) {\n        let node = this;\n        forEach.call(array, key => node = node.getChildTrie(key));\n        return hasOwnProperty.call(node, \"data\")\n            ? node.data\n            : node.data = this.makeData(slice.call(array));\n    }\n    peek(...array) {\n        return this.peekArray(array);\n    }\n    peekArray(array) {\n        let node = this;\n        for (let i = 0, len = array.length; node && i < len; ++i) {\n            const map = this.weakness && isObjRef(array[i]) ? node.weak : node.strong;\n            node = map && map.get(array[i]);\n        }\n        return node && node.data;\n    }\n    getChildTrie(key) {\n        const map = this.weakness && isObjRef(key)\n            ? this.weak || (this.weak = new WeakMap())\n            : this.strong || (this.strong = new Map());\n        let child = map.get(key);\n        if (!child)\n            map.set(key, child = new Trie(this.weakness, this.makeData));\n        return child;\n    }\n}\nfunction isObjRef(value) {\n    switch (typeof value) {\n        case \"object\":\n            if (value === null)\n                break;\n        // Fall through to return true...\n        case \"function\":\n            return true;\n    }\n    return false;\n}\n//# sourceMappingURL=index.js.map","// This currentContext variable will only be used if the makeSlotClass\n// function is called, which happens only if this is the first copy of the\n// @wry/context package to be imported.\nlet currentContext = null;\n// This unique internal object is used to denote the absence of a value\n// for a given Slot, and is never exposed to outside code.\nconst MISSING_VALUE = {};\nlet idCounter = 1;\n// Although we can't do anything about the cost of duplicated code from\n// accidentally bundling multiple copies of the @wry/context package, we can\n// avoid creating the Slot class more than once using makeSlotClass.\nconst makeSlotClass = () => class Slot {\n    constructor() {\n        // If you have a Slot object, you can find out its slot.id, but you cannot\n        // guess the slot.id of a Slot you don't have access to, thanks to the\n        // randomized suffix.\n        this.id = [\n            \"slot\",\n            idCounter++,\n            Date.now(),\n            Math.random().toString(36).slice(2),\n        ].join(\":\");\n    }\n    hasValue() {\n        for (let context = currentContext; context; context = context.parent) {\n            // We use the Slot object iself as a key to its value, which means the\n            // value cannot be obtained without a reference to the Slot object.\n            if (this.id in context.slots) {\n                const value = context.slots[this.id];\n                if (value === MISSING_VALUE)\n                    break;\n                if (context !== currentContext) {\n                    // Cache the value in currentContext.slots so the next lookup will\n                    // be faster. This caching is safe because the tree of contexts and\n                    // the values of the slots are logically immutable.\n                    currentContext.slots[this.id] = value;\n                }\n                return true;\n            }\n        }\n        if (currentContext) {\n            // If a value was not found for this Slot, it's never going to be found\n            // no matter how many times we look it up, so we might as well cache\n            // the absence of the value, too.\n            currentContext.slots[this.id] = MISSING_VALUE;\n        }\n        return false;\n    }\n    getValue() {\n        if (this.hasValue()) {\n            return currentContext.slots[this.id];\n        }\n    }\n    withValue(value, callback, \n    // Given the prevalence of arrow functions, specifying arguments is likely\n    // to be much more common than specifying `this`, hence this ordering:\n    args, thisArg) {\n        const slots = {\n            __proto__: null,\n            [this.id]: value,\n        };\n        const parent = currentContext;\n        currentContext = { parent, slots };\n        try {\n            // Function.prototype.apply allows the arguments array argument to be\n            // omitted or undefined, so args! is fine here.\n            return callback.apply(thisArg, args);\n        }\n        finally {\n            currentContext = parent;\n        }\n    }\n    // Capture the current context and wrap a callback function so that it\n    // reestablishes the captured context when called.\n    static bind(callback) {\n        const context = currentContext;\n        return function () {\n            const saved = currentContext;\n            try {\n                currentContext = context;\n                return callback.apply(this, arguments);\n            }\n            finally {\n                currentContext = saved;\n            }\n        };\n    }\n    // Immediately run a callback function without any captured context.\n    static noContext(callback, \n    // Given the prevalence of arrow functions, specifying arguments is likely\n    // to be much more common than specifying `this`, hence this ordering:\n    args, thisArg) {\n        if (currentContext) {\n            const saved = currentContext;\n            try {\n                currentContext = null;\n                // Function.prototype.apply allows the arguments array argument to be\n                // omitted or undefined, so args! is fine here.\n                return callback.apply(thisArg, args);\n            }\n            finally {\n                currentContext = saved;\n            }\n        }\n        else {\n            return callback.apply(thisArg, args);\n        }\n    }\n};\nfunction maybe(fn) {\n    try {\n        return fn();\n    }\n    catch (ignored) { }\n}\n// We store a single global implementation of the Slot class as a permanent\n// non-enumerable property of the globalThis object. This obfuscation does\n// nothing to prevent access to the Slot class, but at least it ensures the\n// implementation (i.e. currentContext) cannot be tampered with, and all copies\n// of the @wry/context package (hopefully just one) will share the same Slot\n// implementation. Since the first copy of the @wry/context package to be\n// imported wins, this technique imposes a steep cost for any future breaking\n// changes to the Slot class.\nconst globalKey = \"@wry/context:Slot\";\nconst host = \n// Prefer globalThis when available.\n// https://github.com/benjamn/wryware/issues/347\nmaybe(() => globalThis) ||\n    // Fall back to global, which works in Node.js and may be converted by some\n    // bundlers to the appropriate identifier (window, self, ...) depending on the\n    // bundling target. https://github.com/endojs/endo/issues/576#issuecomment-1178515224\n    maybe(() => global) ||\n    // Otherwise, use a dummy host that's local to this module. We used to fall\n    // back to using the Array constructor as a namespace, but that was flagged in\n    // https://github.com/benjamn/wryware/issues/347, and can be avoided.\n    Object.create(null);\n// Whichever globalHost we're using, make TypeScript happy about the additional\n// globalKey property.\nconst globalHost = host;\nexport const Slot = globalHost[globalKey] ||\n    // Earlier versions of this package stored the globalKey property on the Array\n    // constructor, so we check there as well, to prevent Slot class duplication.\n    Array[globalKey] ||\n    (function (Slot) {\n        try {\n            Object.defineProperty(globalHost, globalKey, {\n                value: Slot,\n                enumerable: false,\n                writable: false,\n                // When it was possible for globalHost to be the Array constructor (a\n                // legacy Slot dedup strategy), it was important for the property to be\n                // configurable:true so it could be deleted. That does not seem to be as\n                // important when globalHost is the global object, but I don't want to\n                // cause similar problems again, and configurable:true seems safest.\n                // https://github.com/endojs/endo/issues/576#issuecomment-1178274008\n                configurable: true\n            });\n        }\n        finally {\n            return Slot;\n        }\n    })(makeSlotClass());\n//# sourceMappingURL=slot.js.map","import { Slot } from \"./slot.js\";\nexport { Slot };\nexport const { bind, noContext } = Slot;\n// Like global.setTimeout, except the callback runs with captured context.\nexport { setTimeoutWithContext as setTimeout };\nfunction setTimeoutWithContext(callback, delay) {\n    return setTimeout(bind(callback), delay);\n}\n// Turn any generator function into an async function (using yield instead\n// of await), with context automatically preserved across yields.\nexport function asyncFromGen(genFn) {\n    return function () {\n        const gen = genFn.apply(this, arguments);\n        const boundNext = bind(gen.next);\n        const boundThrow = bind(gen.throw);\n        return new Promise((resolve, reject) => {\n            function invoke(method, argument) {\n                try {\n                    var result = method.call(gen, argument);\n                }\n                catch (error) {\n                    return reject(error);\n                }\n                const next = result.done ? resolve : invokeNext;\n                if (isPromiseLike(result.value)) {\n                    result.value.then(next, result.done ? reject : invokeThrow);\n                }\n                else {\n                    next(result.value);\n                }\n            }\n            const invokeNext = (value) => invoke(boundNext, value);\n            const invokeThrow = (error) => invoke(boundThrow, error);\n            invokeNext();\n        });\n    };\n}\nfunction isPromiseLike(value) {\n    return value && typeof value.then === \"function\";\n}\n// If you use the fibers npm package to implement coroutines in Node.js,\n// you should call this function at least once to ensure context management\n// remains coherent across any yields.\nconst wrappedFibers = [];\nexport function wrapYieldingFiberMethods(Fiber) {\n    // There can be only one implementation of Fiber per process, so this array\n    // should never grow longer than one element.\n    if (wrappedFibers.indexOf(Fiber) < 0) {\n        const wrap = (obj, method) => {\n            const fn = obj[method];\n            obj[method] = function () {\n                return noContext(fn, arguments, this);\n            };\n        };\n        // These methods can yield, according to\n        // https://github.com/laverdet/node-fibers/blob/ddebed9b8ae3883e57f822e2108e6943e5c8d2a8/fibers.js#L97-L100\n        wrap(Fiber, \"yield\");\n        wrap(Fiber.prototype, \"run\");\n        wrap(Fiber.prototype, \"throwInto\");\n        wrappedFibers.push(Fiber);\n    }\n    return Fiber;\n}\n//# sourceMappingURL=index.js.map","import { Slot } from \"@wry/context\";\nexport const parentEntrySlot = new Slot();\nexport function nonReactive(fn) {\n    return parentEntrySlot.withValue(void 0, fn);\n}\nexport { Slot };\nexport { bind as bindContext, noContext, setTimeout, asyncFromGen, } from \"@wry/context\";\n//# sourceMappingURL=context.js.map","export const { hasOwnProperty, } = Object.prototype;\nexport const arrayFromSet = Array.from ||\n    function (set) {\n        const array = [];\n        set.forEach(item => array.push(item));\n        return array;\n    };\nexport function maybeUnsubscribe(entryOrDep) {\n    const { unsubscribe } = entryOrDep;\n    if (typeof unsubscribe === \"function\") {\n        entryOrDep.unsubscribe = void 0;\n        unsubscribe();\n    }\n}\n//# sourceMappingURL=helpers.js.map","import { parentEntrySlot } from \"./context.js\";\nimport { maybeUnsubscribe, arrayFromSet } from \"./helpers.js\";\nconst emptySetPool = [];\nconst POOL_TARGET_SIZE = 100;\n// Since this package might be used browsers, we should avoid using the\n// Node built-in assert module.\nfunction assert(condition, optionalMessage) {\n    if (!condition) {\n        throw new Error(optionalMessage || \"assertion failure\");\n    }\n}\nfunction valueIs(a, b) {\n    const len = a.length;\n    return (\n    // Unknown values are not equal to each other.\n    len > 0 &&\n        // Both values must be ordinary (or both exceptional) to be equal.\n        len === b.length &&\n        // The underlying value or exception must be the same.\n        a[len - 1] === b[len - 1]);\n}\nfunction valueGet(value) {\n    switch (value.length) {\n        case 0: throw new Error(\"unknown value\");\n        case 1: return value[0];\n        case 2: throw value[1];\n    }\n}\nfunction valueCopy(value) {\n    return value.slice(0);\n}\nexport class Entry {\n    constructor(fn) {\n        this.fn = fn;\n        this.parents = new Set();\n        this.childValues = new Map();\n        // When this Entry has children that are dirty, this property becomes\n        // a Set containing other Entry objects, borrowed from emptySetPool.\n        // When the set becomes empty, it gets recycled back to emptySetPool.\n        this.dirtyChildren = null;\n        this.dirty = true;\n        this.recomputing = false;\n        this.value = [];\n        this.deps = null;\n        ++Entry.count;\n    }\n    peek() {\n        if (this.value.length === 1 && !mightBeDirty(this)) {\n            rememberParent(this);\n            return this.value[0];\n        }\n    }\n    // This is the most important method of the Entry API, because it\n    // determines whether the cached this.value can be returned immediately,\n    // or must be recomputed. The overall performance of the caching system\n    // depends on the truth of the following observations: (1) this.dirty is\n    // usually false, (2) this.dirtyChildren is usually null/empty, and thus\n    // (3) valueGet(this.value) is usually returned without recomputation.\n    recompute(args) {\n        assert(!this.recomputing, \"already recomputing\");\n        rememberParent(this);\n        return mightBeDirty(this)\n            ? reallyRecompute(this, args)\n            : valueGet(this.value);\n    }\n    setDirty() {\n        if (this.dirty)\n            return;\n        this.dirty = true;\n        reportDirty(this);\n        // We can go ahead and unsubscribe here, since any further dirty\n        // notifications we receive will be redundant, and unsubscribing may\n        // free up some resources, e.g. file watchers.\n        maybeUnsubscribe(this);\n    }\n    dispose() {\n        this.setDirty();\n        // Sever any dependency relationships with our own children, so those\n        // children don't retain this parent Entry in their child.parents sets,\n        // thereby preventing it from being fully garbage collected.\n        forgetChildren(this);\n        // Because this entry has been kicked out of the cache (in index.js),\n        // we've lost the ability to find out if/when this entry becomes dirty,\n        // whether that happens through a subscription, because of a direct call\n        // to entry.setDirty(), or because one of its children becomes dirty.\n        // Because of this loss of future information, we have to assume the\n        // worst (that this entry might have become dirty very soon), so we must\n        // immediately mark this entry's parents as dirty. Normally we could\n        // just call entry.setDirty() rather than calling parent.setDirty() for\n        // each parent, but that would leave this entry in parent.childValues\n        // and parent.dirtyChildren, which would prevent the child from being\n        // truly forgotten.\n        eachParent(this, (parent, child) => {\n            parent.setDirty();\n            forgetChild(parent, this);\n        });\n    }\n    forget() {\n        // The code that creates Entry objects in index.ts will replace this method\n        // with one that actually removes the Entry from the cache, which will also\n        // trigger the entry.dispose method.\n        this.dispose();\n    }\n    dependOn(dep) {\n        dep.add(this);\n        if (!this.deps) {\n            this.deps = emptySetPool.pop() || new Set();\n        }\n        this.deps.add(dep);\n    }\n    forgetDeps() {\n        if (this.deps) {\n            arrayFromSet(this.deps).forEach(dep => dep.delete(this));\n            this.deps.clear();\n            emptySetPool.push(this.deps);\n            this.deps = null;\n        }\n    }\n}\nEntry.count = 0;\nfunction rememberParent(child) {\n    const parent = parentEntrySlot.getValue();\n    if (parent) {\n        child.parents.add(parent);\n        if (!parent.childValues.has(child)) {\n            parent.childValues.set(child, []);\n        }\n        if (mightBeDirty(child)) {\n            reportDirtyChild(parent, child);\n        }\n        else {\n            reportCleanChild(parent, child);\n        }\n        return parent;\n    }\n}\nfunction reallyRecompute(entry, args) {\n    forgetChildren(entry);\n    // Set entry as the parent entry while calling recomputeNewValue(entry).\n    parentEntrySlot.withValue(entry, recomputeNewValue, [entry, args]);\n    if (maybeSubscribe(entry, args)) {\n        // If we successfully recomputed entry.value and did not fail to\n        // (re)subscribe, then this Entry is no longer explicitly dirty.\n        setClean(entry);\n    }\n    return valueGet(entry.value);\n}\nfunction recomputeNewValue(entry, args) {\n    entry.recomputing = true;\n    const { normalizeResult } = entry;\n    let oldValueCopy;\n    if (normalizeResult && entry.value.length === 1) {\n        oldValueCopy = valueCopy(entry.value);\n    }\n    // Make entry.value an empty array, representing an unknown value.\n    entry.value.length = 0;\n    try {\n        // If entry.fn succeeds, entry.value will become a normal Value.\n        entry.value[0] = entry.fn.apply(null, args);\n        // If we have a viable oldValueCopy to compare with the (successfully\n        // recomputed) new entry.value, and they are not already === identical, give\n        // normalizeResult a chance to pick/choose/reuse parts of oldValueCopy[0]\n        // and/or entry.value[0] to determine the final cached entry.value.\n        if (normalizeResult && oldValueCopy && !valueIs(oldValueCopy, entry.value)) {\n            try {\n                entry.value[0] = normalizeResult(entry.value[0], oldValueCopy[0]);\n            }\n            catch (_a) {\n                // If normalizeResult throws, just use the newer value, rather than\n                // saving the exception as entry.value[1].\n            }\n        }\n    }\n    catch (e) {\n        // If entry.fn throws, entry.value will hold that exception.\n        entry.value[1] = e;\n    }\n    // Either way, this line is always reached.\n    entry.recomputing = false;\n}\nfunction mightBeDirty(entry) {\n    return entry.dirty || !!(entry.dirtyChildren && entry.dirtyChildren.size);\n}\nfunction setClean(entry) {\n    entry.dirty = false;\n    if (mightBeDirty(entry)) {\n        // This Entry may still have dirty children, in which case we can't\n        // let our parents know we're clean just yet.\n        return;\n    }\n    reportClean(entry);\n}\nfunction reportDirty(child) {\n    eachParent(child, reportDirtyChild);\n}\nfunction reportClean(child) {\n    eachParent(child, reportCleanChild);\n}\nfunction eachParent(child, callback) {\n    const parentCount = child.parents.size;\n    if (parentCount) {\n        const parents = arrayFromSet(child.parents);\n        for (let i = 0; i < parentCount; ++i) {\n            callback(parents[i], child);\n        }\n    }\n}\n// Let a parent Entry know that one of its children may be dirty.\nfunction reportDirtyChild(parent, child) {\n    // Must have called rememberParent(child) before calling\n    // reportDirtyChild(parent, child).\n    assert(parent.childValues.has(child));\n    assert(mightBeDirty(child));\n    const parentWasClean = !mightBeDirty(parent);\n    if (!parent.dirtyChildren) {\n        parent.dirtyChildren = emptySetPool.pop() || new Set;\n    }\n    else if (parent.dirtyChildren.has(child)) {\n        // If we already know this child is dirty, then we must have already\n        // informed our own parents that we are dirty, so we can terminate\n        // the recursion early.\n        return;\n    }\n    parent.dirtyChildren.add(child);\n    // If parent was clean before, it just became (possibly) dirty (according to\n    // mightBeDirty), since we just added child to parent.dirtyChildren.\n    if (parentWasClean) {\n        reportDirty(parent);\n    }\n}\n// Let a parent Entry know that one of its children is no longer dirty.\nfunction reportCleanChild(parent, child) {\n    // Must have called rememberChild(child) before calling\n    // reportCleanChild(parent, child).\n    assert(parent.childValues.has(child));\n    assert(!mightBeDirty(child));\n    const childValue = parent.childValues.get(child);\n    if (childValue.length === 0) {\n        parent.childValues.set(child, valueCopy(child.value));\n    }\n    else if (!valueIs(childValue, child.value)) {\n        parent.setDirty();\n    }\n    removeDirtyChild(parent, child);\n    if (mightBeDirty(parent)) {\n        return;\n    }\n    reportClean(parent);\n}\nfunction removeDirtyChild(parent, child) {\n    const dc = parent.dirtyChildren;\n    if (dc) {\n        dc.delete(child);\n        if (dc.size === 0) {\n            if (emptySetPool.length < POOL_TARGET_SIZE) {\n                emptySetPool.push(dc);\n            }\n            parent.dirtyChildren = null;\n        }\n    }\n}\n// Removes all children from this entry and returns an array of the\n// removed children.\nfunction forgetChildren(parent) {\n    if (parent.childValues.size > 0) {\n        parent.childValues.forEach((_value, child) => {\n            forgetChild(parent, child);\n        });\n    }\n    // Remove this parent Entry from any sets to which it was added by the\n    // addToSet method.\n    parent.forgetDeps();\n    // After we forget all our children, this.dirtyChildren must be empty\n    // and therefore must have been reset to null.\n    assert(parent.dirtyChildren === null);\n}\nfunction forgetChild(parent, child) {\n    child.parents.delete(parent);\n    parent.childValues.delete(child);\n    removeDirtyChild(parent, child);\n}\nfunction maybeSubscribe(entry, args) {\n    if (typeof entry.subscribe === \"function\") {\n        try {\n            maybeUnsubscribe(entry); // Prevent double subscriptions.\n            entry.unsubscribe = entry.subscribe.apply(null, args);\n        }\n        catch (e) {\n            // If this Entry has a subscribe function and it threw an exception\n            // (or an unsubscribe function it previously returned now throws),\n            // return false to indicate that we were not able to subscribe (or\n            // unsubscribe), and this Entry should remain dirty.\n            entry.setDirty();\n            return false;\n        }\n    }\n    // Returning true indicates either that there was no entry.subscribe\n    // function or that it succeeded.\n    return true;\n}\n//# sourceMappingURL=entry.js.map","import { parentEntrySlot } from \"./context.js\";\nimport { hasOwnProperty, maybeUnsubscribe, arrayFromSet, } from \"./helpers.js\";\nconst EntryMethods = {\n    setDirty: true,\n    dispose: true,\n    forget: true, // Fully remove parent Entry from LRU cache and computation graph\n};\nexport function dep(options) {\n    const depsByKey = new Map();\n    const subscribe = options && options.subscribe;\n    function depend(key) {\n        const parent = parentEntrySlot.getValue();\n        if (parent) {\n            let dep = depsByKey.get(key);\n            if (!dep) {\n                depsByKey.set(key, dep = new Set);\n            }\n            parent.dependOn(dep);\n            if (typeof subscribe === \"function\") {\n                maybeUnsubscribe(dep);\n                dep.unsubscribe = subscribe(key);\n            }\n        }\n    }\n    depend.dirty = function dirty(key, entryMethodName) {\n        const dep = depsByKey.get(key);\n        if (dep) {\n            const m = (entryMethodName &&\n                hasOwnProperty.call(EntryMethods, entryMethodName)) ? entryMethodName : \"setDirty\";\n            // We have to use arrayFromSet(dep).forEach instead of dep.forEach,\n            // because modifying a Set while iterating over it can cause elements in\n            // the Set to be removed from the Set before they've been iterated over.\n            arrayFromSet(dep).forEach(entry => entry[m]());\n            depsByKey.delete(key);\n            maybeUnsubscribe(dep);\n        }\n    };\n    return depend;\n}\n//# sourceMappingURL=dep.js.map","import { Trie } from \"@wry/trie\";\nimport { StrongCache } from \"@wry/caches\";\nimport { Entry } from \"./entry.js\";\nimport { parentEntrySlot } from \"./context.js\";\n// These helper functions are important for making optimism work with\n// asynchronous code. In order to register parent-child dependencies,\n// optimism needs to know about any currently active parent computations.\n// In ordinary synchronous code, the parent context is implicit in the\n// execution stack, but asynchronous code requires some extra guidance in\n// order to propagate context from one async task segment to the next.\nexport { bindContext, noContext, nonReactive, setTimeout, asyncFromGen, Slot, } from \"./context.js\";\n// A lighter-weight dependency, similar to OptimisticWrapperFunction, except\n// with only one argument, no makeCacheKey, no wrapped function to recompute,\n// and no result value. Useful for representing dependency leaves in the graph\n// of computation. Subscriptions are supported.\nexport { dep } from \"./dep.js\";\n// The defaultMakeCacheKey function is remarkably powerful, because it gives\n// a unique object for any shallow-identical list of arguments. If you need\n// to implement a custom makeCacheKey function, you may find it helpful to\n// delegate the final work to defaultMakeCacheKey, which is why we export it\n// here. However, you may want to avoid defaultMakeCacheKey if your runtime\n// does not support WeakMap, or you have the ability to return a string key.\n// In those cases, just write your own custom makeCacheKey functions.\nlet defaultKeyTrie;\nexport function defaultMakeCacheKey(...args) {\n    const trie = defaultKeyTrie || (defaultKeyTrie = new Trie(typeof WeakMap === \"function\"));\n    return trie.lookupArray(args);\n}\n// If you're paranoid about memory leaks, or you want to avoid using WeakMap\n// under the hood, but you still need the behavior of defaultMakeCacheKey,\n// import this constructor to create your own tries.\nexport { Trie as KeyTrie };\n;\nconst caches = new Set();\nexport function wrap(originalFunction, { max = Math.pow(2, 16), keyArgs, makeCacheKey = defaultMakeCacheKey, normalizeResult, subscribe, cache: cacheOption = StrongCache, } = Object.create(null)) {\n    const cache = typeof cacheOption === \"function\"\n        ? new cacheOption(max, entry => entry.dispose())\n        : cacheOption;\n    const optimistic = function () {\n        const key = makeCacheKey.apply(null, keyArgs ? keyArgs.apply(null, arguments) : arguments);\n        if (key === void 0) {\n            return originalFunction.apply(null, arguments);\n        }\n        let entry = cache.get(key);\n        if (!entry) {\n            cache.set(key, entry = new Entry(originalFunction));\n            entry.normalizeResult = normalizeResult;\n            entry.subscribe = subscribe;\n            // Give the Entry the ability to trigger cache.delete(key), even though\n            // the Entry itself does not know about key or cache.\n            entry.forget = () => cache.delete(key);\n        }\n        const value = entry.recompute(Array.prototype.slice.call(arguments));\n        // Move this entry to the front of the least-recently used queue,\n        // since we just finished computing its value.\n        cache.set(key, entry);\n        caches.add(cache);\n        // Clean up any excess entries in the cache, but only if there is no\n        // active parent entry, meaning we're not in the middle of a larger\n        // computation that might be flummoxed by the cleaning.\n        if (!parentEntrySlot.hasValue()) {\n            caches.forEach(cache => cache.clean());\n            caches.clear();\n        }\n        return value;\n    };\n    Object.defineProperty(optimistic, \"size\", {\n        get: () => cache.size,\n        configurable: false,\n        enumerable: false,\n    });\n    Object.freeze(optimistic.options = {\n        max,\n        keyArgs,\n        makeCacheKey,\n        normalizeResult,\n        subscribe,\n        cache,\n    });\n    function dirtyKey(key) {\n        const entry = key && cache.get(key);\n        if (entry) {\n            entry.setDirty();\n        }\n    }\n    optimistic.dirtyKey = dirtyKey;\n    optimistic.dirty = function dirty() {\n        dirtyKey(makeCacheKey.apply(null, arguments));\n    };\n    function peekKey(key) {\n        const entry = key && cache.get(key);\n        if (entry) {\n            return entry.peek();\n        }\n    }\n    optimistic.peekKey = peekKey;\n    optimistic.peek = function peek() {\n        return peekKey(makeCacheKey.apply(null, arguments));\n    };\n    function forgetKey(key) {\n        return key ? cache.delete(key) : false;\n    }\n    optimistic.forgetKey = forgetKey;\n    optimistic.forget = function forget() {\n        return forgetKey(makeCacheKey.apply(null, arguments));\n    };\n    optimistic.makeCacheKey = makeCacheKey;\n    optimistic.getKey = keyArgs ? function getKey() {\n        return makeCacheKey.apply(null, keyArgs.apply(null, arguments));\n    } : makeCacheKey;\n    return Object.freeze(optimistic);\n}\n//# sourceMappingURL=index.js.map","function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"]; if (it) return (it = it.call(o)).next.bind(it); if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } 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\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, \"prototype\", { writable: false }); return Constructor; }\n\n// === Symbol Support ===\nvar hasSymbols = function () {\n  return typeof Symbol === 'function';\n};\n\nvar hasSymbol = function (name) {\n  return hasSymbols() && Boolean(Symbol[name]);\n};\n\nvar getSymbol = function (name) {\n  return hasSymbol(name) ? Symbol[name] : '@@' + name;\n};\n\nif (hasSymbols() && !hasSymbol('observable')) {\n  Symbol.observable = Symbol('observable');\n}\n\nvar SymbolIterator = getSymbol('iterator');\nvar SymbolObservable = getSymbol('observable');\nvar SymbolSpecies = getSymbol('species'); // === Abstract Operations ===\n\nfunction getMethod(obj, key) {\n  var value = obj[key];\n  if (value == null) return undefined;\n  if (typeof value !== 'function') throw new TypeError(value + ' is not a function');\n  return value;\n}\n\nfunction getSpecies(obj) {\n  var ctor = obj.constructor;\n\n  if (ctor !== undefined) {\n    ctor = ctor[SymbolSpecies];\n\n    if (ctor === null) {\n      ctor = undefined;\n    }\n  }\n\n  return ctor !== undefined ? ctor : Observable;\n}\n\nfunction isObservable(x) {\n  return x instanceof Observable; // SPEC: Brand check\n}\n\nfunction hostReportError(e) {\n  if (hostReportError.log) {\n    hostReportError.log(e);\n  } else {\n    setTimeout(function () {\n      throw e;\n    });\n  }\n}\n\nfunction enqueue(fn) {\n  Promise.resolve().then(function () {\n    try {\n      fn();\n    } catch (e) {\n      hostReportError(e);\n    }\n  });\n}\n\nfunction cleanupSubscription(subscription) {\n  var cleanup = subscription._cleanup;\n  if (cleanup === undefined) return;\n  subscription._cleanup = undefined;\n\n  if (!cleanup) {\n    return;\n  }\n\n  try {\n    if (typeof cleanup === 'function') {\n      cleanup();\n    } else {\n      var unsubscribe = getMethod(cleanup, 'unsubscribe');\n\n      if (unsubscribe) {\n        unsubscribe.call(cleanup);\n      }\n    }\n  } catch (e) {\n    hostReportError(e);\n  }\n}\n\nfunction closeSubscription(subscription) {\n  subscription._observer = undefined;\n  subscription._queue = undefined;\n  subscription._state = 'closed';\n}\n\nfunction flushSubscription(subscription) {\n  var queue = subscription._queue;\n\n  if (!queue) {\n    return;\n  }\n\n  subscription._queue = undefined;\n  subscription._state = 'ready';\n\n  for (var i = 0; i < queue.length; ++i) {\n    notifySubscription(subscription, queue[i].type, queue[i].value);\n    if (subscription._state === 'closed') break;\n  }\n}\n\nfunction notifySubscription(subscription, type, value) {\n  subscription._state = 'running';\n  var observer = subscription._observer;\n\n  try {\n    var m = getMethod(observer, type);\n\n    switch (type) {\n      case 'next':\n        if (m) m.call(observer, value);\n        break;\n\n      case 'error':\n        closeSubscription(subscription);\n        if (m) m.call(observer, value);else throw value;\n        break;\n\n      case 'complete':\n        closeSubscription(subscription);\n        if (m) m.call(observer);\n        break;\n    }\n  } catch (e) {\n    hostReportError(e);\n  }\n\n  if (subscription._state === 'closed') cleanupSubscription(subscription);else if (subscription._state === 'running') subscription._state = 'ready';\n}\n\nfunction onNotify(subscription, type, value) {\n  if (subscription._state === 'closed') return;\n\n  if (subscription._state === 'buffering') {\n    subscription._queue.push({\n      type: type,\n      value: value\n    });\n\n    return;\n  }\n\n  if (subscription._state !== 'ready') {\n    subscription._state = 'buffering';\n    subscription._queue = [{\n      type: type,\n      value: value\n    }];\n    enqueue(function () {\n      return flushSubscription(subscription);\n    });\n    return;\n  }\n\n  notifySubscription(subscription, type, value);\n}\n\nvar Subscription = /*#__PURE__*/function () {\n  function Subscription(observer, subscriber) {\n    // ASSERT: observer is an object\n    // ASSERT: subscriber is callable\n    this._cleanup = undefined;\n    this._observer = observer;\n    this._queue = undefined;\n    this._state = 'initializing';\n    var subscriptionObserver = new SubscriptionObserver(this);\n\n    try {\n      this._cleanup = subscriber.call(undefined, subscriptionObserver);\n    } catch (e) {\n      subscriptionObserver.error(e);\n    }\n\n    if (this._state === 'initializing') this._state = 'ready';\n  }\n\n  var _proto = Subscription.prototype;\n\n  _proto.unsubscribe = function unsubscribe() {\n    if (this._state !== 'closed') {\n      closeSubscription(this);\n      cleanupSubscription(this);\n    }\n  };\n\n  _createClass(Subscription, [{\n    key: \"closed\",\n    get: function () {\n      return this._state === 'closed';\n    }\n  }]);\n\n  return Subscription;\n}();\n\nvar SubscriptionObserver = /*#__PURE__*/function () {\n  function SubscriptionObserver(subscription) {\n    this._subscription = subscription;\n  }\n\n  var _proto2 = SubscriptionObserver.prototype;\n\n  _proto2.next = function next(value) {\n    onNotify(this._subscription, 'next', value);\n  };\n\n  _proto2.error = function error(value) {\n    onNotify(this._subscription, 'error', value);\n  };\n\n  _proto2.complete = function complete() {\n    onNotify(this._subscription, 'complete');\n  };\n\n  _createClass(SubscriptionObserver, [{\n    key: \"closed\",\n    get: function () {\n      return this._subscription._state === 'closed';\n    }\n  }]);\n\n  return SubscriptionObserver;\n}();\n\nvar Observable = /*#__PURE__*/function () {\n  function Observable(subscriber) {\n    if (!(this instanceof Observable)) throw new TypeError('Observable cannot be called as a function');\n    if (typeof subscriber !== 'function') throw new TypeError('Observable initializer must be a function');\n    this._subscriber = subscriber;\n  }\n\n  var _proto3 = Observable.prototype;\n\n  _proto3.subscribe = function subscribe(observer) {\n    if (typeof observer !== 'object' || observer === null) {\n      observer = {\n        next: observer,\n        error: arguments[1],\n        complete: arguments[2]\n      };\n    }\n\n    return new Subscription(observer, this._subscriber);\n  };\n\n  _proto3.forEach = function forEach(fn) {\n    var _this = this;\n\n    return new Promise(function (resolve, reject) {\n      if (typeof fn !== 'function') {\n        reject(new TypeError(fn + ' is not a function'));\n        return;\n      }\n\n      function done() {\n        subscription.unsubscribe();\n        resolve();\n      }\n\n      var subscription = _this.subscribe({\n        next: function (value) {\n          try {\n            fn(value, done);\n          } catch (e) {\n            reject(e);\n            subscription.unsubscribe();\n          }\n        },\n        error: reject,\n        complete: resolve\n      });\n    });\n  };\n\n  _proto3.map = function map(fn) {\n    var _this2 = this;\n\n    if (typeof fn !== 'function') throw new TypeError(fn + ' is not a function');\n    var C = getSpecies(this);\n    return new C(function (observer) {\n      return _this2.subscribe({\n        next: function (value) {\n          try {\n            value = fn(value);\n          } catch (e) {\n            return observer.error(e);\n          }\n\n          observer.next(value);\n        },\n        error: function (e) {\n          observer.error(e);\n        },\n        complete: function () {\n          observer.complete();\n        }\n      });\n    });\n  };\n\n  _proto3.filter = function filter(fn) {\n    var _this3 = this;\n\n    if (typeof fn !== 'function') throw new TypeError(fn + ' is not a function');\n    var C = getSpecies(this);\n    return new C(function (observer) {\n      return _this3.subscribe({\n        next: function (value) {\n          try {\n            if (!fn(value)) return;\n          } catch (e) {\n            return observer.error(e);\n          }\n\n          observer.next(value);\n        },\n        error: function (e) {\n          observer.error(e);\n        },\n        complete: function () {\n          observer.complete();\n        }\n      });\n    });\n  };\n\n  _proto3.reduce = function reduce(fn) {\n    var _this4 = this;\n\n    if (typeof fn !== 'function') throw new TypeError(fn + ' is not a function');\n    var C = getSpecies(this);\n    var hasSeed = arguments.length > 1;\n    var hasValue = false;\n    var seed = arguments[1];\n    var acc = seed;\n    return new C(function (observer) {\n      return _this4.subscribe({\n        next: function (value) {\n          var first = !hasValue;\n          hasValue = true;\n\n          if (!first || hasSeed) {\n            try {\n              acc = fn(acc, value);\n            } catch (e) {\n              return observer.error(e);\n            }\n          } else {\n            acc = value;\n          }\n        },\n        error: function (e) {\n          observer.error(e);\n        },\n        complete: function () {\n          if (!hasValue && !hasSeed) return observer.error(new TypeError('Cannot reduce an empty sequence'));\n          observer.next(acc);\n          observer.complete();\n        }\n      });\n    });\n  };\n\n  _proto3.concat = function concat() {\n    var _this5 = this;\n\n    for (var _len = arguments.length, sources = new Array(_len), _key = 0; _key < _len; _key++) {\n      sources[_key] = arguments[_key];\n    }\n\n    var C = getSpecies(this);\n    return new C(function (observer) {\n      var subscription;\n      var index = 0;\n\n      function startNext(next) {\n        subscription = next.subscribe({\n          next: function (v) {\n            observer.next(v);\n          },\n          error: function (e) {\n            observer.error(e);\n          },\n          complete: function () {\n            if (index === sources.length) {\n              subscription = undefined;\n              observer.complete();\n            } else {\n              startNext(C.from(sources[index++]));\n            }\n          }\n        });\n      }\n\n      startNext(_this5);\n      return function () {\n        if (subscription) {\n          subscription.unsubscribe();\n          subscription = undefined;\n        }\n      };\n    });\n  };\n\n  _proto3.flatMap = function flatMap(fn) {\n    var _this6 = this;\n\n    if (typeof fn !== 'function') throw new TypeError(fn + ' is not a function');\n    var C = getSpecies(this);\n    return new C(function (observer) {\n      var subscriptions = [];\n\n      var outer = _this6.subscribe({\n        next: function (value) {\n          if (fn) {\n            try {\n              value = fn(value);\n            } catch (e) {\n              return observer.error(e);\n            }\n          }\n\n          var inner = C.from(value).subscribe({\n            next: function (value) {\n              observer.next(value);\n            },\n            error: function (e) {\n              observer.error(e);\n            },\n            complete: function () {\n              var i = subscriptions.indexOf(inner);\n              if (i >= 0) subscriptions.splice(i, 1);\n              completeIfDone();\n            }\n          });\n          subscriptions.push(inner);\n        },\n        error: function (e) {\n          observer.error(e);\n        },\n        complete: function () {\n          completeIfDone();\n        }\n      });\n\n      function completeIfDone() {\n        if (outer.closed && subscriptions.length === 0) observer.complete();\n      }\n\n      return function () {\n        subscriptions.forEach(function (s) {\n          return s.unsubscribe();\n        });\n        outer.unsubscribe();\n      };\n    });\n  };\n\n  _proto3[SymbolObservable] = function () {\n    return this;\n  };\n\n  Observable.from = function from(x) {\n    var C = typeof this === 'function' ? this : Observable;\n    if (x == null) throw new TypeError(x + ' is not an object');\n    var method = getMethod(x, SymbolObservable);\n\n    if (method) {\n      var observable = method.call(x);\n      if (Object(observable) !== observable) throw new TypeError(observable + ' is not an object');\n      if (isObservable(observable) && observable.constructor === C) return observable;\n      return new C(function (observer) {\n        return observable.subscribe(observer);\n      });\n    }\n\n    if (hasSymbol('iterator')) {\n      method = getMethod(x, SymbolIterator);\n\n      if (method) {\n        return new C(function (observer) {\n          enqueue(function () {\n            if (observer.closed) return;\n\n            for (var _iterator = _createForOfIteratorHelperLoose(method.call(x)), _step; !(_step = _iterator()).done;) {\n              var item = _step.value;\n              observer.next(item);\n              if (observer.closed) return;\n            }\n\n            observer.complete();\n          });\n        });\n      }\n    }\n\n    if (Array.isArray(x)) {\n      return new C(function (observer) {\n        enqueue(function () {\n          if (observer.closed) return;\n\n          for (var i = 0; i < x.length; ++i) {\n            observer.next(x[i]);\n            if (observer.closed) return;\n          }\n\n          observer.complete();\n        });\n      });\n    }\n\n    throw new TypeError(x + ' is not observable');\n  };\n\n  Observable.of = function of() {\n    for (var _len2 = arguments.length, items = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n      items[_key2] = arguments[_key2];\n    }\n\n    var C = typeof this === 'function' ? this : Observable;\n    return new C(function (observer) {\n      enqueue(function () {\n        if (observer.closed) return;\n\n        for (var i = 0; i < items.length; ++i) {\n          observer.next(items[i]);\n          if (observer.closed) return;\n        }\n\n        observer.complete();\n      });\n    });\n  };\n\n  _createClass(Observable, null, [{\n    key: SymbolSpecies,\n    get: function () {\n      return this;\n    }\n  }]);\n\n  return Observable;\n}();\n\nif (hasSymbols()) {\n  Object.defineProperty(Observable, Symbol('extensions'), {\n    value: {\n      symbol: SymbolObservable,\n      hostReportError: hostReportError\n    },\n    configurable: true\n  });\n}\n\nexport { Observable };\n"],"names":["EntityStore","Root","ApolloCache","assumeImmutableResults","getFragmentDoc","lib","re","graphql_fragments","Yk","max","sizes","Q","cache","weak","k","prototype","batch","options","updateResult","_this","optimisticId","optimistic","performTransaction","update","recordOptimisticTransaction","transaction","transformDocument","document","transformForLink","identify","object","gc","modify","readQuery","read","tslib_es6","pi","rootId","id","watchFragment","latestDiff","fragment","fragmentName","from","_a","otherOptions","_T","query","diffOptions","returnPartialData","zen_observable_ts_module","y","observer","watch","immediate","callback","diff","equalByQuery","W","data","result","complete","missing","mergeDeep","bw","map","error","next","readFragment","writeQuery","write","Object","assign","dataId","writeFragment","updateQuery","value","updateFragment","globalThis","__DEV__","getMemoryInternals","Kb","MissingFieldError","_super","message","path","variables","call","Array","isArray","i","length","__proto__","ZT","Error","hasOwn","hasOwnProperty","isNullish","defaultDataIdFromObject","context","__typename","_id","keyObject","concat","JSON","stringify","defaultConfig","dataIdFromObject","addTypename","resultCaching","canonizeResults","shouldCanonizeResults","config","TypeOrFieldNameRegExp","fieldNameFromStoreName","storeFieldName","match","storeValueIsStoreObject","objects","s","storeUtils","arrays","extractFragmentContext","fragments","fragmentMap","F","getFromAST","kU","lookupFragment","name","def","lookup","DELETE","create","delModifier","INVALIDATE","policies","group","rootIds","refs","getFieldValue","objectOrReference","maybeDeepFreeze","J","get","__ref","canRead","objOrRef","has","toReference","objOrIdOrRef","mergeIntoStore","kQ","ref","merge","toObject","fieldName","depend","storeObject","rootTypenamesById","Layer","parent","dependOnExistence","older","newer","existing","incoming","globals","kG","merged","w0","storeObjectReconciler","caching","fieldsToDirty_1","__exists","keys","forEach","hasKeyArgs","dirty","fields","changedFields_1","needToMerge_1","allDeleted_1","sharedDetails_1","isReference","readField","fieldNameOrOptions","store","fieldValue","newValue","storage","getStorage","checkReference","undefined","warn","seenReference","someNonReference","_i","newValue_1","delete","args","typename","getStoreFieldName","evict","limit","evicted","clear","replace","extract","obj","extraRootIds","getRootIdSet","push","__META","sort","newData","rest_1","retain","release","count","ids","Set","add","snapshot","findChildRefIds","idsToRemove","root_1","found_1","root","workSet_1","key","child","makeCacheKey","keyMaker","lookupArray","arguments","CacheGroup","d","resetCaching","dP","trie_lib","B","canUse","mr","maybeDependOnExistenceOfEntity","entityId","supportsResultCaching","_b","seed","stump","Stump","storageTrie","addLayer","layerId","replay","removeLayer","ownStoreObject","parentStoreObject","equality_lib","D","fromParent","p","apply","existingObject","incomingObject","property","existingValue","incomingValue","ObjectCanon","known","sy","WeakSet","pool","passes","WeakMap","keysByJSON","Map","empty","admit","isKnown","pass","copy","slice","getPrototypeOf","set","original","array","node","freeze","proto_1","array_1","sortedKeys","json","firstValueIndex_1","sorted","obj_1","execSelectionSetKeyArgs","selectionSet","StoreReader","knownResults","compact","o","canon","executeSelectionSet","peekArgs","other","peek","enclosingRef","execSelectionSetImpl","resultCacheMaxSize","keyArgs","varString","executeSubSelectedArray","execSubSelectedArrayImpl","field","resetCanon","diffQueryAgainstStore","_c","_d","O4","iW","rootRef","execResult","p$","canonicalStringify","firstMissing","tree","_","isFresh","latest","objectsToMerge","missingMerger","handleMissing","resultName","rootIdsByTypename","workSet","selections","selection","directives","LZ","My","u2","transform","Gw","added","hi","kind","kinds","h","FRAGMENT_SPREAD","_K","fragmentMatches","finalResult","frozen","childResult","filter","item","assertSelectionSetForIdValue","values","specifierInfoCache","lookupSpecifierInfo","spec","cacheKey","keyFieldsFnFromSpecifier","specifier","info","keyFieldsFn","collectSpecifierPaths","schemaKeyPath","extracted","extractKeyPath","extractKey","join","keyArgsFnFromSpecifier","keyArgsFn","suffix","keyPath","firstKey","firstChar","charAt","O","directiveName_1","find","directiveArgs","NC","variableName","varKeyPath","extractor","merger","getSpecifierPaths","paths","paths_1","currentPath_1","reduce","collected","toMerge","normalize","reducer","argsFromFieldSpecifier","nullKeyFieldsFn","simpleKeyArgsFn","_args","mergeTrueFn","mergeObjects","mergeFalseFn","Policies","typePolicies","toBeAdded","supertypeMap","fuzzySubtypes","usingPossibleTypes","setRootTypename","possibleTypes","addPossibleTypes","addTypePolicies","partialContext","ROOT_QUERY","normalizeReadFieldOptions","policy","getTypePolicy","keyFn","specifierOrId","String","queryType","mutationType","subscriptionType","updateTypePolicy","keyFields","setMerge","getFieldPolicy","which","toUpperCase","old","supertype","getSupertypeSet","subtype","RegExp","policy_1","supertypes_1","size","regExp","fuzzy","test","fuzzySupertypes","inbox","splice","createIfMissing","fieldPolicies","supertypeSet","typeCondition","typenameSupertypeSet","workQueue_1","maybeEnqueue_1","indexOf","needToCheckFuzzySubtypes","checkingFuzzySubtypes","selectionSetMatchesResult","every","fuzzyString","fieldSpec","specifierOrString","vf","PT","readOptions","makeFieldFunctionOptions","reactiveVars","ab","withValue","getReadFunction","getMergeFunction","parentTypename","childTypename","runMergeFunction","makeMergeObjectsFunction","overwrite","readFieldArgs","argc","stringifyForDisplay","v","eType","iType","getContextFlavor","clientOnly","deferred","flavored","flavors","StoreWriter","reader","writeToStore","operationDefinition","$H","written","incomingById","processSelectionSet","mergeTree","fieldNodeSet","entityRef","applied","applyMerges","fieldsWithSelectionSets_1","hasMergeFunction_1","childTree","Boolean","warnAboutDataLoss","existingRef","incomingObj","getChild","parentType","typeDotName","warnings","childTypenames","includes","qw","result_1","flattenFields","getChildMergeTree","processFieldValue","maybeRecycleChildMergeTree","e","dataRef","sets","previous_1","mergeMergeTrees","left","right","mergeTreeIsEmpty","needToMergeMaps","remainingRightKeys_1","leftTree","cloneDeep","X","fieldMap","limitingTrie","flatten","inheritedContext","visitedNode","visited","dir","if","getStorageArgs","e_1","i_1","getValue_1","eVal","iVal","aVal","pop","emptyMergeTreePool","InMemoryCache","watches","addTypenameTransform","DocumentTransform","A","makeVar","QS","txCount","init","rootStore","optimisticData","resetResultCache","resetResultIdentities","previousReader","storeReader","storeWriter","maybeBroadcastWatch","c","broadcastWatch","restore","broadcast","broadcastWatches","_v","li","forget","reset","print","S","resetCache","resetCaches","discardWatches","Promise","resolve","removeOptimistic","idToRemove","newOptimisticData","onWatchUpdated","perform","layer","alreadyDirty","addTypenameToDocument","addFragmentsToDocument","lastDiff","fromOptimisticTransaction","q4","cacheSlot","optimism__WEBPACK_IMPORTED_MODULE_0__","g7","cacheInfoMap","getCacheInfo","vars","dep","forgetCache","rv","recallCache","attachCache","caches","listeners","oldListeners","listener","getValue","attach","onNextChange","execute","ApolloLink","asyncMap","observable","mapFn","catchFn","promiseQueue","then","makeCallback","examiner","arg","both","closed","handler","sub","subscribe","unsubscribe","graphQLResultHasError","errors","getGraphQLErrorsFromResult","graphQLErrors","incrementalResult","GG","incremental","iterateObserversSafely","observers","method","argument","observersWithMethod","obs","fixObservableSubclass","subclass","defineProperty","aS","Symbol","species","isPromiseLike","Concast","sources","addObserver","removeObserver","promise","reject","handlers","notify","setTimeout","shift","nextResultListeners","cancel","reason","catch","iterable","start","deliverLastMessage","nextOrError","beforeNext","called","ObservableQuery_assign","ObservableQuery_hasOwnProperty","ObservableQuery","queryManager","queryInfo","subObserver","_subscription","_observer","defaultSubscriptionObserverErrorCallback","first","last","reobserve","tearDownQuery","subscriptions","waitForOwnResult","skipCacheDataFor","fetchPolicy","isTornDown","subscribeToMore","bind","defaultOptions","watchQuery","defaultFetchPolicy","_e","_f","initialFetchPolicy","queryId","generateQueryId","opDef","queryName","lastQuery","enumerable","configurable","removeQuery","subscription","resetDiff","getCurrentResult","saveAsLastResult","lastResult","getLastResult","networkStatus","core_networkStatus","Ie","ready","loading","Oj","getDocumentInfo","hasForcedResolvers","getDiff","partial","partialRefetch","logMissingFieldErrors","updateLastResult","isDifferentFromLastResult","newResult","hasNonreactiveDirective","getLast","variablesMustMatch","getLastError","resetLastResults","resetQueryStoreErrors","resetErrors","refetch","reobserveOptions","pollInterval","queryDef","variableDefinitions","some","variable","resetLastWrite","fetchMore","fetchMoreOptions","combinedOptions","qid","originalNetworkStatus","notifyOnNetworkStatusChange","observe","updatedQuerySet","isCached","fetchQuery","fetchMoreResult","previous","reportResult","finally","reobserveCacheFirst","startGraphQLSubscription","subscriptionData","err","onError","setOptions","newOptions","silentSetOptions","mergedOptions","setVariables","broadcastQueries","startPolling","updatePolling","stopPolling","applyNextFetchPolicy","nextFetchPolicy","fetch","newNetworkStatus","setObservableQuery","ssrMode","pollingInfo","hasObservers","clearTimeout","timeout","interval","maybeFetch","skipPollAttempt","poll","reobserveAsConcast","useDisposableConcast","oldVariables","oldFetchPolicy","finishWaitingForOwnResult","concast","fromLink","client_errors","MS","cA","networkError","reportError","resubscribeAfterError","lastError","isDifferent","errorResult","stopQuery","obsQuery","currentFetchPolicy","stack","debug","destructiveMethodCounts","wrapDestructiveCacheMethod","methodName","cancelNotifyTimeout","QueryInfo","lastRequestId","stopped","observableQuery","getDiffOptions","updateWatch","oq","updateLastDiff","setDiff","oldDiff","notifyTimeout","oqListener","shouldNotify","stop","watchOptions","watcher","lastWatch","lastWrite","shouldWrite","dmCount","markResult","cacheWriteBehavior","mergedData","mT","hasNext","shouldWriteResult","errorPolicy","markReady","markError","ignoreErrors","writeWithErrors","QueryManager_hasOwnProperty","IGNORE","QueryManager","clientAwareness","queries","fetchCancelFns","transformCache","queryIdCounter","requestIdCounter","mutationIdCounter","inFlightLinkObservables","defaultDocumentTransform","link","queryDeduplication","localState","documentTransform","defaultContext","onBroadcast","mutationStore","_info","stopQueryNoBroadcast","cancelPendingFetches","mutate","mG","mutationId","hasClientExports","mutationStoreValue","isOptimistic","self","mutation","optimisticResponse","updateQueries","refetchQueries","awaitRefetchQueries","updateWithProxyFn","onQueryUpdated","_g","_h","keepRootFields","Jh","_j","label","generateMutationId","getVariables","addExportedVariables","sent","markMutationOptimistic","getObservableFromLink","storeResult","markMutationResult","cacheWrites","skipCache","asQuery","updateQueries_1","updater","currentQueryResult","nextQueryResult","mutationResult","rY","queryVariables","results_1","updateCache","isFinalResult","M0","include","all","fetchConcastWithInfo","getQueryStore","cacheEntry","mj","shouldForceResolvers","FS","clientQuery","serverQuery","bi","remove","defaultVars","definitions","operation","generateRequestId","stopQueryInStore","stopQueryInStoreNoBroadcast","clearStore","getObservableQueries","queryNamesAndDocs","legacyQueryOptions","desc","JW","makeUniqueId","getQuery","included","nameOrDoc","reFetchObservableQueries","includeStandby","observableQueryPromises","extensions","makeObservable","hasErrors","hasProtocolErrors","ls","protocolErrors","YG","observablePromise_1","getLocalState","deduplication","inFlightLinkObservables_1","operationName","prepareContext","forceFetch","printedServerQuery_1","varJson_1","entry","of","runResolvers","remoteResult","getResultsFromLink","requestId","linkDocument","aqr","containsDataFromLink","defaults","normalized","fromVariables","sourcesWithInfo","fetchQueryByPolicy","cleanupCancelFn","includedQueriesById","results","refetchWritePolicy","oldNetworkStatus","readCache","resultsFromCache","fromData","onlyRunForcedResolvers","resolved","resultsFromLink","newContext","isSelectionNode","FIELD","INLINE_FRAGMENT","LocalState","client","resolvers","fragmentMatcher","selectionsToResolveCache","addResolvers","setFragmentMatcher","resolverGroup","Ee","setResolvers","getResolvers","resolveDocument","localResult","getFragmentMatcher","ob","getCacheKey","document_1","buildRootValueFromCache","exportedVariables","forceResolvers","visitor","Vn","Directive","enter","$_","aL","rootValue_1","rootValue","mainDefinition","selectionsToResolve","definitionOperation","defaultOperationType","execContext","collectSelectionsToResolve","resolveSelectionSet","isClientFieldDescendant","resultsToMerge","resolveField","fieldResult","Ao","fragmentResult","aliasedFieldName","aliasUsed","defaultResult","resultPromise","resolverType","resolverMap","directive","isClientField","resolveSubSelectedArray","isSingleASTNode","collectByDefinition","definitionNode","matches_1","__","___","ancestors","FragmentSpread","spread","fragmentSelections","hasSuggestedDevtools","ApolloClient","resetStoreCallbacks","clearStoreCallbacks","uri","credentials","headers","ssrForceFetchDelay","connectToDevTools","typeDefs","clientAwarenessName","clientAwarenessVersion","version","devtools","HttpLink","u","disableNetworkFetches","devtoolsConfig","enabled","resetStore","devToolsHookCb","action","state","mutations","dataWithOptimisticResults","window","windowWithDevTools","devtoolsSymbol","for","__APOLLO_CLIENT__","top","location","protocol","__APOLLO_DEVTOOLS_GLOBAL_HOOK__","nav","navigator","ua","userAgent","url","log","mergeOptions","__actionHookForDevTools","cb","__requestRaw","payload","fn","onResetStore","onClearStore","serializedState","setLocalStateFragmentMatcher","setLink","newLink","su","aData","aRest","tslib__WEBPACK_IMPORTED_MODULE_1__","bData","bRest","_wry_equality__WEBPACK_IMPORTED_MODULE_0__","Z","equalBySelectionSet","aResult","bResult","seenSelections","_utilities_index_js__WEBPACK_IMPORTED_MODULE_4__","selectionHasNonreactiveDirective","_utilities_index_js__WEBPACK_IMPORTED_MODULE_5__","resultKey","aResultChild","bResultChild","childSelectionSet","aChildIsArray","bChildIsArray","length_1","_utilities_index_js__WEBPACK_IMPORTED_MODULE_3__","_utilities_index_js__WEBPACK_IMPORTED_MODULE_2__","directiveIsNonreactive","passthrough","op","forward","toLink","isTerminating","request","links","x","split","leftLink","rightLink","transformedOperation","starting","validateOperation","OPERATION_FIELDS","second","firstLink","nextLink","setOnError","_ApolloLink_js__WEBPACK_IMPORTED_MODULE_0__","errorHandler","_core_index_js__WEBPACK_IMPORTED_MODULE_0__","_utilities_index_js__WEBPACK_IMPORTED_MODULE_1__","retriedSub","retriedResult","response","ErrorLink","tslib__WEBPACK_IMPORTED_MODULE_2__","serializeFetchParameter","serialized","parseError","readerIterator","iterator","DN","asyncIterator","throwServerError","statusCode","status","parseAndCheckHttpResponse_hasOwnProperty","parseJsonBody","bodyText","getResult","parse","checkFetcher","fetcher","fallbackHttpConfig","http","includeQuery","includeExtensions","preserveHeaderCase","accept","defaultPrinter","ast","printer","fromError","errorValue","backupFetch","wY","createHttpLink","linkOptions","preferredFetch","useGETForQueries","includeUnusedVariables","requestOptions","linkConfig","fetchOptions","fallbackURI","unusedNames","controller","chosenURI","getContext","clientAwarenessHeaders","name_1","contextHeaders","contextConfig","transformedQuery","selectHttpOptionsAndBodyInternal","configs","removeDuplicateHeaders","normalizedHeaders_1","toLowerCase","headerData","originalName","normalizedHeaders","body","Variable","_key","signal","AbortController","isSubscription","hasDefer","acceptHeader","rewriteURIForGET","queryParams","addQueryParam","encodeURIComponent","serializedVariables","serializedExtensions","preFragment","fragmentStart","substr","queryParamsPrefix","newURI","currentFetch","observerNext","setContext","ctype","readMultipartBody","nextValue","decoder","contentType","delimiter","boundaryVal","boundary","buffer","running","done","chunk","searchFrom","contentType_1","TextDecoder","substring","trim","responseIterator","source","getReader","stream","arrayBuffer","pipe","nodeStreamIterator","cleanup","waiting","onData","shiftedArr","pair","onEnd","removeListener","on","decode","headerText","headersInit","line","yU","parseAndCheckHttpResponse","text","operations","abort","sortingMap","stableObjectReplacer","_utilities_caching_index_js__WEBPACK_IMPORTED_MODULE_0__","L","_utilities_caching_index_js__WEBPACK_IMPORTED_MODULE_1__","proto","everyKeyInOrder","unsortedKey","sortedKey","sortedObject_1","_caching_getMemoryInternals_js__WEBPACK_IMPORTED_MODULE_2__","zP","toString","cloneDeepHelper","val","seen","copy_1","copy_2","isExecutionPatchIncrementalResult","isExecutionPatchResult","isApolloPayloadResult","_objects_js__WEBPACK_IMPORTED_MODULE_0__","mergeIncrementalData","prevResult","_mergeDeep_js__WEBPACK_IMPORTED_MODULE_1__","_arrays_js__WEBPACK_IMPORTED_MODULE_2__","parent_1","isNumericKey","mergeDeepArray","target","DeepMerger","defaultReconciler","reconciler","isObject","pastCopies","sourceKey","targetValue","ev","shallowCopyForMerge","identity","resultCache","_common_canUse_js__WEBPACK_IMPORTED_MODULE_3__","cached","predicate","stableCacheKeys_1","_wry_trie__WEBPACK_IMPORTED_MODULE_0__","performWork","optimism__WEBPACK_IMPORTED_MODULE_2__","cacheKeys","_globals_index_js__WEBPACK_IMPORTED_MODULE_1__","_caching_index_js__WEBPACK_IMPORTED_MODULE_4__","_wry_caches__WEBPACK_IMPORTED_MODULE_5__","_getFromAST_js__WEBPACK_IMPORTED_MODULE_6__","A$","transformedDocument","otherTransform","shouldInclude","getInclusionDirectives","directiveArguments","directiveName","_globals_index_js__WEBPACK_IMPORTED_MODULE_0__","ifArgument","ifValue","evaledValue","hasDirectives","names","nameSet","uniqueCount","graphql__WEBPACK_IMPORTED_MODULE_1__","getFragmentQueryDocument","actualFragmentName","definition","createFragmentMap","symTable","getFragmentFromSelection","checkDocument","doc","getOperationDefinition","getOperationName","getFragmentDefinitions","getQueryDefinition","getFragmentDefinition","fragmentDef","getMainDefinition","queryDoc","fragmentDefinition","getDefaultValues","defaultValues","defs","defaultValue","_storeUtils_js__WEBPACK_IMPORTED_MODULE_1__","vb","printCache","escapedRegExp","escapedReplacer","str","escapeSequences","charCodeAt","printDocASTReducer","Name","leave","Document","OperationDefinition","varDefs","wrap","prefix","VariableDefinition","type","SelectionSet","block","Field","alias","argsLine","indent","Argument","InlineFragment","FragmentDefinition","IntValue","FloatValue","StringValue","isBlockString","blockString","BooleanValue","NullValue","EnumValue","ListValue","ObjectValue","ObjectField","NamedType","ListType","NonNullType","SchemaDefinition","description","operationTypes","OperationTypeDefinition","ScalarTypeDefinition","ObjectTypeDefinition","interfaces","FieldDefinition","hasMultilineItems","InputValueDefinition","InterfaceTypeDefinition","UnionTypeDefinition","types","EnumTypeDefinition","EnumValueDefinition","InputObjectTypeDefinition","DirectiveDefinition","repeatable","locations","SchemaExtension","ScalarTypeExtension","ObjectTypeExtension","InterfaceTypeExtension","UnionTypeExtension","EnumTypeExtension","InputObjectTypeExtension","maybeArray","separator","_maybeArray$filter$jo","maybeString","end","_maybeArray$some","print_print","getTypenameFromResult","isField","resultKeyNameFromField","fragments_1","_fragments_js__WEBPACK_IMPORTED_MODULE_3__","makeReference","isDocumentNode","_common_objects_js__WEBPACK_IMPORTED_MODULE_1__","valueToObjectRepresentation","argObj","isIntValue","Number","isBooleanValue","nestedArgObj_1","variableValue","listValue","nestedArgArrayObj","storeKeyNameFromField","directivesObj","getStoreKeyName","KNOWN_DIRECTIVES","storeKeyNameStringify","_common_canonicalStringify_js__WEBPACK_IMPORTED_MODULE_2__","filterKeys","filteredArgs_1","completeFieldName","stringifiedArgs","setStringify","argumentsObjectFromField","argObj_1","isInlineFragment","TYPENAME_FIELD","NAME","makeInUseGetterFunction","defaultKey","inUse","fragmentSpreads","removeDirectivesFromDocument","_getFromAST_js__WEBPACK_IMPORTED_MODULE_2__","tests","getInUseByOperationName","getInUseByFragmentName","getInUse","ancestor","_common_arrays_js__WEBPACK_IMPORTED_MODULE_4__","OPERATION_DEFINITION","FRAGMENT_DEFINITION","operationCount","directiveMatcher","testConfig","shouldRemoveField","nodeDirectives","originalFragmentDefsByPath","firstVisitMadeChanges","fieldOrInlineFragmentVisitor","docWithoutDirectiveSubtrees","graphql__WEBPACK_IMPORTED_MODULE_5__","_parent","_path","removed","populateTransitiveVars","transitiveVars","childFragmentName","varName","allFragmentNamesUsed","enterVisitor","usedVariableNames_1","tslib__WEBPACK_IMPORTED_MODULE_6__","varDef","isEmpty","pD","_storeUtils_js__WEBPACK_IMPORTED_MODULE_7__","lastIndexOf","buildQueryFromSelectionSet","removeClientSetsFromDocument","defaultMakeData","Trie","constructor","weakness","makeData","getChildTrie","peekArray","len","mapFor","removeArray","head","strong","isObjRef","BREAK","visit","visitorKeys","_ast_mjs__WEBPACK_IMPORTED_MODULE_0__","h8","enterLeaveMap","_kinds_mjs__WEBPACK_IMPORTED_MODULE_1__","getEnterLeaveForKind","kindVisitor","inArray","index","edits","_enterLeaveMap$get","_enterLeaveMap$get2","_node$kind","isLeaving","isEdited","editOffset","editKey","editValue","arrayKey","defineProperties","getOwnPropertyDescriptors","prev","UG","_jsutils_devAssert_mjs__WEBPACK_IMPORTED_MODULE_2__","a","_jsutils_inspect_mjs__WEBPACK_IMPORTED_MODULE_3__","visitFn","defaultKeyTrie","lib_hasOwnProperty","currentContext","MISSING_VALUE","idCounter","maybe","ignored","globalKey","host","global","Slot","globalHost","writable","Date","now","Math","random","hasValue","slots","thisArg","saved","noContext","parentEntrySlot","helpers_hasOwnProperty","arrayFromSet","maybeUnsubscribe","entryOrDep","emptySetPool","assert","condition","optionalMessage","valueIs","b","valueGet","Entry","parents","childValues","dirtyChildren","recomputing","deps","mightBeDirty","rememberParent","recompute","forgetChildren","recomputeNewValue","maybeSubscribe","setDirty","eachParent","reportCleanChild","reportDirtyChild","dispose","forgetChild","dependOn","forgetDeps","oldValueCopy","normalizeResult","parentCount","parentWasClean","childValue","removeDirtyChild","dc","_value","EntryMethods","depsByKey","entryMethodName","m","defaultMakeCacheKey","trie","originalFunction","cacheOption","clean","dirtyKey","peekKey","forgetKey","getKey","_arrayLikeToArray","arr","arr2","_defineProperties","props","descriptor","_createClass","Constructor","protoProps","staticProps","hasSymbols","hasSymbol","getSymbol","SymbolIterator","SymbolObservable","SymbolSpecies","getMethod","getSpecies","ctor","Observable","hostReportError","enqueue","cleanupSubscription","_cleanup","closeSubscription","_queue","_state","notifySubscription","onNotify","flushSubscription","queue","Subscription","subscriber","subscriptionObserver","SubscriptionObserver","_proto","_proto2","_subscriber","_proto3","_this2","_this3","_this4","C","hasSeed","acc","_this5","_len","startNext","flatMap","_this6","outer","inner","completeIfDone","_step","_iterator","_createForOfIteratorHelperLoose","allowArrayLike","it","_unsupportedIterableToArray","minLen","n","_len2","items","_key2","symbol"],"sourceRoot":""}